Changeset 2822 for code/branches/netp
- Timestamp:
- Mar 23, 2009, 10:28:25 AM (16 years ago)
- Location:
- code/branches/netp/src/network/synchronisable
- Files:
-
- 4 edited
Legend:
- Unmodified
- Added
- Removed
-
code/branches/netp/src/network/synchronisable/Synchronisable.cc
r2773 r2822 66 66 objectID=OBJECTID_UNKNOWN; 67 67 classID = static_cast<uint32_t>(-1); 68 68 69 // set dataSize to 0 70 this->dataSize_ = 0; 69 71 // set standard priority 70 72 this->setPriority( priority::normal ); … … 251 253 assert(this->classID==this->getIdentifier()->getNetworkID()); 252 254 std::list<SynchronisableVariableBase*>::iterator i; 253 uint32_t size;254 size=getSize(id, mode);255 255 256 256 // start copy header 257 257 SynchronisableHeader header(mem); 258 header.setDataSize( size ); 258 mem += SynchronisableHeader::getSize(); 259 // end copy header 260 261 262 COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << std::endl; 263 // copy to location 264 for(i=syncList.begin(); i!=syncList.end(); ++i){ 265 tempsize += (*i)->getData( mem, mode ); 266 //tempsize += (*i)->getSize( mode ); 267 } 268 269 tempsize += SynchronisableHeader::getSize(); 259 270 header.setObjectID( this->objectID ); 260 271 header.setCreatorID( this->creatorID ); 261 272 header.setClassID( this->classID ); 262 273 header.setDataAvailable( true ); 263 tempsize += SynchronisableHeader::getSize(); 264 mem += SynchronisableHeader::getSize(); 265 // end copy header 266 267 268 COUT(5) << "Synchronisable getting data from objectID: " << objectID << " classID: " << classID << " length: " << size << std::endl; 269 // copy to location 270 for(i=syncList.begin(); i!=syncList.end(); ++i){ 271 (*i)->getData( mem, mode ); 272 tempsize += (*i)->getSize( mode ); 273 } 274 header.setDataSize( tempsize ); 275 276 #ifndef NDEBUG 277 uint32_t size; 278 size=getSize(id, mode); 274 279 assert(tempsize==size); 280 #endif 275 281 return true; 276 282 } … … 325 331 uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){ 326 332 int tsize=SynchronisableHeader::getSize(); 327 if (mode==0x0)333 if (mode==0x0) 328 334 mode=state_; 329 if (!doSync(id, mode))335 if (!doSync(id, mode)) 330 336 return 0; 337 assert( mode==state_ ); 338 tsize += this->dataSize_; 331 339 std::list<SynchronisableVariableBase*>::iterator i; 332 for(i=s yncList.begin(); i!=syncList.end(); i++){340 for(i=stringList.begin(); i!=stringList.end(); ++i){ 333 341 tsize += (*i)->getSize( mode ); 334 342 } -
code/branches/netp/src/network/synchronisable/Synchronisable.h
r2773 r2822 36 36 #include <queue> 37 37 #include <cassert> 38 #include <string> 38 39 #include "util/Math.h" 39 40 #include "util/mbool.h" … … 139 140 Synchronisable(BaseObject* creator); 140 141 template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false); 141 template <class T> void unregisterVariable(T& var);142 //template <class T> void unregisterVariable(T& var); 142 143 void setObjectMode(uint8_t mode); 143 144 void setPriority(unsigned int freq){ objectFrequency_ = freq; } … … 156 157 157 158 std::list<SynchronisableVariableBase*> syncList; 159 std::list<SynchronisableVariableBase*> stringList; 160 uint32_t dataSize_; //size of all variables except strings 158 161 static uint8_t state_; // detemines wheter we are server (default) or client 159 162 bool backsync_; // if true the variables with mode > 1 will be synchronised to server (client -> server) … … 164 167 }; 165 168 166 template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional)167 {168 if (bidirectional)169 syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb));170 else171 syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb));172 }173 174 template <class T> void Synchronisable::unregisterVariable(T& var){175 std::list<SynchronisableVariableBase*>::iterator it = syncList.begin();176 while(it!=syncList.end()){177 if( ((*it)->getReference()) == &var ){178 delete (*it);179 syncList.erase(it);180 return;181 }182 else183 it++;184 }185 bool unregistered_nonexistent_variable = false;186 assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:187 // the variable has not been registered before188 }189 190 169 // ================= Specialisation declarations 170 171 // template <> _NetworkExport void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional); 172 template <> _NetworkExport void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional); 191 173 template <> _NetworkExport void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional); 192 174 template <> _NetworkExport void Synchronisable::registerVariable( ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional); … … 200 182 template <> _NetworkExport void Synchronisable::registerVariable( const Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional); 201 183 template <> _NetworkExport void Synchronisable::registerVariable( Quaternion& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional); 184 185 template <class T> void Synchronisable::registerVariable(T& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional) 186 { 187 if (bidirectional) 188 syncList.push_back(new SynchronisableVariableBidirectional<const T>(variable, mode, cb)); 189 else 190 syncList.push_back(new SynchronisableVariable<const T>(variable, mode, cb)); 191 if ( this->state_ == mode ) 192 this->dataSize_ += syncList.back()->getSize(state_); 193 } 194 195 196 197 // template <class T> void Synchronisable::unregisterVariable(T& var){ 198 // std::list<SynchronisableVariableBase*>::iterator it = syncList.begin(); 199 // while(it!=syncList.end()){ 200 // if( ((*it)->getReference()) == &var ){ 201 // delete (*it); 202 // syncList.erase(it); 203 // return; 204 // } 205 // else 206 // it++; 207 // } 208 // bool unregistered_nonexistent_variable = false; 209 // assert(unregistered_nonexistent_variable); //if we reach this point something went wrong: 210 // // the variable has not been registered before 211 // } 212 213 202 214 } 203 215 -
code/branches/netp/src/network/synchronisable/SynchronisableSpecialisations.cc
r2662 r2822 29 29 30 30 #include "network/synchronisable/Synchronisable.h" 31 #include <string> 31 32 32 33 // ================ template spezialisation … … 34 35 35 36 namespace orxonox{ 37 38 // template <> void Synchronisable::registerVariable( const std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional) 39 // { 40 // if (bidirectional) 41 // syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb)); 42 // else 43 // syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb)); 44 // stringList.push_back(syncList.back()); 45 // } 46 47 template <> void Synchronisable::registerVariable( std::string& variable, uint8_t mode, NetworkCallbackBase *cb, bool bidirectional) 48 { 49 if (bidirectional) 50 syncList.push_back(new SynchronisableVariableBidirectional<const std::string>(variable, mode, cb)); 51 else 52 syncList.push_back(new SynchronisableVariable<const std::string>(variable, mode, cb)); 53 stringList.push_back(syncList.back()); 54 } 36 55 37 56 template <> void Synchronisable::registerVariable( const ColourValue& variable, uint8_t mode, NetworkCallbackBase* cb, bool bidirectional) -
code/branches/netp/src/network/synchronisable/SynchronisableVariable.h
r2794 r2822 56 56 { 57 57 public: 58 virtual voidgetData(uint8_t*& mem, uint8_t mode)=0;58 virtual uint32_t getData(uint8_t*& mem, uint8_t mode)=0; 59 59 virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false)=0; 60 60 virtual uint32_t getSize(uint8_t mode)=0; … … 74 74 75 75 virtual inline uint8_t getMode(){ return mode_; } 76 virtual inline voidgetData(uint8_t*& mem, uint8_t mode);76 virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode); 77 77 virtual inline void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false); 78 78 virtual inline uint32_t getSize(uint8_t mode); … … 97 97 98 98 virtual inline uint8_t getMode(){ return 0x3; } //this basically is a hack ^^ 99 virtual inline voidgetData(uint8_t*& mem, uint8_t mode);99 virtual inline uint32_t getData(uint8_t*& mem, uint8_t mode); 100 100 virtual void putData(uint8_t*& mem, uint8_t mode, bool forceCallback = false); 101 101 virtual inline uint32_t getSize(uint8_t mode); … … 122 122 } 123 123 124 template <class T> inline voidSynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode)124 template <class T> inline uint32_t SynchronisableVariable<T>::getData(uint8_t*& mem, uint8_t mode) 125 125 { 126 126 if ( state_ == this->mode_ ) 127 { 127 128 getAndIncrease( mem ); 129 return returnSize(); 130 } 131 else 132 return 0; 128 133 // mem += SynchronisableVariable<T>::getSize(); 129 134 } … … 230 235 } 231 236 232 template <class T> voidSynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode)237 template <class T> uint32_t SynchronisableVariableBidirectional<T>::getData(uint8_t*& mem, uint8_t mode) 233 238 { 234 239 if ( this->mode_ == mode ) … … 246 251 SynchronisableVariable<T>::getAndIncrease( mem ); 247 252 // mem += SynchronisableVariable<T>::getSize(); 253 return SynchronisableVariableBidirectional::getSize(mode); 248 254 } 249 255
Note: See TracChangeset
for help on using the changeset viewer.