source: source/ariba/utility/transport/asio/asio_io_service.cpp@ 5450

// Internal version: Please do not publish!
// (... until released under FreeBSD-like license *g*)
// Code: Sebastian Mies <mies@tm.uka.de>

#include "asio_io_service.h"

#include <boost/asio.hpp>
#include <boost/thread.hpp>

namespace ariba {
namespace transport {
namespace detail {

using namespace boost::asio;
using namespace std;

asio_io_service* asio_io_service::singleton = NULL;

//#define DBG(x) cout << x << endl;
#define DBG(x)

void asio_io_service::operator ()() {
        running = true;
        DBG("io_service started");
        boost::asio::io_service::work work(*service);
        service->run();
        DBG("io_service stopped");
        if (destroy) {
                delete singleton;
                singleton = NULL;
                DBG(cout << "asio io_service singleton destroyed" << endl);
        }
        running = false;
}

asio_io_service::asio_io_service() :
        references(1), running(false), destroy(false), thread(NULL), service(NULL) {
        service = new io_service();
}

asio_io_service::~asio_io_service() {
        if (thread != NULL) delete thread;
        if (service != NULL) delete service;
        thread = NULL;
        service = NULL;
}

void asio_io_service::internal_start() {
        if (!running) {
                if (thread != NULL) delete thread;
                thread = new boost::thread(boost::ref(*this));
        }
}

void asio_io_service::internal_stop() {
        service->stop();
        singleton->running = false;
}

io_service& asio_io_service::alloc() {
        if (singleton != NULL) {
                DBG("new asio io_service reference");
                singleton->references++;
                return *singleton->service;
        } else {
                DBG("creating new asio io_service singleton");
                singleton = new asio_io_service();
                return *singleton->service;
        }
}

void asio_io_service::free() {
        if (singleton != NULL) {
                DBG("decreasing asio io_service reference");
                singleton->references--;
                if (singleton->references == 0) {
                        DBG("request asio io_service destruction");
                        if (singleton->running == false) {
                                delete singleton;
                                singleton = NULL;
                                DBG("asio io_service singleton destroyed");
                        } else {
                                singleton->destroy = true;
                                singleton->service->stop();
                        }
                }
        }
}

void asio_io_service::start() {
        singleton->internal_start();
}

void asio_io_service::stop() {
        singleton->internal_stop();
}


}}} // namespace ariba::transport::detail