ConditionsDependencyCollection.h

Go to the documentation of this file.

// $Id$
//==========================================================================
//  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 DDCOND_CONDITIONSDEPENDENCYCOLLECTION_H
#define DDCOND_CONDITIONSDEPENDENCYCOLLECTION_H

// Framework include files
#include "DD4hep/Detector.h"
#include "DD4hep/Conditions.h"
#include "DD4hep/ConditionDerived.h"

// C++ include files
#include <map>
#include <set>

namespace DD4hep {

  namespace Conditions {

    // Forward declarations
    class UserPool;
    class ConditionDependency;
    

    class ConditionsDependencyCollection     {
    public:

      typedef ConditionDependency                Dependency;
      struct Holder  {
        int         flag;
        Dependency* dep;
        Holder(Dependency* d) : flag(0), dep(d) {}
        Holder& operator=(Dependency* d) { dep = d; flag=0; return *this; }
        operator int()  const            { return dep ? 1 : 0;            }
        operator Dependency*&()          { return dep;                    }
        Dependency* operator->()  const  { return dep;                    }
        Dependency* get()  const         { return dep;                    }
      };

      typedef std::map<unsigned int,Holder>      Dependencies;
      typedef Dependencies::const_iterator       const_iterator;
      typedef Dependencies::iterator             iterator;
      typedef Dependencies::key_type             key_type;
      typedef Dependencies::mapped_type          mapped_type;


      class Functor  {
      public:
        typedef ConditionsDependencyCollection::Dependency   Dependency;
        typedef ConditionsDependencyCollection::Dependencies Dependencies;
      };
      Dependencies dependencies;
    public:
      ConditionsDependencyCollection();
      ConditionsDependencyCollection(const ConditionsDependencyCollection& copy);
      virtual ~ConditionsDependencyCollection();
      void clear();
      bool empty()  const            {  return dependencies.empty();      }
      size_t size()  const           {  return dependencies.size();       }
      iterator       begin()         {  return dependencies.begin();      }
      const_iterator begin()  const  {  return dependencies.begin();      }
      iterator       end()           {  return dependencies.end();        }
      const_iterator end()    const  {  return dependencies.end();        }
      iterator       find(Condition::key_type key)
      {  return dependencies.find(key);                                   }
      const_iterator find(Condition::key_type key) const
      {  return dependencies.find(key);                                   }
      std::pair<iterator,bool> insert(const Dependencies::value_type& entry);
      std::pair<iterator,bool> insert(Dependency* dep);
      template <typename T> void for_each(const T& function)  const
      {  std::for_each(dependencies.begin(),dependencies.end(),function); }
    };


    template <typename Data, typename Oper>
    class DependencyCollector : public ConditionsDependencyCollection::Functor    {
    public:
      Data& user_data;
      const Oper& user_oper;
      DependencyCollector(Data& d, const Oper& o) : user_data(d), user_oper(o)    {}
      void operator()(const Dependencies::value_type& e) const
      {  user_oper(user_data, e);                                                  }
    };
  }        /* End namespace Conditions                   */
}          /* End namespace DD4hep                       */

#endif     /* DDCOND_CONDITIONSDEPENDENCYCOLLECTION_H    */