CAmCommonAPIWrapper.h

Go to the documentation of this file.

#ifndef COMMONAPIWRAPPER_H_
#define COMMONAPIWRAPPER_H_

#include <string>
#include <list>
#include <map>
#include <queue>
#include <memory>
#include <cassert>
#include <CommonAPI/CommonAPI.hpp>
#ifndef COMMONAPI_INTERNAL_COMPILATION
#define COMMONAPI_INTERNAL_COMPILATION
#include <CommonAPI/MainLoopContext.hpp>
#undef COMMONAPI_INTERNAL_COMPILATION
#endif
#include <CommonAPI/Utils.hpp>
#include "audiomanagerconfig.h"
#include "CAmSocketHandler.h"

namespace am
{

class CAmSocketHandler;

class CAmCommonAPIWrapper
{
    void commonPrepareCallback(const sh_pollHandle_t handle, void* userData);
    TAmShPollPrepare<CAmCommonAPIWrapper> pCommonPrepareCallback;

    bool commonDispatchCallback(const sh_pollHandle_t handle, void* userData);
    TAmShPollDispatch<CAmCommonAPIWrapper> pCommonDispatchCallback;

    void commonFireCallback(const pollfd pollfd, const sh_pollHandle_t, void*);
    TAmShPollFired<CAmCommonAPIWrapper> pCommonFireCallback;

    bool commonCheckCallback(const sh_pollHandle_t handle, void*);
    TAmShPollCheck<CAmCommonAPIWrapper> pCommonCheckCallback;

    void commonTimerCallback(sh_timerHandle_t handle, void* userData);
    TAmShTimerCallBack<CAmCommonAPIWrapper> pCommonTimerCallback;

     struct timerHandles
    {
        sh_timerHandle_t handle;
        CommonAPI::Timeout* timeout;
    };

    CAmSocketHandler *mpSocketHandler; 

    std::shared_ptr<CommonAPI::Runtime> mRuntime;
    std::shared_ptr<CommonAPI::MainLoopContext> mContext;

    CommonAPI::DispatchSourceListenerSubscription mDispatchSourceListenerSubscription;
    CommonAPI::WatchListenerSubscription mWatchListenerSubscription;
    CommonAPI::TimeoutSourceListenerSubscription mTimeoutSourceListenerSubscription;
    CommonAPI::WakeupListenerSubscription mWakeupListenerSubscription;
    std::multimap<CommonAPI::DispatchPriority, CommonAPI::DispatchSource*> mRegisteredDispatchSources;
    std::map<int,CommonAPI::Watch*> mMapWatches;
    CommonAPI::Watch* mWatchToCheck;
    std::list<CommonAPI::DispatchSource*> mSourcesToDispatch;
    std::vector<timerHandles> mpListTimerhandles;

    void registerDispatchSource(CommonAPI::DispatchSource* dispatchSource, const CommonAPI::DispatchPriority dispatchPriority);
    void deregisterDispatchSource(CommonAPI::DispatchSource* dispatchSource);
    void registerWatch(CommonAPI::Watch* watch, const CommonAPI::DispatchPriority dispatchPriority);
    void deregisterWatch(CommonAPI::Watch* watch);
    void registerTimeout(CommonAPI::Timeout* timeout, const CommonAPI::DispatchPriority dispatchPriority);
    void deregisterTimeout(CommonAPI::Timeout* timeout);
    void wakeup();

protected:
    CAmCommonAPIWrapper(CAmSocketHandler* socketHandler, const std::string & applicationName = "") ;

public:

    virtual ~CAmCommonAPIWrapper();

    static CAmCommonAPIWrapper* getInstance();

    static void deleteInstance();

    static CAmCommonAPIWrapper* instantiateOnce(CAmSocketHandler* socketHandler, const std::string & applicationName = "");


    CAmSocketHandler *getSocketHandler() const { return mpSocketHandler; }
#if COMMONAPI_VERSION_NUMBER >= 300

    template <class TStubImp> bool registerService(const std::shared_ptr<TStubImp> & shStub, const std::string & domain, const std::string & instance, const CommonAPI::ConnectionId_t & connectionId)
    {
        return mRuntime->registerService(domain, instance, shStub, connectionId);
    }
#endif

    template <class TStubImp> bool registerService(const std::shared_ptr<TStubImp> & shStub, const std::string & domain, const std::string & instance)
    {
        return mRuntime->registerService(domain, instance, shStub, mContext);
    }

    bool unregisterService(const std::string &domain, const std::string &interface, const std::string &instance)
    {
        return mRuntime->unregisterService(domain, interface, instance);
    }

    template <class TStubImp> bool __attribute__((deprecated)) registerStub(const std::shared_ptr<TStubImp> & shStub, const std::string & address)
    {
        std::vector<std::string> parts = CommonAPI::split(address, ':');
        assert(parts.size()==3);

        return registerService(shStub, parts[0], parts[2]);
    }

    bool __attribute__((deprecated)) unregisterStub(const std::string & address)
    {
        std::vector<std::string> parts = CommonAPI::split(address, ':');
        assert(parts.size()==3);

        return unregisterService(parts[0], parts[1], parts[2]);
    }

#if COMMONAPI_VERSION_NUMBER >= 300

    template<template<typename ...> class ProxyClass, typename ... AttributeExtensions>
    std::shared_ptr<ProxyClass<AttributeExtensions...>> buildProxy(const std::string &domain, const std::string &instance, const CommonAPI::ConnectionId_t & connectionId)
    {
        return mRuntime->buildProxy<ProxyClass>(domain, instance, connectionId);
    }
#endif

    template<template<typename ...> class ProxyClass, typename ... AttributeExtensions>
    std::shared_ptr<ProxyClass<AttributeExtensions...>> buildProxy(const std::string &domain, const std::string &instance)
    {
        return mRuntime->buildProxy<ProxyClass>(domain, instance, mContext);
    }


    template<template<typename ...> class ProxyClass, typename ... AttributeExtensions>
    std::shared_ptr<ProxyClass<AttributeExtensions...>> __attribute__((deprecated)) buildProxy(const std::string & address)
    {
        std::vector<std::string> parts=CommonAPI::split(address, ':');
        assert(parts.size()==3);

        return buildProxy<ProxyClass>(parts[0], parts[2]);
    }

};


//Alias
extern CAmCommonAPIWrapper* (*getCAPI)();

#ifndef AMCAPI
    #define AMCAPI getCAPI()
#endif

#ifndef AM_CAPI
    #define AM_CAPI getCAPI()
#endif

#ifndef CAPI
    #define CAPI getCAPI()
#endif


}

#endif /* COMMONAPIWRAPPER_H_ */