ProjectionHandler.hh

// -*- C++ -*-
#ifndef RIVET_ProjectionHandler_HH
#define RIVET_ProjectionHandler_HH
 
// @todo all thread/mutex code belongs to a temporary fix to allow for
// basic threading
#include <thread>
#include <mutex>
#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Projection.fhh"
 
namespace Rivet {
 
 
  typedef std::shared_ptr<const Projection> ProjHandle;
 
  // Forward declaration.
  class ProjectionApplier;
 
  class ProjectionHandler {
  public:
 
    friend class ProjectionApplier;
 
    typedef set<ProjHandle> ProjHandles;
 
    typedef map<string, ProjHandle> NamedProjs;
 
    enum ProjDepth { SHALLOW, DEEP };
 
 
  private:
 
    typedef map<const ProjectionApplier*, NamedProjs> NamedProjsMap;
 
    NamedProjsMap _namedprojs;
 
    ProjHandles _projs;
 
 
  public:
 
 
 
    ~ProjectionHandler() = default;
 
    ProjectionHandler& operator = (const ProjectionHandler&) = delete;
 
    ProjectionHandler(const ProjectionHandler&) = delete;
 
    ProjectionHandler() = default;
 
 
    // @todo the following is a temporary fix to allow for basic
    // threading. The proper fix will involve the AnalysisHandler
    // having it's own ProjectionHandler object.
 
    // private:
  public:
 
    static std::mutex mtx;
    static ProjectionHandler& getInstance() {
      // static ProjectionHandler _instance;
      // return _instance;
      std::unique_lock<std::mutex> lock(mtx);
      static map<std::thread::id,ProjectionHandler> _instances;
      return _instances[std::this_thread::get_id()];
      
    }
 
 
  public:
 
 
 
    const Projection& registerProjection(const ProjectionApplier& parent,
                                         const Projection& proj,
                                         const string& name);
 
 
  private:
 
 
 
    ProjHandle _getEquiv(const Projection& proj) const;
 
    unique_ptr<Projection> _clone(const Projection& proj);
 
    const Projection& _register(const ProjectionApplier& parent,
                                ProjHandle proj,
                                const string& name);
 
    string _getStatus() const;
 
    bool _checkDuplicate(const ProjectionApplier& parent,
                         const Projection& proj,
                         const string& name) const;
 
 
 
  public:
 
 
 
    bool hasProjection(const ProjectionApplier& parent, const string& name) const;
 
    const Projection& getProjection(const ProjectionApplier& parent,
                                    const string& name) const;
 
    set<const Projection*> getChildProjections(const ProjectionApplier& parent,
                                               ProjDepth depth=SHALLOW) const;
 
 
  private:
 
    void removeProjectionApplier(ProjectionApplier& parent);
 
 
  private:
 
    // /// Get map of named projections belonging to @a parent.
    // /// Throws an exception if @a parent has not got any registered projections.
    // const NamedProjs& namedProjs(const ProjectionApplier* parent) const {
    //   NamedProjsMap::const_iterator nps = _namedprojs.find(parent);
    //   if (nps == _namedprojs.end()) {
    //     stringstream ss;
    //     ss << "No NamedProjs registered for parent " << parent;
    //     throw Error(ss.str());
    //   }
    //   return *nps;
    // }
 
 
  };
 
 
}
 
#endif