connection.h

网络游戏通用架构, 这是基于boost和libevent写的一个程序

#ifndef CONNECTION_H
#define CONNECTION_H

#include <stddef.h>
#include <assert.h>
#include <string.h>
#include <list>
#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/thread/recursive_mutex.hpp>

#include "common.h"
#include "socket_api.h"

using namespace std;
using namespace boost;

class Network;
class Remote;
class Message;

EXPORT void connection_accept( int __fd, short _event, void* __arg );
EXPORT void connection_recv( int __fd, short _event, void* __arg );
EXPORT void connection_send( int __fd, short _event, void* __arg );

class EXPORT Buffer
{
    friend class Connection;
    template< typename T >
    friend EXPORT Buffer& operator >> ( Buffer& __buffer, T& __t );
    template< typename T >
    friend EXPORT Buffer& operator << ( Buffer& __buffer, const T& __t );
public:
    Buffer& operator () ( char* __buf, int __len )
    {
        _buf= __buf;
        _len= __len;
        return *this;
    }
protected:
    char* _buf;
    int _len;
};

template< typename T >
EXPORT Buffer& operator >> ( Buffer& __buffer, T& __t );

template< typename T >
EXPORT Buffer& operator << ( Buffer& __buffer, const T& __t );

template< typename T >
Buffer& operator >> ( Buffer& __buffer, T* __t )
{
    return __buffer >> (*__t);
}

template< typename T >
Buffer& operator << ( Buffer& __buffer, const T* __t )
{
    return __buffer << (*__t);
}

#define INSTANTIATION_TYPE( TYPE ) \
    template<> \
    EXPORT Buffer& operator >> <TYPE> ( Buffer& __buffer, TYPE& __t ) \
    { \
        if( sizeof(TYPE) <= __buffer._len ){ \
            __t= ( *reinterpret_cast<TYPE*>( __buffer._buf ) ); \
            __buffer._buf += sizeof(TYPE); \
            __buffer._len -= sizeof(TYPE); \
        }else{ \
            throw -1; \
        } \
        return __buffer; \
    } \
    template<> \
    EXPORT Buffer& operator << <TYPE> ( Buffer& __buffer, const TYPE& __t ) \
    { \
        if( sizeof(TYPE) <= __buffer._len ){ \
            ( *reinterpret_cast<TYPE*>( __buffer._buf ) )= __t; \
            __buffer._buf += sizeof(TYPE); \
            __buffer._len -= sizeof(TYPE); \
        }else{ \
            throw -1; \
        } \
        return __buffer; \
    } \


class EXPORT Connection
{
friend class Network;
friend void connection_accept( int __fd, short _event, void* __arg );
friend void connection_recv( int __fd, short _event, void* __arg );
friend void connection_send( int __fd, short _event, void* __arg );
public:
    void send( shared_ptr<Message>& __msg_ptr );
    static int get_default_recv_buf_len(void);
    static void set_default_recv_buf_len( int __len );
    static int get_default_send_buf_len(void);
    static void set_default_send_buf_len( int __len );
    static int get_type_size(void);
    static void set_type_size( int __size );
    static int get_len_size(void);
    static void set_len_size( int __size );
    Remote* getRemote(void)
    {
        recursive_mutex::scoped_lock lock( _mutex );
        return _remote;
    }
    void setRemote( Remote* __remote )
    {
        recursive_mutex::scoped_lock lock( _mutex );
        _remote= __remote;
    }
protected:
    Connection();
    Connection( SOCKET __fd, sockaddr_in& __address );
    ~Connection();
protected:
    int listen( int __port, int __backlog );
    int connect( const char* __server_ip, int __port );
    void accept(void);
    void recv(void);
    void send(void);
protected:
    static Network* _network;
    static int _default_recv_buf_len;
    static int _default_send_buf_len;
    static int _type_size;//2 or 4
    static int _len_size;//2 or 4
    bool _connected;
    SOCKET _fd;
    sockaddr_in _address;
    Buffer BUFFER;
    /* recving states */
        int _recv_buf_len;
        char* _recv_buf;
        int _recv_data_len;
    /* sending states */
        int _send_buf_len;
        char* _send_buf;
        char* _send_data;
        int _send_data_len;
    event _read_ev;
    event _write_ev;
    Remote* _remote;
    list< shared_ptr<Message> > _msgs_sending;
    recursive_mutex _mutex;
    recursive_mutex _mutex_msgs_sending;
};

#endif