BaseActionProvider.h

// BaseActionProvider.h:
// ---------------------
//

#ifndef __IPSDKCORE_BASEACTIONPROVIDER_H__
#define __IPSDKCORE_BASEACTIONPROVIDER_H__

// suppression warnings
// warning C4251: 'ipsdk::core::BaseActionProvider::_priority' : class 'ipsdk::core::ePriority' needs to have dll-interface to be used by clients of class 'ipsdk::core::BaseActionProvider'
// warning C4275: non dll-interface class 'boost::noncopyable_::noncopyable' used as base for dll-interface class 'ipsdk::core::BaseActionProvider'
#pragma warning (push)
#pragma warning (disable : 4251 4275)

#include <IPSDKCore/IPSDKCoreExports.h>
#include <IPSDKCore/Processing/ProcessingTypes.h>
#include <IPSDKCore/Processing/ActionProvider/ActionProviderTypes.h>
#include <IPSDKCore/Processing/Priority/PriorityTypes.h>
#include <IPSDKComm/TcpIp/Types.h>
#include <IPSDKUtil/Tools/Chrono.h>
#include <IPSDKUtil/Tools/Guid.h>
#include <boost/noncopyable.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/chrono/duration.hpp>

namespace ipsdk {
namespace processor {
    class BaseAsyncProcessor;
}
namespace core {

class BaseRequestOrigin;
class BasePriority;
class ThreadManager;
class ProviderManager;
class AskForRemoteAction;
class UpdateRemoteAction;
class UpdatePendingAction;


class IPSDKCORE_API BaseActionProvider : public boost::noncopyable,
                                         public boost::enable_shared_from_this<BaseActionProvider>
{
    // friend class for protected accesses
    friend class processor::BaseAsyncProcessor;
    friend class ThreadManager;
    friend class ProviderManager;
    friend class AskForRemoteAction;
    friend class UpdateRemoteAction;
    friend class UpdatePendingAction;

public:
    BaseActionProvider();
    virtual ~BaseActionProvider() = 0;
    
// methods
public:
    bool                    isInit() const;

    const Guid&             getGuid() const;

    const ePriority&        getActionsPriority() const;

    eExecutionStatus        getStatus() const;

    void                    addCompletionCB(const ProviderCompletionCB& completionCB);

    bool                    areActionsPending() const;

    void                    waitForCompletion();

    bool                    waitForCompletion(const boost::chrono::milliseconds& duration);

    bool                    waitForCompletion(const boost::chrono::system_clock::time_point& deadLineTime);

    void                    requestCancellation();

    bool                    isCancellationRequested() const;

    ExecResult              getGlobalResult() const;

    double                  getFullExecutionDuration() const;

    void                    clear();

protected:
    BoolResult              initBase(const BasePriority& actionsPriority,
                                     const Guid& providerGuid = Guid());

    bool                    existsRemoteProvider(const Guid& socketGuid);

    void                    addRemoteProvider(const Guid& socketGuid);

    bool                    unRegisterRemoteProvider(const Guid& socketGuid);

    BoolResult              registerRemoteProvider(const Guid& socketGuid);

    BoolResult              registerRemoteProviders();

    virtual QueryResult     queryNextAction(const BaseRequestOrigin& requestOrigin,
                                            ActionRequestPtr& pActionRequest,
                                            bool& bProcessCompletionCheck,
                                            SerializationObjectPtr& pCbAdditionalData) = 0;

    virtual bool            hasPendingAction() const = 0;

    virtual BoolResult      notifyDerived(const ActionRequestPtr& pActionRequest,
                                          const SerializationObjectConstPtr& pCbAdditionalData,
                                          bool& bRestartProvider) {
        bRestartProvider = false;
        return true;
    }

    virtual void            clearDerived() {}

    virtual void            requestCancellationDerived() {}

private:
    void                    notifyCompletion(const ActionRequestPtr& pActionRequest,
                                             const SerializationObjectConstPtr& pCbAdditionalData);

    QueryResult             getNextAction(const BaseRequestOrigin& requestOrigin,
                                          ActionRequestPtr& pActionRequest);

    ActionRequestPtr        getActionRequest(const Guid& requestGuid);

    void                    internalClear();

    void                    addCompletionCB(const ProviderCompletionCB& completionCB,
                                            bool bPushBack);

    void                    checkForCompletion();

    void                    connectionLostCB(const tcpip::SocketDesc& socketDesc,
                                             const boost::system::error_code& ec);

// attributes
private:
    Guid                        _providerGuid;

    eExecutionStatus            _providerStatus;

    ePriority                   _actionsPriority;

    ProviderCompletionCBColl    _completionCBColl;

    boost::mutex                _completionCBMutex;

    bool volatile               _bCancellationRequested;

    ExecResult                  _bGlobalResult;

    bool volatile               _bPendingActions;

    ActionRequestColl           _currentActionRequestColl;

    Chrono                      _fullExecutionClk;

    double                      _fullExecutionDuration;

    typedef std::map<Guid, Guid> GuidMap;

    GuidMap                     _socketCBGuidColl;

    mutable boost::mutex        _mutex;

    boost::condition_variable   _condition;

    bool                        _bInit;
};


inline bool
BaseActionProvider::isInit() const
{
    return _bInit;
}


} // end of namespace core
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKCORE_BASEACTIONPROVIDER_H__