Objectively 1.0.0
Ultra-lightweight object oriented framework for GNU C.
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
Macros | Functions
Operation.c File Reference
#include <assert.h>
#include "Operation.h"
#include "OperationQueue.h"

Go to the source code of this file.

Macros

#define _Class   _Operation
 

Functions

Class_Operation (void)
 
static void addDependency (Operation *self, Operation *dependency)
 
static void cancel (Operation *self)
 
static Objectcopy (const Object *self)
 
static void dealloc (Object *self)
 
static Arraydependencies (const Operation *self)
 
static Operationinit (Operation *self)
 
static void initialize (Class *clazz)
 
static OperationinitWithFunction (Operation *self, OperationFunction function, ident data)
 
static _Bool isReady (const Operation *self)
 
static void removeDepdenency (Operation *self, Operation *dependency)
 
static void start (Operation *self)
 
static void waitUntilFinished (const Operation *self)
 

Macro Definition Documentation

◆ _Class

#define _Class   _Operation

Definition at line 29 of file Operation.c.

Function Documentation

◆ _Operation()

Class * _Operation ( void  )

Definition at line 233 of file Operation.c.

233 {
234 static Class *clazz;
235 static Once once;
236
237 do_once(&once, {
238 clazz = _initialize(&(const ClassDef) {
239 .name = "Operation",
240 .superclass = _Object(),
241 .instanceSize = sizeof(Operation),
242 .interfaceOffset = offsetof(Operation, interface),
243 .interfaceSize = sizeof(OperationInterface),
245 });
246 });
247
248 return clazz;
249}
Class * _initialize(const ClassDef *def)
Initializes the given Class.
Definition: Class.c:91
static void initialize(Class *clazz)
Definition: Operation.c:213
long Once
The Once type.
Definition: Once.h:37
#define do_once(once, block)
Executes the given block at most one time.
Definition: Once.h:43
ClassDefs are passed to _initialize via an archetype to initialize a Class.
Definition: Class.h:41
The runtime representation of a Class.
Definition: Class.h:95
Class * _Object(void)
The Object archetype.
Definition: Object.c:136
An abstraction for discrete units of work, or tasks.
Definition: Operation.h:50

◆ addDependency()

static void addDependency ( Operation self,
Operation dependency 
)
static

Definition at line 60 of file Operation.c.

60 {
61
62 assert(dependency);
63 assert(dependency != self);
64
65 assert($((Array *) self->locals.dependencies, indexOfObject, dependency) == -1);
66
67 $(self->locals.dependencies, addObject, dependency);
68}
Immutable arrays.
Definition: Array.h:56
ssize_t indexOfObject(const Array *self, const ident obj)
Definition: Array.c:271
void addObject(MutableArray *self, const ident obj)
Adds the specified Object to this MutableArray.
Definition: MutableArray.c:99
MutableArray * dependencies
Contains Operations which must finish before this one can start.
Definition: Operation.h:76

◆ cancel()

static void cancel ( Operation self)
static

Definition at line 74 of file Operation.c.

74 {
75
76 if (self->isCancelled == false) {
77 if (self->isFinished == false) {
78 if (self->isExecuting == false) {
79 self->isCancelled = true;
80 }
81 }
82 }
83}
_Bool isCancelled
true when this Operation has been cancelled, false otherwise.
Definition: Operation.h:99
_Bool isExecuting
true when this Operation is executing, false otherwise.
Definition: Operation.h:104
_Bool isFinished
true when this Operation is finished, false otherwise.
Definition: Operation.h:109

◆ copy()

static Object * copy ( const Object self)
static
See also
Object::copy(const Object *)

Definition at line 36 of file Operation.c.

36 {
37
38 return NULL;
39}

◆ dealloc()

static void dealloc ( Object self)
static
See also
Object::dealloc(Object *)

Definition at line 44 of file Operation.c.

44 {
45
46 Operation *this = (Operation *) self;
47
48 release(this->locals.condition);
49 release(this->locals.dependencies);
50
51 super(Object, self, dealloc);
52}
ident release(ident obj)
Atomically decrement the given Object's reference count. If the resulting reference count is 0,...
Definition: Class.c:196
#define super(type, obj, method,...)
Object is the root Class of The Objectively Class hierarchy.
Definition: Object.h:46
void dealloc(Object *self)
Frees all resources held by this Object.
Definition: Array.c:50

◆ dependencies()

static Array * dependencies ( const Operation self)
static

Definition at line 89 of file Operation.c.

89 {
90
91 ident dependencies = $((Object *) self->locals.dependencies, copy);
92
93 return (Array *) dependencies;
94}
void * ident
The identity type, similar to Objective-C id.
Definition: Types.h:49
Object * copy(const Object *self)
Creates a shallow copy of this Object.
Definition: Array.c:40
Array * dependencies(const Operation *self)
Definition: Operation.c:89

◆ init()

static Operation * init ( Operation self)
static

Definition at line 100 of file Operation.c.

100 {
101
102 self = (Operation *) super(Object, self, init);
103 if (self) {
104
105 self->locals.condition = $(alloc(Condition), init);
106 assert(self->locals.condition);
107
108 self->locals.dependencies = $(alloc(MutableArray), init);
109 assert(self->locals.dependencies);
110 }
111
112 return self;
113}
#define alloc(type)
Allocate and initialize and instance of type.
Definition: Class.h:159
POSIX Threads conditional variables.
Definition: Condition.h:44
Condition * init(Condition *self)
Initializes this Condition.
Definition: Condition.c:67
Mutable arrays.
Definition: MutableArray.h:40
Condition * condition
The Condition enabling waitUntilFinished.
Definition: Operation.h:71

◆ initialize()

static void initialize ( Class clazz)
static
See also
Class::initialize(Class *)

Definition at line 213 of file Operation.c.

213 {
214
215 ((ObjectInterface *) clazz->interface)->copy = copy;
216 ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
217
218 ((OperationInterface *) clazz->interface)->addDependency = addDependency;
219 ((OperationInterface *) clazz->interface)->cancel = cancel;
220 ((OperationInterface *) clazz->interface)->dependencies = dependencies;
221 ((OperationInterface *) clazz->interface)->init = init;
222 ((OperationInterface *) clazz->interface)->initWithFunction = initWithFunction;
223 ((OperationInterface *) clazz->interface)->isReady = isReady;
224 ((OperationInterface *) clazz->interface)->removeDependency = removeDepdenency;
225 ((OperationInterface *) clazz->interface)->start = start;
226 ((OperationInterface *) clazz->interface)->waitUntilFinished = waitUntilFinished;
227}
static void removeDepdenency(Operation *self, Operation *dependency)
Definition: Operation.c:160
ident interface
The interface of the Class.
Definition: Class.h:105
Object * init(Object *self)
Initializes this Object.
Definition: Object.c:83
_Bool isReady(const Operation *self)
Definition: Operation.c:134
void start(Operation *self)
Starts this Operation.
Definition: Operation.c:171
void cancel(Operation *self)
Cancels this Operation, allowing it to complete immediately.
Definition: Operation.c:74
Operation * initWithFunction(Operation *self, OperationFunction function, ident data)
Initializes a synchronous Operation with the given function.
Definition: Operation.c:119
void addDependency(Operation *self, Operation *dependency)
Makes this Operation dependent on the completion of dependency.
Definition: Operation.c:60
void waitUntilFinished(const Operation *self)
Blocks the current thread until this Operation isFinished.
Definition: Operation.c:199

◆ initWithFunction()

static Operation * initWithFunction ( Operation self,
OperationFunction  function,
ident  data 
)
static

Definition at line 119 of file Operation.c.

119 {
120
121 self = $(self, init);
122 if (self) {
123 self->function = function;
124 self->data = data;
125 }
126
127 return self;
128}
MutableData * data(void)
Returns a new MutableData.
Definition: MutableData.c:75
ident data
The user data.
Definition: Operation.h:89
OperationFunction function
The Operation function.
Definition: Operation.h:94

◆ isReady()

static _Bool isReady ( const Operation self)
static

Definition at line 134 of file Operation.c.

134 {
135
136 if (self->isExecuting || self->isFinished) {
137 return false;
138 }
139
140 if (self->isCancelled) {
141 return true;
142 }
143
144 const Array *dependencies = (Array *) self->locals.dependencies;
145 for (size_t i = 0; i < dependencies->count; i++) {
146
147 Operation *dependency = $(dependencies, objectAtIndex, i);
148 if (dependency->isFinished == false) {
149 return false;
150 }
151 }
152
153 return true;
154}
ident objectAtIndex(const Array *self, int index)
size_t count
The count of elements.
Definition: Array.h:72

◆ removeDepdenency()

static void removeDepdenency ( Operation self,
Operation dependency 
)
static

Definition at line 160 of file Operation.c.

160 {
161
162 assert(dependency);
163
164 $(self->locals.dependencies, removeObject, dependency);
165}
void removeObject(MutableArray *self, const ident obj)
Removes the specified Object from this MutableArray.
Definition: MutableArray.c:270

◆ start()

static void start ( Operation self)
static

Definition at line 171 of file Operation.c.

171 {
172
173 if (self->isFinished || self->isExecuting) {
174 return;
175 }
176
177 if (self->isCancelled == false) {
178 self->isExecuting = true;
179 self->function(self);
180 self->isExecuting = false;
181 }
182
183 self->isFinished = true;
184
185 synchronized(self->locals.condition, {
186 $(self->locals.condition, broadcast);
187 });
188
190 if (currentQueue) {
192 }
193}
void broadcast(Condition *self)
Signals all Threads waiting on this Condition.
Definition: Condition.c:57
OperationQueues provide a thread of execution for Operations.
OperationQueue * currentQueue(void)
void removeOperation(OperationQueue *self, Operation *operation)
Removes the Operation from this queue.

◆ waitUntilFinished()

static void waitUntilFinished ( const Operation self)
static

Definition at line 199 of file Operation.c.

199 {
200
201 synchronized(self->locals.condition, {
202 while (self->isFinished == false) {
203 $(self->locals.condition, wait);
204 }
205 });
206}
void wait(Condition *self)
Waits indefinitely for this Condition to be signaled.