Changeset 2531 for code/branches/bugger/src/network

Timestamp:

Dec 23, 2008, 11:09:55 PM (16 years ago)

Author:

rgrieder

Message:

Merged revision 2371 to bugger branch.

Location:

code/branches/bugger

Files:

• . (modified) (1 prop)
• src/network/CMakeLists.txt (modified) (1 diff)
• src/network/Client.cc (modified) (1 diff)
• src/network/ClientInformation.cc (modified) (1 diff)
• src/network/ClientInformation.h (modified) (1 diff)
• src/network/ConnectionManager.cc (modified) (1 diff)
• src/network/GamestateClient.cc (modified) (2 diffs)
• src/network/GamestateManager.cc (modified) (3 diffs)
• src/network/NetworkCallback.h (deleted)
• src/network/NetworkPrereqs.h (modified) (2 diffs)
• src/network/Synchronisable.cc (deleted)
• src/network/Synchronisable.h (deleted)
• src/network/TrafficControl.cc (copied) (copied from code/branches/presentation/src/network/TrafficControl.cc)
• src/network/TrafficControl.h (copied) (copied from code/branches/presentation/src/network/TrafficControl.h)
• src/network/packet/DeleteObjects.cc (modified) (1 diff)
• src/network/packet/Gamestate.cc (modified) (18 diffs)
• src/network/packet/Gamestate.h (modified) (3 diffs)
• src/network/packet/Welcome.cc (modified) (5 diffs)
• src/network/synchronisable (copied) (copied from code/branches/presentation/src/network/synchronisable)
• src/network/synchronisable/CMakeLists.txt (copied) (copied from code/branches/presentation/src/network/synchronisable/CMakeLists.txt)
• src/network/synchronisable/NetworkCallback.h (copied) (copied from code/branches/presentation/src/network/synchronisable/NetworkCallback.h)
• src/network/synchronisable/NetworkCallbackManager.cc (copied) (copied from code/branches/presentation/src/network/synchronisable/NetworkCallbackManager.cc)
• src/network/synchronisable/NetworkCallbackManager.h (copied) (copied from code/branches/presentation/src/network/synchronisable/NetworkCallbackManager.h)
• src/network/synchronisable/Synchronisable.cc (copied) (copied from code/branches/presentation/src/network/synchronisable/Synchronisable.cc) (2 diffs)
• src/network/synchronisable/Synchronisable.h (copied) (copied from code/branches/presentation/src/network/synchronisable/Synchronisable.h) (1 diff)
• src/network/synchronisable/SynchronisableSpecialisations.cc (copied) (copied from code/branches/presentation/src/network/synchronisable/SynchronisableSpecialisations.cc)
• src/network/synchronisable/SynchronisableVariable.cc (copied) (copied from code/branches/presentation/src/network/synchronisable/SynchronisableVariable.cc)
• src/network/synchronisable/SynchronisableVariable.h (copied) (copied from code/branches/presentation/src/network/synchronisable/SynchronisableVariable.h)

code/branches/bugger/src/network/CMakeLists.txt

@@ -11 +11 @@
   PacketBuffer.cc
   Server.cc
-  Synchronisable.cc
+  TrafficControl.cc
   Host.cc
 )
 
 ADD_SOURCE_DIRECTORY(NETWORK_SRC_FILES packet)
+ADD_SOURCE_DIRECTORY(NETWORK_SRC_FILES synchronisable)
+
 
 IF(WIN32)

code/branches/bugger/src/network/Client.cc

@@ -43 +43 @@
 #include "Client.h"
 #include "Host.h"
-#include "Synchronisable.h"
+#include "synchronisable/Synchronisable.h"
 #include "core/CoreIncludes.h"
 #include "packet/Packet.h"

code/branches/bugger/src/network/ClientInformation.cc

@@ -45 +45 @@
 namespace orxonox
 {
+  
 
   ClientInformation *ClientInformation::head_=0;

code/branches/bugger/src/network/ClientInformation.h

@@ -46 +46 @@
 #include <boost/thread/recursive_mutex.hpp>
 
+
 // WATCH OUT: THE CLIENTINFORMATION LIST IS NOT THREADSAFE ANYMORE
 
 namespace orxonox
 {
-  static const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
-  static const unsigned int CLIENTID_UNKNOWN = (unsigned int)-2;
 
   /**

code/branches/bugger/src/network/ConnectionManager.cc

@@ -52 +52 @@
 #include "util/Sleep.h"
 #include "ClientInformation.h"
-#include "Synchronisable.h"
+#include "synchronisable/Synchronisable.h"
 #include "packet/ClassID.h"
 

code/branches/bugger/src/network/GamestateClient.cc

@@ -35 +35 @@
 #include "core/BaseObject.h"
 #include "core/Iterator.h"
-#include "Synchronisable.h"
+#include "synchronisable/Synchronisable.h"
+#include "synchronisable/NetworkCallbackManager.h"
 #include "packet/Acknowledgement.h"
 
@@ -77 +78 @@
     packet::Gamestate *processed = processGamestate(tempGamestate_);
 //    assert(processed);
+    
+    //now call the queued callbacks
+    NetworkCallbackManager::callCallbacks();
+    
     if (!processed){
       sendAck(0);

code/branches/bugger/src/network/GamestateManager.cc

@@ -49 +49 @@
 #include "core/BaseObject.h"
 #include "ClientInformation.h"
-#include "Synchronisable.h"
+#include "synchronisable/Synchronisable.h"
+#include "synchronisable/NetworkCallbackManager.h"
 #include "packet/Acknowledgement.h"
 
@@ -87 +88 @@
     // now clear the queue
     gamestateQueue.clear();
+    //and call all queued callbacks
+    NetworkCallbackManager::callCallbacks();
     return true;
   }
@@ -135 +138 @@
     if(!reference)
       return 0;
-    gs = reference->doSelection(clientID);
-//     gs = new packet::Gamestate(*reference);
+    gs = reference->doSelection(clientID, 10000);
 //     gs = new packet::Gamestate(*reference);
     // save the (undiffed) gamestate in the clients gamestate map

code/branches/bugger/src/network/NetworkPrereqs.h

@@ -57 +57 @@
 
 //-----------------------------------------------------------------------
+// Includes
+//-----------------------------------------------------------------------
+#include "util/Integers.h"
+
+
+//-----------------------------------------------------------------------
 // Forward declarations
 //-----------------------------------------------------------------------
 namespace orxonox
 {
+
+// Constants definition
+
+  static const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
+  static const unsigned int CLIENTID_UNKNOWN = (unsigned int)-2;
+  static const uint32_t OBJECTID_UNKNOWN = static_cast<uint32_t>(-1);
+  static const unsigned int SCHED_PRIORITY_OFFSET = -5;
+
+  
+
+  
   class Client;
   class ClientConnection;
@@ -70 +87 @@
   class GamestateManager;
   class GamestateHandler;
+  class NetworkCallbackBase;
+  template <class T> class NetworkCallback;
+  class NetworkCallbackManager;
   class PacketBuffer;
   class Server;
   class ServerFrameListener;
   class Synchronisable;
+  class SynchronisableVariableBase;
+  template <class T> class SynchronisableVariable;
+  template <class T> class SynchronisableVariableBidirectional;
   struct ClientList;
   struct PacketEnvelope;
   struct QueueItem;
   struct syncData;
-  struct synchronisableVariable;
+  class obj;
+  class objInfo;
   namespace packet{
     class Gamestate;

code/branches/bugger/src/network/packet/DeleteObjects.cc

@@ -30 +30 @@
 #include "DeleteObjects.h"
 #include <enet/enet.h>
-#include "network/Synchronisable.h"
+#include "network/synchronisable/Synchronisable.h"
 #include "core/CoreIncludes.h"
 #include <assert.h>

code/branches/bugger/src/network/packet/Gamestate.cc

@@ -28 +28 @@
 
 #include "Gamestate.h"
-#include "network/ClientInformation.h"
-#include "network/GamestateHandler.h"
+#include "../GamestateHandler.h"
+#include "../synchronisable/Synchronisable.h"
+#include "../TrafficControl.h"
 #include "core/Core.h"
 #include "core/CoreIncludes.h"
@@ -49 +50 @@
 
 #define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
+  
+TrafficControl Gamestate::trafficControl_;
 
 Gamestate::Gamestate()
@@ -74 +77 @@
 bool Gamestate::collectData(int id, uint8_t mode)
 {
-  unsigned int tempsize=0, currentsize=0;
+  uint32_t tempsize=0, currentsize=0;
   assert(data_==0);
-  unsigned int size = calcGamestateSize(id, mode);
+  uint32_t size = calcGamestateSize(id, mode);
 
   COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
@@ -110 +113 @@
 
     //if(it->doSelection(id))
-    dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
+    if(tempsize!=0)
+      dataMap_.push_back( obj(it->getObjectID(), it->getCreatorID(), tempsize, mem-data_) );
+//     dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
     if(!it->getData(mem, id, mode))
       return false; // mem pointer gets automatically increased because of call by reference
@@ -150 +155 @@
     {
       if (!Core::isMaster())
-        Synchronisable::fabricate(mem, mode);
+        s = Synchronisable::fabricate(mem, mode);
       else
         mem += objectheader->size;
+      assert(s);
     }
     else
@@ -170 +176 @@
 }
 
-unsigned int Gamestate::getSize() const
+uint32_t Gamestate::getSize() const
 {
   assert(data_);
@@ -255 +261 @@
   assert(HEADER->compressed);
   COUT(4) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
-  unsigned int datasize = HEADER->datasize;
-  unsigned int compsize = HEADER->compsize;
-  unsigned int bufsize;
+  uint32_t datasize = HEADER->datasize;
+  uint32_t compsize = HEADER->compsize;
+  uint32_t bufsize;
 //  assert(compsize<=datasize);
   bufsize = datasize;
@@ -306 +312 @@
   //unsigned char *basep = base->getGs()/*, *gs = getGs()*/;
   uint8_t *basep = GAMESTATE_START(base->data_), *gs = GAMESTATE_START(this->data_);
-  unsigned int of=0; // pointers offset
-  unsigned int dest_length=0;
+  uint32_t of=0; // pointers offset
+  uint32_t dest_length=0;
   dest_length=HEADER->datasize;
   if(dest_length==0)
@@ -336 +342 @@
 }
 
-Gamestate* Gamestate::doSelection(unsigned int clientID){
+Gamestate* Gamestate::doSelection(unsigned int clientID, unsigned int targetSize){
   assert(data_);
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::list<obj>::iterator it;
 
   // allocate memory for new data
@@ -345 +351 @@
   Gamestate *gs = new Gamestate(gdata);
   uint8_t *newdata = gdata + sizeof(GamestateHeader);
-  uint8_t *origdata = GAMESTATE_START(data_);
+//   uint8_t *origdata = GAMESTATE_START(data_);
 
   //copy the GamestateHeader
@@ -351 +357 @@
 
   synchronisableHeader *oldobjectheader, *newobjectheader;
-  unsigned int objectOffset;
-
+  uint32_t objectOffset;
+  unsigned int objectsize, destsize=0;
+  Synchronisable *object;
+
+  //call TrafficControl
+  trafficControl_.processObjectList( clientID, HEADER->id, &dataMap_ );
+  
   //copy in the zeros
   for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
-    if(it->second->getSize(HEADER->id)==0)
+    if((*it).objSize==0)
       continue;
-    oldobjectheader = (synchronisableHeader*)origdata;
+    oldobjectheader = (synchronisableHeader*)(data_ + (*it).objDataOffset);
     newobjectheader = (synchronisableHeader*)newdata;
-    unsigned int objectsize = oldobjectheader->size;
-    assert(it->second->objectID==oldobjectheader->objectID);
+    object = Synchronisable::getSynchronisable( (*it).objID );
+    assert(object->objectID == oldobjectheader->objectID);
+    objectsize = oldobjectheader->size;
     *newobjectheader = *oldobjectheader;
     objectOffset=sizeof(synchronisableHeader); //skip the size and the availableData variables in the objectheader
-    if(it->second->doSelection(HEADER->id)){
+    if ( /*object->doSelection(HEADER->id)*/true ){
       assert(newobjectheader->dataAvailable==true);
-      memcpy(newdata+objectOffset, origdata+objectOffset, objectsize-objectOffset);
+      memcpy(newdata+objectOffset, data_ + (*it).objDataOffset + objectOffset, objectsize-objectOffset);
     }else{
       newobjectheader->dataAvailable=false;
@@ -372 +384 @@
     }
     newdata += objectsize;
-    origdata += objectsize;
-  }
+    destsize += objectsize;
+//     origdata += objectsize;
+  }
+  ((GamestateHeader*)gdata)->datasize = destsize;
+  assert(destsize!=0);
   return gs;
 }
@@ -388 +403 @@
 
   //preparations
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::list<obj>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
-  unsigned int objectOffset, streamOffset=0;    //data offset
-  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  uint32_t objectOffset, streamOffset=0;    //data offset
+  uint32_t minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
+  Synchronisable *object;
 
   origdata = GAMESTATE_START(this->data_);
@@ -403 +419 @@
   for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
     assert(streamOffset<HEADER->datasize);
-    bool sendData = it->second->doSelection(HEADER->id);
     origheader = (synchronisableHeader *)(origdata+streamOffset);
     destheader = (synchronisableHeader *)(destdata+streamOffset);
+    object = Synchronisable::getSynchronisable(origheader->objectID);
+    bool sendData = object->doSelection(HEADER->id);
 
     //copy and partially diff the object header
-    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
+    assert(sizeof(synchronisableHeader)==3*sizeof(uint32_t)+sizeof(bool));
     *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
     *(bool*)(destdata+sizeof(uint32_t)) = sendData;
@@ -456 +473 @@
 
   //preparations
-  std::map<unsigned int, Synchronisable *>::iterator it;
+  std::list<obj>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
-  unsigned int objectOffset, streamOffset=0;    //data offset
-  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  uint32_t objectOffset, streamOffset=0;    //data offset
+  uint32_t minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
+  Synchronisable *object;
 
   origdata = GAMESTATE_START(this->data_);
@@ -473 +491 @@
     origheader = (synchronisableHeader *)(origdata+streamOffset);
     destheader = (synchronisableHeader *)(destdata+streamOffset);
+    object = Synchronisable::getSynchronisable( origheader->objectID );
     bool sendData;
 
     //copy and partially diff the object header
-    assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
-    *(unsigned int*)destdata = *(unsigned int*)origdata; //size (do not diff)
-    *(bool*)(destdata+sizeof(unsigned int)) = *(bool*)(origdata+sizeof(unsigned int));
-    sendData = *(bool*)(origdata+sizeof(unsigned int));
+    assert(sizeof(synchronisableHeader)==3*sizeof(uint32_t)+sizeof(bool));
+    *(uint32_t*)destdata = *(uint32_t*)origdata; //size (do not diff)
+    *(bool*)(destdata+sizeof(uint32_t)) = *(bool*)(origdata+sizeof(uint32_t));
+    sendData = *(bool*)(origdata+sizeof(uint32_t));
     if(sendData){
-      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = *(unsigned int*)(basedata+sizeof(unsigned int)+sizeof(bool)) ^ *(unsigned int*)(origdata+sizeof(unsigned int)+sizeof(bool)); //objectid (diff it)
-      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = *(unsigned int*)(basedata+2*sizeof(unsigned int)+sizeof(bool)) ^ *(unsigned int*)(origdata+2*sizeof(unsigned int)+sizeof(bool)); //classid (diff it)
+      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = *(uint32_t*)(basedata+sizeof(uint32_t)+sizeof(bool)) ^ *(uint32_t*)(origdata+sizeof(uint32_t)+sizeof(bool)); //objectid (diff it)
+      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = *(uint32_t*)(basedata+2*sizeof(uint32_t)+sizeof(bool)) ^ *(uint32_t*)(origdata+2*sizeof(uint32_t)+sizeof(bool)); //classid (diff it)
     }else{
-      *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
-      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
+      *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
+      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
     }
     objectOffset=sizeof(synchronisableHeader);
@@ -523 +542 @@
   uint8_t *basep = GAMESTATE_START(base->data_);
   uint8_t *gs = GAMESTATE_START(this->data_);
-  unsigned int of=0; // pointers offset
-  unsigned int dest_length=0;
+  uint32_t of=0; // pointers offset
+  uint32_t dest_length=0;
   dest_length=HEADER->datasize;
   if(dest_length==0)
@@ -554 +573 @@
 
 
-unsigned int Gamestate::calcGamestateSize(unsigned int id, uint8_t mode)
-{
-  unsigned int size=0;
+uint32_t Gamestate::calcGamestateSize(int32_t id, uint8_t mode)
+{
+  uint32_t size=0;
     // get the start of the Synchronisable list
   ObjectList<Synchronisable>::iterator it;

code/branches/bugger/src/network/packet/Gamestate.h

@@ -31 +31 @@
 #define NETWORK_PACKETGAMESTATE_H
 
-#include "../NetworkPrereqs.h"
+#include "network/NetworkPrereqs.h"
 
 #include "Packet.h"
-#include "network/Synchronisable.h"
+#include "network/TrafficControl.h"
+#include "core/CoreIncludes.h"
 #include <map>
+#include <list>
 #ifndef NDEBUG
 #include "util/CRC32.h"
@@ -79 +81 @@
     Gamestate *undiff(Gamestate *base);
     Gamestate* intelligentUnDiff(Gamestate *base);
-    Gamestate* doSelection(unsigned int clientID);
+    Gamestate* doSelection(unsigned int clientID, unsigned int targetSize);
     bool compressData();
     bool decompressData();
@@ -85 +87 @@
     // Packet functions
   private:
-    virtual unsigned int getSize() const;
+    virtual uint32_t getSize() const;
     virtual bool process();
 
     bool operator ==(packet::Gamestate gs);
   private:
-    unsigned int calcGamestateSize(unsigned int id, uint8_t mode=0x0);
+    uint32_t calcGamestateSize(int32_t id, uint8_t mode=0x0);
     void removeObject(ObjectListIterator<Synchronisable> &it);
-    std::map<unsigned int, Synchronisable*> dataMap_;
+    std::list<obj> dataMap_;
+    static TrafficControl trafficControl_;
 };
 

code/branches/bugger/src/network/packet/Welcome.cc

@@ -32 +32 @@
 #include "Welcome.h"
 #include "network/Host.h"
-#include "network/Synchronisable.h"
+#include "network/synchronisable/Synchronisable.h"
 #include "core/CoreIncludes.h"
 #include <assert.h>
@@ -43 +43 @@
 #define _CLIENTID             _PACKETID + sizeof(ENUM::Type)
 #define _SHIPID               _CLIENTID + sizeof(uint32_t)
+#define _ENDIANTEST           _SHIPID + sizeof(uint32_t)
   
   Welcome::Welcome( unsigned int clientID, unsigned int shipID )
@@ -52 +53 @@
   assert(data_);
   *(packet::ENUM::Type *)(data_ + _PACKETID ) = packet::ENUM::Welcome;
-  *(uint32_t *)&data_[ _CLIENTID ] = clientID;
-  *(uint32_t *)&data_[ _SHIPID ] = shipID;
+  *(uint32_t *)(data_ + _CLIENTID ) = clientID;
+  *(uint32_t *)(data_ + _SHIPID ) = shipID;
+  *(uint32_t *)(data_ + _ENDIANTEST ) = 0xFEDC4321;
 }
 
@@ -70 +72 @@
 
 unsigned int Welcome::getSize() const{
-  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t);
+  return sizeof(packet::ENUM::Type) + 3*sizeof(uint32_t);
 }
 
@@ -77 +79 @@
   clientID = *(uint32_t *)&data_[ _CLIENTID ];
   shipID = *(uint32_t *)&data_[ _SHIPID ];
+  assert(*(uint32_t *)(data_ + _ENDIANTEST ) == 0xFEDC4321);
   Host::setClientID(clientID);
   Host::setShipID(shipID);

code/branches/bugger/src/network/synchronisable/Synchronisable.cc

@@ -79 +79 @@
 
 
-#ifndef NDEBUG
-    ObjectList<Synchronisable>::iterator it;
-    for(it = ObjectList<Synchronisable>::begin(); it!=ObjectList<Synchronisable>::end(); ++it){
-      if( it->getObjectID()==this->objectID )
-        assert(*it==this || (it->objectID==OBJECTID_UNKNOWN && it->objectMode_==0x0));
-    }
-#endif
+//#ifndef NDEBUG
+//    ObjectList<Synchronisable>::iterator it;
+//    for(it = ObjectList<Synchronisable>::begin(); it!=ObjectList<Synchronisable>::end(); ++it){
+//        if(!(*it==this || (it->objectID==OBJECTID_UNKNOWN && it->objectMode_==0x0)))
+//        {
+//            COUT(1) << "Assertion failed: *it==this || (it->objectID==OBJECTID_UNKNOWN && it->objectMode_==0x0)" << std::endl;
+//            COUT(1) << "Possible reason for this error: Client created a synchronized object without the Server's approval." << std::endl;
+//            abort();
+//        }
+//    }
+//#endif
 
     this->creatorID = OBJECTID_UNKNOWN;
@@ -159 +163 @@
 
     Identifier* id = ClassByID(header->classID);
+    if (!id)
+    {
+        COUT(1) << "Assertion failed: id" << std::endl;
+        COUT(1) << "Possible reason for this error: Client received a synchronizable object whose class has no factory." << std::endl;
+        abort();
+    }
     assert(id);
     BaseObject* creator = 0;

code/branches/bugger/src/network/synchronisable/Synchronisable.h

@@ -90 +90 @@
     static uint32_t popDeletedObject(){ uint32_t i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
 
-    inline uint32_t getObjectID(){return objectID;}
-    inline unsigned int getCreatorID(){return creatorID;}
-    inline uint32_t getClassID(){return classID;}
-    inline unsigned int getPriority(){ return objectFrequency_;}
+    inline uint32_t getObjectID() const {return objectID;}
+    inline unsigned int getCreatorID() const {return creatorID;}
+    inline uint32_t getClassID() const {return classID;}
+    inline unsigned int getPriority() const { return objectFrequency_;}
 
   protected: