Common base class for Projection and Analysis, used for internal polymorphism. More...

#include <ProjectionApplier.hh>

Public Member Functions
	ProjectionApplier ()
	Constructor.
virtual	~ProjectionApplier ()
void	markAsOwned () const
Metadata functions
virtual std::string	name () const =0
	Get the name of this Projection or Analysis class.
Projection "getting" functions
std::set< ConstProjectionPtr >	getProjections () const
	Get the contained projections, including recursion.
template<typename PROJ >
const PROJ &	getProjection (const std::string &name) const
template<typename PROJ >
const PROJ &	get (const std::string &name) const
const Projection &	getProjection (const std::string &name) const
Projection applying functions
template<typename PROJ >
const PROJ &	applyProjection (const Event &evt, const Projection &proj) const
	Apply the supplied projection on event evt.
template<typename PROJ >
const PROJ &	apply (const Event &evt, const Projection &proj) const
template<typename PROJ >
const PROJ &	applyProjection (const Event &evt, const PROJ &proj) const
	Apply the supplied projection on event evt.
template<typename PROJ >
const PROJ &	apply (const Event &evt, const PROJ &proj) const
template<typename PROJ >
const PROJ &	applyProjection (const Event &evt, const std::string &name) const
template<typename PROJ >
const PROJ &	apply (const Event &evt, const std::string &name) const
Protected Member Functions
Log &	getLog () const
ProjectionHandler &	getProjHandler () const
	Get a reference to the ProjectionHandler for this thread.
const Projection &	_applyProjection (const Event &evt, const std::string &name) const
const Projection &	_applyProjection (const Event &evt, const Projection &proj) const
Projection registration functions
template<typename PROJ >
const PROJ &	declareProjection (const PROJ &proj, const std::string &name)
	Register a contained projection.
template<typename PROJ >
const PROJ &	declare (const PROJ &proj, const std::string &name)
	Register a contained projection (user-facing version)
template<typename PROJ >
const PROJ &	addProjection (const PROJ &proj, const std::string &name)
	Register a contained projection (user-facing version)
const Projection &	_declareProjection (const Projection &proj, const std::string &name)
	Untemplated function to do the work...
Protected Attributes
bool	_allowProjReg
	Flag to forbid projection registration in analyses until the init phase.
Private Attributes
bool	_owned
	Mark object as owned by the _projhandler.
ProjectionHandler &	_projhandler
	Pointer to projection handler.

Detailed Description

Common base class for Projection and Analysis, used for internal polymorphism.

Empty interface used for storing Projection and Analysis pointers in the same container (used by the ProjectionHandler)

Definition at line 21 of file ProjectionApplier.hh.

Constructor & Destructor Documentation

ProjectionApplier ( )

Constructor.

Definition at line 10 of file ProjectionApplier.cc.

    : _allowProjReg(true), _owned(false),
      _projhandler(ProjectionHandler::getInstance())
  {  }

~ProjectionApplier ( ) [virtual]

Definition at line 16 of file ProjectionApplier.cc.

                                        {
    if ( ! _owned )
      getProjHandler().removeProjectionApplier(*this);
  }

Member Function Documentation

const Projection & _applyProjection	(	const Event &	evt,
		const std::string &	name
	)		const `[protected]`

Non-templated version of string-based applyProjection, to work around header dependency issue.

Definition at line 22 of file ProjectionApplier.cc.

                                                                                  {
    return evt.applyProjection(getProjection(name));
  }

const Projection & _applyProjection	(	const Event &	evt,
		const Projection &	proj
	)		const `[protected]`

Non-templated version of proj-based applyProjection, to work around header dependency issue.

Definition at line 28 of file ProjectionApplier.cc.

                                                                                      {
    return evt.applyProjection(proj);
  }

const Projection & _declareProjection	(	const Projection &	proj,
		const std::string &	name
	)		`[protected]`

Untemplated function to do the work...

Definition at line 34 of file ProjectionApplier.cc.

                                                                             {
    if (!_allowProjReg) {
      cerr << "Trying to register projection '"
           << proj.name() << "' before init phase in '" << this->name() << "'." << endl;
      exit(2);
    }
    const Projection& reg = getProjHandler().registerProjection(*this, proj, name);
    return reg;
  }

const PROJ& addProjection	(	const PROJ &	proj,
		const std::string &	name
	)		`[inline, protected]`

Register a contained projection (user-facing version)

Deprecated:: Use declareProjection() or declare()

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 157 of file ProjectionApplier.hh.

{ return declareProjection(proj, name); }

const PROJ& apply	(	const Event &	evt,
		const Projection &	proj
	)		const `[inline]`

Apply the supplied projection on event evt (user-facing alias).

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 80 of file ProjectionApplier.hh.

{ return applyProjection<PROJ>(evt, proj); }

const PROJ& apply	(	const Event &	evt,
		const PROJ &	proj
	)		const `[inline]`

Apply the supplied projection on event evt (user-facing alias).

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 92 of file ProjectionApplier.hh.

{ return applyProjection<PROJ>(evt, proj); }

const PROJ& apply	(	const Event &	evt,
		const std::string &	name
	)		const `[inline]`

Apply the supplied projection on event evt (user-facing alias).

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 104 of file ProjectionApplier.hh.

{ return applyProjection<PROJ>(evt, name); }

const PROJ& applyProjection	(	const Event &	evt,
		const Projection &	proj
	)		const `[inline]`

Apply the supplied projection on event evt.

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 74 of file ProjectionApplier.hh.

                                                                                {
      return pcast<PROJ>(_applyProjection(evt, proj));
    }

const PROJ& applyProjection	(	const Event &	evt,
		const PROJ &	proj
	)		const `[inline]`

Apply the supplied projection on event evt.

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 86 of file ProjectionApplier.hh.

                                                                          {
      return pcast<PROJ>(_applyProjection(evt, proj));
    }

const PROJ& applyProjection	(	const Event &	evt,
		const std::string &	name
	)		const `[inline]`

Apply the named projection on event evt.

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 98 of file ProjectionApplier.hh.

                                                                               {
      return pcast<PROJ>(_applyProjection(evt, name));
    }

const PROJ& declare	(	const PROJ &	proj,
		const std::string &	name
	)		`[inline, protected]`

Register a contained projection (user-facing version)

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 151 of file ProjectionApplier.hh.

{ return declareProjection(proj, name); }

const PROJ& declareProjection	(	const PROJ &	proj,
		const std::string &	name
	)		`[inline, protected]`

Register a contained projection.

The type of the argument is used to instantiate a new projection internally: this new object is applied to events rather than the argument object. Hence you are advised to only use locally-scoped Projection objects in your Projection and Analysis constructors, and to avoid polymorphism (e.g. handling ConcreteProjection via a pointer or reference to type Projection) since this will screw up the internal type management.

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 142 of file ProjectionApplier.hh.

                                                                           {
      const Projection& reg = _declareProjection(proj, name);
      const PROJ& rtn = dynamic_cast<const PROJ&>(reg);
      return rtn;
    }

const PROJ& get ( const std::string & name ) const [inline]

Get the named projection, specifying return type via a template argument (user-facing alias).

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 57 of file ProjectionApplier.hh.

{ return getProjection<PROJ>(name); }

Log& getLog ( ) const [inline, protected]

Reimplemented in Analysis, and Projection.

Definition at line 116 of file ProjectionApplier.hh.

                        {
      return Log::getLog("Rivet.ProjectionHandler");
    }

const PROJ& getProjection ( const std::string & name ) const [inline]

Get the named projection, specifying return type via a template argument.

Todo:: Add SFINAE to require that PROJ inherit from Projection

Definition at line 50 of file ProjectionApplier.hh.

                                                           {
      const Projection& p = getProjHandler().getProjection(*this, name);
      return pcast<PROJ>(p);
    }

const Projection& getProjection ( const std::string & name ) const [inline]

Get the named projection (non-templated, so returns as a reference to a Projection base class).

Definition at line 61 of file ProjectionApplier.hh.

                                                                 {
      return getProjHandler().getProjection(*this, name);
    }

std::set<ConstProjectionPtr> getProjections ( ) const [inline]

Get the contained projections, including recursion.

Definition at line 43 of file ProjectionApplier.hh.

                                                      {
      return getProjHandler().getChildProjections(*this, ProjectionHandler::DEEP);
    }

ProjectionHandler& getProjHandler ( ) const [inline, protected]

Get a reference to the ProjectionHandler for this thread.

Definition at line 122 of file ProjectionApplier.hh.

                                              {
      return _projhandler;
    }

void markAsOwned ( ) const [inline]

Mark object as owned by the _projhandler

Todo:: Huh? What's this for?

Definition at line 111 of file ProjectionApplier.hh.

{ _owned = true; }

virtual std::string name ( ) const [pure virtual]

Get the name of this Projection or Analysis class.

Implemented in Analysis, and Projection.

Member Data Documentation

bool _allowProjReg [protected]

Flag to forbid projection registration in analyses until the init phase.

Definition at line 176 of file ProjectionApplier.hh.

bool _owned [mutable, private]

Mark object as owned by the _projhandler.

Definition at line 182 of file ProjectionApplier.hh.

ProjectionHandler& _projhandler [private]

Pointer to projection handler.

Definition at line 185 of file ProjectionApplier.hh.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation