ComponentProperties.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
//
//==========================================================================
#ifndef DD4HEP_COMPONENTPROPERTIES_H
#define DD4HEP_COMPONENTPROPERTIES_H
 
// Framework include files
#include <DD4hep/Grammar.h>
 
// C/C++ include files
#include <algorithm>
#include <typeinfo>
#include <string>
#include <map>
 
namespace dd4hep {
 
  class Property;
  class BasicGrammar;
 
 
  class Property {
  protected:
    void* m_par                { nullptr };
    const BasicGrammar* m_hdl  { nullptr };
 
  public:
    Property() = default;
    Property(const Property& p) = default;
    template <typename TYPE> Property(TYPE& val);
    static std::string type(const Property& proptery);
    static std::string type(const std::type_info& proptery);
    void* ptr() const {      return m_par;    }
    std::string type() const;
    const BasicGrammar& grammar() const;
    std::string str() const;
    Property& str(const std::string& input);
    const Property& str(const std::string& input)  const;
    Property& operator=(const Property& p) = default;
    Property& operator=(const char* val);
    //Property& operator=(const std::string& val);
    template <typename TYPE> Property& operator=(const TYPE& val);
    template <typename TYPE> TYPE value() const;
    template <typename TYPE> void value(TYPE& value) const;
    template <typename TYPE> void set(const TYPE& value);
  };
 
  template <typename TYPE> Property::Property(TYPE& val)
    : m_par(&val), m_hdl(0)
    {
      m_hdl = &BasicGrammar::get(typeid(TYPE));
    }
 
  template <typename TYPE> void Property::set(const TYPE& val) {
    const auto& grm = grammar();
    if (grm.type() == typeid(TYPE))
      *(TYPE*) m_par = val;
    else if (!grm.fromString(m_par, BasicGrammar::instance< TYPE >().str(&val)))
      BasicGrammar::invalidConversion(typeid(TYPE), grm.type());
  }
 
  template <typename TYPE> Property& Property::operator=(const TYPE& val) {
    this->set(val);
    return *this;
  }
 
  template <typename TYPE> void Property::value(TYPE& val) const {
    const auto& grm = grammar();
    if (grm.type() == typeid(TYPE))
      val = *(TYPE*) m_par;
    else if (!BasicGrammar::instance< TYPE >().fromString(&val, this->str()))
      BasicGrammar::invalidConversion(grm.type(), typeid(TYPE));
  }
 
  template <typename TYPE> TYPE Property::value() const {
    TYPE temp;
    this->value(temp);
    return temp;
  }
 
 
  template <class TYPE> class PropertyValue : private Property {
  public:
    TYPE data  {};
    PropertyValue() : Property(data) {}
    PropertyValue(const PropertyValue& c) = default;
    PropertyValue& operator=(const PropertyValue& c) = default;
    PropertyValue& operator=(const TYPE& val) { data = val; return *this;      }
    bool operator==(const TYPE& val) const { return val == data;               }
    const BasicGrammar& grammar() const    { return this->Property::grammar(); }
    std::string str() const                { return this->Property::str();     }
    template <typename T> T value() const  { return this->Property::value<T>();}
    template <typename T>
    void value(TYPE& val) const            { this->Property::value(val);       }
    template <typename T> void set(const T& val)  { this->Property::set(val);  }
  };
 
 
  class PropertyManager {
  public:
    typedef std::map<std::string, Property> Properties;
  protected:
    Properties m_properties;
 
    void verifyNonExistence(const std::string& name) const;
    Properties::iterator verifyExistence(const std::string& name);
    Properties::const_iterator verifyExistence(const std::string& name) const;
 
  public:
    PropertyManager();
    virtual ~PropertyManager();
    size_t size()  const;
    bool exists(const std::string& name) const;
    Properties& properties()  {  return m_properties;  }
    const Properties& properties()  const  {  return m_properties;  }
    const Property& property(const std::string& name) const;
    Property& property(const std::string& name);
    Property& operator[](const std::string& name);
    const Property& operator[](const std::string& name) const;
    void add(const std::string& name, const Property& property);
    template <typename T> void add(const std::string& name, T& value)   {
      add(name, Property(value));
    }
    template <typename FUNCTOR> void for_each(FUNCTOR& func)   {
      std::for_each(m_properties.begin(), m_properties.end(), func);
    }
    template <typename FUNCTOR> void for_each(const FUNCTOR& func)   {
      std::for_each(m_properties.begin(), m_properties.end(), func);
    }
    void adopt(const PropertyManager& copy);
    void dump() const;
  };
 
 
  class PropertyInterface  {
  public:
    virtual ~PropertyInterface() = default;
    virtual PropertyManager& properties() = 0;
    virtual const PropertyManager& properties() const = 0;
    virtual bool hasProperty(const std::string& name) const = 0;
    virtual Property& property(const std::string& name) = 0;
  };
  
 
  class PropertyConfigurable : virtual public PropertyInterface {
  protected:
    PropertyManager m_properties;
 
  public:
    PropertyConfigurable();
    virtual ~PropertyConfigurable();
    virtual PropertyManager& properties() override {
      return m_properties;
    }
    virtual const PropertyManager& properties() const override {
      return m_properties;
    }
    virtual bool hasProperty(const std::string& name) const override;
    virtual Property& property(const std::string& name) override;
    template <typename T> void declareProperty(const std::string& nam, T& val);
    template <typename T> void declareProperty(const char* nam, T& val);
  };
 
  template <typename T> 
  void PropertyConfigurable::declareProperty(const std::string& nam, T& val) {
    m_properties.add(nam, val);
  }
 
  template <typename T> 
  void PropertyConfigurable::declareProperty(const char* nam, T& val) {
    m_properties.add(nam, val);
  }
 
}      // End namespace dd4hep
#endif // DD4HEP_COMPONENTPROPERTIES_H