BaseAction.h

// BaseAction.h:
// -------------
//

#ifndef __IPSDKCORE_BASEACTION_H__
#define __IPSDKCORE_BASEACTION_H__

// suppression warnings
// warning C4251: 'boost::enable_shared_from_this<T>::weak_this_' : class 'boost::weak_ptr<T>' needs to have dll-interface to be used by clients of class 'boost::enable_shared_from_this<T>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKCore/IPSDKCoreExports.h>
#include <IPSDKCore/Processing/ProcessingTypes.h>
#include <IPSDKCore/Processing/Action/ActionTypes.h>
#include <IPSDKCore/Processing/Action/ActionHdrMacros.h>
#include <IPSDKCore/Processing/Priority/NormalPriority.h>
#include <IPSDKBaseData/ToolTip/BaseToolTip.h>
#include <IPSDKSerialization/Engine/SerializationObjectWithGuid.h>
#include <IPSDKUtil/Tools/Guid.h>
#include <IPSDKUtil/Tools/Chrono.h>
#include <boost/enable_shared_from_this.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/optional/optional.hpp>

namespace ipsdk {
namespace core {


class IPSDKCORE_API BaseAction : public SerializationObjectWithGuid,
                                 public BaseToolTip,
                                 public boost::enable_shared_from_this<BaseAction>
{
    // friend class for protected accesses
    friend class LocalActionRequest;
    friend class RemoteActionRequest;
    friend class PendingActionRequest;

    // declare serial class
    IPSDK_DECLARE_ABSTRACT_SERIAL_WITHOUT_COPY(IPSDKCore, BaseAction)

protected:
    BaseAction();

public:
    virtual ~BaseAction() = 0;
    
// methods
public:
    virtual bool                isComplexAction() const = 0;

    bool                        isInit() const;

    eExecutionStatus            getStatus() const;

    const ePriority&            getActionPriority() const;

    void                        setActionPriority(const BasePriority& actionPriority);

    void                        addCompletionCB(const ActionCompletionCB& completionCB);


    bool                        hasSocketGuid() const;

    void                        setSocketGuid(const Guid& socketGuid);

    const Guid&                 getSocketGuid() const;

    // \return execution result
    ExecResult                  run(const eSynchroType& synchroType = eSynchroType::eST_Default);

    void                        requestCancellation();

    bool                        isCancellationRequested() const;

    void                        waitForCompletion();

    ExecResult                  getActionResult() const;

    double                      getFullActionDuration() const;

    double                      getExecutionActionDuration() const;

    BoolResult                  clear();

protected:
    bool                        isSynchronismForced() const;

    BoolResult                  initBase(const BasePriority& defaultPriority = NormalPriority());

    virtual BoolResult          globalCleanDerived() {return true;}

    IPSDK_ENUM(eCleanReason,
        (eCR_Failure)       
        (eCR_Exception)     
        (eCR_Cancellation)  
    )

    
    virtual BoolResult          cleanOnErrorDerived(const eCleanReason& cleanReason) {return true;}    

    IPSDK_ENUM(eExecutionResultDerived,
        (eERD_Success)      
        (eERD_Failure)      
        (eERD_Canceled)     
        (eERD_Running)      
    )

    
    typedef ProcessingResult<eExecutionResultDerived> ExecResultDerived;

    virtual ExecResultDerived   runDerived() = 0;

    virtual void                requestCancellationdDerived() {}

    void                        notifyCompletion(const ExecResult& bCompletionResult);

    ExecResultDerived           toExecResultDerived(const ExecResult& execResult) const;

    virtual BoolResult          syncInputDataDerived(const Guid& processingSocketGuid) {return true;}

    virtual BoolResult          syncOutputDataDerived(const Guid& processingSocketGuid) {return true;}

    virtual void                clearInputData() {}

    virtual void                clearIntermediateData() {}

    virtual void                clearOutputData() {}

private:
    BoolResult                  syncInputData(const Guid& processingSocketGuid);

    BoolResult                  syncOutputData(const Guid& processingSocketGuid);

    BoolResult                  globalClean();

    BoolResult                  cleanOnError(const eCleanReason& cleanReason);

    ExecResult                  syncRun(bool bForceSynchronous);

    ExecResult                  asyncRun();

    void                        processCancellation();

    void                        processRunException(const std::string& msg);

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

    void                        callCompletionCB();

// attributes
private:
    eExecutionStatus            _actionStatus;

    ePriority                   _actionPriority;

    ActionCompletionCBColl      _completionCBColl;

    ExecResult                  _bResult;

    Chrono                      _fullActionChrono;

    double                      _fullActionDuration;

    Chrono                      _executionActionChrono;

    double                      _executionActionDuration;

    boost::optional<Guid>       _pSocketGuid;

    bool volatile               _bCancellationRequested;

    mutable boost::mutex        _mutex;

    boost::condition_variable   _condition;

    bool                        _bForceSynchronous;

    bool                        _bInit;
};


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


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

#pragma warning (pop)

#endif // __IPSDKCORE_BASEACTION_H__