ComponentProperties.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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_DDG4_COMPONENTPROPERTIES_H
#define DD4HEP_DDG4_COMPONENTPROPERTIES_H

// Framework include files

// C/C++ include files
#include <algorithm>
#include <stdexcept>
#include <typeinfo>
#include <string>
#include <map>

namespace DD4hep {

  class Property;
  class BasicGrammar;
  class PropertyGrammar;


  class PropertyConfigurator {
  protected:
    virtual ~PropertyConfigurator();
  public:
    virtual void set(const PropertyGrammar& setter, const std::string&, const std::string&, void* ptr) const = 0;
  };



  class PropertyGrammar {
  protected:
    friend class Property;
    const BasicGrammar& m_grammar;
  public:
    PropertyGrammar(const BasicGrammar& g);
    virtual ~PropertyGrammar();
    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);
    virtual const std::type_info& type() const;
    virtual std::string str(const void* ptr) const;
    virtual bool fromString(void* ptr, const std::string& value) const;
  };


  class Property {
  protected:
    void* m_par = 0;
    const PropertyGrammar* m_hdl = 0;

    template <typename TYPE> void make(TYPE& value);
  public:
    Property() = default;
    Property(const Property& p) = default;
    template <typename TYPE> Property(TYPE& val) : m_par(0), m_hdl(0) {
      make(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 PropertyGrammar& grammar() const;
    std::string str() const;
    Property& str(const std::string& input);
    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 <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 PropertyGrammar& 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();
    bool exists(const std::string& name) const;
    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));
    }
    void set(const std::string& component_name, PropertyConfigurator& setup);
    template <typename FUNCTOR> void for_each(FUNCTOR& func) {
      std::for_each(m_properties.begin(), m_properties.end(), func);
    }
    void adopt(const PropertyManager& copy);
    void dump() const;
  };


  class PropertyConfigurable  {
  protected:
    PropertyManager m_properties;

  public:
    PropertyConfigurable();
    virtual ~PropertyConfigurable();
    PropertyManager& properties() {
      return m_properties;
    }
    bool hasProperty(const std::string& name) const;
    Property& property(const std::string& name);
    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_DDG4_COMPONENTPROPERTIES_H