alproxy.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALPROXY_H_
#define _LIBALCOMMON_ALCOMMON_ALPROXY_H_

# include <alcommon/api.h>
# include <alcommon/almoduleinfo.h>
# include <alcommon/almodule.h>
# include <alvalue/alvalue.h>
# include <alerror/alerror.h>

# include <boost/shared_ptr.hpp>
# include <boost/smart_ptr/enable_shared_from_this.hpp>
# include <qi/anyobject.hpp>
# include <qi/session.hpp>

#ifdef _WIN32
# pragma warning(disable:4996)
# pragma warning(disable:4800)
#endif

namespace AL
{



  class ALProxyPrivate;

  class ALCOMMON_API ALProxy : public ::boost::enable_shared_from_this<ALProxy>
  {
  public:
    typedef boost::shared_ptr<ALProxy> Ptr;
    typedef boost::weak_ptr<ALProxy>   WeakPtr;

    typedef int (*onFinishedCallback)(const char*, int, const AL::ALValue &);

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

    enum pProxyOption
      {
        NO_OPTION       = 0, 
        FORCED_LOCAL    = 1, 
        NO_LOAD_DEPENDS = 2, 
        MAIN_PROXY      = 4  
      };

    ALProxy(boost::shared_ptr<ALBroker> pBroker,
            const std::string &pModuleName,
            int pProxyMask = 0,
            int timeout = 0);

    ALProxy(const qi::SessionPtr& session, const std::string &serviceName);

    ALProxy(qi::AnyObject pObject, const std::string &pModuleName);

    ALProxy(const std::string &pModuleName,
            const std::string &pIp,
            int pPort,
            int pProxyMask = 0,
            int timeout = 0);

    ALProxy(const std::string &pModuleName,
            const std::string &pIp,
            int pPort,
            boost::shared_ptr<ALBroker> pBroker,
            int pProxyMask = 0,
            int timeout = 0);

    virtual ~ALProxy(void);

    // This is not copyable
    ALProxy(const ALProxy &rhs) = delete;
    ALProxy& operator=(const ALProxy &rhs) = delete;

    // This is movable
    // TODO VS2015: use default implementation
    ALProxy(ALProxy&& other);
    ALProxy& operator=(ALProxy&& other);

    std::string remoteBrokerName();

    AL::ALValue genericCall(const std::string &strMethodName,
                            const AL::ALValue &listParams);


    int genericPCall(const std::string  &strMethodName,
                     const AL::ALValue  &listParams,
                     onFinishedCallback pCallbackToCallOnFinished = NULL,
                     const char         *pszCallerName = NULL);

    std::string version();

    boost::shared_ptr<ALModule>     getModule() const;
    boost::shared_ptr<ALModuleCore> getModuleCore() const;

    int getInfo(ALModuleInfo &pModuleInfo);

    bool isLocal();

    bool isValid();

    boost::shared_ptr<ALFunctorBase> getFunctor(const std::string &pName,
                                                const std::vector<std::string> &pParamTypes);

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

    void destroyConnection(void);

    template <typename R>
    R call(const std::string &pName);

    template <typename R, typename P1>
    R call(const std::string &pName, const P1 &p1);

    template <typename R, typename P1, typename P2>
    R call(const std::string &pName, const P1 &p1, const P2 &p2);

    template <typename R, typename P1, typename P2, typename P3>
    R call(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3);

    template <typename R, typename P1, typename P2, typename P3, typename P4>
    R call(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4);

    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
    R call(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5);

    template <typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    R call(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6);

    inline void callVoid(const std::string &pName);

    template <typename P1>
    void callVoid(const std::string &pName, const P1 &p1);

    template <typename P1, typename P2>
    void callVoid(const std::string &pName, const P1 &p1, const P2 &p2);

    template <typename P1, typename P2, typename P3>
    void callVoid(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3);

    template <typename P1, typename P2, typename P3, typename P4>
    void callVoid(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4);

    template <typename P1, typename P2, typename P3, typename P4, typename P5>
    void callVoid(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5);

    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    void callVoid(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6);

    inline int pCall(const std::string &pName);

    template <typename P1>
    int pCall(const std::string &pName, const P1 &p1);

    template <typename P1, typename P2>
    int pCall(const std::string &pName, const P1 &p1, const P2 &p2);

    template <typename P1, typename P2, typename P3>
    int pCall(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3);

    template <typename P1, typename P2, typename P3, typename P4>
    int pCall(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4);

    template <typename P1, typename P2, typename P3, typename P4, typename P5>
    int pCall(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5);

    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
    int pCall(const std::string &pName, const P1 &p1, const P2 &p2, const P3 &p3, const P4 &p4, const P5 &p5, const P6 &p6);

    bool wait(const int &id, const int &timeoutPeriod);

    qi::FutureSync<void> wait(const int &id);

    void stop(const int &id);

    bool isRunning(const int &id);

    int pCallNotify(const std::string &name,
                    const std::string &key,
                    const ALValue &value,
                    const ALValue &message = std::string(),
                    std::pair<int, int>* cache = 0);

    std::string moduleName() const;

    qi::AnyObject asObject();

    std::unique_ptr<ALProxyPrivate> _p;
    qi::AnyWeakObject _object;
  protected:
    int xMetaPCall(const std::string &signature, const qi::GenericFunctionParameters &in);

    friend class AL::ALModuleCore;
  };  // ALProxy

  typedef boost::shared_ptr<ALProxy> ALProxyPtr;

  template<typename ProxyType>
  boost::shared_ptr<ProxyType> makeProxy(
      const qi::SessionPtr& session,
      const std::string& serviceName)
  {
    return boost::make_shared<ProxyType>(boost::make_shared<ALProxy>(session, serviceName));
  }
}   // namespace AL

#include <alcommon/alproxy.hxx>

#endif  // _LIBALCOMMON_ALCOMMON_ALPROXY_H_