/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/CommonTools/Utils/src/MethodInvoker.h

Go to the documentation of this file.

#ifndef CommonTools_Utils_MethodInvoker_h
#define CommonTools_Utils_MethodInvoker_h
#include "FWCore/Utilities/interface/ObjectWithDict.h"
#include "FWCore/Utilities/interface/FunctionWithDict.h"
#include "FWCore/Utilities/interface/MemberWithDict.h"
#include "FWCore/Utilities/interface/TypeID.h"
#include "CommonTools/Utils/src/AnyMethodArgument.h"
#include "CommonTools/Utils/src/TypeCode.h"
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
#include <vector>
#include <map>

namespace reco {
  namespace parser {

    struct MethodInvoker {
      explicit MethodInvoker(const edm::FunctionWithDict & method,
                             const std::vector<AnyMethodArgument>    & ints   = std::vector<AnyMethodArgument>() );
      explicit MethodInvoker(const edm::MemberWithDict & member);
      MethodInvoker(const MethodInvoker &); 

      edm::ObjectWithDict
      invoke(const edm::ObjectWithDict & o, edm::ObjectWithDict &retstore) const;
      edm::FunctionWithDict const method() const {return method_;}
      edm::MemberWithDict const member() const {return member_;}
      MethodInvoker & operator=(const MethodInvoker &);
      bool isFunction() const {return isFunction_;}
      std::string methodName() const;
      std::string returnTypeName() const;
    private:
      edm::FunctionWithDict method_;
      edm::MemberWithDict member_;
      std::vector<AnyMethodArgument> ints_; // already fixed to the correct type
      std::vector<void*> args_;
      bool isFunction_;
      void setArgs();
    };

    struct SingleInvoker : boost::noncopyable {
        SingleInvoker(const edm::TypeWithDict &t,
                      const std::string &name, 
                      const std::vector<AnyMethodArgument> &args)  ;
        ~SingleInvoker();

        std::pair<edm::ObjectWithDict,bool> invoke(const edm::ObjectWithDict & o, std::vector<edm::ObjectWithDict> &v) const;
        
        // convert the output of invoke to a double, if possible
        double retToDouble(const edm::ObjectWithDict & o) const;
        void   throwFailedConversion(const edm::ObjectWithDict & o) const;
      private:
        method::TypeCode            retType_;
        std::vector<MethodInvoker>  invokers_;
        mutable edm::ObjectWithDict      storage_;
        bool                        storageNeedsDestructor_;
        bool isRefGet_;
    };


    struct LazyInvoker {
      explicit LazyInvoker(const std::string &name,
                           const std::vector<AnyMethodArgument> &args);
      ~LazyInvoker();
      edm::ObjectWithDict invoke(const edm::ObjectWithDict & o, std::vector<edm::ObjectWithDict> &v) const;
      double invokeLast(const edm::ObjectWithDict & o, std::vector<edm::ObjectWithDict> &v) const;
    private:
      std::string name_;
      std::vector<AnyMethodArgument> argsBeforeFixups_;
      typedef boost::shared_ptr<SingleInvoker> SingleInvokerPtr; // the shared ptr is only to make the code exception safe
      mutable std::map<edm::TypeID, SingleInvokerPtr> invokers_;        // otherwise I think it could leak if the constructor of
      const SingleInvoker & invoker(const edm::TypeWithDict &t) const ; // SingleInvoker throws an exception (which can happen)
    };

  }
}

#endif