albroker.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALBROKER_H_
#define _LIBALCOMMON_ALCOMMON_ALBROKER_H_

# include <list>
# include <map>

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

# include <boost/shared_ptr.hpp>
# include <boost/smart_ptr/enable_shared_from_this.hpp>
# include <boost/noncopyable.hpp>

//needed because templated code initialize an ALProxy in this file
# include <alcommon/alproxy.h>

# include <qi/macro.hpp>
# include <qi/session.hpp>

# define BROKERMASK_KEEPALIVE     1  
# define BROKERMASK_LIGHT         2  
# define BROKERMASK_NOSERVER      4  
# define BROKERMASK_NOHEARTBEAT   8  
# define BROKERMASK_WITHALNETWORK 16 
namespace AL
{
  class ALTask;
  class ALModuleCore;
  class ALBrokerManager;
  class ALBrokerInfo;

  class ALBrokerPrivate;
  class ALBroker : public ::boost::enable_shared_from_this<ALBroker>, public ::boost::noncopyable
  {
  public:
    typedef boost::shared_ptr<ALBroker> Ptr;
    typedef boost::weak_ptr<ALBroker>   WeakPtr;

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

    ALBroker();

    virtual ~ALBroker(void);

    void setBrokerManagerInstance(boost::shared_ptr<ALBrokerManager> pBrokerManager);

    boost::shared_ptr<ALModuleCore> getModuleByName(const std::string &pModuleName);

    int unregisterModule(const std::string &pModuleName);

    bool isModulePresent(const std::string &pModuleName);

    int getModuleList(boost::shared_ptr<std::vector<ALModuleInfo> > pModuleList);

    int getBrokerList(std::vector<ALModuleInfo> &pBrokerList);

    int getGlobalModuleList(boost::shared_ptr<std::vector<ALModuleInfo> > pModuleList);


    bool isExiting() const;

    bool isConnected();

    int shutdown();

    std::string getName() const;

    std::string getIP() const;

    int getPort() const;

    std::string getParentIP() const;

    int getParentPort() const;

    boost::shared_ptr<ALProxy> getProxy(const std::string &pProxyName, int deprecated = 0);

    std::string httpGet(const std::string &pPath);


    template <typename T>
    boost::shared_ptr<T> getSpecialisedProxy(const std::string &name = std::string()) {
      //if (name.empty())
        //return boost::shared_ptr<T>(new T(getThis()));
      //else
      return boost::shared_ptr<T>(new T(getProxy(name)));
    }

    #define getMemoryProxy()      getSpecialisedProxy<AL::ALMemoryProxy>("ALMemory")

    #define getLedsProxy()        getSpecialisedProxy<AL::ALLedsProxy>("ALLeds")

    #define getLoggerProxy()      getSpecialisedProxy<AL::ALLoggerProxy>("ALLogger")

    #define getMotionProxy()      getSpecialisedProxy<AL::ALMotionProxy>("ALMotion")

    #define getPreferencesProxy() getSpecialisedProxy<AL::ALPreferencesProxy>("ALPreferences")

    #define getDcmProxy()         getSpecialisedProxy<AL::DCMProxy>("DCM")


    static boost::shared_ptr<ALBroker> createBroker(const std::string &pName,
                                                    const std::string &pIP,
                                                    int pPort,
                                                    const std::string &pParentIP,
                                                    int pParentPort,
                                                    int pKeepAlive = 0,
                                                    std::string pPath = "",
                                                    bool pLoadLib = true);

    static boost::shared_ptr<ALBroker> createBroker(const std::string &name, qi::SessionPtr session);

    qi::SessionPtr session();
  public:
    boost::weak_ptr<ALBrokerManager> fBrokerManager;

    ALBrokerPrivate *_p;

  };

  typedef boost::shared_ptr<ALBroker> ALBrokerPtr;

} // !namespace AL


#endif  // _LIBALCOMMON_ALCOMMON_ALBROKER_H_