Changeset 7153 for code/branches/presentation3/src/libraries/network/synchronisable/Synchronisable.h
- Timestamp:
- Jul 12, 2010, 1:08:58 PM (14 years ago)
- Location:
- code/branches/presentation3
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
code/branches/presentation3
- Property svn:mergeinfo changed
/code/branches/network2 (added) merged: 6448-6450,6455-6458,6462,6464-6465
- Property svn:mergeinfo changed
-
code/branches/presentation3/src/libraries/network/synchronisable/Synchronisable.h
r7127 r7153 65 65 }; 66 66 } 67 68 typedef uint8_t VariableID; 67 69 68 70 /** … … 72 74 * in an emulated bitset. 73 75 * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream 74 * Bit 32 is a bool and defines whether the data is actually stored or is just filled up with 076 * Bit 32 is a bool and defines whether the variables are stored in diff mode 75 77 * Byte 5 to 8: objectID_ 76 78 * Byte 9 to 12: classID_ … … 78 80 */ 79 81 class _NetworkExport SynchronisableHeader{ 82 friend class SynchronisableHeaderLight; 80 83 private: 81 uint8_t *data_;84 uint8_t* data_; 82 85 public: 83 86 SynchronisableHeader(uint8_t* data) 84 87 { data_ = data; } 85 88 inline static uint32_t getSize() 86 { return 1 6; }87 inline uint 32_t getDataSize() const88 { return (*(uint 32_t*)data_) & 0x7FFFFFFF; } //only use the first 31 bits89 inline void setDataSize(uint 32_t size)90 { *(uint 32_t*)(data_) = (size & 0x7FFFFFFF) | (*(uint32_t*)(data_) & 0x80000000 ); }91 inline bool isD ataAvailable() const92 { return ( (*(uint 32_t*)data_) & 0x80000000 ) == 0x80000000; }93 inline void setD ataAvailable( bool b)94 { *(uint 32_t*)(data_) = (b << 31) | (*(uint32_t*)(data_) & 0x7FFFFFFF ); }89 { return 14; } 90 inline uint16_t getDataSize() const 91 { return (*(uint16_t*)data_) & 0x7FFF; } //only use the first 31 bits 92 inline void setDataSize(uint16_t size) 93 { *(uint16_t*)(data_) = (size & 0x7FFFFFFF) | (*(uint16_t*)(data_) & 0x8000 ); } 94 inline bool isDiffed() const 95 { return ( (*(uint16_t*)data_) & 0x8000 ) == 0x8000; } 96 inline void setDiffed( bool b) 97 { *(uint16_t*)(data_) = (b << 15) | (*(uint16_t*)(data_) & 0x7FFF ); } 95 98 inline uint32_t getObjectID() const 96 { return *(uint32_t*)(data_+ 4); }99 { return *(uint32_t*)(data_+2); } 97 100 inline void setObjectID(uint32_t objectID_) 98 { *(uint32_t*)(data_+ 4) = objectID_; }101 { *(uint32_t*)(data_+2) = objectID_; } 99 102 inline uint32_t getClassID() const 100 { return *(uint32_t*)(data_+ 8); }103 { return *(uint32_t*)(data_+6); } 101 104 inline void setClassID(uint32_t classID_) 102 { *(uint32_t*)(data_+ 8) = classID_; }105 { *(uint32_t*)(data_+6) = classID_; } 103 106 inline uint32_t getCreatorID() const 104 { return *(uint32_t*)(data_+1 2); }107 { return *(uint32_t*)(data_+10); } 105 108 inline void setCreatorID(uint32_t creatorID_) 106 { *(uint32_t*)(data_+1 2) = creatorID_; }109 { *(uint32_t*)(data_+10) = creatorID_; } 107 110 inline void operator=(SynchronisableHeader& h) 108 111 { memcpy(data_, h.data_, getSize()); } 109 112 }; 110 113 114 /** 115 * @brief: stores information about a Synchronisable (light version) 116 * 117 * This class stores the information about a Synchronisable (objectID_, dataSize) 118 * in an emulated bitset. 119 * Bit 1 to 31 store the size of the Data the synchronisable consumes in the stream 120 * Bit 32 is a bool and defines whether the variables are stored in diff mode 121 * Byte 5 to 8: objectID_ 122 */ 123 class _NetworkExport SynchronisableHeaderLight{ 124 private: 125 uint8_t* data_; 126 public: 127 SynchronisableHeaderLight(uint8_t* data) 128 { data_ = data; } 129 inline static uint32_t getSize() 130 { return 6; } 131 inline uint16_t getDataSize() const 132 { return (*(uint16_t*)data_) & 0x7FFF; } //only use the first 31 bits 133 inline void setDataSize(uint16_t size) 134 { *(uint16_t*)(data_) = (size & 0x7FFFFFFF) | (*(uint16_t*)(data_) & 0x8000 ); } 135 inline bool isDiffed() const 136 { return ( (*(uint16_t*)data_) & 0x8000 ) == 0x8000; } 137 inline void setDiffed( bool b) 138 { *(uint16_t*)(data_) = (b << 15) | (*(uint16_t*)(data_) & 0x7FFF ); } 139 inline uint32_t getObjectID() const 140 { return *(uint32_t*)(data_+2); } 141 inline void setObjectID(uint32_t objectID_) 142 { *(uint32_t*)(data_+2) = objectID_; } 143 inline void operator=(SynchronisableHeader& h) 144 { memcpy(data_, h.data_, getSize()); } 145 }; 111 146 112 147 /** … … 135 170 136 171 void setSyncMode(uint8_t mode); 172 173 inline uint32_t getNrOfVariables(){ return this->syncList_.size(); } 174 inline uint32_t getVarSize( VariableID ID ) 175 { return this->syncList_[ID]->getSize(state_); } 137 176 138 177 protected: … … 140 179 template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false); 141 180 template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false); 181 template <class T> void unregisterVariable(T& var); 142 182 143 183 void setPriority(unsigned int freq){ objectFrequency_ = freq; } … … 145 185 146 186 private: 147 uint32_t getData(uint8_t*& me n, int32_t id, uint8_t mode=0x0);187 uint32_t getData(uint8_t*& mem, std::vector<uint32_t>& sizes, int32_t id, uint8_t mode); 148 188 uint32_t getSize(int32_t id, uint8_t mode=0x0); 149 189 bool updateData(uint8_t*& mem, uint8_t mode=0x0, bool forceCallback=false); 150 bool isMyData(uint8_t* mem);151 190 bool doSync(int32_t id, uint8_t mode=0x0); 152 191 … … 158 197 uint32_t classID_; 159 198 160 std::vector<SynchronisableVariableBase*> syncList ;161 std::vector<SynchronisableVariableBase*> stringList ;199 std::vector<SynchronisableVariableBase*> syncList_; 200 std::vector<SynchronisableVariableBase*> stringList_; 162 201 uint32_t dataSize_; //size of all variables except strings 163 202 static uint8_t state_; // detemines wheter we are server (default) or client … … 173 212 if (bidirectional) 174 213 { 175 syncList .push_back(new SynchronisableVariableBidirectional<T>(variable, mode, cb));176 this->dataSize_ += syncList .back()->getSize(state_);214 syncList_.push_back(new SynchronisableVariableBidirectional<T>(variable, mode, cb)); 215 this->dataSize_ += syncList_.back()->getSize(state_); 177 216 } 178 217 else 179 218 { 180 syncList .push_back(new SynchronisableVariable<T>(variable, mode, cb));219 syncList_.push_back(new SynchronisableVariable<T>(variable, mode, cb)); 181 220 if ( this->state_ == mode ) 182 this->dataSize_ += syncList .back()->getSize(state_);221 this->dataSize_ += syncList_.back()->getSize(state_); 183 222 } 223 } 224 225 template <class T> void Synchronisable::unregisterVariable(T& variable){ 226 std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); 227 while(it!=syncList_.end()){ 228 if( ((*it)->getReference()) == &variable ){ 229 this->dataSize_ -= (*it)->getSize(Synchronisable::state_); 230 delete (*it); 231 syncList_.erase(it); 232 return; 233 } 234 else 235 it++; 236 } 237 bool unregistered_nonexistent_variable = false; 238 assert(unregistered_nonexistent_variable); //if we reach this point something went wrong: 239 // the variable has not been registered before 184 240 } 185 241 … … 191 247 else 192 248 sv = new SynchronisableVariable<std::set<T> >(variable, mode, cb); 193 syncList .push_back(sv);194 stringList .push_back(sv);249 syncList_.push_back(sv); 250 stringList_.push_back(sv); 195 251 } 196 252 197 253 template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional); 198 254 // template <class T> _NetworkExport void Synchronisable::registerVariable<std::set<T> >( std::set<T>& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional); 255 template <> _NetworkExport void Synchronisable::unregisterVariable( std::string& variable ); 199 256 200 257
Note: See TracChangeset
for help on using the changeset viewer.