- Timestamp:
- Aug 11, 2010, 8:55:13 AM (14 years ago)
- Location:
- code/trunk
- Files:
-
- 2 edited
Legend:
- Unmodified
- Added
- Removed
-
code/trunk
- Property svn:mergeinfo changed
-
code/trunk/src/libraries/network/synchronisable/Synchronisable.cc
r6417 r7163 49 49 * Initializes all Variables and sets the right objectID_ 50 50 */ 51 Synchronisable::Synchronisable(BaseObject* creator ){ 51 Synchronisable::Synchronisable(BaseObject* creator ) 52 { 52 53 RegisterRootObject(Synchronisable); 53 54 static uint32_t idCounter=0; 54 55 objectMode_=0x1; // by default do not send data to server 55 if ( GameMode::isMaster() || ( Host::running() && Host::isServer() ))56 if ( GameMode::isMaster()/* || ( Host::running() && Host::isServer() )*/ ) 56 57 { 57 58 this->setObjectID( idCounter++ ); … … 73 74 else 74 75 this->creatorID_ = OBJECTID_UNKNOWN; 75 76 /*searchcreatorID:77 if (creator)78 {79 Synchronisable* synchronisable_creator = orxonox_cast<Synchronisable*>(creator);80 if (synchronisable_creator && synchronisable_creator->objectMode_)81 {82 this->creatorID = synchronisable_creator->getScene()->getObjectID();83 }84 else if (creator != creator->getCreator())85 {86 creator = creator->getCreator();87 goto searchcreatorID;88 }89 }*/90 76 } 91 77 … … 94 80 * Delete all callback objects and remove objectID_ from the objectMap_ 95 81 */ 96 Synchronisable::~Synchronisable(){ 82 Synchronisable::~Synchronisable() 83 { 97 84 // delete callback function objects 98 85 if(!Identifier::isCreatingHierarchy()){ … … 101 88 deletedObjects_.push(objectID_); 102 89 } 103 // delete all Synchronisable Variables from syncList ( which are also in stringList)104 for(std::vector<SynchronisableVariableBase*>::iterator it = syncList .begin(); it!=syncList.end(); it++)90 // delete all Synchronisable Variables from syncList_ ( which are also in stringList_ ) 91 for(std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); it!=syncList_.end(); it++) 105 92 delete (*it); 106 syncList .clear();107 stringList .clear();93 syncList_.clear(); 94 stringList_.clear(); 108 95 std::map<uint32_t, Synchronisable*>::iterator it; 109 96 it = objectMap_.find(objectID_); … … 118 105 * @param b true if this object is located on a client or on a server 119 106 */ 120 void Synchronisable::setClient(bool b){ 107 void Synchronisable::setClient(bool b) 108 { 121 109 if(b) // client 122 110 state_=0x2; … … 135 123 { 136 124 SynchronisableHeader header(mem); 137 138 if(!header.isDataAvailable()) 139 { 140 mem += header.getDataSize(); 141 return 0; 142 } 125 assert( !header.isDiffed() ); 143 126 144 127 COUT(4) << "fabricating object with id: " << header.getObjectID() << std::endl; … … 160 143 if (!synchronisable_creator) 161 144 { 162 mem += header.getDataSize() ; //.TODO: this suckz.... remove size from header145 mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header 163 146 assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^ 164 147 return 0; … … 177 160 no->setClassID(header.getClassID()); 178 161 assert(no->creatorID_ == header.getCreatorID()); 162 if( creator ) 163 bo->setLevel(creator->getLevel()); // Note: this ensures that the level is known on the client for child objects of the scene (and the scene itself) 179 164 //assert(no->classID_ == header.getClassID()); 180 165 COUT(4) << "fabricate objectID_: " << no->objectID_ << " classID_: " << no->classID_ << std::endl; … … 196 181 * @return true/false 197 182 */ 198 bool Synchronisable::deleteObject(uint32_t objectID_){ 183 bool Synchronisable::deleteObject(uint32_t objectID_) 184 { 199 185 if(!getSynchronisable(objectID_)) 200 186 return false; … … 213 199 * @return pointer to the Synchronisable with the objectID_ 214 200 */ 215 Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_){ 201 Synchronisable* Synchronisable::getSynchronisable(uint32_t objectID_) 202 { 216 203 std::map<uint32_t, Synchronisable*>::iterator it1; 217 204 it1 = objectMap_.find(objectID_); 218 205 if (it1 != objectMap_.end()) 219 206 return it1->second; 220 221 // ObjectList<Synchronisable>::iterator it;222 // for(it = ObjectList<Synchronisable>::begin(); it; ++it){223 // if( it->getObjectID()==objectID_ ){224 // objectMap_[objectID_] = *it;225 // return *it;226 // }227 // }228 207 // if the objects not in the map it should'nt exist at all anymore 229 208 return NULL; … … 245 224 * @return true: if !doSync or if everything was successfully saved 246 225 */ 247 uint32_t Synchronisable::getData(uint8_t*& mem, int32_t id, uint8_t mode){ 226 uint32_t Synchronisable::getData(uint8_t*& mem, std::vector<uint32_t>& sizes, int32_t id, uint8_t mode) 227 { 228 unsigned int test = 0; 248 229 if(mode==0x0) 249 230 mode=state_; … … 253 234 uint32_t tempsize = 0; 254 235 #ifndef NDEBUG 236 uint8_t* oldmem = mem; 255 237 if (this->classID_==0) 256 238 COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl; … … 270 252 // end copy header 271 253 272 273 COUT(5) << "Synchronisable getting data from objectID_: " << objectID_ << " classID_: " << classID_ << std::endl;254 CCOUT(5) << "getting data from objectID_: " << objectID_ << ", classID_: " << classID_ << std::endl; 255 // COUT(4) << "objectid: " << this->objectID_ << ":"; 274 256 // copy to location 275 for(i=syncList.begin(); i!=syncList.end(); ++i){ 276 tempsize += (*i)->getData( mem, mode ); 257 for(i=syncList_.begin(); i!=syncList_.end(); ++i) 258 { 259 uint32_t varsize = (*i)->getData( mem, mode ); 260 // COUT(4) << " " << varsize; 261 tempsize += varsize; 262 sizes.push_back(varsize); 263 ++test; 277 264 //tempsize += (*i)->getSize( mode ); 278 265 } 279 280 tempsize += SynchronisableHeader::getSize(); 266 // COUT(4) << endl; 267 281 268 header.setObjectID( this->objectID_ ); 282 269 header.setCreatorID( this->creatorID_ ); 283 270 header.setClassID( this->classID_ ); 284 header.setDataAvailable( true );285 271 header.setDataSize( tempsize ); 272 assert( tempsize == mem-oldmem-SynchronisableHeader::getSize() ); 273 assert( test == this->getNrOfVariables() ); 274 header.setDiffed(false); 275 tempsize += SynchronisableHeader::getSize(); 286 276 287 277 #ifndef NDEBUG … … 300 290 * @return true/false 301 291 */ 302 bool Synchronisable::updateData(uint8_t*& mem, uint8_t mode, bool forceCallback){ 292 bool Synchronisable::updateData(uint8_t*& mem, uint8_t mode, bool forceCallback) 293 { 303 294 if(mode==0x0) 304 295 mode=state_; 305 std::vector<SynchronisableVariableBase *>::iterator i;306 if(syncList.empty()){296 if(syncList_.empty()) 297 { 307 298 assert(0); 308 COUT( 4) << "Synchronisable::updateData syncListis empty" << std::endl;299 COUT(2) << "Synchronisable::updateData syncList_ is empty" << std::endl; 309 300 return false; 310 301 } … … 312 303 uint8_t* data=mem; 313 304 // start extract header 314 SynchronisableHeader syncHeader(mem); 315 assert(syncHeader.getObjectID()==this->objectID_); 316 assert(syncHeader.getCreatorID()==this->creatorID_); 317 assert(syncHeader.getClassID()==this->classID_); 318 if(syncHeader.isDataAvailable()==false){ 319 mem += syncHeader.getDataSize(); 320 return true; 321 } 322 323 mem += SynchronisableHeader::getSize(); 324 // stop extract header 305 SynchronisableHeaderLight syncHeaderLight(mem); 306 assert(syncHeaderLight.getObjectID()==this->getObjectID()); 325 307 326 308 //COUT(5) << "Synchronisable: objectID_ " << syncHeader.getObjectID() << ", classID_ " << syncHeader.getClassID() << " size: " << syncHeader.getDataSize() << " synchronising data" << std::endl; 327 for(i=syncList.begin(); i!=syncList.end(); i++) 328 { 329 assert( mem <= data+syncHeader.getDataSize() ); // always make sure we don't exceed the datasize in our stream 330 (*i)->putData( mem, mode, forceCallback ); 331 } 332 assert(mem == data+syncHeader.getDataSize()); 309 if( !syncHeaderLight.isDiffed() ) 310 { 311 SynchronisableHeader syncHeader2(mem); 312 assert( this->getClassID() == syncHeader2.getClassID() ); 313 assert( this->getCreatorID() == syncHeader2.getCreatorID() ); 314 mem += SynchronisableHeader::getSize(); 315 std::vector<SynchronisableVariableBase *>::iterator i; 316 for(i=syncList_.begin(); i!=syncList_.end(); i++) 317 { 318 assert( mem <= data+syncHeader2.getDataSize()+SynchronisableHeader::getSize() ); // always make sure we don't exceed the datasize in our stream 319 (*i)->putData( mem, mode, forceCallback ); 320 } 321 assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeader::getSize() ); 322 } 323 else 324 { 325 mem += SynchronisableHeaderLight::getSize(); 326 // COUT(0) << "objectID: " << this->objectID_ << endl; 327 while( mem < data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() ) 328 { 329 VariableID varID = *(VariableID*)mem; 330 // COUT(0) << "varID: " << varID << endl; 331 assert( varID < syncList_.size() ); 332 mem += sizeof(VariableID); 333 syncList_[varID]->putData( mem, mode, forceCallback ); 334 } 335 assert(mem == data+syncHeaderLight.getDataSize()+SynchronisableHeaderLight::getSize() ); 336 } 333 337 return true; 334 338 } … … 340 344 * @return amount of bytes 341 345 */ 342 uint32_t Synchronisable::getSize(int32_t id, uint8_t mode){ 343 int tsize=SynchronisableHeader::getSize(); 346 uint32_t Synchronisable::getSize(int32_t id, uint8_t mode) 347 { 348 uint32_t tsize=SynchronisableHeader::getSize(); 344 349 if (mode==0x0) 345 350 mode=state_; … … 349 354 tsize += this->dataSize_; 350 355 std::vector<SynchronisableVariableBase*>::iterator i; 351 for(i=stringList.begin(); i!=stringList.end(); ++i){ 356 for(i=stringList_.begin(); i!=stringList_.end(); ++i) 357 { 352 358 tsize += (*i)->getSize( mode ); 353 359 } … … 360 366 * @return true/false 361 367 */ 362 bool Synchronisable::doSync(int32_t id, uint8_t mode){ 368 bool Synchronisable::doSync(int32_t id, uint8_t mode) 369 { 363 370 if(mode==0x0) 364 371 mode=state_; 365 return ( (this->objectMode_ & mode)!=0 && (!syncList.empty() ) ); 366 } 367 368 /** 369 * This function looks at the header located in the bytestream and checks wheter objectID_ and classID_ match with the Synchronisables ones 370 * @param mem pointer to the bytestream 371 */ 372 bool Synchronisable::isMyData(uint8_t* mem) 373 { 374 SynchronisableHeader header(mem); 375 assert(header.getObjectID()==this->objectID_); 376 return header.isDataAvailable(); 372 return ( (this->objectMode_ & mode)!=0 && (!syncList_.empty() ) ); 377 373 } 378 374 … … 385 381 * @param mode same as in registerVar 386 382 */ 387 void Synchronisable::setSyncMode(uint8_t mode){ 383 void Synchronisable::setSyncMode(uint8_t mode) 384 { 388 385 assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3); 389 386 this->objectMode_=mode; … … 397 394 else 398 395 sv = new SynchronisableVariable<std::string>(variable, mode, cb); 399 syncList.push_back(sv); 400 stringList.push_back(sv); 396 syncList_.push_back(sv); 397 stringList_.push_back(sv); 398 } 399 400 template <> void Synchronisable::unregisterVariable( std::string& variable ) 401 { 402 bool unregistered_nonexistent_variable = true; 403 std::vector<SynchronisableVariableBase*>::iterator it = syncList_.begin(); 404 while(it!=syncList_.end()) 405 { 406 if( ((*it)->getReference()) == &variable ) 407 { 408 delete (*it); 409 syncList_.erase(it); 410 unregistered_nonexistent_variable = false; 411 break; 412 } 413 else 414 ++it; 415 } 416 assert(unregistered_nonexistent_variable == false); 417 418 it = stringList_.begin(); 419 while(it!=stringList_.end()) 420 { 421 if( ((*it)->getReference()) == &variable ) 422 { 423 delete (*it); 424 stringList_.erase(it); 425 return; 426 } 427 else 428 ++it; 429 } 430 unregistered_nonexistent_variable = true; 431 assert(unregistered_nonexistent_variable == false); //if we reach this point something went wrong: 432 // the variable has not been registered before 401 433 } 402 434
Note: See TracChangeset
for help on using the changeset viewer.