BaseOFConnection.hh

#ifndef __BASEOFCONNECTION_HH__
#define __BASEOFCONNECTION_HH__

#include <stdlib.h>
#include <vector>

#include "fluid/base/EventLoop.hh"

namespace fluid_base {
class BaseOFHandler;

class BaseOFConnection {
public:
    BaseOFConnection(int id,
                     BaseOFHandler* ofhandler,
                     EventLoop* evloop,
                     int fd,
                     bool secure);
    virtual ~BaseOFConnection();

    enum Event {
        EVENT_UP,
        EVENT_DOWN,
        EVENT_CLOSED
    };

    void send(void* data, size_t len);

    void add_timed_callback(void* (*cb)(void*), int interval, void* arg);
    // TODO: add the option for the function to unschedule itself by returning
    // false

    // TODO: these methods are not thread-safe, and they really aren't
    // currently called from more than one thread. But perhaps we should
    // consider that...

    void set_manager(void* manager);

    void* get_manager();

    int get_id();

    void close();

    static void free_data(void* data);

private:
    int id;
    EventLoop* evloop;
    class OFReadBuffer;
    OFReadBuffer* buffer;
    void* manager;
    bool secure;
    BaseOFHandler* ofhandler;

    bool running;
    
    // Types for internal use (timed callbacks)
    struct timed_callback {
        void* (*cb)(void*);
        void* cb_arg;
        void* data;
    };
    std::vector<struct timed_callback*> timed_callbacks;

    void notify_msg_cb(void* data, size_t n);
    void notify_conn_cb(BaseOFConnection::Event event_type);
    void do_close();

    class LibEventBaseOFConnection;
    friend class LibEventBaseOFConnection;
    LibEventBaseOFConnection* m_implementation;
};

class BaseOFHandler {
public:
    virtual ~BaseOFHandler() {}

    virtual void base_connection_callback(BaseOFConnection* conn,
                                          BaseOFConnection::Event event_type)
                                          = 0;

    virtual void base_message_callback(BaseOFConnection* conn,
                                       void* data,
                                       size_t len) = 0;
                                       
    virtual void free_data(void* data) = 0;                                       
};

}

#endif