1

     2

#include <cassert>

     3

     4

#include "Object.hh"

     5

     6

/* 

     7

 * NetworkObject_Controller 

     8

 */

     9

NetworkObjectController::NetworkObjectController (NetworkSession &session, NetworkChannelID channel_id) :

    10

    session(session), channel_id(channel_id) {

    11

    12

    // setup signals

    13

    slot_message = session.sig_chan_message(channel_id).connect(this, &NetworkObjectController::on_message);

    14

}

    15

    16

void NetworkObjectController::on_message (NetworkPacketInput &pkt, NetworkNode *node) {

    17

    uint32_t obj_id = pkt.read_uint32();

    18

    uint16_t msg_id = pkt.read_uint16();

    19

    20

    // lookup object

    21

    NetworkObject *obj = objects[obj_id];

    22

    23

    if (obj) {

    24

        obj->handle_packet(node, msg_id, pkt);

    25

    26

    } else {

    27

        handle_create(obj_id, msg_id, pkt, node);

    28

    }

    29

}

    30

    31

NetworkObject* NetworkObjectController::read_object (NetworkPacketInput &pkt) {

    32

    uint32_t obj_id = pkt.read_uint32();

    33

    34

    // lookup object

    35

    NetworkObject *obj = obj_id ? objects[obj_id] : NULL;

    36

    37

    // return

    38

    return obj;

    39

}

    40

    41

/* 

    42

 * NetworkObject_ServerController 

    43

 */

    44

NetworkObject_ServerController::NetworkObject_ServerController (NetworkSession &session, NetworkChannelID channel_id) :

    45

    NetworkObjectController(session, channel_id), id_pool(0) {

    46

    47

}

    48

    49

NetworkObjectID NetworkObject_ServerController::getObjectID (void) {

    50

    return ++id_pool;

    51

}

    52

    53

void NetworkObject_ServerController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node) {

    54

    (void) obj_id;

    55

    (void) msg_id;

    56

    (void) pkt;

    57

    (void) node;

    58

    59

    // XXX: fail

    60

    throw CL_Error("clients cannot create objects");

    61

}

    62

    63

/* 

    64

 * NetworkObject_ClientController *

    65

 */

    66

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

    67

    NetworkObjectController(session, channel_id), server(server) 

    68

{

    69

    70

    71

}

    72

    73

void NetworkObject_ClientController::handle_create (NetworkObjectID obj_id, NetworkMessageID msg_id, NetworkPacketInput &pkt, NetworkNode *node) {

    74

    // we only communicate with the server

    75

    if (node != &server)

    76

        assert(false);

    77

    78

    // create new object

    79

    NetworkObject_Client *obj = new NetworkObject_Client(*this, obj_id);

    80

    81

    // signal

    82

    // XXX: this leaks if it's not handled

    83

   _map_sig_create[msg_id](obj, pkt); 

    84

}

    85

    86

/* 

    87

 * NetworkObject 

    88

 */

    89

NetworkObject::NetworkObject (NetworkObjectController &controller, NetworkObjectID obj_id) :

    90

    controller(controller), obj_id(obj_id) {

    91

    92

    assert(obj_id);

    93

    94

    controller.objects[obj_id] = this;

    95

}

    96

    97

NetworkObject::~NetworkObject (void) {

    98

    controller.objects.erase(obj_id);

    99

}

   100

   101

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

   102

    return s << "<NetworkObject #" << obj.obj_id << ">";

   103

}

   104

   105

/* 

   106

 * NetworkObject_Server 

   107

 */

   108

NetworkObject_Server::NetworkObject_Server (NetworkObject_ServerController &controller) :

   109

    NetworkObject(controller, controller.getObjectID()), controller(controller) {

   110

   111

}

   112

   113

void NetworkObject_Server::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt) {

   114

    _map_sig_message[msg_id](node, pkt);

   115

}

   116

   117

/* 

   118

 * NetworkObject_Client 

   119

 */

   120

NetworkObject_Client::NetworkObject_Client (NetworkObject_ClientController &controller, NetworkObjectID id) :

   121

    NetworkObject(controller, id), controller(controller) { 

   122

   123

    // nothing

   124

}

   125

   126

void NetworkObject_Client::handle_packet (NetworkNode *node, NetworkMessageID msg_id, NetworkPacketInput &pkt) {

   127

    if (node != &controller.server)

   128

        throw Error("Reject NetworkObject packet from non-server");

   129

   130

    _map_sig_message[msg_id](pkt);

   131

}

   132