Conditions.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_CONDITIONS_CONDITIONS_H
#define DD4HEP_CONDITIONS_CONDITIONS_H

// Framework include files
#include "DD4hep/OpaqueData.h"
#include "DD4hep/Handle.h"
#include "DD4hep/IOV.h"

// C/C++ include files
#include <vector>

namespace DD4hep {

  class BasicGrammar;

  namespace Geometry {
    // Forward declarations
    class DetElement;
    class LCDD;
  }

  namespace Conditions   {

    // The DetElement is a central object. We alias it here.
    using Geometry::DetElement;
    using Geometry::LCDD;

    // Forward declarations
    class ConditionsManagerObject;
    class ConditionsManager;
    class ConditionsLoader;
    class UserPool;

    namespace Interna  {
      class ConditionContainer;
      class ConditionObject;
    }


    class Condition: public Handle<Interna::ConditionObject> {
    public:
      typedef Interna::ConditionObject    Object;
      typedef unsigned int                key_type;
      typedef IOV                         iov_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,
        TEMPERATURE      = 1<<4,
        PRESSURE         = 1<<5,
        ALIGNMENT        = 1<<6,
        // Keep bit 7-15 for other generic types
        // Bit 16-31 is reserved for user classifications
        USER_FLAGS_FIRST = 1<<16,
        USER_FLAGS_LAST  = 1<<31
      };


      class Processor {
      public:
        Processor();
        virtual ~Processor() = default;
        virtual int operator()(Condition c) = 0;
      };

      Condition() = default;
      Condition(const Condition& c) = default;
      Condition(Object* p);
      template <typename Q> Condition(const Handle<Q>& e) : Handle<Object>(e) {}
      Condition(const std::string& name, const std::string& type);
      Condition& operator=(const Condition& c) = default;

      std::string str(int with_data=WITH_IOV|WITH_ADDRESS|WITH_DATATYPE)  const;

      int dataType()  const;
      OpaqueData& data()  const;

      const IOVType& iovType()  const;
      const iov_type& iov()  const;

      const std::string& type()  const;
      const std::string& comment()  const;
      const std::string& value()  const;
      const std::string& address()  const;

      const std::type_info& typeInfo() const;
      const BasicGrammar& descriptor() const;
      key_type key()  const;
      
      Condition& rebind();

      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;
      bool is_bound()  const  {  return isValid() ? data().is_bound() : false;  }
    };

    inline Condition::Condition(Condition::Object* p) : Handle<Condition::Object>(p)  {
    }


    class Container : public Handle<Interna::ConditionContainer> {

    public:

      class Processor {
      public:
        Processor();
        virtual ~Processor() = default;
        virtual int operator()(Container container) = 0;
      };

      typedef Interna::ConditionContainer      Object;
      typedef Condition::key_type              key_type;
      typedef Condition::iov_type              iov_type;
      typedef std::pair<key_type, std::string> key_value;
      typedef std::map<key_type, key_value>    Keys;

    public:
      Container() = default;
      Container(const Container& c) = default;

      template <typename Q> Container(const Handle<Q>& e) : Handle<Object>(e) {}

      Container& operator=(const Container& c) = default;

      size_t numKeys() const;

      const Keys&  keys()  const;
      
      Condition get(const std::string& condition_key, const iov_type& iov);

      Condition get(key_type condition_key, const iov_type& iov);

      Condition get(const std::string& condition_key, const UserPool& pool);

      Condition get(key_type condition_key, const UserPool& pool);
    };


    class ConditionKey  {
    public:
      typedef Condition::key_type      key_type;

      std::string  name;
      key_type     hash;

    public:
      ConditionKey() : hash(0)  {}
      ConditionKey(const std::string& compare);
      ConditionKey(const std::string& s, key_type h) : name(s), hash(h) {}
      ConditionKey(const ConditionKey& c) : name(c.name), hash(c.hash) {}

      static key_type hashCode(const char* value);
      static key_type hashCode(const std::string& value);

      ConditionKey& operator=(const std::string& value);
      ConditionKey& operator=(const ConditionKey& key);
      bool operator==(const ConditionKey& compare)  const;
      bool operator==(const key_type compare)  const;
      bool operator==(const std::string& compare)  const;

      bool operator<(const ConditionKey& compare)  const;
      bool operator<(const key_type compare)  const;
      bool operator<(const std::string& compare)  const;

      operator const std::string& ()  const  {  return name;     }
      operator key_type () const             {  return hash;     }
    };

    inline ConditionKey::key_type ConditionKey::hashCode(const char* value)
    {   return hash32(value);    }

    inline ConditionKey::key_type ConditionKey::hashCode(const std::string& value)
    {   return hash32(value);    }

    inline ConditionKey& ConditionKey::operator=(const ConditionKey& key)  {
      if ( this != &key )  {
        hash  = key.hash;
        name  = key.name;
      }
      return *this;
    }

    inline bool ConditionKey::operator==(const ConditionKey& compare)  const
    {  return hash == compare.hash;                            }

    inline bool ConditionKey::operator==(const key_type compare)  const
    {  return hash == compare;                                 }

    inline bool ConditionKey::operator<(const ConditionKey& compare)  const
    {  return hash < compare.hash;                             }

    inline bool ConditionKey::operator<(const key_type compare)  const
    {  return hash < compare;                                  }

    ConditionKey make_key(Condition c);

    // Utility type definitions
    typedef std::vector<Condition>          RangeConditions;
    typedef std::pair<RangeConditions,bool> RangeStatus;

  } /* End namespace Conditions             */
} /* End namespace DD4hep                   */
#endif    /* DD4HEP_CONDITIONS_CONDITIONS_H */