MethodInvoker.h

Go to the documentation of this file.

#ifndef CommonTools_Utils_MethodInvoker_h
#define CommonTools_Utils_MethodInvoker_h
#include "Reflex/Object.h"
#include "Reflex/Member.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 Reflex::Member & method,
                 const std::vector<AnyMethodArgument>    & ints   = std::vector<AnyMethodArgument>() );
      MethodInvoker(const MethodInvoker &); 

      Reflex::Object
      invoke(const Reflex::Object & o, Reflex::Object &retstore) const;
      const Reflex::Member & method() const { return method_; }
      MethodInvoker & operator=(const MethodInvoker &);
    private:
      Reflex::Member method_;
      std::vector<AnyMethodArgument> ints_; // already fixed to the correct type
      std::vector<void*> args_;
      bool isFunction_;
      void setArgs();
    };

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

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


    struct LazyInvoker {
      explicit LazyInvoker(const std::string &name,
               const std::vector<AnyMethodArgument> &args);
      ~LazyInvoker();
      Reflex::Object invoke(const Reflex::Object & o, std::vector<Reflex::Object> &v) const;
      double invokeLast(const Reflex::Object & o, std::vector<Reflex::Object> &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<void *, SingleInvokerPtr> invokers_;        // otherwise I think it could leak if the constructor of
      const SingleInvoker & invoker(const Reflex::Type &t) const ; // SingleInvoker throws an exception (which can happen)
    };

  }
}

#endif