ProjectionApplier.hh

// -*- C++ -*-
#ifndef RIVET_ProjectionApplier_HH
#define RIVET_ProjectionApplier_HH
 
#include "Rivet/Projection.fhh"
#include "Rivet/ProjectionHandler.hh"
#include "Rivet/Config/RivetCommon.hh"
#include "Rivet/Tools/Logging.hh"
#include <deque>
 
namespace Rivet {
 
 
  // Forward declarations
  class Event;
 

  class ProjectionApplier {
  public:
 
    // The proj handler needs access to reset the _allowProjReg flag before calling a.init()
    // friend class ProjectionHandler;

    ProjectionApplier();
 
    // Virtual destructor: ensure that inheritance is possible.
    virtual ~ProjectionApplier();
 

    virtual std::string name() const = 0;


    std::set<ConstProjectionPtr> getProjections() const {
      return getProjHandler().getChildProjections(*this, ProjectionHandler::DEEP);
    }

    std::set<ConstProjectionPtr> getImmediateChildProjections() const {
      return getProjHandler().getChildProjections(*this, ProjectionHandler::SHALLOW);
    }

    bool hasProjection(const std::string& name) const {
      if (_projhandler != nullptr) {
        // If we have a registered proj handler, check its registered names for this PA
        return getProjHandler().hasProjection(*this, name);
      }
      else {
        // If we don't have a registered proj handler yet, check names against the queue
        for (const auto& ptr_name_pair : _declQueue) {
          if (ptr_name_pair.second == name) return true;
        }
        return false;
      }
    }

    template <typename PROJ>
    const PROJ& getProjection(const std::string& name) const {
      if (_projhandler != nullptr) {
        const Projection& p = getProjHandler().getProjection(*this, name);
        return pcast<PROJ>(p);
      }
      else {
        return getProjectionFromDeclQueue<PROJ>(name);
      }
    }

    template <typename PROJ>
    const PROJ& get(const std::string& name) const {
      return getProjection<PROJ>(name);
    }

    const Projection& getProjection(const std::string& name) const {
      return getProjHandler().getProjection(*this, name);
    }

    template <typename PROJ>
    const PROJ& getProjectionFromDeclQueue(const std::string name) const {
      auto it = std::find_if(_declQueue.begin(), _declQueue.end(),
                             [&name](const std::pair<std::shared_ptr<Projection>, std::string>& Qmember) {
                               return Qmember.second == name;
                             });
      if (it != _declQueue.end()) {
        return dynamic_cast<PROJ&>(*(it->first));
      }
      else {
        //If projection isn't found, deal with it properly.
        MSG_ERROR("Projection " << name << " not found in declQueue of " << this << " (" << this->name()
                                << ")");
        throw RangeError("Projection lookup failed in getProjectionFromDeclQueue");
      }
    }

 

 
  public:


    template <typename PROJ = Projection>
    typename std::enable_if_t<std::is_base_of<Projection, PROJ>::value, const PROJ&> apply(
        const Event& evt,
        const Projection& proj) const {
      return pcast<PROJ>(_apply(evt, proj));
    }

    template <typename PROJ = Projection>
    typename std::enable_if_t<std::is_base_of<Projection, PROJ>::value, const PROJ&> apply(
        const Event& evt,
        const PROJ& proj) const {
      return pcast<PROJ>(_apply(evt, proj));
    }

    template <typename PROJ = Projection>
    typename std::enable_if_t<std::is_base_of<Projection, PROJ>::value, const PROJ&> apply(
        const Event& evt,
        const std::string& name) const {
      return pcast<PROJ>(_apply(evt, name));
    }

    template <typename PROJ = Projection>
    typename std::enable_if_t<std::is_base_of<Projection, PROJ>::value, const PROJ&> apply(
        const std::string& name,
        const Event& evt) const {
      return pcast<PROJ>(_apply(evt, name));
    }

 

    void markAsOwned() const {
      _owned = true;
    }
 
 
  protected:
 
    Log& getLog() const {
      return Log::getLog("Rivet.ProjectionHandler");
    }
 

    ProjectionHandler& getProjHandler() const {
      return *_projhandler;
    }
 
 
  private:


    template <typename PROJ>
    const PROJ& declareProjection(const PROJ& proj, const std::string& name) const {
      const Projection& reg = _declareProjection(proj, name);
      const PROJ& rtn = dynamic_cast<const PROJ&>(reg);
      rtn.setProjectionHandler(getProjHandler());
      return rtn;
    }
 
  protected:

    template <typename PROJ>
    const PROJ& declare(const PROJ& proj, const std::string& name) const {
      std::shared_ptr<Projection> projClone = proj.clone();
      _declQueue.push_back(make_pair(projClone, name));
      return (dynamic_cast<PROJ&>(*projClone));
    }

    template <typename PROJ>
    const PROJ& declare(const std::string& name, const PROJ& proj) const {
      std::shared_ptr<Projection> projClone = proj.clone();
      _declQueue.push_back(make_pair(projClone, name));
      return (dynamic_cast<PROJ&>(*projClone));
    }
 

    const Projection& _declareProjection(const Projection& proj, const std::string& name) const;

 

    const Projection& _apply(const Event& evt, const std::string& name) const;

    const Projection& _apply(const Event& evt, const Projection& proj) const;
 

    void setProjectionHandler(ProjectionHandler& projectionHandler) const;

    bool _allowProjReg;
 
 
  private:

    mutable bool _owned;

    mutable ProjectionHandler* _projhandler;

    mutable std::deque<pair<std::shared_ptr<Projection>, string>> _declQueue;
 
  protected:

    void _syncDeclQueue() const;
  };
}
 
#endif