reco::parser::MethodSetter Class Reference

#include <MethodSetter.h>

Public Member Functions
	MethodSetter (MethodStack &methStack, LazyMethodStack &lazyMethStack, TypeStack &typeStack, MethodArgumentStack &intStack, bool lazy=false)
void	operator() (const char *, const char *) const
bool	push (const std::string &, const std::vector< AnyMethodArgument > &, const char *, bool deep=true) const

Private Attributes
MethodArgumentStack &	intStack_
bool	lazy_
LazyMethodStack &	lazyMethStack_
MethodStack &	methStack_
TypeStack &	typeStack_

Detailed Description

Definition at line 17 of file MethodSetter.h.

Constructor & Destructor Documentation

MethodSetter()

reco::parser::MethodSetter::MethodSetter ( MethodStack &  methStack, LazyMethodStack &  lazyMethStack, TypeStack &  typeStack, MethodArgumentStack &  intStack, bool  lazy = false  )

inlineexplicit

Definition at line 26 of file MethodSetter.h.

          : methStack_(methStack),
            lazyMethStack_(lazyMethStack),
            typeStack_(typeStack),
            intStack_(intStack),
            lazy_(lazy) {}

Member Function Documentation

operator()()

void MethodSetter::operator()	(	const char *	begin,
		const char *	end
	)		const

Definition at line 15 of file MethodSetter.cc.

References writedatasetfile::args, Exception, mps_fire::i, Skims_PA_cff::name, and edm_modernize_messagelogger::parenthesis.

                                                                      {
  string name(begin, end);
  string::size_type parenthesis = name.find_first_of('(');
  if ((*begin == '[') || (*begin == '(')) {
    name.insert(0, "operator..");     // operator..[arg];
    parenthesis = 10;                 //           ^--- idx = 10
    name[8] = *begin;                 // operator[.[arg];
    name[9] = name[name.size() - 1];  // operator[][arg];
    name[10] = '(';                   // operator[](arg];
    name[name.size() - 1] = ')';      // operator[](arg);
    // we don't actually need the last two, but just for extra care
    //std::cout << "Transformed {" << string(begin,end) << "} into
    //  {"<< name <<"}" << std::endl;
  }
  std::vector<AnyMethodArgument> args;
  if (parenthesis != string::npos) {
    name.erase(parenthesis, name.size());
    if (intStack_.empty()) {
      throw Exception(begin) << "expected method argument, but non given.";
    }
    for (vector<AnyMethodArgument>::const_iterator i = intStack_.begin(); i != intStack_.end(); ++i) {
      args.push_back(*i);
    }
    intStack_.clear();
  }
  string::size_type endOfExpr = name.find_last_of(' ');
  if (endOfExpr != string::npos) {
    name.erase(endOfExpr, name.size());
  }
  //std::cerr << "Pushing [" << name << "] with " << args.size()
  //  << " args " << (lazy_ ? "(lazy)" : "(immediate)") << std::endl;
  if (lazy_) {
    // for lazy parsing we just push method name and arguments
    lazyMethStack_.push_back(LazyInvoker(name, args));
  } else {
    // otherwise we really have to resolve the method
    push(name, args, begin);
  }
  //std::cerr << "Pushed [" << name << "] with " << args.size() <<
  //  " args " << (lazy_ ? "(lazy)" : "(immediate)") << std::endl;
}

push()

bool MethodSetter::push	(	const std::string &	,
		const std::vector< AnyMethodArgument > &	,
		const char *	,
		bool	deep = true
	)		const

Resolve the name to either a function member or a data member, push a MethodInvoker on the MethodStack, and its return type to the TypeStack (after stripping "*" and "&").

This method is used also by the LazyInvoker to perform the fetch once the final type is known.

If the object is an edm::Ref/Ptr/RefToBase and the method is not found in the class:

1) it pushes a no-argument 'get()' method

2) if deep = true, it attempts to resolve and push the method on the object to which the edm ref points to. In that case, the MethodStack will contain two more items after this call instead of just one. This behaviour is what you want for non-lazy parsing.

2b) if instead deep = false, it just pushes the 'get' on the stack. this will allow the LazyInvoker to then re-discover the runtime type of the pointee

The method will:

• throw exception, if the member can't be resolved
• return 'false' if deep = false and it only pushed - return true otherwise

Definition at line 57 of file MethodSetter.cc.

References writedatasetfile::args, relativeConstraints::error, Exception, f, reco::findDataMember(), reco::findMethod(), stringResolutionProvider_cfi::functions, reco::parser::kIsNotConst, reco::parser::kIsNotPublic, reco::parser::kIsStatic, reco::parser::kNameDoesNotExist, reco::parser::kWrongArgumentType, reco::parser::kWrongNumberOfArguments, visualization-live-secondInstance_cfg::m, mem, Skims_PA_cff::name, reco::returnType(), and edm::MemberWithDict::typeOf().

Referenced by reco::parser::SingleInvoker::SingleInvoker(), esMonitoring.LineHistoryEnd::write(), and esMonitoring.LineHistoryStart::write().

                                                                                                                     {
  edm::TypeWithDict type = typeStack_.back();
  vector<AnyMethodArgument> fixups;
  int error = 0;
  pair<edm::FunctionWithDict, bool> mem = reco::findMethod(type, name, args, fixups, begin, error);
  if (bool(mem.first)) {
    // We found the method.
    edm::TypeWithDict retType = reco::returnType(mem.first);
    if (!bool(retType)) {
      // Invalid return type, fatal error, throw.
      throw Exception(begin) << "member \"" << mem.first.name() << "\" return type is invalid:\n"
                             << "  return type: \"" << mem.first.typeName() << "\"\n";
    }
    typeStack_.push_back(retType);
    // check for edm::Ref, edm::RefToBase, edm::Ptr
    if (mem.second) {
      // Without fixups.
      //std::cout << "Mem.second, so book " << mem.first.name() <<
      //  " without fixups." << std::endl;
      methStack_.push_back(MethodInvoker(mem.first));
      if (!deep) {
        return false;
      }
      // note: we have not found the method, so we have not
      // fixupped the arguments
      push(name, args, begin);
    } else {
      // With fixups.
      //std::cout << "Not mem.second, so book " << mem.first.name()
      //  << " with #args = " << fixups.size() << std::endl;
      methStack_.push_back(MethodInvoker(mem.first, fixups));
    }
    return true;
  }
  if (error != reco::parser::kNameDoesNotExist) {
    // Fatal error, throw.
    switch (error) {
      case reco::parser::kIsNotPublic:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name()
                               << "\" is not publically accessible.";
        break;
      case reco::parser::kIsStatic:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name() << "\" is static.";
        break;
      case reco::parser::kIsNotConst:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name() << "\" is not const.";
        break;
      case reco::parser::kWrongNumberOfArguments:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name()
                               << "\" was passed the wrong number of arguments.";
        break;
      case reco::parser::kWrongArgumentType:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name()
                               << "\" was passed the wrong types of arguments.";
        break;
      default:
        throw Exception(begin) << "method named \"" << name << "\" for type \"" << type.name()
                               << "\" is not usable in this context.";
    }
  }
  // Not a method, check for a data member.
  error = 0;
  edm::MemberWithDict member(reco::findDataMember(type, name, error));
  if (!bool(member)) {
    // Not a data member either, fatal error, throw.
    switch (error) {
      case reco::parser::kNameDoesNotExist: {
        Exception ex(begin);
        ex << "no method or data member named \"" << name << "\" found for type \"" << type.name() << "\"\n";
        // The following information is for temporary debugging only, intended to be removed later
        ex << "It has the following methods\n";
        edm::TypeFunctionMembers functions(type);
        for (auto const& f : functions) {
          ex << " " << f->GetName() << "\n";
        }
        ex << "and the following data members\n";
        edm::TypeDataMembers members(type);
        for (auto const& m : members) {
          ex << " " << m->GetName() << "\n";
        }
        throw ex;
      } break;
      case reco::parser::kIsNotPublic:
        throw Exception(begin) << "data member named \"" << name << "\" for type \"" << type.name()
                               << "\" is not publically accessible.";
        break;
      default:
        throw Exception(begin) << "data member named \"" << name << "\" for type \"" << type.name()
                               << "\" is not usable in this context.";
        break;
    }
  }
  // Ok, it was a data member.
  typeStack_.push_back(member.typeOf());
  methStack_.push_back(MethodInvoker(member));
  return true;
}

Member Data Documentation

intStack_

MethodArgumentStack& reco::parser::MethodSetter::intStack_

private

Definition at line 22 of file MethodSetter.h.

lazy_

bool reco::parser::MethodSetter::lazy_

private

Definition at line 23 of file MethodSetter.h.

lazyMethStack_

LazyMethodStack& reco::parser::MethodSetter::lazyMethStack_

private

Definition at line 20 of file MethodSetter.h.

methStack_

MethodStack& reco::parser::MethodSetter::methStack_

private

Definition at line 19 of file MethodSetter.h.

typeStack_

TypeStack& reco::parser::MethodSetter::typeStack_

private

Definition at line 21 of file MethodSetter.h.