Promise.cc

Go to the documentation of this file.

/*
 * Promise.cc
 *
 * Smalltalk like class library for C++
 * Thread wrapper returning value.
 *
 * Copyright (c) 2003-05 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stlib/os/Promise.h>

#include <stlib/Object.h>
#include <stlib/Array.h>
#include <stlib/GenericException.h>

#include <stlib/os/Semaphore.h>
#include <stlib/os/Thread.h>

using namespace OS;

Promise::Promise(Callback<Object *> *receiver)
{
    Callback<void> *callback;

    _receiver = receiver;
    _arguments = nil;
    sync = new Semaphore;
    callback = new Callback0<Promise, void>(this, &Promise::executePromise);
    thread = new Thread(callback);
    has_value = false;
    _value = nil;
    _exception = nil;
}

Promise::~Promise(void)
{
    delete thread;
    thread = nil;
    _receiver = nil;
    delete sync;
}

/* Class-accessing protocol */
String *Promise::className(void) const
{
    return new String("Promise");
}

/* Instance creation protocol */
Promise *Promise::perform(Callback<Object *> *receiver, Array *args)
{
    Promise *promise;
    promise = new Promise(receiver);
    promise->arguments(args);
    promise->run();
    return promise;
}

void Promise::run(void)
{
    thread->run();
}

/* Accessing-child protocol */
void Promise::exception(GenericException *ex)
{
    /* Garbage collecor must be stopped here 'cause data are tranfered across
       two processes. If I don't stop it, it may reclaim the exception and
       thus cause segfault. */
//    GC_disable();
    _exception = ex;
    has_value = true;
    sync->signal();
//    GC_enable();
}

void Promise::value(Object *object)
{
    /* Garbage collecor must be stopped here 'cause data are tranfered across
       two processes. If I don't stop it, it may reclaim the value and
       thus cause segfault. */
//    GC_disable();
    _value = object;
    has_value = true;
    sync->signal();
//    GC_enable();
}

/* Accessing-parent protocol */
void Promise::arguments(Array *args)
{
    _arguments = args;
}

bool Promise::hasValue(void)
{
    return has_value;
}

Object *Promise::value(void)
{
    sync->wait();
    sync->signal();
    if (_exception != nil) {
        _exception->pass();
    }
    return _value;
}

/* Private protocol */
void Promise::executePromise(void)
{
    try {
        value(_receiver->executeWith(_arguments));
    }
    catch (GenericException *ex) {
        exception(ex);
    }
}

---