almodulecore.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALMODULECORE_H_
#define _LIBALCOMMON_ALCOMMON_ALMODULECORE_H_

# include <alcommon/api.h>
# include <boost/enable_shared_from_this.hpp>
# include <boost/shared_ptr.hpp>
# include <boost/noncopyable.hpp>

# include <alcommon/almoduleinfo.h>
# include <alcommon/almethodinfo.h>
# include <alcommon/alfunctor.h>

# include <alerror/alerror.h>
# include <qi/log.hpp>
# include <map>

#include <qitype/dynamicobject.hpp>
#include <qitype/signature.hpp>
#include <qitype/anyfunction.hpp>
#include <qitype/dynamicobjectbuilder.hpp>
#include <qitype/dynamicobject.hpp>

//legacy hell, LEGACY HELL
#define BIND_OBJ_METHOD(objptr, meth) _builder.advertiseMethod(_mBuilder, objptr, &meth)
#define BIND_METHOD(meth) _builder.advertiseMethod(_mBuilder, this, &meth)

#define BIND_OBJ_METHOD_PTR(objptr, methptr) _builder.advertiseMethod(_mBuilder, objptr, methptr)
#define BIND_METHOD_PTR(methptr) _builder.advertiseMethod(_mBuilder, this, methptr)

namespace AL
{
  class ALBroker;
  class ALProxy;
  class ALValue;
  class ALModuleCorePrivate;

  class ALModuleCore: public ::boost::enable_shared_from_this<ALModuleCore>, public ::boost::noncopyable, public qi::DynamicObject
  {
  public:
    typedef boost::shared_ptr<ALModuleCore>       Ptr;
    typedef boost::weak_ptr<ALModuleCore>         WeakPtr;

    enum ModuleType
      {
        CPP    = 0, 
        PYTHON = 1, 
        RUBY   = 2, 
        LUA    = 3, 
        MATLAB = 4, 
        URBI        
      };

    ALModuleCore(boost::shared_ptr<ALBroker> pBroker,
                 const std::string &pName);

    virtual ~ALModuleCore();

    ALMethodInfo& getCurrentMethodDescription();

    boost::shared_ptr<ALModuleCore> getThis();
    boost::shared_ptr<const ALModuleCore> getThis() const;

    bool isClosing();

    void initModule(void);

    boost::shared_ptr<AL::ALProxy> getProxy(const std::string &pModuleName);

    std::string getBrokerName();

    ModuleType getModuleType(void);

    void setModuleType(ModuleType pType);

    virtual ALMethodInfo* execute(const std::string &pMethod,
                                  const AL::ALValue &pParams,
                                  AL::ALValue &pResult);

    std::vector<std::string> getMethodList();

    AL::ALValue getMethodHelp(const std::string &pMethodName);

    ALMethodInfo getMethodHelpObject(const std::string &pMethodName);

    AL::ALValue moduleHelp();

    bool ping(void);

    virtual std::string version();

    virtual void exit();

    const std::string& getName() const;

    boost::shared_ptr<ALModuleInfo> getModuleInfo();

    virtual std::string httpGet();

    ALMethodInfo* getMethodInfoByNameMember(const std::string &pName,
                                            const std::vector<std::string> &paramType,
                                            bool softCompare = true);

    ALMethodInfo* getMethodInfo(const std::string &pName);

    ALMethodInfo* getMethodInfo(const std::string &pName,
                                std::vector<std::string> pParamsType);

    ALMethodInfo* getMethodInfo(const std::string &pName,
                                const AL::ALValue &pParams);

    ALMethodInfo* getFunctionDesc(const std::string &pName);

    ALMethodInfo* getFunctionDesc(const std::string &pName,
                                  std::vector<std::string> pParamsType);

    ALMethodInfo* getFunctionDesc(const std::string &pName,
                                  const AL::ALValue &pParams);

    ALMethodInfo* getFunctionDescByNameMember(const std::string &pName,
                                              const std::vector<std::string> &paramType,
                                              bool softCompare = true);

    boost::shared_ptr<ALBroker> getParentBroker() const;

    void functionStop(int pTaskID);


    void setModuleDescription(const std::string &pDesc);

    std::string getUsage(const std::string &methodName);

    template <class T>
    static boost::shared_ptr<T> createModuleCore(boost::shared_ptr<ALBroker> pBroker)
    {
      boost::shared_ptr<T> module = boost::shared_ptr<T>(new T(pBroker));
      module->initModule();  // register module in broker
      try
      {
        // we call init on a ALModule::Ptr as init may be protected
        // init is a virtual method that can be reimplemented
        (boost::static_pointer_cast<ALModuleCore>(module))->init();
      }
      catch(const ALError& e)
      {
        module->exit();
        throw(e);
      }
      return module;
    }

    template <class T>
    static boost::shared_ptr<T> createModuleCoreNoRegister(boost::shared_ptr<ALBroker> pBroker, const std::string &name)
    {
      boost::shared_ptr<T> module = boost::shared_ptr<T>(new T(pBroker, name));
      //module->initModule();  // register module in broker
      try
      {
        // we call init on a ALModule::Ptr as init may be protected
        // init is a virtual method that can be reimplemented
        (boost::static_pointer_cast<ALModuleCore>(module))->init();
      }
      catch(const ALError& e)
      {
        module->exit();
        throw(e);
      }
      return module;
    }

    template <class T>
    static boost::shared_ptr<T> createModuleCore(boost::shared_ptr<ALBroker> pBroker,
                                                 const std::string &name)
    {
      boost::shared_ptr<T> module = boost::shared_ptr<T>(new T(pBroker, name));
      module->initModule();
      try
      {
        // init if you redefined it
        (boost::static_pointer_cast<ALModuleCore>(module))->init();
      }
      catch(const ALError& e)
      {
        module->exit();
        throw(e);
      }
      return module;
    }

    template <class T>
    static boost::shared_ptr<T> createUrbiModule(boost::shared_ptr<ALBroker> pBroker,
                                                 const std::string &name)
    {
      boost::shared_ptr<T> module = createModuleCore<T>(pBroker, name);
      module->setModuleType(AL::ALModuleCore::URBI);
      return module;
    }

    bool isModuleStopped();

    void setModuleID(int id);

    int getModuleID();

    void bindMethod(boost::shared_ptr<ALFunctorBase> pFunctor);

    void bindMethod(boost::shared_ptr<ALFunctorBase> pFunctor,
                    const std::string &pName,
                    const std::string &pClass,
                    const std::string &pFunctionDescription,
                    const ALMethodInfo &pMethodDescription);

    void bindMethodOverload(boost::shared_ptr<ALFunctorBase> pFunctor);

    void functionName(const std::string &pName,
                      const std::string &pClass,
                      const std::string &pFunctionDescription,
                      int pMask = 0);

    void addParam(const std::string &pName,
                  const std::string &pDesc);

    void addModuleExample(const std::string &pLanguage,
                          const std::string &pExample);

    void addMethodExample(const std::string &pLanguage,
                          const std::string &pExample);

    void setReturn(const std::string &pName, const std::string &pDesc);

    virtual qi::Future<qi::AnyReference> metaCall(qi::AnyObject context, unsigned int method, const qi::GenericFunctionParameters &in, qi::MetaCallType callType, qi::Signature returnSignature);


    qi::AnyObject asObject();

    qi::DynamicObjectBuilder& getBuilder() {return _builder;};


    int pCall(const qi::AnyArguments& args);

  protected:
    virtual void init(void) {}

  private:
    int _pCall(const unsigned int &methodId, const std::vector<qi::AnyValue> &args);

  protected:
    qi::DynamicObjectBuilder _builder;
    friend class baseModule; // for inaoqi that needs to advertise methods
  public:
    qi::GenericObject _go;
    ALModuleCorePrivate *_p;
    qi::MetaMethodBuilder _mBuilder;

  };  // !ALModuleCore
}

#endif  // _LIBALCOMMON_ALCOMMON_ALMODULECORE_H_