Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 21, 2009, 1:18:36 PM (15 years ago)
Author:
rgrieder
Message:

Found some non empty new lines.

Location:
code/branches/presentation2/src/libraries/network
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • code/branches/presentation2/src/libraries/network/Client.cc

    r6134 r6387  
    113113    return true;
    114114  }
    115  
     115
    116116  void Client::printRTT(){
    117117    COUT(0) << "Round trip time to server is " << ClientConnection::getRTT() << " ms" << endl;
    … …  
    155155    }
    156156    sendPackets(); // flush the enet queue
    157    
     157
    158158    Connection::processQueue();
    159159    if(gamestate.processGamestates())
    … …  
    167167    return;
    168168  }
    169  
     169
    170170  void Client::connectionClosed()
    171171  {

  • code/branches/presentation2/src/libraries/network/ClientConnection.cc

    r5965 r6387  
    6969  {
    7070    ENetEvent event;
    71    
     71
    7272    this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, 0, 0);
    7373    if ( this->host_ == NULL )
    … …  
    9999  bool ClientConnection::closeConnection() {
    100100    ENetEvent event;
    101    
     101
    102102    if ( !this->established_ )
    103103      return true;
    … …  
    146146    this->connectionClosed();
    147147  }
    148  
     148
    149149  uint32_t ClientConnection::getRTT()
    150150  {

  • code/branches/presentation2/src/libraries/network/ClientConnection.h

    r5961 r6387  
    2626 *
    2727 */
    28  
     28
    2929#ifndef _ClientConnection_H__
    3030#define _ClientConnection_H__
    … …  
    4040    ClientConnection();
    4141    virtual ~ClientConnection();
    42    
     42
    4343    void setServerAddress( const std::string& serverAddress );
    4444    void setPort( unsigned int port );
    45    
     45
    4646    ENetEvent *getEvent();
    4747    // check wheter the packet queue is empty
    … …  
    5959    virtual void addPeer(ENetEvent* event);
    6060    virtual void removePeer(ENetEvent* event);
    61    
     61
    6262    bool disconnectConnection();
    6363    // enet stuff

  • code/branches/presentation2/src/libraries/network/ClientConnectionListener.cc

    r5929 r6387  
    4545            it->clientConnected(clientID);
    4646    }
    47    
     47
    4848    void ClientConnectionListener::broadcastClientDisconnected(unsigned int clientID)
    4949    {

  • code/branches/presentation2/src/libraries/network/ClientConnectionListener.h

    r5929 r6387  
    4040            ClientConnectionListener();
    4141            virtual ~ClientConnectionListener() {}
    42            
     42
    4343            static void broadcastClientConnected(unsigned int clientID);
    4444            static void broadcastClientDisconnected(unsigned int clientID);

  • code/branches/presentation2/src/libraries/network/ClientInformation.cc

    r5961 r6387  
    4646namespace orxonox
    4747{
    48  
     48
    4949
    5050  ClientInformation *ClientInformation::head_=0;

  • code/branches/presentation2/src/libraries/network/Connection.cc

    r5929 r6387  
    7575  void Connection::processQueue() {
    7676    ENetEvent event;
    77    
     77
    7878    assert(this->host_);
    7979

  • code/branches/presentation2/src/libraries/network/Connection.h

    r5929 r6387  
    5454  public:
    5555    virtual ~Connection();
    56    
     56
    5757    static bool addPacket(ENetPacket *packet, ENetPeer *peer);
    5858    bool sendPackets();
    … …  
    6262    Connection();
    6363    static Connection* getInstance(){ return Connection::instance_; }
    64    
     64
    6565    int service(ENetEvent* event);
    6666    virtual void disconnectPeer(ENetPeer *peer);
    67    
     67
    6868    void processQueue();
    6969    virtual void addPeer(ENetEvent* event)=0;
    7070    virtual void removePeer(ENetEvent* event)=0;
    7171    virtual bool processPacket(ENetEvent* event);
    72    
     72
    7373    ENetHost *host_;
    7474  private:

  • code/branches/presentation2/src/libraries/network/FunctionCallManager.cc

    r6073 r6387  
    3131
    3232namespace orxonox {
    33    
     33
    3434std::map<uint32_t, packet::FunctionCalls*> FunctionCallManager::clientMap_;
    3535

  • code/branches/presentation2/src/libraries/network/FunctionCallManager.h

    r6073 r6387  
    4949  static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
    5050  static void addCallStatic(uint32_t functionID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
    51  
     51
    5252  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID);
    5353  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1);
    … …  
    5656  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4);
    5757  static void addCallMember(uint32_t functionID, uint32_t objectID, uint32_t clientID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5);
    58  
     58
    5959  static void sendCalls();
    60  
     60
    6161  static std::map<uint32_t, packet::FunctionCalls*> clientMap_;
    6262protected:

  • code/branches/presentation2/src/libraries/network/GamestateClient.cc

    r5929 r6387  
    8181    packet::Gamestate *processed = processGamestate(tempGamestate_);
    8282    assert(processed);
    83    
     83
    8484    //now call the queued callbacks
    8585    NetworkCallbackManager::callCallbacks();
    86    
     86
    8787    if (!processed){
    8888      sendAck(0);

  • code/branches/presentation2/src/libraries/network/GamestateHandler.cc

    r5781 r6387  
    3333
    3434GamestateHandler *GamestateHandler::instance_=0;
    35  
     35
    3636GamestateHandler::GamestateHandler()
    3737{

  • code/branches/presentation2/src/libraries/network/GamestateManager.cc

    r5929 r6387  
    126126    return true;
    127127  }
    128  
     128
    129129  void GamestateManager::sendGamestates()
    130130  {
    … …  
    142142      COUT(5) << "Server: doing gamestate gamestate preparation" << std::endl;
    143143      int cid = temp->getID(); //get client id
    144      
     144
    145145      unsigned int gID = temp->getGamestateID();
    146146      if(!reference)
    147147        return;
    148      
     148
    149149      packet::Gamestate *client=0;
    150150      if(gID != GAMESTATEID_INITIAL){
    … …  
    156156        }
    157157      }
    158      
     158
    159159      clientGamestates.push(0);
    160160      finishGamestate( cid, &clientGamestates.back(), client, reference );
    … …  
    165165//       this->threadPool_->passFunction( executor, true );
    166166//       (*functor)( cid, &(clientGamestates.back()), client, reference );
    167      
     167
    168168      temp = temp->next();
    169169    }
    170    
     170
    171171//     threadPool_->synchronise();
    172    
     172
    173173    while( !clientGamestates.empty() )
    174174    {
    … …  
    185185    // save the (undiffed) gamestate in the clients gamestate map
    186186    //chose wheather the next gamestate is the first or not
    187    
     187
    188188    packet::Gamestate *gs = gamestate->doSelection(clientID, 20000);
    189189//     packet::Gamestate *gs = new packet::Gamestate(*gamestate);
    … …  
    193193    gamestateMap_[clientID][gamestate->getID()]=gs;
    194194//     this->threadMutex_->unlock();
    195    
     195
    196196    if(base)
    197197    {
    198        
     198
    199199//       COUT(3) << "diffing" << std::endl;
    200200//       packet::Gamestate* gs1  = gs;
    … …  
    210210      gs = new packet::Gamestate(*gs);
    211211    }
    212    
    213    
     212
     213
    214214    bool b = gs->compressData();
    215215    assert(b);

  • code/branches/presentation2/src/libraries/network/NetworkFunction.cc

    r6160 r6387  
    3333{
    3434  std::map<uint32_t, bool> NetworkFunctionBase::isStaticMap_;
    35      
     35
    3636  std::map<NetworkFunctionPointer, NetworkMemberFunctionBase*> NetworkMemberFunctionBase::functorMap_;
    3737  std::map<uint32_t, NetworkMemberFunctionBase*> NetworkMemberFunctionBase::idMap_;
    … …  
    4040  {
    4141    RegisterRootObject(NetworkFunctionBase);
    42    
     42
    4343    static uint32_t networkID = 0;
    4444    this->networkID_ = networkID++;
    45    
     45
    4646    this->name_ = name;
    4747    NetworkFunctionBase::getNameMap()[name] = this;
    … …  
    5050  {
    5151  }
    52  
    53  
     52
     53
    5454  void NetworkFunctionBase::destroyAllNetworkFunctions()
    5555  {
    … …  
    5959      it->second->destroy();
    6060  }
    61  
    62  
     61
     62
    6363  /*static*/ std::map<std::string, NetworkFunctionBase*>& NetworkFunctionBase::getNameMap()
    6464  {
    … …  
    6666    return nameMap_;
    6767  }
    68  
    69  
     68
     69
    7070  NetworkFunctionStatic::NetworkFunctionStatic(FunctorStatic* functor, const std::string& name, const NetworkFunctionPointer& p):
    7171    NetworkFunctionBase(name)
    7272  {
    7373    RegisterObject(NetworkFunctionStatic);
    74    
     74
    7575    this->functor_ = functor;
    7676    NetworkFunctionStatic::getFunctorMap()[p] = this;
    7777    NetworkFunctionStatic::getIdMap()[ this->getNetworkID() ] = this;
    7878  }
    79  
     79
    8080  NetworkFunctionStatic::~NetworkFunctionStatic()
    8181  {
    8282    delete this->functor_;
    8383  }
    84  
     84
    8585  /*static*/ std::map<NetworkFunctionPointer, NetworkFunctionStatic*>& NetworkFunctionStatic::getFunctorMap()
    8686  {
    … …  
    8888    return functorMap_;
    8989  }
    90  
     90
    9191  /*static*/ std::map<uint32_t, NetworkFunctionStatic*>& NetworkFunctionStatic::getIdMap()
    9292  {
    … …  
    9494    return idMap_;
    9595  }
    96  
    97  
     96
     97
    9898  NetworkMemberFunctionBase::NetworkMemberFunctionBase(const std::string& name, const NetworkFunctionPointer& p):
    9999    NetworkFunctionBase(name)
    100100  {
    101101    RegisterObject(NetworkMemberFunctionBase);
    102    
     102
    103103    this->functorMap_[p] = this;
    104104    this->idMap_[ this->getNetworkID() ] = this;
    105105  }
    106  
     106
    107107  NetworkMemberFunctionBase::~NetworkMemberFunctionBase()
    108108  {
    109109  }
    110  
     110
    111111
    112112}

  • code/branches/presentation2/src/libraries/network/NetworkFunction.h

    r6160 r6387  
    7474    NetworkFunctionBase(const std::string& name);
    7575    ~NetworkFunctionBase();
    76    
     76
    7777    virtual void        setNetworkID(uint32_t id)       { this->networkID_ = id; }
    7878    inline uint32_t     getNetworkID() const            { return this->networkID_; }
    7979    inline const std::string& getName() const           { return name_; }
    8080    static inline bool  isStatic( uint32_t networkID )  { return isStaticMap_[networkID]; }
    81    
     81
    8282    static inline void setNetworkID(const std::string& name, uint32_t id)
    8383    {
    … …  
    8686        map[name]->setNetworkID(id);
    8787    }
    88    
     88
    8989    static void destroyAllNetworkFunctions();
    90    
     90
    9191  protected:
    9292    static std::map<uint32_t, bool> isStaticMap_;
    93    
     93
    9494  private:
    9595    static std::map<std::string, NetworkFunctionBase*>& getNameMap();
    9696    uint32_t networkID_;
    9797    std::string name_;
    98      
     98
    9999};
    100100
    … …  
    104104    NetworkFunctionStatic(FunctorStatic* functor, const std::string& name, const NetworkFunctionPointer& p);
    105105    ~NetworkFunctionStatic();
    106    
     106
    107107    inline void call(){ (*this->functor_)(); }
    108108    inline void call(const MultiType& mt1){ (*this->functor_)(mt1); }
    … …  
    111111    inline void call(const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4){ (*this->functor_)(mt1, mt2, mt3, mt4); }
    112112    inline void call(const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5){ (*this->functor_)(mt1, mt2, mt3, mt4, mt5); }
    113    
     113
    114114    virtual void setNetworkID( uint32_t id )
    115115        { NetworkFunctionBase::setNetworkID( id ); NetworkFunctionStatic::getIdMap()[id] = this; }
    … …  
    120120    static NetworkFunctionStatic* getFunction( const NetworkFunctionPointer& p )
    121121        { assert( NetworkFunctionStatic::getFunctorMap().find(p) != NetworkFunctionStatic::getFunctorMap().end() ); return NetworkFunctionStatic::getFunctorMap()[p]; }
    122        
     122
    123123  private:
    124124    static std::map<NetworkFunctionPointer, NetworkFunctionStatic*>& getFunctorMap();
    125125    static std::map<uint32_t, NetworkFunctionStatic*>& getIdMap();
    126126    FunctorStatic* functor_;
    127    
     127
    128128};
    129129
    … …  
    133133    NetworkMemberFunctionBase(const std::string& name, const NetworkFunctionPointer& p);
    134134    ~NetworkMemberFunctionBase();
    135    
     135
    136136    virtual void setNetworkID( uint32_t id ){ NetworkFunctionBase::setNetworkID( id ); idMap_[id] = this; }
    137137    static inline NetworkMemberFunctionBase* getNetworkFunction( uint32_t id){ assert( idMap_.find(id)!=idMap_.end() ); return idMap_[id]; }
    138138    static NetworkMemberFunctionBase* getFunction( uint32_t id ){ assert( idMap_.find(id) != idMap_.end() ); return idMap_[id]; }
    139139    static NetworkMemberFunctionBase* getFunction( const NetworkFunctionPointer& p ){ assert( functorMap_.find(p) != functorMap_.end() ); return functorMap_[p]; }
    140    
     140
    141141    //
    142142    virtual void call(uint32_t objectID)=0;
    … …  
    146146    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)=0;
    147147    virtual void call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)=0;
    148    
     148
    149149  private:
    150150    static std::map<NetworkFunctionPointer, NetworkMemberFunctionBase*> functorMap_;
    … …  
    157157    NetworkMemberFunction(FunctorMember<T>* functor, const std::string& name, const NetworkFunctionPointer& p);
    158158    ~NetworkMemberFunction();
    159    
     159
    160160    inline void call(uint32_t objectID)
    161161    {
    … …  
    188188        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);
    189189    }
    190    
     190
    191191  private:
    192192    FunctorMember<T>* functor_;

  • code/branches/presentation2/src/libraries/network/Server.cc

    r5961 r6387  
    137137    // receive incoming packets
    138138    Connection::processQueue();
    139    
     139
    140140    if ( ClientInformation::hasClients() )
    141141    {
    142142      // process incoming gamestates
    143143      GamestateManager::processGamestates();
    144      
     144
    145145      // send function calls to clients
    146146      FunctionCallManager::sendCalls();
    147      
     147
    148148      //this steers our network frequency
    149149      timeSinceLastUpdate_+=time.getDeltaTime();
    … …  
    160160    return ServerConnection::addPacket(packet, clientID);
    161161  }
    162  
     162
    163163  /**
    164164   * @brief: returns ping time to client in milliseconds
    … …  
    168168    return ClientInformation::findClient(clientID)->getRTT();
    169169  }
    170  
     170
    171171  void Server::printRTT()
    172172  {
    … …  
    317317    }
    318318    COUT(5) << "Con.Man: creating client id: " << temp->getID() << std::endl;
    319    
     319
    320320    // synchronise class ids
    321321    syncClassid(temp->getID());
    322    
     322
    323323    // now synchronise functionIDs
    324324    packet::FunctionIDs *fIDs = new packet::FunctionIDs();
    … …  
    326326    bool b = fIDs->send();
    327327    assert(b);
    328    
     328
    329329    temp->setSynched(true);
    330330    COUT(4) << "sending welcome" << std::endl;
    … …  
    344344    return true;
    345345  }
    346  
     346
    347347  void Server::disconnectClient( ClientInformation *client ){
    348348    ServerConnection::disconnectClient( client );

  • code/branches/presentation2/src/libraries/network/Server.h

    r5961 r6387  
    6666    unsigned int shipID(){return 0;}
    6767    unsigned int playerID(){return 0;}
    68    
     68
    6969    void addPeer(ENetEvent *event);
    7070    void removePeer(ENetEvent *event);
    71    
     71
    7272    bool createClient(int clientID);
    7373    void disconnectClient( ClientInformation *client);

  • code/branches/presentation2/src/libraries/network/ServerConnection.cc

    r5929 r6387  
    9999    return true;
    100100  }
    101  
     101
    102102  void ServerConnection::disconnectClient(ClientInformation *client)
    103103  {
    104104    Connection::disconnectPeer( client->getPeer() );
    105105  }
    106  
     106
    107107  void ServerConnection::disconnectClient(int clientID){
    108108    ClientInformation *client = ClientInformation::findClient(clientID);

  • code/branches/presentation2/src/libraries/network/ServerConnection.h

    r5929 r6387  
    5050  public:
    5151    ~ServerConnection();
    52    
     52
    5353    void setBindAddress( const std::string& bindAddress );
    5454    void setPort( unsigned int port );
    55    
     55
    5656    bool openListener();
    5757    bool closeListener();

  • code/branches/presentation2/src/libraries/network/TrafficControl.cc

    r6073 r6387  
    145145    assert(clientListPerm_.find(clientID) != clientListPerm_.end() );
    146146    assert( clientListTemp_[clientID].find(gamestateID) != clientListTemp_[clientID].end() );
    147    
     147
    148148    // shortcut for maps
    149149    std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
    … …  
    236236      //if listToProcess contains new Objects, add them to clientListPerm
    237237      std::list<obj>::iterator itvec;
    238    
     238
    239239      std::map<unsigned int, objInfo >& objectListPerm = clientListPerm_[clientID];
    240    
     240
    241241      for( itvec=list.begin(); itvec != list.end(); itvec++)
    242242      {
    … …  
    256256      }
    257257    //end compare listToProcess vs clientListPerm
    258      
     258
    259259      //sort copied list according to priorities
    260260      // use boost bind here because we need to pass a memberfunction to stl sort
    261261//       sort( list.begin(), list.end(), boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
    262262      list.sort( boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
    263      
     263
    264264//       list.sort(boost::bind(&TrafficControl::prioritySort, this, clientID, _1, _2) );
    265265
    … …  
    277277//       sort(list.begin(), list.end(), boost::bind(&TrafficControl::dataSort, this, _1, _2) );
    278278      list.sort( boost::bind(&TrafficControl::dataSort, this, _1, _2) );
    279      
     279
    280280      //diese Funktion updateClientList muss noch gemacht werden
    281281      updateClientListTemp(list);

  • code/branches/presentation2/src/libraries/network/TrafficControl.h

    r6073 r6387  
    6969      obj( uint32_t ID, uint32_t creatorID, uint32_t size, uint32_t offset );
    7070  };
    71  
     71
    7272
    7373
    … …  
    9797    unsigned int targetSize;
    9898    bool         bActive_;
    99    
     99
    100100    void insertinClientListPerm(unsigned int clientID, obj objinf);
    101    
     101
    102102    void cut(std::list<obj>& list, unsigned int targetsize);
    103103    void updateClientListTemp(std::list<obj>& list);//done
    … …  
    107107    void evaluateList(unsigned int clientID, std::list<obj>& list);//done   
    108108    void ack(unsigned int clientID, unsigned int gamestateID);  // this function gets called when the server receives an ack from the client
    109    
     109
    110110    //ClientConnectionListener functions
    111111    virtual void clientConnected(unsigned int clientID){};
    112112    virtual void clientDisconnected(unsigned int clientID);
    113113
    114  
     114
    115115  protected:
    116116    static TrafficControl *instance_;
    … …  
    131131    { return instance_->ack(clientID, gamestateID); }
    132132    void deleteObject(unsigned int objectID);               // this function gets called when an object has been deleted (in order to clean up lists and maps)
    133    
     133
    134134    bool prioritySort(uint32_t clientID, obj i, obj j);
    135135    bool dataSort(obj i, obj j);

  • code/branches/presentation2/src/libraries/network/packet/Acknowledgement.cc

    r5781 r6387  
    3838#define _PACKETID           0
    3939#define _ACKID              _PACKETID + sizeof(packet::Type::Value)
    40  
     40
    4141Acknowledgement::Acknowledgement( unsigned int id, unsigned int clientID )
    4242 : Packet()

  • code/branches/presentation2/src/libraries/network/packet/Chat.cc

    r5781 r6387  
    3535namespace orxonox {
    3636namespace packet {
    37  
     37
    3838#define   PACKET_FLAGS_CHAT PacketFlag::Reliable
    3939#define   _PACKETID         0

  • code/branches/presentation2/src/libraries/network/packet/ClassID.h

    r6073 r6387  
    3636namespace packet {
    3737
    38  
     38
    3939/**
    4040    @author

  • code/branches/presentation2/src/libraries/network/packet/DeleteObjects.cc

    r6192 r6387  
    4141#define _QUANTITY           _PACKETID + sizeof(Type::Value)
    4242#define _OBJECTIDS          _QUANTITY + sizeof(uint32_t)
    43  
     43
    4444DeleteObjects::DeleteObjects()
    4545 : Packet()

  • code/branches/presentation2/src/libraries/network/packet/FunctionCalls.cc

    r5781 r6387  
    3636namespace orxonox {
    3737namespace packet {
    38  
     38
    3939#define   PACKET_FLAGS_FUNCTIONCALLS PacketFlag::Reliable
    4040#define   _PACKETID         0
    4141const unsigned int FUNCTIONCALLS_MEM_ALLOCATION = 1000;
    42    
     42
    4343FunctionCalls::FunctionCalls()
    4444 : Packet()
    … …  
    171171void FunctionCalls::addCallStatic( uint32_t networkID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    172172  assert(!isDataENetAllocated());
    173  
     173
    174174  // first determine the size that has to be reserved for this call
    175175  uint32_t callsize = 2*sizeof(uint32_t)+sizeof(uint8_t); //size for network-function-id and nrOfArguments and for bool isStatic
    … …  
    200200    }
    201201  }
    202  
     202
    203203  // now allocated mem if neccessary
    204204  if( currentSize_ + callsize > currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION )
    … …  
    210210    data_ = temp;
    211211  }
    212  
     212
    213213  // now serialise the mt values and copy the function id and isStatic
    214214  uint8_t* temp = data_+currentSize_;
    … …  
    240240  //currentSize_ += callsize;
    241241  currentSize_ = temp-data_;
    242  
     242
    243243}
    244244
    245245void FunctionCalls::addCallMember( uint32_t networkID, uint32_t objectID, const MultiType* mt1, const MultiType* mt2, const MultiType* mt3, const MultiType* mt4, const MultiType* mt5){
    246246  assert(!isDataENetAllocated());
    247  
     247
    248248  // first determine the size that has to be reserved for this call
    249249  uint32_t callsize = 3*sizeof(uint32_t)+sizeof(uint8_t); //size for network-function-id and nrOfArguments and the objectID
    … …  
    274274    }
    275275  }
    276  
     276
    277277  // now allocated mem if neccessary
    278278  if( currentSize_ + callsize > currentMemBlocks_*FUNCTIONCALLS_MEM_ALLOCATION )
    … …  
    284284    data_ = temp;
    285285  }
    286  
     286
    287287  // now serialise the mt values and copy the function id
    288288  uint8_t* temp = data_+currentSize_;
    … …  
    314314  }
    315315  currentSize_ += callsize;
    316  
     316
    317317}
    318318

  • code/branches/presentation2/src/libraries/network/packet/FunctionIDs.cc

    r5781 r6387  
    5353  flags_ = flags_ | PACKET_FLAGS_FUNCTIONIDS;
    5454  std::queue<std::pair<uint32_t, std::string> > tempQueue;
    55  
     55
    5656  //calculate total needed size (for all strings and integers)
    5757  ObjectList<NetworkFunctionBase>::iterator it;
    … …  
    6464    packetSize += (functionname.size()+1)+sizeof(uint32_t)+sizeof(uint32_t); // reserver size for the functionname string, the functionname length and the networkID
    6565  }
    66  
     66
    6767  this->data_=new uint8_t[ packetSize ];
    6868  //set the appropriate packet id
    6969  assert(this->data_);
    7070  *(Type::Value *)(this->data_ + _PACKETID ) = Type::FunctionIDs;
    71  
     71
    7272  uint8_t *temp=data_+sizeof(uint32_t);
    7373  // save the number of all classes
    7474  *(uint32_t*)temp = nrOfFunctions;
    7575  temp += sizeof(uint32_t);
    76  
     76
    7777  // now save all classids and classnames
    7878  std::pair<uint32_t, std::string> tempPair;
    … …  
    8585    temp+=2*sizeof(uint32_t)+tempPair.second.size()+1;
    8686  }
    87  
     87
    8888  COUT(5) << "FunctionIDs packetSize is " << packetSize << endl;
    89  
     89
    9090}
    9191
    … …  
    106106  temp += sizeof(uint32_t);
    107107  totalsize += sizeof(uint32_t); // storage size for nr of all classes
    108  
     108
    109109  for(unsigned int i=0; i<nrOfFunctions; i++){
    110110    totalsize += 2*sizeof(uint32_t) + *(uint32_t*)(temp + sizeof(uint32_t)); // for each network function add size for id, sizeof(string) and length of string itself to totalsize
    … …  
    121121  uint32_t stringsize;
    122122  unsigned char *functionname;
    123  
     123
    124124  COUT(4) << "=== processing functionids: " << endl;
    125125  std::pair<uint32_t, std::string> tempPair;
    … …  
    127127  nrOfFunctions = *(uint32_t*)temp;
    128128  temp += sizeof(uint32_t);
    129  
     129
    130130  for( int i=0; i<nrOfFunctions; i++){
    131131    networkID = *(uint32_t*)temp;

  • code/branches/presentation2/src/libraries/network/packet/FunctionIDs.h

    r6073 r6387  
    3636namespace packet {
    3737
    38  
     38
    3939/**
    4040    @author

  • code/branches/presentation2/src/libraries/network/packet/Gamestate.cc

    r5929 r6387  
    9595    return false;
    9696  }
    97  
     97
    9898  // create the header object
    9999  assert( header_ == 0 );
    … …  
    105105  ObjectList<Synchronisable>::iterator it;
    106106  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
    107    
     107
    108108//     tempsize=it->getSize(id, mode);
    109109
    … …  
    111111    if ( tempsize != 0 )
    112112      dataVector_.push_back( obj(it->getObjectID(), it->getCreatorID(), tempsize, mem-data_) );
    113    
     113
    114114#ifndef NDEBUG
    115115    if(currentsize+tempsize > size){
    … …  
    362362  assert(!header_->isCompressed() && !base->header_->isCompressed());
    363363  assert(!header_->isDiffed());
    364  
     364
    365365  uint8_t *basep = GAMESTATE_START(base->data_);
    366366  uint8_t *gs = GAMESTATE_START(this->data_);
    367367  uint32_t dest_length = header_->getDataSize();
    368  
     368
    369369  if(dest_length==0)
    370370    return NULL;
    371  
     371
    372372  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
    373373  uint8_t *dest = GAMESTATE_START(ndata);
    374  
     374
    375375  rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
    376376#ifndef NDEBUG
    … …  
    398398  assert(!header_->isCompressed() && !base->header_->isCompressed());
    399399  assert(header_->isDiffed());
    400  
     400
    401401  uint8_t *basep = GAMESTATE_START(base->data_);
    402402  uint8_t *gs = GAMESTATE_START(this->data_);
    403403  uint32_t dest_length = header_->getDataSize();
    404  
     404
    405405  if(dest_length==0)
    406406    return NULL;
    407  
     407
    408408  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
    409409  uint8_t *dest = ndata + GamestateHeader::getSize();
    410  
     410
    411411  rawDiff( dest, gs, basep, header_->getDataSize(), base->header_->getDataSize() );
    412  
     412
    413413  Gamestate *g = new Gamestate(ndata, getClientID());
    414414  assert(g->header_);
    … …  
    481481  uint64_t* bd = (uint64_t*)basedata;
    482482  uint64_t* nd = (uint64_t*)newdata;
    483  
     483
    484484  unsigned int i;
    485485  for( i=0; i<datalength/8; i++ )

  • code/branches/presentation2/src/libraries/network/packet/Packet.cc

    r6105 r6387  
    101101@brief
    102102    Destroys a packet completely.
    103    
     103
    104104    That also means destroying the ENetPacket if one exists. There
    105105*/

  • code/branches/presentation2/src/libraries/network/synchronisable/NetworkCallback.h

    r6192 r6387  
    3636
    3737namespace orxonox{
    38  
     38
    3939  struct EmptyType{};
    40  
     40
    4141  class _NetworkExport NetworkCallbackBase
    4242  {
    … …  
    6060      void (T::*function_) (void);
    6161  };
    62  
     62
    6363  template <class T, class U>
    6464  class NetworkCallbackNotify: public NetworkCallbackBase

  • code/branches/presentation2/src/libraries/network/synchronisable/NetworkCallbackManager.cc

    r5781 r6387  
    2626 *
    2727 */
    28  
     28
    2929#include "NetworkCallbackManager.h"
    3030#include "NetworkCallback.h"
    3131
    3232namespace orxonox{
    33  
     33
    3434  std::set<NetworkCallbackBase*> NetworkCallbackManager::callbackSet_;
    3535  std::queue<NetworkCallbackBase*> NetworkCallbackManager::triggeredCallbacks_;
    36  
     36
    3737  void NetworkCallbackManager::registerCallback(NetworkCallbackBase *cb)
    3838  {
    … …  
    4848    }
    4949  }
    50  
     50
    5151  void NetworkCallbackManager::triggerCallback(NetworkCallbackBase *cb)
    5252  {

  • code/branches/presentation2/src/libraries/network/synchronisable/NetworkCallbackManager.h

    r5781 r6387  
    3737
    3838namespace orxonox{
    39  
     39
    4040  class _NetworkExport NetworkCallbackManager{
    4141    public:
    … …  
    4848      static std::queue<NetworkCallbackBase*> triggeredCallbacks_;
    4949  };
    50  
     50
    5151
    5252}

  • code/branches/presentation2/src/libraries/network/synchronisable/Synchronisable.cc

    r6192 r6387  
    6262    }
    6363    classID_ = static_cast<uint32_t>(-1);
    64    
     64
    6565    // set dataSize to 0
    6666    this->dataSize_ = 0;
    … …  
    277277      //tempsize += (*i)->getSize( mode );
    278278    }
    279    
     279
    280280    tempsize += SynchronisableHeader::getSize();
    281281    header.setObjectID( this->objectID_ );
    … …  
    284284    header.setDataAvailable( true );
    285285    header.setDataSize( tempsize );
    286    
     286
    287287#ifndef NDEBUG
    288288    uint32_t size;

  • code/branches/presentation2/src/libraries/network/synchronisable/Synchronisable.h

    r6193 r6387  
    132132    inline unsigned int getPriority() const { return this->objectFrequency_;}
    133133    inline uint8_t getSyncMode() const { return this->objectMode_; }
    134    
     134
    135135    void setSyncMode(uint8_t mode);
    136136
    … …  
    138138    Synchronisable(BaseObject* creator);
    139139    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
    140    
     140
    141141    void setPriority(unsigned int freq){ objectFrequency_ = freq; }
    142142
    … …  
    148148    bool isMyData(uint8_t* mem);
    149149    bool doSync(int32_t id, uint8_t mode=0x0);
    150    
     150
    151151    inline void setObjectID(uint32_t id){ this->objectID_ = id; objectMap_[this->objectID_] = this; }
    152152    inline void setClassID(uint32_t id){ this->classID_ = id; }
    … …  
    181181    }
    182182  }
    183  
     183
    184184  template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional);
    185185
    186  
     186
    187187}
    188188

  • code/branches/presentation2/src/libraries/network/synchronisable/SynchronisableVariable.h

    r6192 r6387  
    4141
    4242namespace orxonox{
    43  
     43
    4444  namespace VariableDirection{
    4545    enum Value{
    … …  
    5454    };
    5555  }
    56  
     56
    5757  class _NetworkExport SynchronisableVariableBase
    5858  {
    … …  
    8585      NetworkCallbackBase      *callback_;
    8686  };
    87  
     87
    8888  template <class T>
    8989  class SynchronisableVariableBidirectional: public SynchronisableVariable<T>
    … …  
    9292      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
    9393      virtual ~SynchronisableVariableBidirectional();
    94      
     94
    9595      virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^
    9696      virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode);
    … …  
    112112    }
    113113  }
    114  
     114
    115115  template <class T> SynchronisableVariable<T>::~SynchronisableVariable()
    116116  {
    … …  
    253253      return returnSize( this->variable_ ) + sizeof(varReference_);
    254254    }
    255  
     255
    256256
    257257}
Note: See TracChangeset for help on using the changeset viewer.