alcommon/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/almoduleinfo.h>
# include <alvalue/alvalue.h>

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

# include <qi/macro.hpp>

# define BROKERMASK_KEEPALIVE     1  
# define BROKERMASK_LIGHT         2  
# define BROKERMASK_NOSERVER      4  
# define BROKERMASK_NOHEARTBEAT   8  
# define BROKERMASK_WITHALNETWORK 16 
namespace AL
{
  class ALMemoryProxy;
  class ALLedsProxy;
  class ALLoggerProxy;
  class ALMotionProxy;
  class ALPreferencesProxy;
  class DCMProxy;

  class ALTask;
  class ALModuleCore;
  class ALProxy;
  class ALBrokerManager;
  class ALBrokerInfo;
  class ALBrokerImpl;

  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 registerModule(boost::shared_ptr<ALModuleCore> pModule);

    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;

    int shutdown();

    std::string getName() const;

    std::string getIP() const;

    int getPort() const;

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

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

    QI_API_DEPRECATED boost::shared_ptr<ALMemoryProxy> getMemoryProxy(void);

    QI_API_DEPRECATED boost::shared_ptr<ALLedsProxy> getLedsProxy(void);

    QI_API_DEPRECATED boost::shared_ptr<ALLoggerProxy> getLoggerProxy(void);

    QI_API_DEPRECATED boost::shared_ptr<ALMotionProxy> getMotionProxy(void);

    QI_API_DEPRECATED boost::shared_ptr<ALPreferencesProxy> getPreferencesProxy(void);

    QI_API_DEPRECATED boost::shared_ptr<DCMProxy> getDcmProxy(void);

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

  public:
    boost::weak_ptr<ALBrokerManager> fBrokerManager;

    ALBrokerImpl *_private;

  };

} // !namespace AL

#endif  // _LIBALCOMMON_ALCOMMON_ALBROKER_H_