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/Utilities/interface/FunctionWithDict.h"
#include "FWCore/Utilities/interface/MemberWithDict.h"
#include "FWCore/Utilities/interface/ObjectWithDict.h"
#include "FWCore/Utilities/interface/TypeID.h"

#include <boost/shared_ptr.hpp>
#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 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;
};

} // namesapce parser
} // namespace reco

#endif // CommonTools_Utils_MethodInvoker_h