Objectively
Object oriented framework for C.
Loading...
Searching...
No Matches
Operation.c File Reference
#include <assert.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 Object * copy (const Object *self)
 
static void dealloc (Object *self)
 
static Array * dependencies (const Operation *self)
 
static Operation * init (Operation *self)
 
static void initialize (Class *clazz)
 
static Operation * initWithFunction (Operation *self, OperationFunction function, ident data)
 
static bool isCancelled (const Operation *self)
 
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 28 of file Operation.c.

Function Documentation

◆ _Operation()

Class * _Operation ( void  )

Definition at line 243 of file Operation.c.

243 {
244 static Class *clazz;
245 static Once once;
246
247 do_once(&once, {
248 clazz = _initialize(&(const ClassDef) {
249 .name = "Operation",
250 .superclass = _Object(),
251 .instanceSize = sizeof(Operation),
252 .interfaceSize = sizeof(OperationInterface),
253 .initialize = initialize,
254 });
255 });
256
257 return clazz;
258}
Class * _initialize(const ClassDef *def)
Initializes the given Class.
Definition Class.c:151
Class * _Object(void)
Definition Object.c:136
static void initialize(Class *clazz)
Definition Operation.c:222
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:90
An abstraction for discrete units of work, or tasks.
Definition Operation.h:53

◆ addDependency()

static void addDependency ( Operation *  self,
Operation *  dependency 
)
static

Definition at line 59 of file Operation.c.

59 {
60
61 assert(dependency);
62 assert(dependency != self);
63
64 assert($((Array *) self->dependencies, indexOfObject, dependency) == -1);
65
66 $(self->dependencies, addObject, dependency);
67}
static void addObject(Array *self, const ident obj)
Definition Array.c:181
static ssize_t indexOfObject(const Array *self, const ident obj)
Definition Array.c:403
Arrays.
Definition Array.h:56

◆ cancel()

static void cancel ( Operation *  self)
static

Definition at line 73 of file Operation.c.

73 {
74
75 if ($(self, isCancelled) || self->isFinished) {
76 return;
77 }
78
79 __atomic_store_n(&self->isCancelled, true, __ATOMIC_RELEASE);
80
81 if (self->isExecuting == false) {
82 OperationQueue *queue = self->queue;
83 if (queue) {
84 synchronized(queue->condition, {
85 $(queue->condition, signal);
86 });
87 }
88 }
89}
static bool isCancelled(const Operation *self)
Definition Operation.c:140
bool isFinished
true when this Operation is finished, false otherwise.
Definition Operation.h:116
bool isExecuting
true when this Operation is executing, false otherwise.
Definition Operation.h:111
OperationQueues provide threads of execution for Operations.

◆ copy()

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

Definition at line 35 of file Operation.c.

35 {
36
37 return NULL;
38}

◆ dealloc()

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

Definition at line 43 of file Operation.c.

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

◆ dependencies()

static Array * dependencies ( const Operation *  self)
static

Definition at line 95 of file Operation.c.

95 {
96
97 ident dependencies = $((Object *) self->dependencies, copy);
98
99 return (Array *) dependencies;
100}
static Object * copy(const Object *self)
Definition Operation.c:35
void * ident
The identity type, similar to Objective-C id.
Definition Types.h:49

◆ init()

static Operation * init ( Operation *  self)
static

Definition at line 106 of file Operation.c.

106 {
107
108 self = (Operation *) super(Object, self, init);
109 if (self) {
110
111 self->condition = $(alloc(Condition), init);
112 assert(self->condition);
113
114 self->dependencies = $(alloc(Array), init);
115 assert(self->dependencies);
116 }
117
118 return self;
119}
#define alloc(type)
Allocate and initialize and instance of type.
Definition Class.h:226
static Operation * init(Operation *self)
Definition Operation.c:106
POSIX Threads conditional variables.
Definition Condition.h:44

◆ initialize()

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

Definition at line 222 of file Operation.c.

222 {
223
224 ((ObjectInterface *) clazz->interface)->copy = copy;
225 ((ObjectInterface *) clazz->interface)->dealloc = dealloc;
226
227 ((OperationInterface *) clazz->interface)->addDependency = addDependency;
228 ((OperationInterface *) clazz->interface)->cancel = cancel;
229 ((OperationInterface *) clazz->interface)->dependencies = dependencies;
230 ((OperationInterface *) clazz->interface)->init = init;
231 ((OperationInterface *) clazz->interface)->initWithFunction = initWithFunction;
232 ((OperationInterface *) clazz->interface)->isCancelled = isCancelled;
233 ((OperationInterface *) clazz->interface)->isReady = isReady;
234 ((OperationInterface *) clazz->interface)->removeDependency = removeDepdenency;
235 ((OperationInterface *) clazz->interface)->start = start;
236 ((OperationInterface *) clazz->interface)->waitUntilFinished = waitUntilFinished;
237}
static void removeDepdenency(Operation *self, Operation *dependency)
Definition Operation.c:174
static void waitUntilFinished(const Operation *self)
Definition Operation.c:208
static Operation * initWithFunction(Operation *self, OperationFunction function, ident data)
Definition Operation.c:125
static void start(Operation *self)
Definition Operation.c:185
static void cancel(Operation *self)
Definition Operation.c:73
static void addDependency(Operation *self, Operation *dependency)
Definition Operation.c:59
static bool isReady(const Operation *self)
Definition Operation.c:148
Array * init(Array *self)
Initializes this Array.
Definition Array.c:420
ident interface
The interface of the Class.
Definition Class.h:100
void dealloc(Object *self)
Frees all resources held by this Object.
Definition Array.c:99
Operation * initWithFunction(Operation *self, OperationFunction function, ident data)
Initializes a synchronous Operation with the given function.
Definition Operation.c:125

◆ initWithFunction()

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

Definition at line 125 of file Operation.c.

125 {
126
127 self = $(self, init);
128 if (self) {
129 self->function = function;
130 self->data = data;
131 }
132
133 return self;
134}
static Data * data(void)
Definition Data.c:286
ident data
The user data.
Definition Operation.h:81
OperationFunction function
The Operation function.
Definition Operation.h:92

◆ isCancelled()

static bool isCancelled ( const Operation *  self)
static

Definition at line 140 of file Operation.c.

140 {
141 return __atomic_load_n(&self->isCancelled, __ATOMIC_ACQUIRE);
142}

◆ isReady()

static bool isReady ( const Operation *  self)
static

Definition at line 148 of file Operation.c.

148 {
149
150 if (self->isDispatched || self->isExecuting || self->isFinished) {
151 return false;
152 }
153
154 if ($(self, isCancelled)) {
155 return true;
156 }
157
158 const Array *dependencies = (Array *) self->dependencies;
159 for (size_t i = 0; i < dependencies->count; i++) {
160
161 Operation *dependency = $(dependencies, objectAtIndex, i);
162 if (dependency->isFinished == false) {
163 return false;
164 }
165 }
166
167 return true;
168}
static ident objectAtIndex(const Array *self, size_t index)
Definition Array.c:578
size_t count
The count of elements.
Definition Array.h:72
bool isDispatched
True once an OperationQueue has dispatched this Operation to one of its Threads, so that no other Thr...
Definition Operation.h:106

◆ removeDepdenency()

static void removeDepdenency ( Operation *  self,
Operation *  dependency 
)
static

Definition at line 174 of file Operation.c.

174 {
175
176 assert(dependency);
177
178 $(self->dependencies, removeObject, dependency);
179}
static void removeObject(Array *self, const ident obj)
Definition Array.c:642

◆ start()

static void start ( Operation *  self)
static

Definition at line 185 of file Operation.c.

185 {
186
187 if (self->isFinished || self->isExecuting) {
188 return;
189 }
190
191 if ($(self, isCancelled) == false) {
192 self->isExecuting = true;
193 self->function(self);
194 self->isExecuting = false;
195 }
196
197 self->isFinished = true;
198
199 synchronized(self->condition, {
200 $(self->condition, broadcast);
201 });
202}
static void broadcast(Condition *self)
Definition Condition.c:57

◆ waitUntilFinished()

static void waitUntilFinished ( const Operation *  self)
static

Definition at line 208 of file Operation.c.

208 {
209
210 synchronized(self->condition, {
211 while (self->isFinished == false) {
212 $(self->condition, wait);
213 }
214 });
215}