ConditionsLinearPool.cpp

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_CONDITIONSLINEARPOOL_H
#define DDCOND_CONDITIONSLINEARPOOL_H
 
// Framework include files
#include <DDCond/ConditionsPool.h>
#include <DDCond/ConditionsManager.h>
#include <DDCond/ConditionsSelectors.h>
 
#include <DD4hep/Printout.h>
 
// C/C++ include files
#include <list>
 
namespace dd4hep {
 
  namespace cond {
 
 
    template<typename MAPPING, typename BASE> 
    class ConditionsLinearPool : public BASE   {
    protected:
      MAPPING m_entries;
 
      template <typename R,typename T> size_t loop(R& result, T functor) {
        size_t len = result.size();
        for_each(m_entries.begin(),m_entries.end(),functor);
        return result.size() - len;
      }
    public:
      ConditionsLinearPool(ConditionsManager mgr, IOV* iov);
 
      virtual ~ConditionsLinearPool();
 
      virtual size_t size()  const   final  {
        return m_entries.size();
      }
 
      virtual void clear()  final   {
        for_each(m_entries.begin(), m_entries.end(), Operators::poolRemove(*this));
        m_entries.clear();
      }
 
      virtual Condition exists(Condition::key_type key)  const  final   {
        auto i = find_if(m_entries.begin(), m_entries.end(), Operators::keyFind(key));
        return i==m_entries.end() ? Condition() : (*i);
      }
 
      virtual bool insert(Condition condition)  final 
      {  m_entries.emplace(m_entries.end(),condition.access()); return true;     }
 
      virtual void insert(RangeConditions& rc)  final 
      {  for_each(rc.begin(), rc.end(), Operators::sequenceSelect(m_entries));  }
 
      virtual size_t select(Condition::key_type key, RangeConditions& result)  final 
      {  return loop(result, Operators::keyedSelect(key, result));              }
 
      virtual size_t select_all(const ConditionsSelect& result)  final 
      {  return loop(result, Operators::operatorWrapper(result));               }
 
      virtual size_t select_all(RangeConditions& result)  final 
      {  return loop(result, Operators::sequenceSelect(result));                }
 
      virtual size_t select_all(ConditionsPool& result)  final 
      {  return loop(result, Operators::poolSelect(result));                    }
    };
 
 
    template<typename MAPPING, typename BASE> class ConditionsLinearUpdatePool 
      : public ConditionsLinearPool<MAPPING,BASE>
    {
    public:
      ConditionsLinearUpdatePool(ConditionsManager mgr, IOV*)
        : ConditionsLinearPool<MAPPING,BASE>(mgr,0)
      {
        this->BASE::SetTitle("ConditionsLinearUpdatePool");
      }
 
      virtual ~ConditionsLinearUpdatePool()  {
      }
 
      virtual size_t popEntries(UpdatePool::UpdateEntries& entries)   final  {
        MAPPING& m = this->ConditionsLinearPool<MAPPING,BASE>::m_entries;
        size_t len = entries.size();
        if ( !m.empty() )  {
          for(auto* o : m)
            entries[o->iov].emplace_back(o);
          m.clear();        
        }
        return entries.size()-len;
      }
 
      virtual void select_range(Condition::key_type key,
                                const IOV& req, 
                                RangeConditions& result)  final 
      {
        MAPPING& m = this->ConditionsLinearPool<MAPPING,BASE>::m_entries;
        if ( !m.empty() )   {
          unsigned int req_typ = req.iovType ? req.iovType->type : req.type;
          const IOV::Key& req_key = req.key();
          for(auto* e : m )  {
            if ( key == e->hash )  {
              const IOV* _iov = e->iov;
              unsigned int typ = _iov->iovType ? _iov->iovType->type : _iov->type;
              if ( req_typ == typ )   {
                if ( IOV::key_is_contained(_iov->key(),req_key) )
                  // IOV test contained in key. Take it!
                  result.emplace_back(e);
                else if ( IOV::key_overlaps_lower_end(_iov->key(),req_key) )
                  // IOV overlap on test on the lower end of key
                  result.emplace_back(e);
                else if ( IOV::key_overlaps_higher_end(_iov->key(),req_key) )
                  // IOV overlap of test on the higher end of key
                  result.emplace_back(e);
              }
            }
          }
        }
      }
 
    };
 
 
  } /* End namespace cond             */
} /* End namespace dd4hep                   */
#endif // DDCOND_CONDITIONSLINEARPOOL_H
 
//==========================================================================
//  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
//
//==========================================================================
 
// Framework include files
//#include <DDCond/ConditionsLinearPool.h>
#include <DD4hep/InstanceCount.h>
 
using namespace dd4hep::cond;
 
template<typename MAPPING, typename BASE>
ConditionsLinearPool<MAPPING,BASE>::ConditionsLinearPool(ConditionsManager mgr, IOV* i)
  : BASE(mgr, i)
{
  this->BASE::SetName(i ? i->str().c_str() : "Unknown IOV");
  this->BASE::SetTitle("ConditionsLinearPool");
  InstanceCount::increment(this);
}
 
template<typename MAPPING, typename BASE>
ConditionsLinearPool<MAPPING,BASE>::~ConditionsLinearPool()  {
  clear();
  detail::deletePtr(this->BASE::iov);
  InstanceCount::decrement(this);
}
 
namespace dd4hep {
 
  namespace cond {
 
  } /* End namespace cond             */
} /* End namespace dd4hep                   */
 
#include <DD4hep/Factories.h>
namespace {
  ConditionsManager _mgr(int argc, char** argv)  {
    if ( argc > 0 )  {
      ConditionsManager::Object* m = (ConditionsManager::Object*)argv[0];
      return m;
    }
    dd4hep::except("ConditionsLinearPool","++ Insufficient arguments: arg[0] = ConditionManager!");
    return ConditionsManager(0);
  }
  dd4hep::IOV* _iov(int argc, char** argv)  {
    if ( argc > 1 )  {
      dd4hep::IOV* i = (dd4hep::IOV*)argv[1];
      return i;
    }
    dd4hep::except("ConditionsLinearPool","++ Insufficient arguments: arg[1] = IOV!");
    return nullptr;
  }
 
#define _CR(fun,x,b,y) void* fun(dd4hep::Detector&, int argc, char** argv) \
  {  return new b<x<dd4hep::Condition::Object*>,y>(_mgr(argc,argv), _iov(argc,argv));  }
  _CR(create_vector_pool,std::vector,ConditionsLinearPool,ConditionsPool)
  _CR(create_list_pool,std::list,ConditionsLinearPool,ConditionsPool)
  _CR(create_vector_update_pool,std::vector,ConditionsLinearUpdatePool,UpdatePool)
  _CR(create_list_update_pool,std::list,ConditionsLinearUpdatePool,UpdatePool)
}
 
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearPool,            create_vector_pool)
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearVectorPool,      create_vector_pool)
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearUpdatePool,      create_vector_update_pool)
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearVectorUpdatePool,create_vector_update_pool)
 
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearListPool,        create_list_pool)
DECLARE_DD4HEP_CONSTRUCTOR(DD4hep_ConditionsLinearListUpdatePool,  create_list_update_pool)