Conditions.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_CONDITIONS_H
#define DD4HEP_CONDITIONS_H
 
// Framework include files
#include <DD4hep/IOV.h>
#include <DD4hep/Handle.h>
#include <DD4hep/OpaqueData.h>
 
// C/C++ include files
#include <vector>
 
namespace dd4hep {
 
  // Forward declarations
  class BasicGrammar;
  class DetElement;
  class Detector;
 
  namespace detail  {
    class ConditionObject;
  }
 
 
  class Condition: public Handle<detail::ConditionObject> {
  public:
    typedef unsigned long long int key_type;
    typedef unsigned int           detkey_type;
    typedef unsigned int           itemkey_type;
    typedef unsigned int           mask_type;
 
  public:
    enum StringFlags  {
      WITH_IOV            =  1<<0,
      WITH_ADDRESS        =  1<<1,
      WITH_TYPE           =  1<<2,
      WITH_COMMENT        =  1<<4,
      WITH_DATATYPE       =  1<<5,
      WITH_DATA           =  1<<6,
      NO_NAME             =  1<<20,
      NONE
    };
    enum ConditionState {
      INACTIVE            =  0,
      ACTIVE              =  1<<0,
      CHECKED             =  1<<2,
      DERIVED             =  1<<3,
      ONSTACK             =  1<<4,
      // Flags for specific conditions
      TEMPERATURE         =  1<<5,
      TEMPERATURE_DERIVED =  1<<6|DERIVED,
      PRESSURE            =  1<<7,
      PRESSURE_DERIVED    =  1<<8|DERIVED,
      ALIGNMENT_DELTA     =  1<<9,
      ALIGNMENT_DERIVED   =  1<<10|DERIVED,
      // Keep bit 10-15 for other generic types
      // Bit 16-31 is reserved for user classifications
      USER_FLAGS_FIRST    =  1<<16,
      USER_FLAGS_LAST     =  1<<31
    };
    enum ConditionItemRangeKeys {
      FIRST_ITEM_KEY      =  0x0U,
      LAST_ITEM_KEY       = ~0x0U
    };
    enum ConditionDetectorRangeKeys {
      FIRST_DET_KEY       =  0x0U,
      LAST_DET_KEY        = ~0x0U
    };
    static constexpr unsigned long long int FIRST_KEY =  0x0ULL, LAST_KEY  = ~0x0ULL;
 
 
    class Processor {
    protected:
      Processor(Processor&& copy) = default;
      Processor(const Processor& copy) = default;
      Processor& operator=(const Processor& copy) = delete;
    public:
      Processor() = default;
      virtual ~Processor() = default;
      virtual int process(Condition c)  const = 0;
      virtual int operator()(Condition c)  const
      {  return this->process(c);                   }
      virtual int operator()(const std::pair<Condition::key_type,Condition>& e)  const
      {  return this->process(e.second);            }
    };
 
    Condition() = default;
    Condition(Condition&& c) = default;
    Condition(const Condition& c) = default;
    Condition(Object* p);
    template <typename Q> Condition(const Handle<Q>& e);
    Condition(key_type hash_key);
    Condition(const std::string& name, const std::string& type);
    Condition(const std::string& name, const std::string& type, size_t memory);
    Condition& operator=(Condition&& c) = default;
    Condition& operator=(const Condition& c) = default;
 
    std::string str(int with_data=WITH_IOV|WITH_ADDRESS|WITH_DATATYPE)  const;
 
    int dataType()  const;
 
    const IOVType& iovType()  const;
    const IOV& iov()  const;
 
    key_type key()  const;
    detkey_type  detector_key()  const;
    itemkey_type item_key()  const;
 
#if defined(DD4HEP_CONDITIONS_DEBUG) || !defined(DD4HEP_MINIMAL_CONDITIONS)
    const std::string& type()  const;
    const std::string& value()  const;
    const std::string& comment()  const;
    const std::string& address()  const;
#endif
    mask_type flags()  const;
    void setFlag(mask_type option);
    void unFlag(mask_type option);
    bool testFlag(mask_type option) const;
 
    OpaqueDataBlock& data()  const;
    const std::type_info& typeInfo() const;
    const BasicGrammar& descriptor() const;
    bool is_bound()  const  {  return isValid() ? data().is_bound() : false;  }
    template <typename T, typename... Args> T& construct(Args... args);
    template <typename T> T& bind();
    template <typename T> T& bind(const std::string& val);
    template <typename T> T& get();
    template <typename T> const T& get() const;
    template <typename T> T& as();
    template <typename T> const T& as() const;
 
    static int haveInventory(int value = -1);
  };
 
  inline Condition::Condition(Condition::Object* p)
    : Handle<Condition::Object>(p)  {}
 
  template <typename Q> inline Condition::Condition(const Handle<Q>& e)
    : Handle<Condition::Object>(e) {}
 
  template <typename T, typename... Args> T& Condition::construct(Args... args)   {
    return data().construct<T,Args...>(args...);
  }
  template <typename T> inline T& Condition::bind()   {
    return data().bind<T>();
  }
  template <typename T> inline T& Condition::bind(const std::string& val)   {
    return data().bind<T>(val);
  }
  template <typename T> inline T& Condition::get() {
    return data().get<T>();
  }
  template <typename T> inline const T& Condition::get() const {
    return data().get<T>();
  }    
  template <typename T> inline T& Condition::as() {
    return data().as<T>();
  }
  template <typename T> inline const T& Condition::as() const {
    return data().as<T>();
  }
    
 
  class ConditionKey  {
  public:
#if defined(DD4HEP_CONDITIONS_HAVE_NAME)
    std::string  name;
#endif
    Condition::key_type     hash = 0;
 
 
    union KeyMaker  {
      Condition::key_type  hash;
      struct {
        Condition::itemkey_type item_key;
        Condition::detkey_type  det_key;
      } values;
      KeyMaker()  {
        this->hash = 0;
      }
      KeyMaker(Condition::key_type k)  {
        this->hash = k;
      }
      KeyMaker(Condition::detkey_type det, Condition::itemkey_type item)  {
        this->values.det_key  = det;
        this->values.item_key = item;
      }
      KeyMaker(Condition::detkey_type det, const std::string& value);
      KeyMaker(DetElement detector, const std::string& value);
      KeyMaker(DetElement detector, Condition::itemkey_type item_key);
    };
    
 
    struct HashCompare {
      Condition::key_type key;
      HashCompare(Condition::key_type k) : key(k) {}
      bool operator==(const ConditionKey& k) const { return key==k.hash; }
    };
  public:
    ConditionKey() = default;
    ConditionKey(Condition::key_type key) : hash(key) {}
    ConditionKey(DetElement detector, const std::string& identifier);
    ConditionKey(Condition::detkey_type det_key, const std::string& identifier);
    ConditionKey(DetElement detector, Condition::itemkey_type item_key);
    ConditionKey(Condition::detkey_type det_key, Condition::itemkey_type item_key);
    ConditionKey(const ConditionKey& c) = default;
 
    Condition::detkey_type detector_key()  const   {
      return KeyMaker(hash).values.det_key;
    }
    Condition::itemkey_type item_key()  const   {
      return KeyMaker(hash).values.item_key;
    }
    static Condition::key_type hashCode(DetElement detector, const char* value);
    static Condition::key_type hashCode(DetElement detector, const std::string& value);
    static Condition::itemkey_type itemCode(const char* value);
    static Condition::itemkey_type itemCode(const std::string& value);
       
    ConditionKey& operator=(const ConditionKey& key) = default;
    bool operator==(const ConditionKey& compare)  const;
    bool operator==(const Condition::key_type compare)  const;
    //bool operator==(const std::string& compare)  const;
 
    bool operator<(const ConditionKey& compare)  const;
    bool operator<(const Condition::key_type compare)  const;
    operator Condition::key_type () const   {  return hash;     }
    std::string toString()  const;
  };
 
  inline ConditionKey::ConditionKey(Condition::detkey_type det_key, Condition::itemkey_type item_key)  {
    hash = KeyMaker(det_key,item_key).hash;
  }
    
  inline bool ConditionKey::operator==(const ConditionKey& compare)  const
  {  return hash == compare.hash;                            }
 
  inline bool ConditionKey::operator==(const Condition::key_type compare)  const
  {  return hash == compare;                                 }
 
  inline bool ConditionKey::operator<(const ConditionKey& compare)  const
  {  return hash < compare.hash;                             }
 
  inline bool ConditionKey::operator<(const Condition::key_type compare)  const
  {  return hash < compare;                                  }
 
 
 
  class ConditionsSelect   {
  protected:
    ConditionsSelect() = default;
    ConditionsSelect(const ConditionsSelect& copy) = default;
    virtual ~ConditionsSelect();
    ConditionsSelect& operator=(const ConditionsSelect& copy) = default;
 
  public:
    bool operator()(Condition cond)  const  { return (*this)(cond.ptr()); }
    bool operator()(std::pair<Condition::key_type,Condition::Object*> cond) const
    { return (*this)(cond.second);            }
 
    bool operator()(std::pair<Condition::key_type,Condition> cond) const
    { return (*this)(cond.second.ptr());      }
 
    virtual size_t size()  const  { return 0; }
    virtual bool operator()(Condition::Object* cond) const = 0;
  };
 
 
  template <typename OBJECT> class ConditionsSelectWrapper : public ConditionsSelect {
  private:
    ConditionsSelectWrapper() = delete;
    bool operator==(const ConditionsSelectWrapper& compare) = delete;
 
  public:
    OBJECT& object;
 
  public:
    ConditionsSelectWrapper(OBJECT& o) : ConditionsSelect(), object(o) {}
    ConditionsSelectWrapper(const ConditionsSelectWrapper& copy) = default;
    virtual ~ConditionsSelectWrapper() = default;
    ConditionsSelectWrapper& operator=(const ConditionsSelectWrapper& copy) = default;
  };
 
  // Utility type definitions
  typedef std::vector<Condition>          RangeConditions;
 
  namespace detail  {
 
    int have_condition_item_inventory(int value = -1);
 
    
 
    std::string get_condition_item_name(Condition::itemkey_type key);
 
 
    std::string get_condition_item_name(Condition::key_type key);
  }
  
}          /* End namespace dd4hep                   */
#endif // DD4HEP_CONDITIONS_H