taskrequirestask.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 <cx/struct.h>
#include "taskrequires.h"
#include <cx/taskqueue/task/task.h>
 
CX_C_BEGIN
 
typedef struct ComplexTask ComplexTask;
typedef struct ComplexTask_WeakRef ComplexTask_WeakRef;
typedef struct TaskQueue TaskQueue;
typedef struct TaskQueue_WeakRef TaskQueue_WeakRef;
typedef struct TQWorker TQWorker;
typedef struct TQWorker_WeakRef TQWorker_WeakRef;
typedef struct TaskControl TaskControl;
typedef struct TaskRequiresTask TaskRequiresTask;
typedef struct TaskRequiresTask_WeakRef TaskRequiresTask_WeakRef;
saDeclarePtr(TaskRequiresTask);
saDeclarePtr(TaskRequiresTask_WeakRef);
#define _sti_TaskRequiresTask _sti_object
#define SType_TaskRequiresTask TaskRequiresTask*
#define STStorageType_TaskRequiresTask TaskRequiresTask*
#define STypeArg_TaskRequiresTask(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(TaskRequiresTask, val))
#define STypeArgPtr_TaskRequiresTask(type, val) (stgeneric*)objInstCheckClassPtr(TaskRequiresTask, val)
#define STypeCheckedArg_TaskRequiresTask(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_TaskRequiresTask(type, val) stType(type), stArgPtr(type, val)
 
typedef struct TaskRequiresTask_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    uint32 (*state)(_In_ void* self, ComplexTask* task);
    int64 (*progress)(_In_ void* self);
    bool (*tryAcquire)(_In_ void* self, ComplexTask* task);
    bool (*release)(_In_ void* self, ComplexTask* task);
    void (*cancel)(_In_ void* self);
    bool (*registerTask)(_In_ void* self, _In_ ComplexTask* task);
} TaskRequiresTask_ClassIf;
extern TaskRequiresTask_ClassIf TaskRequiresTask_ClassIf_tmpl;
 
typedef struct TaskRequiresTask {
    union {
        TaskRequiresTask_ClassIf* _;
        void* _is_TaskRequiresTask;
        void* _is_TaskRequires;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    int64 expires;        
    Task* task;        
    bool failok;        
} TaskRequiresTask;
extern ObjClassInfo TaskRequiresTask_clsinfo;
#define TaskRequiresTask(inst) objInstCheckClass(TaskRequiresTask, inst)
#define TaskRequiresTaskNone ((TaskRequiresTask*)NULL)
 
typedef struct TaskRequiresTask_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_TaskRequiresTask_WeakRef;
        void* _is_TaskRequires_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} TaskRequiresTask_WeakRef;
#define TaskRequiresTask_WeakRef(inst) objWeakRefCheckClass(TaskRequiresTask, inst)
 
_objfactory_guaranteed TaskRequiresTask* TaskRequiresTask_create(_In_ Task* deptask, bool failok);
#define taskrequirestaskCreate(deptask, failok) TaskRequiresTask_create(Task(deptask), failok)
 
// uint32 taskrequirestaskState(TaskRequiresTask* self, ComplexTask* task);
#define taskrequirestaskState(self, task) (self)->_->state(TaskRequiresTask(self), ComplexTask(task))
// int64 taskrequirestaskProgress(TaskRequiresTask* self);
#define taskrequirestaskProgress(self) (self)->_->progress(TaskRequiresTask(self))
// bool taskrequirestaskTryAcquire(TaskRequiresTask* self, ComplexTask* task);
#define taskrequirestaskTryAcquire(self, task) (self)->_->tryAcquire(TaskRequiresTask(self), ComplexTask(task))
// bool taskrequirestaskRelease(TaskRequiresTask* self, ComplexTask* task);
#define taskrequirestaskRelease(self, task) (self)->_->release(TaskRequiresTask(self), ComplexTask(task))
// void taskrequirestaskCancel(TaskRequiresTask* self);
#define taskrequirestaskCancel(self) (self)->_->cancel(TaskRequiresTask(self))
// bool taskrequirestaskRegisterTask(TaskRequiresTask* self, ComplexTask* task);
#define taskrequirestaskRegisterTask(self, task) (self)->_->registerTask(TaskRequiresTask(self), ComplexTask(task))
 
CX_C_END