Grammar.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
//
// NOTE:
//
// This is an internal include file. It should only be included to 
// instantiate code. Otherwise the BasicGrammar include file should be
// sufficient for all practical purposes.
//
//==========================================================================
#ifndef DD4HEP_GRAMMAR_H
#define DD4HEP_GRAMMAR_H
 
// Framework include files
#include <DD4hep/config.h>
#include <DD4hep/Primitives.h>
 
// C/C++ include files
#include <string>
#include <typeinfo>
 
// Forward declarations
class TClass;
 
namespace dd4hep {
 
  class GrammarRegistry;
  
 
  class BasicGrammar {
    friend class GrammarRegistry;
  public:
    typedef unsigned long long int key_type;
    const std::string   name;
    const key_type      hash_value     = 0;
    mutable TClass*     root_class     = 0;
    mutable int         root_data_type = -1;
    mutable bool        inited         = false;
 
    struct specialization_t   {
      const Cast* cast = 0;
      void (*bind)(void* pointer) = 0;
      void (*copy)(void* to, const void* from) = 0;
      std::string (*str)(const BasicGrammar& gr, const void* ptr) = 0;
      bool (*fromString)(const BasicGrammar& gr, void* ptr, const std::string& value) = 0;
      int  (*eval)(const BasicGrammar& gr, void* ptr, const std::string& val) = 0;
      specialization_t() = default;
      specialization_t(specialization_t&& copy) = default;
      specialization_t(const specialization_t& copy) = default;
      specialization_t& operator=(specialization_t&& copy) = default;
      specialization_t& operator=(const specialization_t& copy) = default;
      bool operator==(const specialization_t& copy)  const;
    } specialization;
    
  protected:
    BasicGrammar(const std::string& typ);
 
    virtual ~BasicGrammar();
 
    void    initialize()   const;
    int     initialized_data_type()  const;
    TClass* initialized_clazz()  const;
 
    
    static void pre_note(const std::type_info& info, const BasicGrammar& (*fcn)(), specialization_t specs);
    
  public:
    template <typename TYPE> static const BasicGrammar& instance();
    static const BasicGrammar& get(const std::type_info& info);
    static const BasicGrammar& get(unsigned long long int hash_code);
    static void invalidConversion(const std::type_info& from, const std::type_info& to);
    static void invalidConversion(const std::string& value, const std::type_info& to);
 
    key_type hash() const                 {  return hash_value;   }
    const std::string& type_name() const  {  return name;         }
    int data_type()  const  {
      if ( inited ) return root_data_type;
      return initialized_data_type();
    }
    TClass* clazz()  const   {
      if ( inited ) return root_class;
      return initialized_clazz();
    }
    virtual void setCast(const Cast* cast)  const;
    virtual const Cast& cast() const;
    virtual bool equals(const std::type_info& other_type) const = 0;
    virtual const std::type_info& type() const = 0;
    virtual size_t sizeOf() const = 0;
    virtual void destruct(void* pointer) const = 0;
    virtual std::string str(const void* ptr) const;
    virtual bool fromString(void* ptr, const std::string& value) const;
    virtual int evaluate(void* ptr, const std::string& value) const;
  };
 
 
  template <typename TYPE> class Grammar : public BasicGrammar {
  private:
    
    friend class BasicGrammar;
    virtual ~Grammar();
    Grammar();
 
  public:
    typedef TYPE type_t;
    
    virtual const std::type_info& type() const  override;
    virtual bool equals(const std::type_info& other_type) const  override;
    virtual size_t sizeOf() const  override;
    virtual void destruct(void* pointer) const  override;
    template <typename... Args> void construct(void* pointer, Args... args)  const;
  };
 
  template <typename TYPE> Grammar<TYPE>::Grammar()
    : BasicGrammar(typeName(typeid(TYPE)))
  {
  }
 
  template <typename TYPE> Grammar<TYPE>::~Grammar() {
  }
 
  template <typename TYPE> const std::type_info& Grammar<TYPE>::type() const {
    return typeid(TYPE);
  }
 
  template <typename TYPE> bool Grammar<TYPE>::equals(const std::type_info& other_type) const  {
    return other_type == typeid(TYPE);
  }
  
  template <typename TYPE> size_t Grammar<TYPE>::sizeOf() const   {
    return sizeof(TYPE);
  }
 
  template <typename TYPE> void Grammar<TYPE>::destruct(void* pointer) const   {
    TYPE* obj = (TYPE*)pointer;
    obj->~TYPE();
  }
 
  template <typename TYPE> template <typename... Args>
  void Grammar<TYPE>::construct(void* pointer, Args... args)  const  {
    new(pointer) TYPE(std::forward<Args>(args)...);
  }
 
 
  class GrammarRegistry {
    GrammarRegistry() = default;
    template <typename T> static std::string str(const BasicGrammar&, const void*)  { return ""; }
  public:
    static const GrammarRegistry& instance();
    
    template <typename T> static const GrammarRegistry& pre_note_specs(BasicGrammar::specialization_t specs)   {
      void (Grammar<T>::*destruct)(void*) const = &Grammar<T>::destruct;
      if ( !destruct ) {
        BasicGrammar::invalidConversion("Grammar",typeid(T));
      }
      BasicGrammar::pre_note(typeid(T), BasicGrammar::instance<T>, specs);
      return instance();
    }
    template <typename T> static const GrammarRegistry& pre_note(int)   {
      BasicGrammar::specialization_t spec;
      spec.bind = detail::constructObject<T>;
      spec.copy = detail::copyObject<T>;
      spec.str  = GrammarRegistry::str<T>;
      return pre_note_specs<T>(spec);
    }
    template <typename T> static const GrammarRegistry& pre_note()   {
      return pre_note_specs<T>({});
    }
  };
}
#endif // DD4HEP_GRAMMAR_H