ReflexTools.h

Go to the documentation of this file.

#ifndef FWCore_Utilities_ReflexTools_h
#define FWCore_Utilities_ReflexTools_h

/*----------------------------------------------------------------------

ReflexTools provides a small number of Reflex-based tools, used in
the CMS event model.

----------------------------------------------------------------------*/

#include "Reflex/Object.h"
#include "Reflex/Type.h"

#include <ostream>
#include <set>
#include <string>
#include <typeinfo>
#include <vector>

namespace edm {

  typedef std::set<std::string> StringSet;

  bool
  find_nested_type_named(std::string const& nested_type,
             Reflex::Type const& type_to_search,
             Reflex::Type& found_type);

  inline
  bool
  value_type_of(Reflex::Type const& t, Reflex::Type& found_type) {
    return find_nested_type_named("value_type", t, found_type);
  }


  inline
  bool
  wrapper_type_of(Reflex::Type const& possible_wrapper,
          Reflex::Type& found_wrapped_type) {
    return find_nested_type_named("wrapped_type",
                  possible_wrapper,
                  found_wrapped_type);
  }

  bool
  is_RefVector(Reflex::Type const& possible_ref_vector,
           Reflex::Type& value_type);

  bool
  is_PtrVector(Reflex::Type const& possible_ref_vector,
           Reflex::Type& value_type);
  bool
  is_RefToBaseVector(Reflex::Type const& possible_ref_vector,
             Reflex::Type& value_type);

  void checkDictionaries(std::string const& name, bool noComponents = false);
  void throwMissingDictionariesException();
  void loadMissingDictionaries();
  StringSet& missingTypes();
  StringSet& foundTypes();

  void public_base_classes(Reflex::Type const& type,
                           std::vector<Reflex::Type>& baseTypes);


  // It would be nice to use void const* for the type of 'raw', but
  // the Reflex interface for creating an Object will not allow that.

  template <class T>
  T const*
  reflex_cast(void* raw, Reflex::Type const& dynamicType) {
    static Reflex::Type const
      toType(Reflex::Type::ByTypeInfo(typeid(T)));

    Reflex::Object obj(dynamicType, raw);
    return static_cast<T const*>(obj.CastObject(toType).Address());

    // This alternative implementation of reflex_cast would allow us
    // to remove the compile-time depenency on Reflex/Type.h and
    // Reflex/Object.h, at the cost of some speed.
    //
    //     return static_cast<T const*>(reflex_pointer_adjust(raw,
    //                             dynamicType,
    //                             typeid(T)));
  }

  // The following function should not now be used. It is here in case
  // we need to get rid of the compile-time dependency on
  // Reflex/Type.h and Reflex/Object.h introduced by the current
  // implementation of reflex_cast (above). If we have to be rid of
  // that dependency, the alternative implementation of reflex_cast
  // uses this function, at the cost of some speed: repeated lookups
  // of the same Reflex::Type object for the same type will have
  // to be made.


  void const*
  reflex_pointer_adjust(void* raw,
            Reflex::Type const& dynamicType,
            std::type_info const& toType);
}

#endif