#include <MethodInvoker.h>

Public Member Functions
std::pair< edm::ObjectWithDict, bool >	invoke (const edm::ObjectWithDict &o, std::vector< edm::ObjectWithDict > &v) const

SingleInvoker &	operator= (const SingleInvoker &)=delete

double	retToDouble (const edm::ObjectWithDict &) const
	convert the output of invoke to a double, if possible More...

	SingleInvoker (const SingleInvoker &)=delete

	SingleInvoker (const edm::TypeWithDict &, const std::string &name, const std::vector< AnyMethodArgument > &args)

void	throwFailedConversion (const edm::ObjectWithDict &) const

	~SingleInvoker ()

Private Attributes
std::vector< MethodInvoker >	invokers_

bool	isRefGet_
	true if this invoker just pops out a ref and returns (ref.get(), false) More...

method::TypeCode	retType_

edm::ObjectWithDict	storage_

bool	storageNeedsDestructor_

Detailed Description

A bigger brother of the MethodInvoker:

it owns also the object in which to store the result
it handles by itself the popping out of Refs and Ptrs in this way, it can map 1-1 to a name and set of args

Definition at line 63 of file MethodInvoker.h.

Constructor & Destructor Documentation

reco::parser::SingleInvoker::SingleInvoker ( const SingleInvoker & )

delete

SingleInvoker::SingleInvoker	(	const edm::TypeWithDict &	type,
		const std::string &	name,
		const std::vector< AnyMethodArgument > &	args
	)

Definition at line 188 of file MethodInvoker.cc.

References invokers_, isRefGet_, reco::parser::ExpressionVar::makeStorage(), reco::parser::MethodSetter::push(), retType_, storage_, storageNeedsDestructor_, and reco::typeCode().

                                                                        {
   TypeStack typeStack(1, type);
   LazyMethodStack dummy;
   MethodArgumentStack dummy2;
   MethodSetter setter(invokers_, dummy, typeStack, dummy2, false);
   isRefGet_ = !setter.push(name, args, "LazyInvoker dynamic resolution", false);
   //std::cerr  << "SingleInvoker on type " <<  type.qualifiedName() <<
   //  ", name " << name << (isRefGet_ ? " is just a ref.get " : " is real") <<
   //  std::endl;
   if (invokers_.front().isFunction()) {
     edm::TypeWithDict retType = invokers_.front().method().finalReturnType();
     storageNeedsDestructor_ = ExpressionVar::makeStorage(storage_, retType);
   } else {
     storage_ = edm::ObjectWithDict();
     storageNeedsDestructor_ = false;
   }
   // typeStack[0] = type of self
   // typeStack[1] = type of ret
   retType_ = reco::typeCode(typeStack[1]);
 }

SingleInvoker::~SingleInvoker ( )

Definition at line 211 of file MethodInvoker.cc.

References reco::parser::ExpressionVar::delStorage(), and storage_.

211 { ExpressionVar::delStorage(storage_); }

reco::parser::SingleInvoker::storage_

edm::ObjectWithDict storage_

Definition: MethodInvoker.h:67

reco::parser::ExpressionVar::delStorage

static void delStorage(edm::ObjectWithDict &)

Definition: ExpressionVar.cc:45

Member Function Documentation

pair< edm::ObjectWithDict, bool > SingleInvoker::invoke	(	const edm::ObjectWithDict &	o,
		std::vector< edm::ObjectWithDict > &	v
	)		const

If the member is found in object o, evaluate and return (value,true) If the member is not found but o is a Ref/RefToBase/Ptr, (return o.get(), false) the actual edm::ObjectWithDict where the result is stored will be pushed in vector so that, if needed, its destructor can be called

Definition at line 213 of file MethodInvoker.cc.

References invokers_, isRefGet_, runTheMatrix::ret, storage_, and storageNeedsDestructor_.

Referenced by reco::parser::LazyInvoker::invoke(), and reco::parser::LazyInvoker::invokeLast().

                                                                                              {
   // std::cerr << "[SingleInvoker::invoke] member " <<
   //   invokers_.front().method().qualifiedName() <<
   //   " of type " <<
   //   o.typeOf().qualifiedName() <<
   //   (!isRefGet_ ? " is one shot" : " needs another round") <<
   //   std::endl;
   pair<edm::ObjectWithDict, bool> ret(invokers_.front().invoke(o, storage_), !isRefGet_);
   if (storageNeedsDestructor_) {
     //std::cerr << "Storage type: " << storage_.typeOf().qualifiedName() <<
     //  ", I have to call the destructor." << std::endl;
     v.push_back(storage_);
   }
   return ret;
 }

SingleInvoker& reco::parser::SingleInvoker::operator= ( const SingleInvoker & )

delete

double SingleInvoker::retToDouble ( const edm::ObjectWithDict & o ) const

convert the output of invoke to a double, if possible

Definition at line 230 of file MethodInvoker.cc.

References reco::parser::ExpressionVar::isValidReturnType(), reco::parser::ExpressionVar::objToDouble(), retType_, and throwFailedConversion().

Referenced by reco::parser::LazyInvoker::invokeLast().

                                                                   {
   if (!ExpressionVar::isValidReturnType(retType_)) {
     throwFailedConversion(o);
   }
   return ExpressionVar::objToDouble(o, retType_);
 }

void SingleInvoker::throwFailedConversion ( const edm::ObjectWithDict & o ) const

Definition at line 237 of file MethodInvoker.cc.

References edm::errors::Configuration, Exception, invokers_, edm::TypeWithDict::qualifiedName(), and edm::ObjectWithDict::typeOf().

Referenced by retToDouble().

                                                                           {
   throw edm::Exception(edm::errors::Configuration)
       << "member \"" << invokers_.back().methodName() << "\" return type is \"" << invokers_.back().returnTypeName()
       << "\" retured a \"" << o.typeOf().qualifiedName() << "\" which is not convertible to double.";
 }