taskrequiresgate.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/thread/mutex.h>
#include <cx/taskqueue/task/complextask.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 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 TRGate TRGate;
typedef struct TRGate_WeakRef TRGate_WeakRef;
typedef struct TaskRequiresGate TaskRequiresGate;
typedef struct TaskRequiresGate_WeakRef TaskRequiresGate_WeakRef;
saDeclarePtr(TRGate);
saDeclarePtr(TRGate_WeakRef);
#define _sti_TRGate _sti_object
#define SType_TRGate TRGate*
#define STStorageType_TRGate TRGate*
#define STypeArg_TRGate(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(TRGate, val))
#define STypeArgPtr_TRGate(type, val) (stgeneric*)objInstCheckClassPtr(TRGate, val)
#define STypeCheckedArg_TRGate(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_TRGate(type, val) stType(type), stArgPtr(type, val)
saDeclarePtr(TaskRequiresGate);
saDeclarePtr(TaskRequiresGate_WeakRef);
#define _sti_TaskRequiresGate _sti_object
#define SType_TaskRequiresGate TaskRequiresGate*
#define STStorageType_TaskRequiresGate TaskRequiresGate*
#define STypeArg_TaskRequiresGate(type, val) stgeneric(object, (ObjInst*)objInstCheckClass(TaskRequiresGate, val))
#define STypeArgPtr_TaskRequiresGate(type, val) (stgeneric*)objInstCheckClassPtr(TaskRequiresGate, val)
#define STypeCheckedArg_TaskRequiresGate(type, val)    stType(type), stArg(type, val)
#define STypeCheckedPtrArg_TaskRequiresGate(type, val) stType(type), stArgPtr(type, val)
 
typedef struct TRGate_ClassIf {
    ObjIface* _implements;
    ObjIface* _parent;
    size_t _size;
 
    bool (*open)(_In_ void* self);
    bool (*seal)(_In_ void* self);
    void (*progress)(_In_ void* self);
    bool (*registerTask)(_In_ void* self, ComplexTask* task);
} TRGate_ClassIf;
extern TRGate_ClassIf TRGate_ClassIf_tmpl;
 
typedef struct TaskRequiresGate_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);
} TaskRequiresGate_ClassIf;
extern TaskRequiresGate_ClassIf TaskRequiresGate_ClassIf_tmpl;
 
typedef struct TRGate {
    union {
        TRGate_ClassIf* _;
        void* _is_TRGate;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    string name;        
    atomic(uint32) state;        
    Mutex _wlmtx;
    sa_ComplexTask _waitlist;
    int64 lastprogress;        
} TRGate;
extern ObjClassInfo TRGate_clsinfo;
#define TRGate(inst) objInstCheckClass(TRGate, inst)
#define TRGateNone ((TRGate*)NULL)
 
typedef struct TRGate_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_TRGate_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} TRGate_WeakRef;
#define TRGate_WeakRef(inst) objWeakRefCheckClass(TRGate, inst)
 
_objfactory_guaranteed TRGate* TRGate_create(_In_opt_ strref name);
#define trgateCreate(name) TRGate_create(name)
 
#define trgateOpen(self) (self)->_->open(TRGate(self))
#define trgateSeal(self) (self)->_->seal(TRGate(self))
#define trgateProgress(self) (self)->_->progress(TRGate(self))
#define trgateRegisterTask(self, task) (self)->_->registerTask(TRGate(self), ComplexTask(task))
 
typedef struct TaskRequiresGate {
    union {
        TaskRequiresGate_ClassIf* _;
        void* _is_TaskRequiresGate;
        void* _is_TaskRequires;
        void* _is_ObjInst;
    };
    ObjClassInfo* _clsinfo;
    atomic(uintptr) _ref;
    atomic(ptr) _weakref;
 
    int64 expires;        
    TRGate* gate;        
} TaskRequiresGate;
extern ObjClassInfo TaskRequiresGate_clsinfo;
#define TaskRequiresGate(inst) objInstCheckClass(TaskRequiresGate, inst)
#define TaskRequiresGateNone ((TaskRequiresGate*)NULL)
 
typedef struct TaskRequiresGate_WeakRef {
    union {
        ObjInst* _inst;
        void* _is_TaskRequiresGate_WeakRef;
        void* _is_TaskRequires_WeakRef;
        void* _is_ObjInst_WeakRef;
    };
    atomic(uintptr) _ref;
    RWLock _lock;
} TaskRequiresGate_WeakRef;
#define TaskRequiresGate_WeakRef(inst) objWeakRefCheckClass(TaskRequiresGate, inst)
 
_objfactory_guaranteed TaskRequiresGate* TaskRequiresGate_create(_In_ TRGate* gate);
#define taskrequiresgateCreate(gate) TaskRequiresGate_create(TRGate(gate))
 
// uint32 taskrequiresgateState(TaskRequiresGate* self, ComplexTask* task);
#define taskrequiresgateState(self, task) (self)->_->state(TaskRequiresGate(self), ComplexTask(task))
// int64 taskrequiresgateProgress(TaskRequiresGate* self);
#define taskrequiresgateProgress(self) (self)->_->progress(TaskRequiresGate(self))
// bool taskrequiresgateTryAcquire(TaskRequiresGate* self, ComplexTask* task);
#define taskrequiresgateTryAcquire(self, task) (self)->_->tryAcquire(TaskRequiresGate(self), ComplexTask(task))
// bool taskrequiresgateRelease(TaskRequiresGate* self, ComplexTask* task);
#define taskrequiresgateRelease(self, task) (self)->_->release(TaskRequiresGate(self), ComplexTask(task))
// void taskrequiresgateCancel(TaskRequiresGate* self);
#define taskrequiresgateCancel(self) (self)->_->cancel(TaskRequiresGate(self))
// bool taskrequiresgateRegisterTask(TaskRequiresGate* self, ComplexTask* task);
#define taskrequiresgateRegisterTask(self, task) (self)->_->registerTask(TaskRequiresGate(self), ComplexTask(task))
 
CX_C_END