Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/FICN/src/network/Synchronisable.cc @ 656

Last change on this file since 656 was 656, checked in by scheusso, 17 years ago

some errors corrected in gamestatehandling

File size: 5.5 KB
Line 
1//
2// C++ Implementation: synchronisable
3//
4// Description:
5//
6//
7// Author:  Dumeni, Oliver Scheuss, (C) 2007
8//
9// Copyright: See COPYING file that comes with this distribution
10//
11
12#include "Synchronisable.h"
13#include "orxonox/core/CoreIncludes.h"
14
15
16namespace network {
17
18/**
19 * Constructor:
20 * calls registarAllVariables, that has to be implemented by the inheriting classID
21 */
22Synchronisable::Synchronisable()
23{
24  RegisterRootObject(Synchronisable);
25  static int idCounter=0;
26  datasize=0;
27  objectID=idCounter++;
28  //registerAllVariables();
29}
30
31
32Synchronisable::~Synchronisable()
33{
34
35}
36
37/**
38 * This function is used to register a variable to be synchronized
39 * also counts the total datasize needed to save the variables
40 * @param var pointer to the variable
41 * @param size size of the datatype the variable consists of
42 */
43void Synchronisable::registerVar(const void *var, int size, variableType t){
44  // create temporary synch.Var struct
45  synchronisableVariable temp={size, var, t};
46  // increase datasize
47  datasize+=sizeof(int)+size;
48  // push temp to syncList (at the bottom)
49  syncList.push_back(temp);
50}
51
52/**
53 * 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)
54 * This function takes all SynchronisableVariables out of the Synchronisable and saves it into a syncData struct
55 * structure of the bitstream:
56 * (var1_size,var1,var2_size,var2,...)
57 * varx_size: size = sizeof(int)
58 * varx: size = varx_size
59 * @return data containing all variables and their sizes
60 */
61// syncData Synchronisable::getData(){
62//   std::list<synchronisableVariable>::iterator i;
63//   int totalsize=0;
64//   //figure out size of data to be allocated
65//   for(i=syncList.begin(); i!=syncList.end(); i++){
66//     // increase size (size of variable and size of size of variable ;)
67//     if(i->type == STRING)
68//       totalsize+=sizeof(int)+((std::string *)i->var)->length()+1;
69//     else
70//       totalsize+=sizeof(int)+i->size;
71//   }
72//   syncData retVal;
73//   retVal.objectID=this->objectID;
74//   retVal.classID=this->classID;
75//   retVal.length=totalsize;
76//   // allocate memory
77//   retVal.data = (unsigned char *)malloc(totalsize);
78//   // copy to location
79//   //CHANGED: REMOVED DECLARATION int n=0 FROM LOOP
80//   int n=0;
81//   for(i=syncList.begin(); n<totalsize && i!=syncList.end(); i++){
82//     std::memcpy(retVal.data+n, (const void*)(i->size), sizeof(int));
83//     n+=sizeof(int);
84//     switch(i->type){
85//     case STRING:
86//       std::memcpy(retVal.data+n, (const void *)(((std::string *)i->var)->c_str()), ((std::string *)i->var)->length()+1);
87//       n+=((std::string *)i->var)->length()+1;
88//       break;
89//     case DATA:
90//       std::memcpy(retVal.data+n, ((const void*)i->var), i->size);
91//       n+=i->size;
92//       break;
93//     }
94//   }
95//   return retVal;
96// }
97/**
98 * This function takes all SynchronisableVariables out of the Synchronisable and saves it into a syncData struct
99 * Difference to the above function:
100 * takes a pointer to already allocated memory (must have at least getSize bytes length)
101 * structure of the bitstream:
102 * (var1_size,var1,var2_size,var2,...)
103 * varx_size: size = sizeof(int)
104 * varx: size = varx_size
105 * @return data containing all variables and their sizes
106 */
107syncData Synchronisable::getData(unsigned char *mem){
108  std::list<synchronisableVariable>::iterator i;
109  syncData retVal;
110  retVal.objectID=this->objectID;
111  retVal.classID=this->classID;
112  retVal.length=getSize();
113  retVal.data=mem;
114  // copy to location
115  int n=0;
116  for(i=syncList.begin(); n<datasize && i!=syncList.end(); ++i){
117    //COUT(2) << "size of variable: " << i->size << std::endl;
118    //(std::memcpy(retVal.data+n, (const void*)(&(i->size)), sizeof(int));
119    memcpy( (void *)(retVal.data+n), (const void*)&(i->size), sizeof(int) );
120    n+=sizeof(int);
121    switch(i->type){
122      case DATA:
123        std::memcpy( (void *)(retVal.data+n), (const void*)(i->var), i->size);
124        n+=i->size;
125        break;
126      case STRING:
127        std::memcpy( retVal.data+n, (const void*)( ( (std::string *) i->var)->c_str()), ( (std::string *)i->var )->length()+1);
128        n+=((std::string *) i->var)->length()+1;
129        break;
130    }
131  }
132  return retVal;
133}
134
135/**
136 * This function takes a syncData struct and takes it to update the variables
137 * @param vars data of the variables
138 * @return true/false
139 */
140bool Synchronisable::updateData(syncData vars){
141  unsigned char *data=vars.data;
142  std::list<synchronisableVariable>::iterator i;
143  for(i=syncList.begin(); i!=syncList.end(); i++){
144    if((int)*data==i->size || i->type==STRING){
145      switch(i->type){
146      case DATA:
147        data+=sizeof(int);
148        memcpy((void*)i->var, data, i->size);
149        data+=i->size;
150        break;
151      case STRING:
152        i->size = (int)*data;
153        data+=sizeof(int);
154        *((std::string *)i->var) = std::string((const char*)data);
155        data += i->size;
156        break;
157      }
158    } else
159      return false; //there was some problem with registerVar
160  }
161  return true;
162}
163
164/**
165 * This function returns the total amount of bytes needed by getData to save the whole content of the variables
166 * @return amount of bytes
167 */
168int Synchronisable::getSize(){
169  int tsize=0;
170  std::list<synchronisableVariable>::iterator i;
171  for(i=syncList.begin(); i!=syncList.end(); i++){
172    switch(i->type){
173    case DATA:
174      tsize+=sizeof(int);
175      tsize+=i->size;
176      break;
177    case STRING:
178      tsize+=sizeof(int);
179      tsize+=((std::string *)i->var)->length()+1;
180      break;
181    }
182  }
183  return tsize;
184}
185
186}
Note: See TracBrowser for help on using the repository browser.