Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members
OS::Promise

OS::Promise Class Reference

Promise is a special kind of Thread (even if it doesn't inherit from). More...

#include <Promise.h>

Inheritance diagram for OS::Promise:

Inheritance graph
[legend]
Collaboration diagram for OS::Promise:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 Promise (Callback< Object * > *receiver)
virtual ~Promise (void)
virtual String * className (void) const
 Answer receiver class name.
virtual void run (void)
virtual void exception (GenericException *ex)
virtual void value (Object *object)
virtual void arguments (Array *args)
virtual bool hasValue (void)
virtual Object * value (void)
virtual void executePromise (void)

Static Public Member Functions

static Promise * perform (Callback< Object * > *receiver, Array *args=nil)
template<class TReceiver>
static Promise * perform (TReceiver *receiver, Object *(TReceiver::*execFunc)(void))
template<class TReceiver>
static Promise * perform (TReceiver *receiver, Object *(TReceiver::*execFunc)(Array *), Array *args)

Protected Attributes

Callback< Object * > * _receiver
Array * _arguments
Thread * thread
Semaphore * sync
Object * _value
bool has_value
GenericException * _exception

Detailed Description

Promise is a special kind of Thread (even if it doesn't inherit from).

Unlike Thread, Promise can answer return value of executed code (or exception if one occures).

Definition at line 44 of file Promise.h.

Constructor & Destructor Documentation

Promise::Promise (  Callback< Object * > *  receiver  ) 
 

Definition at line 35 of file Promise.cc.

References _arguments, _exception, _receiver, _value, executePromise(), has_value, nil, sync, and thread.

Referenced by perform().

00036 {
00037     Callback<void> *callback;
00038 
00039     _receiver = receiver;
00040     _arguments = nil;
00041     sync = new Semaphore;
00042     callback = new Callback0<Promise, void>(this, &Promise::executePromise);
00043     thread = new Thread(callback);
00044     has_value = false;
00045     _value = nil;
00046     _exception = nil;
00047 }

Promise::~Promise (  void   )  [virtual]
 

Definition at line 49 of file Promise.cc.

References _receiver, nil, sync, and thread.

00050 {
00051     delete thread;
00052     thread = nil;
00053     _receiver = nil;
00054     delete sync;
00055 }

Member Function Documentation

void Promise::arguments (  Array *  args  )  [virtual]
 

Definition at line 104 of file Promise.cc.

References _arguments.

Referenced by perform().

00105 {
00106     _arguments = args;
00107 }

String * Promise::className (  void   )  const [virtual]
 

Answer receiver class name.

Because there isn't any standard way to obtain class name this method comes to place.

Every class should rewrite this method but many didn't (yet).

Reimplemented from Core::Object.

Definition at line 58 of file Promise.cc.

00059 {
00060     return new String("Promise");
00061 }

void Promise::exception (  GenericException *  ex  )  [virtual]
 

Definition at line 79 of file Promise.cc.

References _exception, has_value, OS::Semaphore::signal(), and sync.

Referenced by executePromise().

00080 {
00081     /* Garbage collecor must be stopped here 'cause data are tranfered across
00082        two processes. If I don't stop it, it may reclaim the exception and
00083        thus cause segfault. */
00084 //    GC_disable();
00085     _exception = ex;
00086     has_value = true;
00087     sync->signal();
00088 //    GC_enable();
00089 }

void Promise::executePromise (  void   )  [virtual]
 

Definition at line 125 of file Promise.cc.

References _arguments, _receiver, exception(), Core::Callback< ReturnT >::executeWith(), and value().

Referenced by Promise().

00126 {
00127     try {
00128         value(_receiver->executeWith(_arguments));
00129     }
00130     catch (GenericException *ex) {
00131         exception(ex);
00132     }
00133 }

bool Promise::hasValue (  void   )  [virtual]
 

Definition at line 109 of file Promise.cc.

References has_value.

00110 {
00111     return has_value;
00112 }

template<class TReceiver>
static Promise* OS::Promise::perform (  TReceiver *  receiver,
Object *(TReceiver::*)(Array *)  execFunc,
Array *  args
)  [inline, static]
 

Definition at line 75 of file Promise.h.

References perform().

00077     {
00078         Callback1<TReceiver,Object*,Array*> *callback;
00079         callback = new Callback1<TReceiver,Object*,Array*>(receiver, execFunc);
00080         return perform(callback, args);
00081     }

template<class TReceiver>
static Promise* OS::Promise::perform (  TReceiver *  receiver,
Object *(TReceiver::*)(void)  execFunc
)  [inline, static]
 

Definition at line 67 of file Promise.h.

References perform().

00068     {
00069         Callback0<TReceiver,Object *> *callback;
00070         callback = new Callback0<TReceiver,Object *>(receiver, execFunc);
00071         return perform(callback);
00072     }

Promise * Promise::perform (  Callback< Object * > *  receiver,
Array *  args = nil
)  [static]
 

Definition at line 64 of file Promise.cc.

References arguments(), Promise(), and run().

Referenced by perform().

00065 {
00066     Promise *promise;
00067     promise = new Promise(receiver);
00068     promise->arguments(args);
00069     promise->run();
00070     return promise;
00071 }

void Promise::run (  void   )  [virtual]
 

Definition at line 73 of file Promise.cc.

References OS::Thread::run(), and thread.

Referenced by perform().

00074 {
00075     thread->run();
00076 }

Object * Promise::value (  void   )  [virtual]
 

Definition at line 114 of file Promise.cc.

References _exception, _value, nil, Core::GenericException::pass(), OS::Semaphore::signal(), sync, and OS::Semaphore::wait().

Referenced by executePromise().

00115 {
00116     sync->wait();
00117     sync->signal();
00118     if (_exception != nil) {
00119         _exception->pass();
00120     }
00121     return _value;
00122 }

void Promise::value (  Object *  object  )  [virtual]
 

Definition at line 91 of file Promise.cc.

References _value, has_value, OS::Semaphore::signal(), and sync.

00092 {
00093     /* Garbage collecor must be stopped here 'cause data are tranfered across
00094        two processes. If I don't stop it, it may reclaim the value and
00095        thus cause segfault. */
00096 //    GC_disable();
00097     _value = object;
00098     has_value = true;
00099     sync->signal();
00100 //    GC_enable();
00101 }

Member Data Documentation

Array* OS::Promise::_arguments [protected]
 

Definition at line 48 of file Promise.h.

Referenced by arguments(), executePromise(), and Promise().

GenericException* OS::Promise::_exception [protected]
 

Definition at line 54 of file Promise.h.

Referenced by exception(), Promise(), and value().

Callback<Object *>* OS::Promise::_receiver [protected]
 

Definition at line 47 of file Promise.h.

Referenced by executePromise(), Promise(), and ~Promise().

Object* OS::Promise::_value [protected]
 

Definition at line 52 of file Promise.h.

Referenced by Promise(), and value().

bool OS::Promise::has_value [protected]
 

Definition at line 53 of file Promise.h.

Referenced by exception(), hasValue(), Promise(), and value().

Semaphore* OS::Promise::sync [protected]
 

Definition at line 51 of file Promise.h.

Referenced by exception(), Promise(), value(), and ~Promise().

Thread* OS::Promise::thread [protected]
 

Definition at line 49 of file Promise.h.

Referenced by Promise(), run(), and ~Promise().

The documentation for this class was generated from the following files:
Generated on Mon Nov 27 09:52:22 2006 for Smalltalk like C++ Class Library by  doxygen 1.4.2