IJob.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2017.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#ifndef __FWJOBS_IJOB_HPP__
#define __FWJOBS_IJOB_HPP__

#include "fwJobs/config.hpp"

#include <fwCom/Signal.hpp>

#include <fwCore/mt/types.hpp>

#include <cstdint>
#include <functional>
#include <future>
#include <string>
#include <vector>

namespace fwJobs
{

class FWJOBS_CLASS_API IJob
{
public:

    enum State
    {
        WAITING = 0,
        RUNNING,
        CANCELING,
        CANCELED,
        FINISHED
    };

    typedef SPTR (::fwJobs::IJob) sptr;
    typedef WPTR (::fwJobs::IJob) wptr;

    typedef std::function< bool () > CancelRequestCallback;

    typedef std::function< void (IJob&) > JobCancelHook;

    typedef std::function< void (IJob&, const std::string&) > LogHook;

    typedef std::function< void (IJob&, std::uint64_t /*oldDoneWork*/) > DoneWorkHook;

    typedef std::function< void (IJob&, std::uint64_t /*oldTotalWorkUnits*/) > TotalWorkUnitsHook;

    typedef std::function< void () > CancelHook;

    typedef std::function< void ( State ) > StateHook;

    typedef std::vector< JobCancelHook > CancelHookSeq;

    typedef std::vector< DoneWorkHook > DoneWorkHookSeq;

    typedef std::vector< TotalWorkUnitsHook > TotalWorkUnitsHookSeq;

    typedef std::vector< LogHook > LogHookSeq;

    typedef std::vector< StateHook > StateHookSeq;

    typedef std::vector< std::string > Logs;

    typedef ::fwCom::Signal< void () > StateSignal;

    typedef ::fwCom::Signal< void () > CancelRequestedSignal;

    typedef ::fwCom::Signal< void (std::uint64_t, std::uint64_t) > DoneWorkSignal;

    typedef ::fwCom::Signal< void (std::string) > LogSignal;

    typedef std::shared_future< void > SharedFuture;
    FWJOBS_API IJob(const std::string& name = "");

    FWJOBS_API virtual ~IJob();

    FWJOBS_API std::uint64_t getDoneWorkUnits() const;

    FWJOBS_API std::uint64_t getTotalWorkUnits() const;

    FWJOBS_API State getState() const;

    FWJOBS_API const std::string& getName() const;

    FWJOBS_API Logs getLogs() const;

    FWJOBS_API bool isCancelable() const;

    FWJOBS_API void setCancelable(bool cancel);

    FWJOBS_API SharedFuture run();

    FWJOBS_API void wait();

    FWJOBS_API const bool& cancelRequested() const;

    FWJOBS_API CancelRequestCallback cancelRequestedCallback() const;

    FWJOBS_API virtual SharedFuture cancel();

    FWJOBS_API void addSimpleCancelHook(CancelHook callback);

    FWJOBS_API void addCancelHook(JobCancelHook callback);

    FWJOBS_API void addDoneWorkHook(DoneWorkHook callback);

    FWJOBS_API void addTotalWorkUnitsHook(TotalWorkUnitsHook callback);

    FWJOBS_API void addLogHook(LogHook callback);

    FWJOBS_API void addStateHook(StateHook callback);

    FWJOBS_API void log(const std::string& message);

protected:

    IJob(IJob&);
    IJob& operator=(IJob&);
    IJob(IJob&&);
    IJob& operator=(IJob&&);
    FWJOBS_API virtual SharedFuture runImpl() = 0;

    FWJOBS_API virtual void finish();

    FWJOBS_API void finishNoLock();

    // workaround because of vs2010 issue : http://goo.gl/WHEkQ5
    // this is fixed in vs2012 : http://goo.gl/tvO3g7
    // TODO : remove when compiler is up to date
    FWJOBS_API std::function< void() > finishCallback();

    FWJOBS_API State getStateNoLock() const;

    FWJOBS_API void setState( State state );

    FWJOBS_API void setStateNoLock( State state );

    FWJOBS_API void doneWork( std::uint64_t units );

    FWJOBS_API void doneWork( std::uint64_t units, ::fwCore::mt::ReadToWriteLock& lock );

    FWJOBS_API void done();

    FWJOBS_API void setTotalWorkUnits(std::uint64_t units);

    FWJOBS_API void setTotalWorkUnitsUpgradeLock( std::uint64_t units, ::fwCore::mt::ReadToWriteLock& lock );

    FWJOBS_API void addCancelHookNoLock(JobCancelHook callback);

    FWJOBS_API void addDoneWorkHookNoLock(DoneWorkHook callback);

    FWJOBS_API void addTotalWorkUnitsHookNoLock(TotalWorkUnitsHook callback);

    FWJOBS_API void addLogHookNoLock(LogHook callback);

    FWJOBS_API void addStateHookNoLock(StateHook callback);

    FWJOBS_API void logNoLock(const std::string& message);

    SPTR(CancelRequestedSignal) m_sigCancelRequested;

    SPTR(StateSignal) m_sigCanceled;

    SPTR(StateSignal) m_sigStarted;

    SPTR(StateSignal) m_sigFinished;

    SPTR(DoneWorkSignal) m_sigDoneWork;

    SPTR(LogSignal) m_sigLogged;

    mutable ::fwCore::mt::ReadWriteMutex m_mutex;

    std::string m_name;

    Logs m_logs;

    std::uint64_t m_doneWorkUnits;

    std::uint64_t m_totalWorkUnits;

    bool m_cancelRequested;

    bool m_cancelable;

    CancelHookSeq m_cancelHooks;

    DoneWorkHookSeq m_doneWorkHooks;

    TotalWorkUnitsHookSeq m_totalWorkUnitsHooks;

    LogHookSeq m_logHooks;

    StateHookSeq m_stateHooks;

    SharedFuture m_runFuture;

    State m_state;
};

} //namespace fwJobs

#endif //__FWJOBS_IJOB_HPP__