Source/System/State/Base/OSGChunkBlockMapFields.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 by the OpenSG Forum                          *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 //---------------------------------------------------------------------------
  40 //  Includes
  41 //---------------------------------------------------------------------------
  42
  43 #include "OSGFieldContainer.h"
  44 #include "OSGChunkBlockMapFields.h"
  45 #include "OSGChunkBlock.h"
  46 #include "OSGContainerPtrFuncs.h"
  47
  48 #include "OSGTypeBasePredicates.h"
  49 #include "OSGReflexiveContainerTypePredicates.h"
  50 #include "OSGMapHelper.h"
  51
  52 #include "OSGSField.ins"
  53
  54
  55 OSG_BEGIN_NAMESPACE
  56
  57 OSG_FIELD_DLLEXPORT_DEF1(SField, ChunkBlockMap)
  58
  59
  60 const FieldType &GetSFieldHandle<SFChunkBlockPtrMap>::getType(void) const
  61 {
  62     return SFChunkBlockPtrMap::getClassType();
  63 }
  64
  65 const FieldType &EditSFieldHandle<SFChunkBlockPtrMap>::getType(void) const
  66 {
  67     return SFChunkBlockPtrMap::getClassType();
  68 }
  69
  70 SizeT FieldTraits<ChunkBlockMap>::getBinSize(const ChunkBlockMap &aMap)
  71 {
  72     // number of elements in map + binding and pointer id for each element
  73     ChunkBlockMap::const_iterator mapIt  = aMap.begin();
  74     ChunkBlockMap::const_iterator mapEnd = aMap.end  ();
  75
  76     SizeT uiKeySize = 0;
  77
  78     for(;mapIt != mapEnd; ++mapIt)
  79     {
  80         std::vector<std::string> vKeyList;
  81
  82         KeyPool::the()->keyToStringList(mapIt->first, vKeyList);
  83
  84         std::vector<std::string>::const_iterator kIt  = vKeyList.begin();
  85         std::vector<std::string>::const_iterator kEnd = vKeyList.end  ();
  86
  87         uiKeySize += sizeof(UInt32);
  88
  89         for(; kIt != kEnd; ++kIt)
  90         {
  91             uiKeySize += FieldTraits<std::string>::getBinSize(*kIt);
  92         }
  93     }
  94
  95     return sizeof(UInt32) + aMap.size() * sizeof(UInt32) + uiKeySize;
  96 }
  97
  98 void FieldTraits<ChunkBlockMap>::copyToBin(      BinaryDataHandler &pMem,
  99                                            const ChunkBlockMap     &aMap )
 100 {
 101     ChunkBlockMap::const_iterator mapIt  = aMap.begin();
 102     ChunkBlockMap::const_iterator mapEnd = aMap.end  ();
 103
 104     UInt32         numPublicObjects = UInt32(aMap.size());
 105     UInt32         fcId;
 106
 107     pMem.putValue(numPublicObjects);
 108
 109     for(; mapIt != mapEnd; ++mapIt)
 110     {
 111         std::vector<std::string> vKeyList;
 112
 113         KeyPool::the()->keyToStringList(mapIt->first, vKeyList);
 114
 115         std::vector<std::string>::const_iterator kIt  = vKeyList.begin();
 116         std::vector<std::string>::const_iterator kEnd = vKeyList.end  ();
 117
 118         UInt32 uiNumKeys = UInt32(vKeyList.size());
 119
 120         pMem.putValue(uiNumKeys);
 121
 122         for(; kIt != kEnd; ++kIt)
 123         {
 124             FieldTraits<std::string>::copyToBin(pMem, *kIt);
 125         }
 126
 127         fcId  = mapIt->second->getId();
 128
 129         pMem.putValue(fcId);
 130     }
 131 }
 132
 133 void FieldTraits<ChunkBlockMap>::copyFromBin(BinaryDataHandler &pMem,
 134                                              ChunkBlockMap     &aMap )
 135 {
 136     ChunkBlock       *matPtr;
 137     ChunkBlockMapKey  key  = KeyPool::the()->getDefault();
 138     UInt32            fcId;
 139     UInt32            uiNumObjects;
 140
 141     pMem.getValue(uiNumObjects);
 142
 143     ChunkBlockMap::const_iterator mapIt  = aMap.begin();
 144     ChunkBlockMap::const_iterator mapEnd = aMap.end  ();
 145
 146     for(; mapIt != mapEnd; ++mapIt)
 147     {
 148         if((*mapIt).second != NULL)
 149         {
 150             Thread::getCurrentChangeList()->addDelayedSubRef<
 151                 UnrecordedRefCountPolicy>((*mapIt).second);
 152         }
 153     }
 154
 155     aMap.clear();
 156
 157
 158     for(UInt32 i = 0; i < uiNumObjects; ++i)
 159     {
 160         UInt32 uiNumKeys;
 161
 162         pMem.getValue(uiNumKeys);
 163
 164         for(UInt32 j = 0; j < uiNumKeys; ++j)
 165         {
 166             std::string tmpString;
 167
 168             FieldTraits<std::string>::copyFromBin(pMem, tmpString);
 169
 170             ChunkBlockMapKey tmpKey =
 171                 KeyPool::the()->getAuto(tmpString.c_str());
 172
 173             key |= tmpKey;
 174         }
 175
 176         pMem.getValue(fcId);
 177
 178         matPtr = dynamic_cast<ChunkBlock *>(
 179             FieldContainerFactory::the()->getMappedContainer(fcId));
 180
 181         if(matPtr != NULL)
 182         {
 183             UnrecordedRefCountPolicy::addRef(matPtr);
 184
 185             aMap.insert(ChunkBlockMap::value_type(key, matPtr));
 186         }
 187     }
 188 }
 189
 190 void EditSFieldHandle<SFChunkBlockPtrMap>::add(
 191           FieldContainer *rhs,
 192     const std::string    &szBindings)
 193 {
 194     ChunkBlock *pVal = dynamic_cast<ChunkBlock *>(rhs);
 195     KeyType     oKey = 0x0000;
 196
 197     if(pVal == NULL)
 198     {
 199         MapHelper *pMHelper = dynamic_cast<MapHelper *>(rhs);
 200
 201         if(pMHelper != NULL)
 202         {
 203             pVal = dynamic_cast<ChunkBlock *>(pMHelper->getContainer());
 204
 205             const MapHelper::MFKeysType *pKeys = pMHelper->getMFKeys();
 206
 207             if(pKeys->empty() == false)
 208             {
 209                 KeyType tmpKey = KeyPool::the()->getDefault();
 210
 211                 for(UInt32 i = 0; i < pKeys->size(); ++i)
 212                 {
 213                     const std::string &szKey = pMHelper->getKeys(i);
 214
 215                     tmpKey = KeyPool::the()->getAuto(szKey.c_str());
 216
 217                     oKey |= tmpKey;
 218                 }
 219             }
 220         }
 221     }
 222     else
 223     {
 224         if(szBindings.empty() == false)
 225         {
 226             oKey = KeyPool::the()->getAuto(szBindings.c_str());
 227         }
 228     }
 229
 230     if(rhs != NULL && pVal == NULL)
 231         return;
 232
 233
 234     // for whatever reason VS2003 does not like == NULL
 235     if(_fAddMethod)
 236     {
 237         _fAddMethod(pVal, oKey);
 238     }
 239 }
 240
 241 void EditSFieldHandle<SFChunkBlockPtrMap>::traverse(TraverseCallback oCallback)
 242 {
 243     const SFChunkBlockPtrMap *pMap = static_cast<SFChunkBlockPtrMap *>(_pField);
 244
 245     if(oCallback && pMap != NULL)
 246     {
 247         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 248         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 249
 250         for(; mapIt != mapEnd; ++mapIt)
 251         {
 252             oCallback(mapIt->second);
 253         }
 254     }
 255 }
 256
 257 void EditSFieldHandle<SFChunkBlockPtrMap>::flatten(MapList &vList)
 258 {
 259     vList.clear();
 260
 261     const SFChunkBlockPtrMap *pMap = static_cast<SFChunkBlockPtrMap *>(_pField);
 262
 263     if(pMap != NULL)
 264     {
 265         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 266         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 267
 268         for(; mapIt != mapEnd; ++mapIt)
 269         {
 270             ListEntry tmpEntry;
 271
 272             KeyPool::the()->keyToStringList(mapIt->first,
 273                                             tmpEntry.first);
 274
 275             tmpEntry.second = mapIt->second;
 276
 277             vList.push_back(tmpEntry);
 278         }
 279     }
 280 }
 281
 282 void EditSFieldHandle<SFChunkBlockPtrMap>::flatten(ContainerList &vList)
 283 {
 284     vList.clear();
 285
 286     const SFChunkBlockPtrMap *pMap = static_cast<SFChunkBlockPtrMap *>(_pField);
 287
 288     if(pMap != NULL)
 289     {
 290         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 291         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 292
 293         for(; mapIt != mapEnd; ++mapIt)
 294         {
 295             vList.push_back(mapIt->second);
 296         }
 297     }
 298 }
 299
 300 bool EditSFieldHandle<SFChunkBlockPtrMap>::loadFromBin(
 301     BinaryDataHandler        *pMem,
 302     UInt32                    uiNumElements,
 303     bool                      hasBindingInfo,
 304     std::vector<UInt16>      &vBindings,
 305     std::vector<UInt32>      &vIds          )
 306 {
 307     SFChunkBlockPtrMap *pMap = static_cast<SFChunkBlockPtrMap *>(_pField);
 308
 309     if(pMap == NULL)
 310         return true;
 311
 312     ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 313     ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 314
 315     for(; mapIt != mapEnd; ++mapIt)
 316     {
 317         if((*mapIt).second != NULL)
 318         {
 319             Thread::getCurrentChangeList()->addDelayedSubRef<
 320                  UnrecordedRefCountPolicy>((*mapIt).second);
 321         }
 322     }
 323
 324     pMap->getValue().clear();
 325
 326
 327     UInt32 fcId;
 328
 329     union
 330     {
 331         ChunkBlock  *pointerVal;
 332         UIntPointer  uiVal;
 333     } tmpEntry;
 334
 335     for(UInt32 i = 0; i < uiNumElements; ++i)
 336     {
 337         ChunkBlockMapKey  key  = KeyPool::the()->getDefault();
 338         UInt32            uiNumKeys;
 339
 340         pMem->getValue(uiNumKeys);
 341
 342         for(UInt32 j = 0; j < uiNumKeys; ++j)
 343         {
 344             std::string tmpString;
 345
 346             FieldTraits<std::string>::copyFromBin(*pMem, tmpString);
 347
 348             ChunkBlockMapKey tmpKey =
 349                 KeyPool::the()->getAuto(tmpString.c_str());
 350
 351             key |= tmpKey;
 352         }
 353
 354         pMem->getValue(fcId);
 355
 356         tmpEntry.uiVal = fcId;
 357
 358         pMap->getValue().insert(ChunkBlockMap::value_type(key,
 359                                                           tmpEntry.pointerVal));
 360     }
 361
 362     UInt16 uiCount = 0;
 363
 364     ChunkBlockMap::iterator mapWIt = pMap->getValue().begin();
 365                             mapEnd = pMap->getValue().end  ();
 366
 367     for(; mapWIt != mapEnd; ++mapWIt, ++uiCount)
 368     {
 369         tmpEntry.pointerVal = mapWIt->second;
 370
 371         vIds     .push_back(tmpEntry.uiVal);
 372         vBindings.push_back(uiCount       );
 373
 374         mapWIt->second = NULL;
 375     }
 376
 377     return true;
 378 }
 379
 380 void EditSFieldHandle<SFChunkBlockPtrMap>::fillFrom(
 381     const std::vector<UInt16>      &vBindings,
 382     const std::vector<UInt32>      &vIds,
 383     const std::map<UInt32, UInt32> &mIdMap       )
 384 {
 385     SFChunkBlockPtrMap *pMap = static_cast<SFChunkBlockPtrMap *>(_pField);
 386
 387     if(pMap == NULL)
 388         return;
 389
 390     ChunkBlockMap::iterator       mapIt  = pMap->getValue().begin();
 391     ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 392
 393     std::vector<UInt32        >::const_iterator idIt    = vIds.begin();
 394     std::map   <UInt32, UInt32>::const_iterator imapIt;
 395     std::map   <UInt32, UInt32>::const_iterator imapEnd = mIdMap.end();
 396
 397     OSG_ASSERT(vIds     .size() == pMap->getValue().size() &&
 398                vBindings.size() == pMap->getValue().size()  );
 399
 400     ChunkBlock *pMat = NULL;
 401
 402     for(; mapIt != mapEnd; ++mapIt, ++idIt)
 403     {
 404         imapIt  = mIdMap.find(*idIt);
 405
 406         if(imapIt != imapEnd)
 407         {
 408             pMat = dynamic_cast<ChunkBlock *>(
 409                 FieldContainerFactory::the()->getContainer(imapIt->second));
 410
 411             UnrecordedRefCountPolicy::addRef(pMat);
 412         }
 413         else
 414         {
 415             pMat = NULL;
 416         }
 417
 418         mapIt->second = pMat;
 419     }
 420 }
 421
 422
 423 void EditSFieldHandle<SFChunkBlockPtrMap>::cloneValues(
 424           GetFieldHandlePtr  pSrc,
 425     const TypePtrVector     &shareTypes,
 426     const TypePtrVector     &ignoreTypes,
 427     const TypeIdVector      &shareGroupIds,
 428     const TypeIdVector      &ignoreGroupIds) const
 429 {
 430     SFChunkBlockPtrMap::GetHandlePtr pGetHandle =
 431         boost::dynamic_pointer_cast<
 432             SFChunkBlockPtrMap::GetHandle>(pSrc);
 433
 434     if(pGetHandle == NULL || pGetHandle->isValid() == false)
 435         return;
 436
 437     const SFChunkBlockPtrMap &pAttMap = **pGetHandle;
 438
 439     ChunkBlockMap::const_iterator mapIt  = pAttMap.getValue().begin();
 440     ChunkBlockMap::const_iterator mapEnd = pAttMap.getValue().end();
 441
 442     for(; mapIt != mapEnd; ++mapIt)
 443     {
 444         ChunkBlockUnrecPtr att = mapIt->second;
 445         ChunkBlockMapKey   key = mapIt->first;
 446
 447         if(att != NULL)
 448         {
 449             const FieldContainerType &attType = att->getType();
 450
 451             // test if att type should NOT be ignored
 452             if(!TypePredicates::typeInGroupIds (ignoreGroupIds.begin(),
 453                                                 ignoreGroupIds.end(),
 454                                                 attType                ) &&
 455                !TypePredicates::typeDerivedFrom(ignoreTypes.begin(),
 456                                                 ignoreTypes.end(),
 457                                                 attType                )   )
 458             {
 459                 // test if att should cloned
 460                 if(!TypePredicates::typeInGroupIds (shareGroupIds.begin(),
 461                                                     shareGroupIds.end(),
 462                                                     attType               ) &&
 463                    !TypePredicates::typeDerivedFrom(shareTypes.begin(),
 464                                                     shareTypes.end(),
 465                                                     attType               )   )
 466                 {
 467                     att = dynamic_pointer_cast<ChunkBlock>(
 468                         OSG::deepClone(att, shareTypes,    ignoreTypes,
 469                                             shareGroupIds, ignoreGroupIds));
 470                 }
 471             }
 472         }
 473
 474         if(_fAddMethod)
 475         {
 476             _fAddMethod(att, key);
 477         }
 478     }
 479 }
 480
 481
 482 void GetSFieldHandle<SFChunkBlockPtrMap>::traverse(TraverseCallback oCallback)
 483 {
 484     SFChunkBlockPtrMap const *pMap =
 485         static_cast<SFChunkBlockPtrMap const *>(_pField);
 486
 487     if(oCallback && pMap != NULL)
 488     {
 489         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 490         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 491
 492         for(; mapIt != mapEnd; ++mapIt)
 493         {
 494             oCallback(mapIt->second);
 495         }
 496     }
 497 }
 498
 499 void GetSFieldHandle<SFChunkBlockPtrMap>::flatten(MapList &vList)
 500 {
 501     vList.clear();
 502
 503     SFChunkBlockPtrMap const *pMap =
 504         static_cast<SFChunkBlockPtrMap const *>(_pField);
 505
 506     if(pMap != NULL)
 507     {
 508         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 509         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 510
 511         for(; mapIt != mapEnd; ++mapIt)
 512         {
 513             ListEntry   tmpEntry;
 514
 515             KeyPool::the()->keyToStringList(mapIt->first,
 516                                             tmpEntry.first);
 517
 518             tmpEntry.second = mapIt->second;
 519
 520             vList.push_back(tmpEntry);
 521         }
 522     }
 523 }
 524
 525 void GetSFieldHandle<SFChunkBlockPtrMap>::flatten(ContainerList &vList)
 526 {
 527     vList.clear();
 528
 529     SFChunkBlockPtrMap const *pMap =
 530         static_cast<SFChunkBlockPtrMap const *>(_pField);
 531
 532     if(pMap != NULL)
 533     {
 534         ChunkBlockMap::const_iterator mapIt  = pMap->getValue().begin();
 535         ChunkBlockMap::const_iterator mapEnd = pMap->getValue().end  ();
 536
 537         for(; mapIt != mapEnd; ++mapIt)
 538         {
 539             vList.push_back(mapIt->second);
 540         }
 541     }
 542 }
 543
 544 #if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 545
 546 DataType FieldTraits<ChunkBlockMap>::_type(
 547     "ChunkBlockMap",
 548     "FieldContainerPtrMap");
 549
 550 OSG_FIELDTRAITS_GETTYPE(ChunkBlockMap)
 551
 552 #endif // !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 553
 554 OSG_END_NAMESPACE