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 {
      tbb::tbb_hash<std::string> hasher;
      return hasher(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