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();
    Store(const Store&) = delete;
    Store& operator=(const Store&) = delete;

  protected:
    std::map<name_type, prep_type> reg_;
    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