Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 2, 2008, 12:54:17 PM (16 years ago)
Author:
rgrieder
Message:

Test: replacing namespace network with namespace orxonox. network::packet —> orxonox::packet

Location:
code/branches/objecthierarchy/src/network
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • code/branches/objecthierarchy/src/network/ChatListener.cc

    r2072 r2112  
    3232#include "core/Core.h"
    3333
    34 namespace network
     34namespace orxonox
    3535{
    3636    ChatListener::ChatListener()

  • code/branches/objecthierarchy/src/network/ChatListener.h

    r2072 r2112  
    3535#include "core/OrxonoxClass.h"
    3636
    37 namespace network
     37namespace orxonox
    3838{
    39     class _NetworkExport ChatListener : virtual public orxonox::OrxonoxClass
     39    class _NetworkExport ChatListener : virtual public OrxonoxClass
    4040    {
    4141        public:

  • code/branches/objecthierarchy/src/network/Client.cc

    r2070 r2112  
    4949// #include "packet/Acknowledgement.h"
    5050
    51 namespace network
     51namespace orxonox
    5252{
    5353//   SetConsoleCommandShortcut(Client, chat);

  • code/branches/objecthierarchy/src/network/Client.h

    r1953 r2112  
    5454
    5555
    56 namespace network
     56namespace orxonox
    5757{
    5858  /**
    59   network::Client *client;
     59  Client *client;
    6060  * The network/Client class
    6161  * This class implements all necessary function for the network communication

  • code/branches/objecthierarchy/src/network/ClientConnection.cc

    r2111 r2112  
    4848#include "util/Debug.h"
    4949
    50 namespace network
     50namespace orxonox
    5151{
    5252  //static boost::thread_group network_threads;
    … …  
    7272  bool ClientConnection::waitEstablished(int milisec) {
    7373    for(int i=0; i<=milisec && !established; i++)
    74       orxonox::msleep(1);
     74      msleep(1);
    7575
    7676    return established;
    … …  
    184184      case ENET_EVENT_TYPE_NONE:
    185185        //receiverThread_->yield();
    186         orxonox::msleep(1);
     186        msleep(1);
    187187        break;
    188188      }

  • code/branches/objecthierarchy/src/network/ClientConnection.h

    r1953 r2112  
    5050namespace boost { class thread; }
    5151
    52 namespace network
     52namespace orxonox
    5353{
    5454

  • code/branches/objecthierarchy/src/network/ClientConnectionListener.cc

    r1949 r2112  
    33#include "core/Core.h"
    44
    5 namespace network{
     5namespace orxonox{
    66
    77  ClientConnectionListener::ClientConnectionListener()
    … …  
    1111
    1212  void ClientConnectionListener::getConnectedClients(){
    13     if(orxonox::Core::showsGraphics())
     13    if(Core::showsGraphics())
    1414      this->clientConnected(0); //server client id
    1515    ClientInformation *client = ClientInformation::getBegin();

  • code/branches/objecthierarchy/src/network/ClientConnectionListener.h

    r1940 r2112  
    66#include "core/OrxonoxClass.h"
    77
    8 namespace network{
     8namespace orxonox{
    99
    10   class _NetworkExport ClientConnectionListener : virtual public orxonox::OrxonoxClass
     10  class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
    1111  {
    1212    friend class Server;

  • code/branches/objecthierarchy/src/network/ClientInformation.cc

    r2009 r2112  
    4343#include <iostream> //debug
    4444
    45 namespace network
     45namespace orxonox
    4646{
    4747

  • code/branches/objecthierarchy/src/network/ClientInformation.h

    r2009 r2112  
    4848// WATCH OUT: THE CLIENTINFORMATION LIST IS NOT THREADSAFE ANYMORE
    4949
    50 namespace network
     50namespace orxonox
    5151{
    5252  static const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;

  • code/branches/objecthierarchy/src/network/ConnectionManager.cc

    r2111 r2112  
    6565}
    6666
    67 namespace network
     67namespace orxonox
    6868{
    6969  //boost::thread_group network_threads;
    … …  
    227227        case ENET_EVENT_TYPE_NONE:
    228228          //receiverThread_->yield();
    229           orxonox::msleep(1);
     229          msleep(1);
    230230          break;
    231231      }
    … …  
    306306    unsigned int network_id=0, failures=0;
    307307    std::string classname;
    308     orxonox::Identifier *id;
    309     std::map<std::string, orxonox::Identifier*>::const_iterator it = orxonox::Factory::getFactoryMapBegin();
    310     while(it != orxonox::Factory::getFactoryMapEnd()){
     308    Identifier *id;
     309    std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
     310    while(it != Factory::getFactoryMapEnd()){
    311311      id = (*it).second;
    312312      if(id == NULL)

  • code/branches/objecthierarchy/src/network/ConnectionManager.h

    r1953 r2112  
    5959}
    6060
    61 namespace network
     61namespace orxonox
    6262{
    6363    const int NETWORK_PORT = 55556;

  • code/branches/objecthierarchy/src/network/GamestateClient.cc

    r2063 r2112  
    3939
    4040
    41 namespace network
     41namespace orxonox
    4242{
    4343  struct _NetworkExport GameStateItem{
    … …  
    9494  * @return iterator pointing to the next object in the list
    9595  */
    96   void GamestateClient::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
    97     orxonox::ObjectList<Synchronisable>::iterator temp=it;
     96  void GamestateClient::removeObject(ObjectList<Synchronisable>::iterator &it) {
     97    ObjectList<Synchronisable>::iterator temp=it;
    9898    ++it;
    9999    delete  *temp;

  • code/branches/objecthierarchy/src/network/GamestateClient.h

    r2006 r2112  
    5050const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
    5151
    52 namespace network
     52namespace orxonox
    5353{
    5454  class _NetworkExport GamestateClient: public GamestateHandler
    … …  
    6666  private:
    6767    packet::Gamestate *processGamestate(packet::Gamestate *gs);
    68     void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     68    void removeObject(ObjectListIterator<Synchronisable> &it);
    6969    void printGamestateMap();
    7070    bool sendAck(unsigned int gamestateID);

  • code/branches/objecthierarchy/src/network/GamestateHandler.cc

    r1763 r2112  
    44#include "packet/Packet.h"
    55
    6 namespace network {
     6namespace orxonox {
    77
    88GamestateHandler *GamestateHandler::instance_=0;
    … …  
    2222
    2323
    24 }//namespace network
     24}//namespace orxonox

  • code/branches/objecthierarchy/src/network/GamestateHandler.h

    r1990 r2112  
    3434#include "packet/Chat.h"
    3535
    36 namespace network {
     36namespace orxonox {
    3737
    3838/**

  • code/branches/objecthierarchy/src/network/GamestateManager.cc

    r2035 r2112  
    5151#include "Synchronisable.h"
    5252
    53 namespace network
     53namespace orxonox
    5454{
    5555  GamestateManager::GamestateManager() {

  • code/branches/objecthierarchy/src/network/GamestateManager.h

    r1990 r2112  
    4747#include "packet/Gamestate.h"
    4848
    49 namespace network
     49namespace orxonox
    5050{
    5151

  • code/branches/objecthierarchy/src/network/Host.cc

    r1953 r2112  
    3434#include "ChatListener.h"
    3535
    36 namespace network {
     36namespace orxonox {
    3737
    3838SetConsoleCommandShortcut(Host, Chat);
    … …  
    8080// }
    8181
    82 // bool Host::receiveChat(network::packet::Chat *message, unsigned int clientID){
     82// bool Host::receiveChat(packet::Chat *message, unsigned int clientID){
    8383//   if(instance_)
    8484//     return instance_->processChat(message, clientID);
    … …  
    110110
    111111bool Host::incomingChat(const std::string& message, unsigned int playerID){
    112   for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
     112  for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
    113113    it->incomingChat(message, playerID);
    114114
    … …  
    116116}
    117117
    118 }//namespace network
     118}//namespace orxonox

  • code/branches/objecthierarchy/src/network/Host.h

    r1953 r2112  
    3434#include "packet/Chat.h"
    3535
    36 namespace network {
     36namespace orxonox {
    3737
    3838/**

  • code/branches/objecthierarchy/src/network/NetworkCallback.h

    r1947 r2112  
    44#include "NetworkPrereqs.h"
    55
    6 namespace network{
     6namespace orxonox{
    77  class _NetworkExport NetworkCallbackBase
    88  {

  • code/branches/objecthierarchy/src/network/NetworkPrereqs.h

    r1938 r2112  
    5959// Forward declarations
    6060//-----------------------------------------------------------------------
    61 namespace network
     61namespace orxonox
    6262{
    6363  class Client;

  • code/branches/objecthierarchy/src/network/PacketBuffer.cc

    r1505 r2112  
    3939#include <boost/thread/mutex.hpp>
    4040
    41 namespace network
     41namespace orxonox
    4242{
    4343   boost::recursive_mutex PacketBuffer::mutex_;
    … …  
    147147  }
    148148
    149 } // namespace network
     149} // namespace orxonox

  • code/branches/objecthierarchy/src/network/PacketBuffer.h

    r1916 r2112  
    4747#include <boost/thread/recursive_mutex.hpp>
    4848
    49 namespace network
     49namespace orxonox
    5050{
    5151  struct _NetworkExport PacketEnvelope{

  • code/branches/objecthierarchy/src/network/Server.cc

    r2048 r2112  
    6060#include "ChatListener.h"
    6161
    62 namespace network
     62namespace orxonox
    6363{
    6464  const unsigned int MAX_FAILURES = 20;
    … …  
    317317
    318318    // inform all the listeners
    319     orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
     319    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
    320320    while(listener){
    321321      listener->clientConnected(newid);
    … …  
    366366
    367367// inform all the listeners
    368     orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
     368    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
    369369    while(listener){
    370370      listener->clientDisconnected(client->getID());
    … …  
    404404    }
    405405//    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
    406     for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
     406    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
    407407      it->incomingChat(message, clientID);
    408408

  • code/branches/objecthierarchy/src/network/Server.h

    r2009 r2112  
    4949#include "GamestateManager.h"
    5050
    51 namespace network
     51namespace orxonox
    5252{
    5353  const int CLIENTID_SERVER = 0;

  • code/branches/objecthierarchy/src/network/Synchronisable.cc

    r2062 r2112  
    5050// #include "core/Identifier.h"
    5151
    52 namespace network
     52namespace orxonox
    5353{
    5454
    … …  
    6363  * Initializes all Variables and sets the right objectID
    6464  */
    65   Synchronisable::Synchronisable(orxonox::BaseObject* creator){
     65  Synchronisable::Synchronisable(BaseObject* creator){
    6666    RegisterRootObject(Synchronisable);
    6767    static uint32_t idCounter=0;
    … …  
    9696  Synchronisable::~Synchronisable(){
    9797    // delete callback function objects
    98     if(!orxonox::Identifier::isCreatingHierarchy()){
     98    if(!Identifier::isCreatingHierarchy()){
    9999      for(std::list<synchronisableVariable *>::iterator it = syncList->begin(); it!=syncList->end(); it++)
    100100        delete (*it)->callback;
    … …  
    155155    COUT(4) << "fabricating object with id: " << header->objectID << std::endl;
    156156
    157     orxonox::Identifier* id = ClassByID(header->classID);
     157    Identifier* id = ClassByID(header->classID);
    158158    assert(id);
    159     orxonox::BaseObject* creator = 0;
     159    BaseObject* creator = 0;
    160160    if (header->creatorID != OBJECTID_UNKNOWN)
    161161    {
    … …  
    167167      }
    168168      else
    169         creator = dynamic_cast<orxonox::BaseObject*>(synchronisable_creator);
    170     }
    171     orxonox::BaseObject *bo = id->fabricate(creator);
     169        creator = dynamic_cast<BaseObject*>(synchronisable_creator);
     170    }
     171    BaseObject *bo = id->fabricate(creator);
    172172    assert(bo);
    173173    Synchronisable *no = dynamic_cast<Synchronisable *>(bo);
    … …  
    214214   */
    215215  Synchronisable* Synchronisable::getSynchronisable(unsigned int objectID){
    216     orxonox::ObjectList<Synchronisable>::iterator it;
    217     for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
     216    ObjectList<Synchronisable>::iterator it;
     217    for(it = ObjectList<Synchronisable>::begin(); it; ++it){
    218218      if( it->getObjectID()==objectID )
    219219           return *it;
    … …  
    234234  * @param var pointer to the variable
    235235  * @param size size of the datatype the variable consists of
    236   * @param t the type of the variable (network::DATA or network::STRING
     236  * @param t the type of the variable (DATA or STRING
    237237  * @param mode same as in getData
    238238  * @param cb callback object that should get called, if the value of the variable changes

  • code/branches/objecthierarchy/src/network/Synchronisable.h

    r2034 r2112  
    4242
    4343#define REGISTERDATA(varname, ...) \
    44     registerVar((void*)&varname, sizeof(varname), network::DATA, __VA_ARGS__)
     44    registerVar((void*)&varname, sizeof(varname), DATA, __VA_ARGS__)
    4545#define REGISTERSTRING(stringname, ...) \
    46     registerVar(&stringname, stringname.length()+1, network::STRING, __VA_ARGS__)
     46    registerVar(&stringname, stringname.length()+1, STRING, __VA_ARGS__)
    4747
    48 namespace network
     48namespace orxonox
    4949{
    5050  static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
    … …  
    9595  * @author Oliver Scheuss
    9696  */
    97   class _NetworkExport Synchronisable : virtual public orxonox::OrxonoxClass{
     97  class _NetworkExport Synchronisable : virtual public OrxonoxClass{
    9898  public:
    9999    friend class packet::Gamestate;
    … …  
    115115    inline unsigned int getClassID(){return classID;}
    116116  protected:
    117     Synchronisable(orxonox::BaseObject* creator);
     117    Synchronisable(BaseObject* creator);
    118118    void registerVar(void *var, int size, variableType t, int mode=1, NetworkCallbackBase *cb=0);
    119119    void setObjectMode(int mode);

  • code/branches/objecthierarchy/src/network/packet/Acknowledgement.cc

    r1907 r2112  
    3333#include "core/CoreIncludes.h"
    3434
    35 namespace network {
     35namespace orxonox {
    3636namespace packet {
    3737
    3838#define PACKET_FLAGS_ACK    0
    3939#define _PACKETID           0
    40 #define _ACKID              _PACKETID + sizeof(network::packet::ENUM::Type)
     40#define _ACKID              _PACKETID + sizeof(packet::ENUM::Type)
    4141 
    4242Acknowledgement::Acknowledgement( unsigned int id, unsigned int clientID )
    … …  
    7474
    7575} //namespace packet
    76 } //namespace network
     76} //namespace orxonox

  • code/branches/objecthierarchy/src/network/packet/Acknowledgement.h

    r1916 r2112  
    3333
    3434
    35 namespace network {
     35namespace orxonox {
    3636namespace packet {
    3737/**
    … …  
    5353
    5454} //namespace packet
    55 } //namespace network
     55} //namespace orxonox
    5656
    5757#endif

  • code/branches/objecthierarchy/src/network/packet/Chat.cc

    r1907 r2112  
    3131#include "network/Host.h"
    3232
    33 namespace network {
     33namespace orxonox {
    3434namespace packet {
    3535 
    … …  
    7777
    7878} //namespace packet
    79 } //namespace network
     79} //namespace orxonox

  • code/branches/objecthierarchy/src/network/packet/Chat.h

    r1916 r2112  
    1010#include "Packet.h"
    1111
    12 namespace network {
     12namespace orxonox {
    1313namespace packet {
    1414/**
    … …  
    3333
    3434} //namespace packet
    35 } //namespace network
     35} //namespace orxonox
    3636
    3737#endif

  • code/branches/objecthierarchy/src/network/packet/ClassID.cc

    r1907 r2112  
    3434#include <assert.h>
    3535
    36 namespace network {
     36namespace orxonox {
    3737namespace packet {
    3838
    … …  
    6868
    6969unsigned int ClassID::getSize() const{
    70   return sizeof(network::packet::ENUM::Type) + 2*sizeof(uint32_t) + classNameLength_;
     70  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t) + classNameLength_;
    7171}
    7272
    7373bool ClassID::process(){
    7474  COUT(3) << "processing classid: " << getClassID() << " name: " << (const char*)(data_+_CLASSNAME) << std::endl;
    75   orxonox::Identifier *id=ClassByID( std::string((const char*)(data_+_CLASSNAME) ));
     75  Identifier *id=ClassByID( std::string((const char*)(data_+_CLASSNAME) ));
    7676  if(id==NULL)
    7777    return false;
    … …  
    8686
    8787} //namespace packet
    88 }//namespace network
     88}//namespace orxonox

  • code/branches/objecthierarchy/src/network/packet/ClassID.h

    r1916 r2112  
    3535#include "Packet.h"
    3636
    37 namespace network {
     37namespace orxonox {
    3838namespace packet {
    3939
    … …  
    5959
    6060} //namespace packet
    61 } //namespace network
     61} //namespace orxonox
    6262
    6363#endif

  • code/branches/objecthierarchy/src/network/packet/DeleteObjects.cc

    r1907 r2112  
    3434#include <assert.h>
    3535
    36 namespace network {
     36namespace orxonox {
    3737namespace packet {
    3838
    … …  
    9595
    9696} //namespace packet
    97 } //namespace network
     97} //namespace orxonox

  • code/branches/objecthierarchy/src/network/packet/DeleteObjects.h

    r1916 r2112  
    3434
    3535
    36 namespace network {
     36namespace orxonox {
    3737namespace packet {
    3838/**
    … …  
    5555
    5656} //namespace packet
    57 } //namespace network
     57} //namespace orxonox
    5858
    5959#endif

  • code/branches/objecthierarchy/src/network/packet/Gamestate.cc

    r2111 r2112  
    3838
    3939
    40 namespace network {
     40namespace orxonox {
    4141
    4242namespace packet {
    … …  
    9393  uint8_t *mem=data_;
    9494  mem+=sizeof(GamestateHeader);
    95   orxonox::ObjectList<Synchronisable>::iterator it;
    96   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
     95  ObjectList<Synchronisable>::iterator it;
     96  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
    9797    tempsize=it->getSize(id, mode);
    9898
    … …  
    100100      // start allocate additional memory
    101101      COUT(3) << "G.St.Man: need additional memory" << std::endl;
    102       orxonox::ObjectList<Synchronisable>::iterator temp = it;
     102      ObjectList<Synchronisable>::iterator temp = it;
    103103      int addsize=tempsize;
    104104      while(++temp)
    … …  
    147147  uint8_t *mem=data_+sizeof(GamestateHeader);
    148148    // get the start of the Synchronisable list
    149   //orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
     149  //ObjectList<Synchronisable>::iterator it=ObjectList<Synchronisable>::begin();
    150150  Synchronisable *s;
    151151
    … …  
    244244  //copy and modify header
    245245#ifndef NDEBUG
    246   HEADER->crc32 = orxonox::calcCRC(data_+sizeof(GamestateHeader), HEADER->datasize);
     246  HEADER->crc32 = calcCRC(data_+sizeof(GamestateHeader), HEADER->datasize);
    247247#endif
    248248  *GAMESTATE_HEADER(ndata) = *HEADER;
    … …  
    281281  }
    282282#ifndef NDEBUG
    283   assert(HEADER->crc32==orxonox::calcCRC(ndata+sizeof(GamestateHeader), HEADER->datasize));
     283  assert(HEADER->crc32==calcCRC(ndata+sizeof(GamestateHeader), HEADER->datasize));
    284284#endif
    285285
    … …  
    569569  int size=0;
    570570    // get the start of the Synchronisable list
    571   orxonox::ObjectList<Synchronisable>::iterator it;
     571  ObjectList<Synchronisable>::iterator it;
    572572    // get total size of gamestate
    573   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
     573  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
    574574    size+=it->getSize(id, mode); // size of the actual data of the synchronisable
    575575//  size+=sizeof(GamestateHeader);
    … …  
    582582 * @return iterator pointing to the next object in the list
    583583 */
    584   void Gamestate::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
    585     orxonox::ObjectList<Synchronisable>::iterator temp=it;
     584  void Gamestate::removeObject(ObjectList<Synchronisable>::iterator &it) {
     585    ObjectList<Synchronisable>::iterator temp=it;
    586586    ++it;
    587587    delete  *temp;

  • code/branches/objecthierarchy/src/network/packet/Gamestate.h

    r1916 r2112  
    4040#endif
    4141
    42 namespace network {
     42namespace orxonox {
    4343
    4444namespace packet {
    … …  
    9191  private:
    9292    unsigned int calcGamestateSize(unsigned int id, int mode=0x0);
    93     void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
     93    void removeObject(ObjectListIterator<Synchronisable> &it);
    9494    std::map<unsigned int, Synchronisable*> dataMap_;
    9595};

  • code/branches/objecthierarchy/src/network/packet/Packet.cc

    r2084 r2112  
    4646#include "core/CoreIncludes.h"
    4747
    48 namespace network{
     48namespace orxonox{
    4949
    5050namespace packet{
    … …  
    153153//  ENetPacket *temp = enetPacket_;
    154154//  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
    155   network::Host::addPacket( enetPacket_, clientID_);
     155  Host::addPacket( enetPacket_, clientID_);
    156156  return true;
    157157}
    … …  
    219219} // namespace packet
    220220
    221 } // namespace network
    222 
     221} // namespace orxonox
     222

  • code/branches/objecthierarchy/src/network/packet/Packet.h

    r2070 r2112  
    3636#include "util/Integers.h"
    3737
    38 namespace network {
     38namespace orxonox {
    3939
    4040namespace packet{
    … …  
    9898} //namespace packet
    9999
    100 } //namespace network
     100} //namespace orxonox
    101101
    102102#endif

  • code/branches/objecthierarchy/src/network/packet/Welcome.cc

    r1907 r2112  
    3636#include <assert.h>
    3737
    38 namespace network {
     38namespace orxonox {
    3939namespace packet {
    4040
    … …  
    7070
    7171unsigned int Welcome::getSize() const{
    72   return sizeof(network::packet::ENUM::Type) + 2*sizeof(uint32_t);
     72  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t);
    7373}
    7474
    … …  
    8787
    8888} //namespace packet
    89 }//namespace network
     89}//namespace orxonox

  • code/branches/objecthierarchy/src/network/packet/Welcome.h

    r1916 r2112  
    3333#include "Packet.h"
    3434
    35 namespace network {
     35namespace orxonox {
    3636namespace packet {
    3737
    … …  
    5454
    5555} //namespace packet
    56 } //namespace network
     56} //namespace orxonox
    5757
    5858#endif
Note: See TracChangeset for help on using the changeset viewer.