event_loop_cxx.h

Go to the documentation of this file.

#ifndef EVENT_LOOP_CXX_H
#define EVENT_LOOP_CXX_H

#include "event_loop.h"
#include "cgul_exception_cxx.h"

class event_loop_cxx {

public:

    typedef event_loop__timeout_t timeout_t;

    typedef event_loop__fd_ready_cb_t fd_ready_cb_t;

    typedef event_loop__timeout_cb_t timeout_cb_t;

    typedef event_loop__signal_cb_t signal_cb_t;

    static event_loop_cxx*
    get_instance()
    {
        /* Get the current underlying event_loop singleton.  (It can
         * change if "put_instance()" is called.) */
        cgul_exception_t local = NULL;
        event_loop_t instance = event_loop__get_instance(&local);
        if (local) {
            throw cgul_exception_cxx(local);
        }
        /* The original m_obj is freed early via the static constructor. */
        s_instance_wrapper.m_obj = instance;
        return &s_instance_wrapper;
    }

    static void
    put_instance()
    {
        event_loop__put_instance();
        s_instance_wrapper.m_obj = NULL;
    }

    event_loop_cxx()
    {
        cgul_exception_t local = NULL;
        m_obj = event_loop__new(&local);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual
    ~event_loop_cxx()
    {
        /* Note that set_obj() is programmed to reject any attempt to
         * set "m_obj" to be the "event_loop" singleton so "m_obj"
         * should only ever be a per-thread "event_loop" instance
         * which we are free to delete. */
        if (m_obj) {
            event_loop__delete(m_obj);
            m_obj = NULL;
        }
    }

    virtual void
    start()
    {
        cgul_exception_t local = NULL;
        event_loop__start(&local, m_obj);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    stop()
    {
        cgul_exception_t local = NULL;
        event_loop__stop(&local, m_obj);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_signal_handler(int signal_number,
                       signal_cb_t cb,
                       void* cb_data)
    {
        cgul_exception_t local = NULL;
        event_loop__add_signal_handler(
            &local, m_obj, signal_number, cb, cb_data);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_signal_handler(
        int signal_number,
        event_loop_listener* obj,
        void (event_loop_listener::*listener)(int))
    {
        cgul_exception_t local = NULL;
        event_loop__add_signal_handler_listener(
            &local, m_obj, signal_number, obj, listener);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    remove_signal_handler(int signal_number)
    {
        cgul_exception_t local = NULL;
        event_loop__remove_signal_handler(&local, m_obj, signal_number);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual timeout_t
    add_timeout(double period,
                timeout_cb_t cb,
                void* cb_data)
    {
        timeout_t rv = NULL;
        cgul_exception_t local = NULL;
        rv = event_loop__add_timeout(&local, m_obj, period, cb, cb_data);
        if (local) {
            throw cgul_exception_cxx(local);
        }
        return rv;
    }

    virtual timeout_t
    add_timeout(
        double period,
        event_loop_listener* obj,
        void (event_loop_listener::*listener)(timeout_t))
    {
        timeout_t rv = NULL;
        cgul_exception_t local = NULL;
        rv = event_loop__add_timeout_listener(
                 &local, m_obj, period, obj, listener);
        if (local) {
            throw cgul_exception_cxx(local);
        }
        return rv;
    }

    virtual void
    remove_timeout(timeout_t timeout)
    {
        cgul_exception_t local = NULL;
        event_loop__remove_timeout(&local, m_obj, timeout);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_read_fd(int fd,
                fd_ready_cb_t cb,
                void* cb_data)
    {
        cgul_exception_t local = NULL;
        event_loop__add_read_fd(&local, m_obj, fd, cb, cb_data);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_read_fd(
        int fd,
        event_loop_listener* obj,
        void (event_loop_listener::*listener)(int))
    {
        cgul_exception_t local = NULL;
        event_loop__add_read_fd_listener(&local, m_obj, fd, obj, listener);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    remove_read_fd(int fd)
    {
        cgul_exception_t local = NULL;
        event_loop__remove_read_fd(&local, m_obj, fd);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_write_fd(int fd,
                 fd_ready_cb_t cb,
                 void* cb_data)
    {
        cgul_exception_t local = NULL;
        event_loop__add_write_fd(&local, m_obj, fd, cb, cb_data);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_write_fd(
        int fd,
        event_loop_listener* obj,
        void (event_loop_listener::*listener)(int))
    {
        cgul_exception_t local = NULL;
        event_loop__add_write_fd_listener(&local, m_obj, fd, obj, listener);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    remove_write_fd(int fd)
    {
        cgul_exception_t local = NULL;
        event_loop__remove_write_fd(&local, m_obj, fd);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_exception_fd(int fd,
                     fd_ready_cb_t cb,
                     void* cb_data)
    {
        cgul_exception_t local = NULL;
        event_loop__add_exception_fd(&local, m_obj, fd, cb, cb_data);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    add_exception_fd(
        int fd,
        event_loop_listener* obj,
        void (event_loop_listener::*listener)(int))
    {
        cgul_exception_t local = NULL;
        event_loop__add_exception_fd_listener(&local, m_obj, fd, obj, listener);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual void
    remove_exception_fd(int fd)
    {
        cgul_exception_t local = NULL;
        event_loop__remove_exception_fd(&local, m_obj, fd);
        if (local) {
            throw cgul_exception_cxx(local);
        }
    }

    virtual event_loop_t
    get_obj() const
    {
        return m_obj;
    }

    virtual event_loop_t
    take_obj()
    {
        event_loop_t rv = m_obj;
        m_obj = NULL;
        return rv;
    }

    virtual void
    set_obj(event_loop_t rhs)
    {
        /* Do not let the user set the underlying object to be the
         * singleton "event_loop" instance because access to the
         * singleton should only be through the get_instance() method;
         * otherwise, the singleton would be deleted when this object
         * goes out of scope. */
        if (rhs && (rhs != m_obj) && (rhs != get_instance()->get_obj())) {
            if (m_obj) {
                event_loop__delete(m_obj);
            }
            m_obj = rhs;
        }
    }

private:

    /* Hide these. */
    event_loop_cxx(const event_loop_cxx&);
    event_loop_cxx& operator=(const event_loop_cxx&);

    /* Static Constructor */
    class StaticConstructor {
    public:
        StaticConstructor();
    };

    static StaticConstructor s_staticConstructor;

    static event_loop_cxx s_instance_wrapper;

    event_loop_t m_obj;

};

#endif  /*  EVENT_LOOP_CXX_H  */