Source/Base/FieldContainer/Fields/OSGAttachmentMapFields.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 "OSGAttachmentMapSFields.h"
  45 #include "OSGAttachment.h"
  46 #include "OSGAttachmentContainer.h"
  47 #include "OSGContainerPtrFuncs.h"
  48
  49 #include "OSGTypeBasePredicates.h"
  50 #include "OSGReflexiveContainerTypePredicates.h"
  51 #include "OSGMapHelper.h"
  52
  53 #include "OSGSField.ins"
  54
  55
  56 OSG_BEGIN_NAMESPACE
  57
  58 OSG_FIELD_DLLEXPORT_DEF1(SField, AttachmentMap)
  59
  60
  61 const FieldType &GetSFieldHandle<SFAttachmentPtrMap>::getType(void) const
  62 {
  63     return SFAttachmentPtrMap::getClassType();
  64 }
  65
  66 const FieldType &EditSFieldHandle<SFAttachmentPtrMap>::getType(void) const
  67 {
  68     return SFAttachmentPtrMap::getClassType();
  69 }
  70
  71 SizeT FieldTraits<AttachmentMap>::getBinSize(const AttachmentMap &aMap)
  72 {
  73     AttachmentMap::const_iterator mapIt  = aMap.begin();
  74     AttachmentMap::const_iterator mapEnd = aMap.end  ();
  75
  76     UInt32 numPublicObjects = 0;
  77
  78     for(; mapIt != mapEnd; ++mapIt)
  79     {
  80         if(mapIt->second->getInternal() == false)
  81         {
  82             ++numPublicObjects;
  83         }
  84     }
  85
  86     // number of elements in map + binding and pointer id for each element
  87     return sizeof(UInt32) +
  88         numPublicObjects * (sizeof(UInt16) + sizeof(UInt32));
  89 }
  90
  91 void FieldTraits<AttachmentMap>::copyToBin(      BinaryDataHandler &pMem,
  92                                            const AttachmentMap     &aMap )
  93 {
  94     AttachmentMap::const_iterator mapIt  = aMap.begin();
  95     AttachmentMap::const_iterator mapEnd = aMap.end  ();
  96
  97     UInt32 numPublicObjects = 0;
  98     UInt16 binding;
  99     UInt32 fcId;
 100
 101     for(; mapIt != mapEnd; ++mapIt)
 102     {
 103         if(mapIt->second->getInternal() == false)
 104         {
 105             ++numPublicObjects;
 106         }
 107     }
 108
 109     pMem.putValue(numPublicObjects);
 110
 111     for(mapIt = aMap.begin(); mapIt != mapEnd; ++mapIt)
 112     {
 113         if(mapIt->second->getInternal() == false)
 114         {
 115             binding = mapIt->first & 0xFFFF;
 116             fcId    = mapIt->second->getId();
 117
 118             pMem.putValue(binding);
 119             pMem.putValue(fcId   );
 120         }
 121     }
 122 }
 123
 124 void FieldTraits<AttachmentMap>::copyFromBin(BinaryDataHandler &pMem,
 125                                              AttachmentMap     &aMap )
 126 {
 127     Attachment *attPtr;
 128     UInt32      key;
 129     UInt16      binding;
 130     UInt32      fcId;
 131     UInt32      size;
 132
 133     pMem.getValue(size);
 134
 135
 136     AttachmentMap::const_iterator mapIt  = aMap.begin();
 137     AttachmentMap::const_iterator mapEnd = aMap.end  ();
 138
 139     for(; mapIt != mapEnd; ++mapIt)
 140     {
 141         if((*mapIt).second != NULL)
 142         {
 143             Thread::getCurrentChangeList()->addDelayedSubRef<
 144             UnrecordedRefCountPolicy>((*mapIt).second);
 145         }
 146     }
 147
 148     aMap.clear();
 149
 150
 151     for(UInt32 i = 0; i < size; ++i)
 152     {
 153         pMem.getValue(binding);
 154         pMem.getValue(fcId   );
 155
 156         attPtr = dynamic_cast<Attachment *>(
 157             FieldContainerFactory::the()->getMappedContainer(fcId));
 158
 159         if(attPtr != NULL)
 160         {
 161             key = (static_cast<UInt32>(attPtr->getGroupId()) << 16) | binding;
 162
 163             UnrecordedRefCountPolicy::addRef(attPtr);
 164
 165             aMap.insert(AttachmentMap::value_type(key, attPtr));
 166         }
 167     }
 168 }
 169
 170 void EditSFieldHandle<SFAttachmentPtrMap>::add(
 171           FieldContainer *rhs,
 172     const std::string    &szBindings)
 173 {
 174     Attachment *pVal       = dynamic_cast<Attachment *>(rhs);
 175     UInt32      uiBindings = 0;
 176
 177     if(pVal == NULL)
 178     {
 179         MapHelper *pMHelper = dynamic_cast<MapHelper *>(rhs);
 180
 181         if(pMHelper != NULL)
 182         {
 183             pVal = dynamic_cast<Attachment *>(pMHelper->getContainer());
 184
 185             if(pMHelper->getMFKeys()->empty() == false)
 186             {
 187                 const std::string &szKey = pMHelper->getKeys(0);
 188
 189                 uiBindings = TypeTraits<UInt32>::getFromCString(szKey.c_str());
 190             }
 191         }
 192     }
 193     else
 194     {
 195         if(szBindings.empty() == false)
 196         {
 197             uiBindings = TypeTraits<UInt32>::getFromCString(szBindings.c_str());
 198         }
 199     }
 200
 201     if(rhs != NULL && pVal == NULL)
 202         return;
 203
 204
 205     // for whatever reason VS2003 does not like == NULL
 206     if(_fAddMethod)
 207     {
 208         _fAddMethod(pVal, uiBindings);
 209     }
 210 }
 211
 212 void EditSFieldHandle<SFAttachmentPtrMap>::replaceByObj(Attachment * const pOld,
 213                                                         Attachment * const pNew)
 214 {
 215     if(_fReplaceMethod)
 216     {
 217         _fReplaceMethod(pOld, pNew);
 218     }
 219 }
 220
 221 void EditSFieldHandle<SFAttachmentPtrMap>::traverse(TraverseCallback oCallback)
 222 {
 223     const SFAttachmentPtrMap *pMap = static_cast<SFAttachmentPtrMap *>(_pField);
 224
 225     if(oCallback && pMap != NULL)
 226     {
 227         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 228         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 229
 230         for(; mapIt != mapEnd; ++mapIt)
 231         {
 232             oCallback(mapIt->second);
 233         }
 234     }
 235 }
 236
 237 void EditSFieldHandle<SFAttachmentPtrMap>::flatten(MapList &vList)
 238 {
 239     vList.clear();
 240
 241     const SFAttachmentPtrMap *pMap = static_cast<SFAttachmentPtrMap *>(_pField);
 242
 243     if(pMap != NULL)
 244     {
 245         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 246         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 247
 248         for(; mapIt != mapEnd; ++mapIt)
 249         {
 250             if(mapIt->second->getInternal() == true)
 251                 continue;
 252
 253             std::string szKey;
 254
 255             TypeTraits<UInt32>::putToString((mapIt->first & 0x0000FFFF),
 256                                             szKey);
 257
 258             ListEntry tmpEntry;
 259
 260             tmpEntry.first.push_back(szKey);
 261             tmpEntry.second = mapIt->second;
 262
 263             vList.push_back(tmpEntry);
 264         }
 265     }
 266 }
 267
 268 void EditSFieldHandle<SFAttachmentPtrMap>::flatten(ContainerList &vList)
 269 {
 270     vList.clear();
 271
 272     const SFAttachmentPtrMap *pMap = static_cast<SFAttachmentPtrMap *>(_pField);
 273
 274     if(pMap != NULL)
 275     {
 276         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 277         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 278
 279         for(; mapIt != mapEnd; ++mapIt)
 280         {
 281             if(mapIt->second->getInternal() == true)
 282                 continue;
 283
 284             vList.push_back(mapIt->second);
 285         }
 286     }
 287 }
 288
 289 bool EditSFieldHandle<SFAttachmentPtrMap>::loadFromBin(
 290     BinaryDataHandler        *pMem,
 291     UInt32                    uiNumElements,
 292     bool                      hasBindingInfo,
 293     std::vector<UInt16>      &vBindings,
 294     std::vector<UInt32>      &vIds          )
 295 {
 296     UInt32             ptrId;
 297     UInt16             binding;
 298
 299     for(UInt32 i = 0; i < uiNumElements; ++i)
 300     {
 301         pMem->getValue(binding);
 302         pMem->getValue(ptrId  );
 303
 304         FDEBUG(("EditSFieldHandle<SFAttachmentPtrMap>::loadFromBin: "
 305                 "attachment [%u], binding [%u], id [%u].\n",
 306                 i, binding, ptrId));
 307
 308         vBindings.push_back(binding);
 309         vIds     .push_back(ptrId  );
 310     }
 311
 312     return false;
 313 }
 314
 315
 316 void EditSFieldHandle<SFAttachmentPtrMap>::fillFrom(
 317     const std::vector<UInt16>      &vBindings,
 318     const std::vector<UInt32>      &vIds,
 319     const std::map<UInt32, UInt32> &vIdMap   )
 320 {
 321 }
 322
 323 void EditSFieldHandle<SFAttachmentPtrMap>::cloneValues(
 324           GetFieldHandlePtr  pSrc,
 325     const TypePtrVector     &shareTypes,
 326     const TypePtrVector     &ignoreTypes,
 327     const TypeIdVector      &shareGroupIds,
 328     const TypeIdVector      &ignoreGroupIds) const
 329 {
 330     SFAttachmentPtrMap::GetHandlePtr pGetHandle =
 331         boost::dynamic_pointer_cast<
 332             SFAttachmentPtrMap::GetHandle>(pSrc);
 333
 334     if(pGetHandle == NULL || pGetHandle->isValid() == false)
 335         return;
 336
 337     const SFAttachmentPtrMap &pAttMap = **pGetHandle;
 338
 339     AttachmentMap::const_iterator mapIt  = pAttMap.getValue().begin();
 340     AttachmentMap::const_iterator mapEnd = pAttMap.getValue().end();
 341
 342     for(; mapIt != mapEnd; ++mapIt)
 343     {
 344         AttachmentUnrecPtr att       = mapIt->second;
 345         UInt16             uiBinding = UInt16(mapIt->first &
 346                                               0x0000FFFF    );
 347
 348         if(att != NULL)
 349         {
 350             const FieldContainerType &attType = att->getType();
 351
 352             // test if att type should NOT be ignored
 353             if(!TypePredicates::typeInGroupIds (ignoreGroupIds.begin(),
 354                                                 ignoreGroupIds.end(),
 355                                                 attType                ) &&
 356                !TypePredicates::typeDerivedFrom(ignoreTypes.begin(),
 357                                                 ignoreTypes.end(),
 358                                                 attType                )   )
 359             {
 360                 // test if att should cloned
 361                 if(!TypePredicates::typeInGroupIds (shareGroupIds.begin(),
 362                                                     shareGroupIds.end(),
 363                                                     attType               ) &&
 364                    !TypePredicates::typeDerivedFrom(shareTypes.begin(),
 365                                                     shareTypes.end(),
 366                                                     attType               )   )
 367                 {
 368                     att = dynamic_pointer_cast<Attachment>(
 369                         OSG::deepClone(att, shareTypes,    ignoreTypes,
 370                                             shareGroupIds, ignoreGroupIds));
 371                 }
 372             }
 373         }
 374
 375         if(_fAddMethod)
 376         {
 377             _fAddMethod(att, uiBinding);
 378         }
 379     }
 380 }
 381
 382
 383 void GetSFieldHandle<SFAttachmentPtrMap>::traverse(TraverseCallback oCallback)
 384 {
 385     SFAttachmentPtrMap const *pMap =
 386         static_cast<SFAttachmentPtrMap const *>(_pField);
 387
 388     if(oCallback && pMap != NULL)
 389     {
 390         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 391         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 392
 393         for(; mapIt != mapEnd; ++mapIt)
 394         {
 395             oCallback(mapIt->second);
 396         }
 397     }
 398 }
 399
 400 void GetSFieldHandle<SFAttachmentPtrMap>::flatten(MapList &vList)
 401 {
 402     vList.clear();
 403
 404     SFAttachmentPtrMap const *pMap =
 405         static_cast<SFAttachmentPtrMap const *>(_pField);
 406
 407     if(pMap != NULL)
 408     {
 409         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 410         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 411
 412         for(; mapIt != mapEnd; ++mapIt)
 413         {
 414             if(mapIt->second->getInternal() == true)
 415                 continue;
 416
 417             std::string szKey;
 418
 419             TypeTraits<UInt32>::putToString((mapIt->first & 0x0000FFFF),
 420                                             szKey);
 421
 422             ListEntry tmpEntry;
 423
 424             tmpEntry.first.push_back(szKey);
 425             tmpEntry.second = mapIt->second;
 426
 427             vList.push_back(tmpEntry);
 428         }
 429     }
 430 }
 431
 432 void GetSFieldHandle<SFAttachmentPtrMap>::flatten(ContainerList &vList)
 433 {
 434     vList.clear();
 435
 436     SFAttachmentPtrMap const *pMap =
 437         static_cast<SFAttachmentPtrMap const *>(_pField);
 438
 439     if(pMap != NULL)
 440     {
 441         AttachmentMap::const_iterator mapIt  = pMap->getValue().begin();
 442         AttachmentMap::const_iterator mapEnd = pMap->getValue().end  ();
 443
 444         for(; mapIt != mapEnd; ++mapIt)
 445         {
 446             if(mapIt->second->getInternal() == true)
 447                 continue;
 448
 449             vList.push_back(mapIt->second);
 450         }
 451     }
 452 }
 453
 454 #if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 455
 456 DataType FieldTraits<AttachmentMap>::_type(
 457     "AttachmentMap",
 458     "FieldContainerPtrMap");
 459
 460 OSG_FIELDTRAITS_GETTYPE(AttachmentMap)
 461
 462 #endif // !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
 463
 464 OSG_END_NAMESPACE