ConditionsContent.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 DDCOND_CONDITIONSCONTENT_H
#define DDCOND_CONDITIONSCONTENT_H
 
// Framework include files
#include "DD4hep/Memory.h"
#include "DD4hep/Conditions.h"
#include "DD4hep/ConditionDerived.h"
 
// C/C++ include files
#include <memory>
#include <unordered_map>
 
namespace dd4hep {
 
  namespace cond {
 
 
    class ConditionsLoadInfo {
    public:
      int refCount = 0;
    protected:
      virtual ~ConditionsLoadInfo();
    public:
      ConditionsLoadInfo();
      ConditionsLoadInfo(ConditionsLoadInfo&& copy) = delete;
      ConditionsLoadInfo(const ConditionsLoadInfo& copy) = delete;
      ConditionsLoadInfo& operator=(const ConditionsLoadInfo& copy) = delete;
      ConditionsLoadInfo* addRef()  {  ++refCount;  return this; }
      void release() {   --refCount; if ( refCount <= 0 ) delete this;  }
      virtual const std::type_info& type() const = 0;
      virtual const void*           ptr()  const = 0;
      virtual ConditionsLoadInfo*   clone()  const = 0;
      virtual std::string           toString() const = 0;
      template<typename T> T*       data() const {  return (T*)ptr(); }
    };
 
 
    class ConditionsContent  {
    public:
 
      template <typename T> class LoadInfo : public ConditionsLoadInfo {
      public:
        T info;
        LoadInfo(const T& i) : info(i) {}
        LoadInfo()                  = default;
        LoadInfo(const LoadInfo& c) = delete;
        virtual ~LoadInfo()         = default;
        LoadInfo& operator=(const LoadInfo& copy) = delete;
        virtual const std::type_info& type()   const  override
        { return typeid(T);                      }
        virtual const void*           ptr()    const  override
        { return &info;                          }
        virtual ConditionsLoadInfo*   clone()  const  override
        { return new LoadInfo<T>(info);          }
        virtual std::string           toString() const override;
      };
      
      // Looks like tree-maps are a bit slower.
      typedef std::map<Condition::key_type,ConditionDependency* > Dependencies;
      typedef std::map<Condition::key_type,ConditionsLoadInfo* >  Conditions;
      //typedef std::unordered_map<Condition::key_type,ConditionDependency* > Dependencies;
      //typedef std::unordered_map<Condition::key_type,ConditionsLoadInfo* >  Conditions;
 
    protected:
      Conditions        m_conditions;
      Dependencies      m_derived;
 
    private:
      ConditionsContent& operator=(const ConditionsContent& copy) = delete;
      ConditionsContent(const ConditionsContent& copy) = delete;
 
    public:
      ConditionsContent();
      virtual ~ConditionsContent();
      Conditions& conditions()              { return m_conditions;   }
      const Conditions& conditions() const  { return m_conditions;   }
      Dependencies& derived()               { return m_derived;      }
      const Dependencies& derived() const   { return m_derived;      }
      void clear();
      void merge(const ConditionsContent& to_add);
      bool remove(Condition::key_type condition);
      std::pair<Condition::key_type, ConditionsLoadInfo*>
      insertKey(Condition::key_type hash);
      std::pair<Condition::key_type, ConditionsLoadInfo*>
      addLocationInfo(Condition::key_type hash, ConditionsLoadInfo* info);
      template <typename T> std::pair<Condition::key_type, ConditionsLoadInfo*>
      addLocation(Condition::key_type hash, const T& info)   {
        return addLocationInfo(hash, new LoadInfo<T>(info));
      }
      template <typename T> std::pair<Condition::key_type, ConditionsLoadInfo*>
      addLocation(DetElement de, Condition::itemkey_type item, const T& info)   {
        return addLocationInfo(ConditionKey(de, item).hash, new LoadInfo<T>(info));
      }
      std::pair<Condition::key_type, ConditionDependency*>
      addDependency(ConditionDependency* dep);
      std::pair<Condition::key_type, ConditionDependency*>
      addDependency(DetElement de, Condition::itemkey_type item, std::shared_ptr<ConditionUpdateCall> callback);
    };
 
    template <> inline
    std::string ConditionsContent::LoadInfo<std::string>::toString() const   {
      return this->info;
    }
 
  }        /* End namespace cond               */
}          /* End namespace dd4hep                   */
#endif // DDCOND_CONDITIONSCONTENT_H