YiTask.h

Go to the documentation of this file.

// © You i Labs Inc. 2000-2017. All rights reserved.
#ifndef _YI_TASK_H_
#define _YI_TASK_H_

#include "framework/YiPredef.h"
#include "thread/YiMutex.h"
#include "utility/YiBundle.h"

#include "YiFuture.h"

class CYIAbstractFuture;
class CYIMutex;

class CYITaskBase
{
    friend class CYIAbstractFuture;
    template<typename T> friend class CYITask;
    
public:
    typedef enum {
        TASK_NEW,
        TASK_PENDING_EXECUTION,
        TASK_EXECUTING,
        TASK_COMPLETED,
        TASK_CANCELLED
    } TASK_STATE;

    virtual ~CYITaskBase();

    virtual bool TakeOwnershipOfFuture(std::unique_ptr<CYIAbstractFuture> pFuture);

    TASK_STATE GetState() const;
    
    bool IsFutureOwner() const;
    
    bool MarkPendingExecution();
    
    void RequestCancellation();
    
    bool Execute();

protected:
    virtual void RunAndAssignResult() = 0; 

    bool IsCancellationRequested() const;
    
    void SetCancellationRequestSucceeded();
    
    virtual void CleanUpAfterCancellation() {};
    
    mutable CYIMutex    m_mutex;

private:
    // Hiding copy constructor and assignment operator
    CYITaskBase(const CYITaskBase &);
    CYITaskBase &operator=(const CYITaskBase &);
    CYITaskBase(CYIAbstractFuture &rFuture);
    CYITaskBase(std::unique_ptr<CYIAbstractFuture> pFuture);
    CYITaskBase();

    void ExclusiveLock() const; 
    void ExclusiveUnlock() const; 
    void DisconnectFromFuture(); 
    bool SetCancelledNonLocking(); 
    
    CYIAbstractFuture  *m_pFuture;
    std::unique_ptr<CYIAbstractFuture> m_pOwnedFuture;
    TASK_STATE          m_eState;
    std::atomic<bool> m_bCancellationRequested;
    bool             m_bCancellationRequestSucceeded;
};



template <typename ResultType = void>
class CYITask : public CYITaskBase
{
public:
    CYITask();
    CYITask(CYIFuture<ResultType> &rFuture);
    CYITask(std::unique_ptr<CYIFuture<ResultType>> pFuture);
    virtual ~CYITask();

    bool SetFuture(CYIFuture<ResultType> &rFuture);

    bool SetFuture(std::unique_ptr<CYIFuture<ResultType>> rFuture);

private:
    virtual void RunAndAssignResult() override; 
    
protected:
    virtual ResultType Run() = 0;
};


template <>
class CYITask<> : public CYITaskBase
{
public:
    CYITask();
    CYITask(CYIFuture<> &rFuture);
    CYITask(std::unique_ptr<CYIFuture<>> pFuture);
    virtual ~CYITask();

    bool SetFuture(CYIFuture<> &rFuture);

    bool SetFuture(std::unique_ptr<CYIFuture<>> pFuture);

private:
    virtual void RunAndAssignResult() override; 
    
protected:
    virtual void Run() = 0;
};



template <typename ResultType>
class CYITask<ResultType*> : public CYITaskBase
{
public:
    CYITask();
    CYITask(CYIFuture<ResultType*> &rFuture);
    CYITask(std::unique_ptr<CYIFuture<ResultType *>> pFuture);
    virtual ~CYITask();
    
    bool SetFuture(CYIFuture<ResultType*> &rFuture);

    bool SetFuture(std::unique_ptr<CYIFuture<ResultType *>> pFuture);

private:
    virtual void RunAndAssignResult() override; 
    
protected:
    virtual ResultType* Run() = 0;
};



// Use of array types in CYITask objects is not supported.
template <typename ResultType>
class CYITask<ResultType[]> : public CYITaskBase
{
private:
    CYITask();
};


#include "YiTask.inl"

#endif /* _YI_TASK_H_ */