1

#ifndef NETWORK_OBJECT_HH

     2

#define NETWORK_OBJECT_HH

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Object-based network protocol for use with NetworkSession

     8

 */

     9

    10

#include "Session.hh"

    11

#include "Node.hh"

    12

#include "../Logger.hh"

    13

    14

#include <map>

    15

    16

/**

    17

 * A NetworkObject's ID is a 32-bit integer

    18

 */

    19

typedef uint32_t NetworkObjectID;

    20

    21

/**

    22

 * A NetworkObject's message type is a 16-bit integer

    23

 */

    24

typedef uint16_t NetworkMessageID;

    25

    26

// forward-declare

    27

class NetworkObject;

    28

class NetworkObject_Client;

    29

class NetworkObject_Server;

    30

    31

/**

    32

 * A NetworkObjectController contains a mapping of NetworkObjectID -> NetworkObject, and handles the

    33

 * messages received on our channel from the NetworkSession.

    34

 *

    35

 * Additionally, this provides methods to read/write NetworkObject references from/to a NetworkPacket

    36

 */

    37

class NetworkObjectController {

    38

    friend class NetworkObject;

    39

    friend class NetworkObject_Server;

    40

    friend class NetworkObject_Client;

    41

    42

    // XXX: needs to access session and channel_id

    43

    friend class NetworkMessage;

    44

    45

    private:

    46

        /**

    47

         * The NetworkSession that we use

    48

         */

    49

        NetworkSession &session;

    50

    51

        /**

    52

         * The NetworkChannelID that we use to communicate

    53

         */

    54

        NetworkChannelID channel_id;

    55

    56

        /**

    57

         * Our map of NetworkObjectID -> NetworkObject

    58

         */

    59

        std::map<NetworkObjectID, NetworkObject*> objects;

    60

    61

        CL_Slot slot_message;

    62

    63

    protected:

    64

        /**

    65

         * Construct a NetworkObjectController to use the given NetworkSession and NetworkChannelID

    66

         */

    67

        NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id);

    68

    69

    private:

    70

        /**

    71

         * Our NetworkSession::sig_chan_message handler

    72

         *

    73

         * Reads the NetworkObjectID and NetworkMessageID from the packet, and then either calls handle_create or

    74

         * NetworkObject::handle_packet.

    75

         */

    76

        void on_message (NetworkPacketInput &pkt, NetworkNode *node);

    77

    78

    protected:

    79

        /**

    80

         * Abstract method called by on_message if we recieve a message for an unknown NetworkObjectID

    81

         *

    82

         * @param obj_id the unknown NetworkObjectID

    83

         * @param msg_id the packet's NetworkMessageID

    84

         * @param pkt the packet itself, with the header read

    85

         * @param node the node that we got this packet from

    86

         */

    87

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node) = 0; 

    88

    89

    public:

    90

        /**

    91

         * Read an NetworkObjectID from the given packet, and return the corresponding NetworkObject, or NULL if:

    92

         *  * it was zero

    93

         *  * we don't know the object (should this thrown an exception instead?)

    94

         *

    95

         * @return the NetworkObject* corresponding to the NetworkObjectID in the packet, or NULL if zero/not found

    96

         */

    97

        NetworkObject* read_object (NetworkPacketInput &pkt);

    98

};

    99

   100

/**

   101

 * A NetworkObjectController intended for use with a server.

   102

 *

   103

 * This has an id_pool that new NetworkObjectIDs can be generated from, and this doesn't accept unknown

   104

 * NetworkObjectIDs from clients.

   105

 */

   106

class NetworkObject_ServerController : public NetworkObjectController {

   107

    friend class NetworkObject_Server;

   108

   109

    private:

   110

        /**

   111

         * The id_pool that we use to generate NetworkObjectIDs for new NetworkObject's

   112

         */

   113

        NetworkObjectID id_pool;

   114

   115

    public:

   116

        /**

   117

         * @see NetworkObjectController

   118

         */

   119

        NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id);

   120

   121

    protected:

   122

        /**

   123

         * Get a new NetworkObjectID

   124

         */

   125

        NetworkObjectID getObjectID (void);

   126

   127

        /**

   128

         * Throw an error, as we don't accept unknown NetworkObjects from clients

   129

         */

   130

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node);

   131

};

   132

   133

/**

   134

 * A NetworkObjectController intended for use with a client.

   135

 *

   136

 * This provides two ways to handle unknown objects: override handle_create, or use sig_create

   137

 */

   138

class NetworkObject_ClientController : public NetworkObjectController {

   139

    friend class NetworkObject_Client;

   140

   141

    protected:

   142

        /**

   143

         * The server node, as returned by NetworkSession::connect

   144

         */

   145

        NetworkNode &server;

   146

   147

        /**

   148

         * A mapping of NetworkMessageID -> sig_create, used by the default handle_create

   149

         */

   150

        std::map<NetworkMessageID, CL_Signal_v2<NetworkObject_Client*, NetworkPacketInput&> > _map_sig_create;

   151

   152

    public:

   153

        /**

   154

         * Construct a NetworkObjectController using the given NetworkNode (as returned by NetworkSession::connect) as

   155

         * a server.

   156

         *

   157

         * @see NetworkObjectController

   158

         */

   159

        NetworkObject_ClientController (NetworkSession &session, NetworkChannelID channel_id, NetworkNode &server);

   160

   161

    protected:

   162

        /**

   163

         * Handle unknown NetworkObjectIDs by constructing a new NetworkObject_Client and calling sig_create.

   164

         * 

   165

         * This can be overriden to handle this differently, e.g. to create an instance of a NetworkObject_Client

   166

         * subclass instead.

   167

         */

   168

        virtual void handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node);

   169

   170

    public:  

   171

        /**

   172

         * Signal triggered by default handle_create when we get a message for an unknown NetworkObject.

   173

         * The signal gets the new NetworkObject_Client, and the packet itself.

   174

         *

   175

         * @param msg_id the NetworkMessageID to handle creates for

   176

         */

   177

        CL_Signal_v2<NetworkObject_Client*, NetworkPacketInput&>& sig_create (NetworkMessageID msg_id) { return _map_sig_create[msg_id]; }

   178

};

   179

   180

/**

   181

 * Base class of NetworkObject_(Client/Server)

   182

 *

   183

 * A NetworkObject has an NetworkObjectID, and can handle packets to/from this object

   184

 */

   185

class NetworkObject {

   186

    friend class NetworkObjectController;

   187

    friend std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

   188

   189

    // XXX: needs to access controller and obj_id

   190

    friend class NetworkMessage;

   191

   192

    protected:

   193

        /**

   194

         * Generic controller

   195

         */

   196

        NetworkObjectController &controller;

   197

   198

        /**

   199

         * This object's object id

   200

         */

   201

        NetworkObjectID obj_id;

   202

   203

    protected:

   204

        /**

   205

         * Construct a NetworkObject using the given controller and object id

   206

         *

   207

         * @param controller the NetworkObjectController (subclass)

   208

         * @param obj_id our NetworkObjectID

   209

         */

   210

        NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id);

   211

   212

        /**

   213

         * Removes this object from the controller's objects list

   214

         */

   215

        ~NetworkObject (void);

   216

   217

        /**

   218

         * Abstract method to handle packets sent to this object

   219

         *

   220

         * @param node the NetworkNode that sent this packet to us

   221

         * @param msg_id the packet's NetworkMessageID

   222

         * @param pkt the packet itself, with the headers read

   223

         */

   224

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt) = 0;

   225

};

   226

   227

/**

   228

 * Formats the object as "<NetworkObject #" <obj_id> ">"

   229

 */

   230

std::ostream& operator<< (std::ostream &s, const NetworkObject &obj);

   231

   232

/**

   233

 * A server-side NetworkObject

   234

 */

   235

class NetworkObject_Server : public NetworkObject {

   236

    friend class NetworkObject_ServerController;

   237

   238

    protected:

   239

        /**

   240

         * The NetworkObject_ServerController

   241

         */

   242

        NetworkObject_ServerController &controller;

   243

   244

        /**

   245

         * Mapping of NetworkMessageID -> sig_message used for received messages

   246

         */

   247

        std::map<NetworkMessageID, CL_Signal_v2<NetworkNode*, NetworkPacketInput&> > _map_sig_message;

   248

   249

    public:

   250

        /**

   251

         * @see NetworkObject

   252

         */

   253

        NetworkObject_Server (NetworkObject_ServerController &controller);

   254

   255

    protected:

   256

        /**

   257

         * Handle an incoming packet by invoking the appopriate sig_message

   258

         *

   259

         * @see NetworkObject::handlePacket

   260

         */

   261

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt);

   262

   263

    public:

   264

        /**

   265

         * Triggered whenever we receive a message of the given type on this object, giving the node that sent it and the

   266

         * packet itself

   267

         *

   268

         * @param msg_id the NetworkMessageID to handle

   269

         */

   270

        CL_Signal_v2<NetworkNode*, NetworkPacketInput&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }

   271

};

   272

   273

/**

   274

 * A client-side NetworkObject

   275

 */

   276

class NetworkObject_Client : public NetworkObject {

   277

    friend class NetworkObject_ClientController;

   278

   279

    protected:

   280

        /**

   281

         * Our NetworkObject_ClientController

   282

         */

   283

        NetworkObject_ClientController &controller;

   284

   285

        /**

   286

         * Our mapping of NetworkMessageID -> sig_message, used to handle received packets

   287

         */

   288

        std::map<NetworkMessageID, CL_Signal_v1<NetworkPacketInput&> > _map_sig_message;

   289

   290

    protected:

   291

        /**

   292

         * @see NetworkObject

   293

         */

   294

        NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id);

   295

   296

        /**

   297

         * Handle an incoming packet by invoking the appropriate sig_message.

   298

         *

   299

         * This assumes that packets only come from the server

   300

         *

   301

         * @see NetworkObject::handlePacket

   302

         */

   303

        virtual void handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt);

   304

   305

    public:

   306

        /**

   307

         * Triggered whenever we receive a message of the given type on this object from the server.

   308

         *

   309

         * @param msg_id the NetworkMessageID to handle

   310

         */

   311

        CL_Signal_v1<NetworkPacketInput&>& sig_message (NetworkMessageID msg_id) { return _map_sig_message[msg_id]; }

   312

};

   313

   314

#endif /* NETWORK_OBJECT_HH */