alcommon/almodulecore.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALMODULECORE_H_
#define _LIBALCOMMON_ALCOMMON_ALMODULECORE_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/alparamtype.h>
# include <alerror/alerror.h>
# include <alcommon/alfunctor.h>
# include <map>

# define BIND_OBJ_METHOD(objptr, meth)                          \
  {                                                             \
    completeAndCheck(&meth, getCurrentMethodDescription());     \
    bindMethod(createFunctor(objptr, &meth));                   \
  }

# define BIND_METHOD(x) BIND_OBJ_METHOD(this, x)

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

  class ALModuleCore: public ::boost::enable_shared_from_this<ALModuleCore>, public ::boost::noncopyable
  {
    friend class baseModule;
  private:
    boost::shared_ptr<ALModuleCoreImpl> fImpl;

  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> 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();

  protected:
    virtual void init(void) {}

    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);
  };  // !ALModuleCore
}
#endif  // _LIBALCOMMON_ALCOMMON_ALMODULECORE_H_