mptask.h

Go to the documentation of this file.

 
 
#pragma once
// This header file is auto-generated!
// Do not make changes to this file or they will be overwritten.
// clang-format off
#include <cx/obj.h>
#include "complextask.h"
 
typedef struct TaskQueue TaskQueue;
typedef struct TaskQueue_WeakRef TaskQueue_WeakRef;
typedef struct TQWorker TQWorker;
typedef struct TQWorker_WeakRef TQWorker_WeakRef;
typedef struct ComplexTask ComplexTask;
typedef struct ComplexTask_WeakRef ComplexTask_WeakRef;
typedef struct ComplexTask ComplexTask;
typedef struct ComplexTask_WeakRef ComplexTask_WeakRef;
typedef struct TRGate TRGate;
typedef struct TRGate_WeakRef TRGate_WeakRef;
typedef struct ComplexTaskQueue ComplexTaskQueue;
typedef struct ComplexTaskQueue_WeakRef ComplexTaskQueue_WeakRef;
typedef struct TaskControl TaskControl;
typedef struct MultiphaseTask MultiphaseTask;
typedef struct MultiphaseTask_WeakRef MultiphaseTask_WeakRef;
saDeclarePtr(MultiphaseTask);
saDeclarePtr(MultiphaseTask_WeakRef);
 
enum MultiphaseTaskFlagsEnum {
    MPTASK_Greedy = 0x10        
};
typedef uint32 (*MPTPhaseFunc)(void *self, TaskQueue* tq, TQWorker* worker, TaskControl *tcon);
saDeclare(MPTPhaseFunc);
#define mptaskAddPhases(self, parr) mptask_addPhases(self, sizeof(parr) / sizeof((parr)[0]), (parr), false)
#define mptaskAddFailPhases(self, parr) mptask_addPhases(self, sizeof(parr) / sizeof((parr)[0]), (parr), true)
 
typedef struct MultiphaseTask_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    uint32 (*run)(_In_ void* self, _In_ TaskQueue* tq, _In_ TQWorker* worker, _Inout_ TaskControl* tcon);
    void (*runCancelled)(_In_ void* self, _In_ TaskQueue* tq, _In_ TQWorker* worker);
    bool (*cancel)(_In_ void* self);
    bool (*reset)(_In_ void* self);
    bool (*wait)(_In_ void* self, int64 timeout);
    intptr (*cmp)(_In_ void* self, void* other, uint32 flags);
    uint32 (*hash)(_In_ void* self, uint32 flags);
    uint32 (*finish)(_In_ void* self, uint32 result, TaskControl* tcon);
} MultiphaseTask_ClassIf;
extern MultiphaseTask_ClassIf MultiphaseTask_ClassIf_tmpl;
 
typedef struct MultiphaseTask {
    union {
        MultiphaseTask_ClassIf* _;
        void* _is_MultiphaseTask;
        void* _is_ComplexTask;
        void* _is_Task;
        void* _is_BasicTask;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    atomic(uint32) state;        
    string name;        
    int64 last;        
    cchain oncomplete;        
    int64 nextrun;        
    int64 lastprogress;        
    Weak(ComplexTaskQueue)* lastq;        
    sa_TaskRequires _requires;        
    uint16 flags;        
    uint16 _intflags;        
    atomic(uint32) _advcount;        
    sa_MPTPhaseFunc phases;        
    sa_MPTPhaseFunc failphases;        
    uint32 _phase;        
    bool _fail;        
} MultiphaseTask;
extern ObjClassInfo MultiphaseTask_clsinfo;
#define MultiphaseTask(inst) ((MultiphaseTask*)(unused_noeval((inst) && &((inst)->_is_MultiphaseTask)), (inst)))
#define MultiphaseTaskNone ((MultiphaseTask*)NULL)
 
typedef struct MultiphaseTask_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_MultiphaseTask_WeakRef;
        void* _is_ComplexTask_WeakRef;
        void* _is_Task_WeakRef;
        void* _is_BasicTask_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} MultiphaseTask_WeakRef;
#define MultiphaseTask_WeakRef(inst) ((MultiphaseTask_WeakRef*)(unused_noeval((inst) && &((inst)->_is_MultiphaseTask_WeakRef)), (inst)))
 
void MultiphaseTask__addPhases(_In_ MultiphaseTask* self, int32 num, MPTPhaseFunc parr[], bool fail);
#define mptask_addPhases(self, num, parr, fail) MultiphaseTask__addPhases(MultiphaseTask(self), num, parr, fail)
 
#define mptaskRequireTask(self, dep, failok) ComplexTask_requireTask(ComplexTask(self), Task(dep), failok)
 
#define mptaskRequireTaskTimeout(self, dep, failok, timeout) ComplexTask_requireTaskTimeout(ComplexTask(self), Task(dep), failok, timeout)
 
#define mptaskRequireResource(self, res) ComplexTask_requireResource(ComplexTask(self), TaskResource(res))
 
#define mptaskRequireResourceTimeout(self, res, timeout) ComplexTask_requireResourceTimeout(ComplexTask(self), TaskResource(res), timeout)
 
#define mptaskRequireGate(self, gate) ComplexTask_requireGate(ComplexTask(self), TRGate(gate))
 
#define mptaskRequireGateTimeout(self, gate, timeout) ComplexTask_requireGateTimeout(ComplexTask(self), TRGate(gate), timeout)
 
#define mptaskRequire(self, req) ComplexTask_require(ComplexTask(self), TaskRequires(req))
 
#define mptaskAdvance(self) ComplexTask_advance(ComplexTask(self))
 
#define mptaskCheckRequires(self, updateProgress, expires) ComplexTask_checkRequires(ComplexTask(self), updateProgress, expires)
 
#define mptaskCancelRequires(self) ComplexTask_cancelRequires(ComplexTask(self))
 
#define mptaskAcquireRequires(self, acquired) ComplexTask_acquireRequires(ComplexTask(self), acquired)
 
#define mptaskReleaseRequires(self, resources) ComplexTask_releaseRequires(ComplexTask(self), resources)
 
// bool mptask_setState(MultiphaseTask* self, uint32 newstate);
#define mptask_setState(self, newstate) BasicTask__setState(BasicTask(self), newstate)
 
// uint32 mptaskRun(MultiphaseTask* self, TaskQueue* tq, TQWorker* worker, TaskControl* tcon);
#define mptaskRun(self, tq, worker, tcon) (self)->_->run(MultiphaseTask(self), TaskQueue(tq), TQWorker(worker), tcon)
#define mptaskRunCancelled(self, tq, worker) (self)->_->runCancelled(MultiphaseTask(self), TaskQueue(tq), TQWorker(worker))
// bool mptaskCancel(MultiphaseTask* self);
#define mptaskCancel(self) (self)->_->cancel(MultiphaseTask(self))
// bool mptaskReset(MultiphaseTask* self);
#define mptaskReset(self) (self)->_->reset(MultiphaseTask(self))
#define mptaskWait(self, timeout) (self)->_->wait(MultiphaseTask(self), timeout)
// intptr mptaskCmp(MultiphaseTask* self, MultiphaseTask* other, uint32 flags);
#define mptaskCmp(self, other, flags) (self)->_->cmp(MultiphaseTask(self), other, flags)
// uint32 mptaskHash(MultiphaseTask* self, uint32 flags);
#define mptaskHash(self, flags) (self)->_->hash(MultiphaseTask(self), flags)
#define mptaskFinish(self, result, tcon) (self)->_->finish(MultiphaseTask(self), result, tcon)