Store.h

Go to the documentation of this file.

#ifndef DDI_Store_h
#define DDI_Store_h

#include <map>
#include "DetectorDescription/Core/interface/rep_type.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

//;
//FIXME: Store : implement readOnly-behaviour ..
namespace DDI {
   
  template <class N, class I, class K=I>
    class Store 
    {
    public:
    using name_type = N;
    using pimpl_type = I;
    using key_type = K;
    using Rep_type = rep_type< name_type, pimpl_type >;
    using prep_type = Rep_type*;
    using registry_type = std::map< name_type, prep_type>;
    using iterator = typename registry_type::iterator;
    
    auto begin() { return reg_.begin(); }
    auto end() { return reg_.end(); }
    auto size() const { return reg_.size(); } 
    
    // empty shell or fetch from registry
    prep_type create(const name_type &);
      
    // full new object or replace existing with new one
    prep_type create(const name_type &, pimpl_type);
    
    // clear all objects
    void clear();
    
    // swap moves the registry from this guy to another of the same type
    void swap ( Store& );
    
    bool isDefined(const name_type & n ) const;
    void setReadOnly(bool b) { readOnly_ = b; }
    bool readOnly() const { return readOnly_; }
    
    Store() : readOnly_(false) { }
    ~Store();
    
    protected:
    std::map<name_type,prep_type> reg_;
    Store(const Store &) = delete;
    Store & operator=(const Store &) = delete;
    bool readOnly_;
    };
  
  template<class N, class I, class K>
    typename Store<N,I,K>::prep_type 
    Store<N,I,K>::create( const name_type & n )
    {
      prep_type tmp = nullptr;
      auto result = reg_.emplace( n, tmp );
      if( result.second ) {
    if( readOnly_ )
      throw cms::Exception( "DetectorDescriptionStore" )
        << " Store has been locked. Illegal attempt to add "
        << n << " to a global store."; 
    // ELSE     
    result.first->second = new Rep_type( n, nullptr );
      }
      return result.first->second;    
    }
  
  template<class N, class I, class K>
    typename Store<N,I,K>::prep_type
    Store<N,I,K>::create( const name_type & n,
              pimpl_type p )
    {           
      if( readOnly_ )
    throw cms::Exception( "DetectorDescriptionStore" )
      << " Store has been locked. Illegal attempt to add "
      << n << " to a global store."; 
      // ELSE
      prep_type tmp = nullptr;
      auto result = reg_.emplace( n, tmp );
      if( !result.second ) {
    result.first->second->second.swap( p );
      }
      else {
    result.first->second = new Rep_type( n, std::move( p ));
      }
      return result.first->second;
    }

  template <typename I>
    struct Finalize
    {
      static void cleanup( I&& ptr ) {
      }
    };

  template <typename I>
    struct Finalize<I*>
    {
      static void cleanup( I* ptr ) {
    delete ptr;
    ptr = nullptr;
      }
    };
  
  template<class N, class I, class K>
    Store<N,I,K>::~Store()
    {
      for( auto it : reg_ ) {
    Finalize<I>::cleanup( std::move( it.second->second ));
    delete it.second;
    it.second = nullptr;
      }
    }
  
  template<class N, class I, class K>
    bool Store<N,I,K>::isDefined(const name_type & n ) const
    {
      if (readOnly_) edm::LogWarning("DetectorDescriptionStore") << " Store is locked and most likely empty.  isDefined will be false.";
      auto it = reg_.find(n);
      bool result(false);
      if (it != reg_.end()) {
    if (it.second->second) {
      result=true;
    }  
      }
      return result;
    }
  
  template<class N, class I, class K>
    void Store<N, I, K>::swap ( Store<N, I, K>& storeToSwap ) {
    reg_.swap(storeToSwap.reg_);
    storeToSwap.readOnly_ = readOnly_;
  }
  
} // namespace DDI

#endif