MethodInvoker.h

Go to the documentation of this file.

#ifndef CommonTools_Utils_MethodInvoker_h
#define CommonTools_Utils_MethodInvoker_h
 
#include "CommonTools/Utils/src/AnyMethodArgument.h"
#include "CommonTools/Utils/src/TypeCode.h"
#include "FWCore/Reflection/interface/FunctionWithDict.h"
#include "FWCore/Reflection/interface/MemberWithDict.h"
#include "FWCore/Reflection/interface/ObjectWithDict.h"
#include "FWCore/Utilities/interface/TypeID.h"
 
#include <boost/utility.hpp>
 
#include <map>
#include <vector>
 
#include "tbb/concurrent_unordered_map.h"
 
namespace edm {
  struct TypeIDHasher {
    size_t operator()(TypeID const& tid) const { return std::hash<std::string>{}(std::string(tid.name())); }
  };
}  // namespace edm
 
namespace reco {
  namespace parser {
 
    class MethodInvoker {
    private:  // Private Data Members
      edm::FunctionWithDict method_;
      edm::MemberWithDict member_;
      std::vector<AnyMethodArgument> ints_;  // already fixed to the correct type
      std::vector<void*> args_;
 
      bool isFunction_;
      edm::TypeWithDict retTypeFinal_;
 
    private:  // Private Function Members
      void setArgs();
 
    public:  // Public Function Members
      explicit MethodInvoker(const edm::FunctionWithDict& method,
                             const std::vector<AnyMethodArgument>& ints = std::vector<AnyMethodArgument>());
      explicit MethodInvoker(const edm::MemberWithDict&);
      MethodInvoker(const MethodInvoker&);
      MethodInvoker& operator=(const MethodInvoker&);
 
      edm::FunctionWithDict const method() const { return method_; }
      edm::MemberWithDict const member() const { return member_; }
      bool isFunction() const { return isFunction_; }
      std::string methodName() const;
      std::string returnTypeName() const;
 
      edm::ObjectWithDict invoke(const edm::ObjectWithDict& obj, edm::ObjectWithDict& retstore) const;
    };
 
    struct SingleInvoker : boost::noncopyable {
    private:  // Private Data Members
      method::TypeCode retType_;
      std::vector<MethodInvoker> invokers_;
      mutable edm::ObjectWithDict storage_;
      bool storageNeedsDestructor_;
      bool isRefGet_;
 
    public:
      SingleInvoker(const edm::TypeWithDict&, 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;
 
      double retToDouble(const edm::ObjectWithDict&) const;
 
      void throwFailedConversion(const edm::ObjectWithDict&) const;
    };
 
    struct LazyInvoker {
      typedef std::shared_ptr<SingleInvoker> SingleInvokerPtr;
      typedef tbb::concurrent_unordered_map<edm::TypeID, SingleInvokerPtr, edm::TypeIDHasher> InvokerMap;
 
    private:  // Private Data Members
      std::string name_;
      std::vector<AnyMethodArgument> argsBeforeFixups_;
      // the shared ptr is only to make the code exception safe
      // otherwise I think it could leak if the constructor of
      // SingleInvoker throws an exception (which can happen)
      mutable InvokerMap invokers_;
 
    private:  // Private Function Members
      const SingleInvoker& invoker(const edm::TypeWithDict&) const;
 
    public:  // Public Function Members
      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;
    };
 
  }  // namespace parser
}  // namespace reco
 
#endif  // CommonTools_Utils_MethodInvoker_h