Changeset 247 for code/branches/network/src/network/Synchronisable.cc

Timestamp:

Nov 25, 2007, 11:06:13 PM (16 years ago)

Author:

scheusso

Message:

added GameStateManager class:

• gets snapshots of the universe (gamestate) and returns them
• processes snapshots and loads them to the universe

modified Synchronisable

• added a function getData(usigned char *data), which puts the data to

the already given pointer (more efficient memory handling for the
GameState class)

• added a function getSize(), which tells you the total size of the

current gamestate (so that you can allocate enough memory and give it to
getData

File:

• code/branches/network/src/network/Synchronisable.cc (modified) (5 diffs)

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

@@ -5 +5 @@
 //
 //
-// Author:  Oliver Scheuss, (C) 2007
+// Author:  Dumeni, Oliver Scheuss, (C) 2007
 //
 // Copyright: See COPYING file that comes with this distribution
@@ -14 +14 @@
 namespace network {
 
+/**
+ * Constructor:
+ * calls registarAllVariables, that has to be implemented by the inheriting classID
+ */
 Synchronisable::Synchronisable()
 {
+  datasize=0;
   registerAllVariables();
 }
@@ -25 +30 @@
 }
 
+/**
+ * This function is used to register a variable to be synchronized
+ * also counts the total datasize needed to save the variables
+ * @param var pointer to the variable
+ * @param size size of the datatype the variable consists of
+ */
 void Synchronisable::registerVar(const void *var, int size){
+  // create temporary synch.Var struct
   synchronisableVariable temp={size, var};
+  // increase datasize
+  datasize+=sizeof(int)+size;
+  // push temp to syncList (at the bottom)
   syncList.push_back(temp);
 }
+
+/**
+ * note: only use this function for debug use, because it's inefficient (in order to produce a gamestate, you have to copy the whole data again to another memory location after this process)
+ * This function takes all SynchronisableVariables out of the Synchronisable and saves it into a syncData struct
+ * structure of the bitstream:
+ * (var1_size,var1,var2_size,var2,...)
+ * varx_size: size = sizeof(int)
+ * varx: size = varx_size
+ * @return data containing all variables and their sizes
+ */
 syncData Synchronisable::getData(){
   std::list<synchronisableVariable>::iterator i;
@@ -56 +81 @@
   return retVal;
 }
+/**
+ * This function takes all SynchronisableVariables out of the Synchronisable and saves it into a syncData struct
+ * Difference to the above function:
+ * takes a pointer to already allocated memory (must have at least getSize bytes length)
+ * structure of the bitstream:
+ * (var1_size,var1,var2_size,var2,...)
+ * varx_size: size = sizeof(int)
+ * varx: size = varx_size
+ * @return data containing all variables and their sizes
+ */
+syncData Synchronisable::getData(unsigned char *mem){
+  std::list<synchronisableVariable>::iterator i;
+  syncData retVal;
+  retVal.objectID=this->objectID;
+  retVal.classID=this->classID;
+  retVal.length=datasize;
+  retVal.data=mem;
+  // copy to location
+  //CHANGED: REMOVED DECLARATION int n=0 FROM LOOP
+  int n=0;
+  for(i=syncList.begin(); n<datasize && i!=syncList.end(); i++){
+        //CHANGED: i->size TO (const void*)(&(i->size)) memcpy WANTS A CONST VOID* SO CONVERT INT TO CONST VOID*  
+    std::memcpy(retVal.data+n, (const void*)(i->size), sizeof(int));
+    n+=sizeof(int);
+    //CHANGED: i->var TO (const void*)(&(i->var)) SINCE var IS A POINTER, NO & BEFORE i
+    std::memcpy(retVal.data+n, (const void*)(i->var), i->size);
+    n+=i->size;
+  }
+  return retVal;
+}
+
+/**
+ * This function takes a syncData struct and takes it to update the variables
+ * @param vars data of the variables
+ * @return true/false
+ */
 bool Synchronisable::updateData(syncData vars){
   unsigned char *data=vars.data;
@@ -70 +131 @@
 }
 
+/**
+ * This function returns the total amount of bytes needed by getData to save the whole content of the variables
+ * @return amount of bytes
+ */
+int Synchronisable::getSize(){
+  return datasize;
 }
+
+}