Source/Base/FieldContainer/Misc/OSGFieldContainerUtils.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                   Copyright (C) 2008 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 #include "OSGFieldContainerUtils.h"
  40 #include "OSGFieldContainerSFields.h"
  41 #include "OSGFieldContainerMFields.h"
  42 #include "OSGAttachment.h"
  43 #include "OSGAttachmentMapSFields.h"
  44 #include "OSGNameAttachment.h"
  45 #include "OSGNode.h"
  46
  47 #include <boost/bind.hpp>
  48 #include <boost/format.hpp>
  49
  50 #include <ostream>
  51 #include <set>
  52
  53 OSG_BEGIN_NAMESPACE
  54
  55 namespace
  56 {
  57     // anonymous namespace for implementation details of the container
  58     // function.
  59
  60 typedef std::set<const FieldContainer *> FCSet;
  61
  62 // forward declarations
  63 bool comparePointerFields(
  64     GetFieldHandlePtr  lhsField,
  65     GetFieldHandlePtr  rhsField,
  66     FCSet             &lhsVisitedSet,
  67     FCSet             &rhsVisitedSet,
  68     bool               ignoreAttachments,
  69     bool               compareIdentity   );
  70
  71 /*! Implementation of \c compareContainerEqual. The two \c FCSet parameters
  72     keep track of visited fields in each hierarchy to avoid looping.
  73  */
  74 bool compareContainerEqualImpl(
  75     const FieldContainer *lhs,
  76     const FieldContainer *rhs,
  77           FCSet          &lhsVisitedSet,
  78           FCSet          &rhsVisitedSet,
  79           bool            ignoreAttachments,
  80           bool            compareIdentity   )
  81 {
  82     // compare pointers
  83     if(lhs == rhs)
  84         return true;
  85
  86     if(lhs == NULL || rhs == NULL)
  87         return false;
  88
  89     // different types ?
  90     if(lhs->getType() != rhs->getType())
  91         return false;
  92
  93     UInt32 lhsFCount = lhs->getType().getNumFieldDescs();
  94     UInt32 rhsFCount = rhs->getType().getNumFieldDescs();
  95
  96     // different number of (dynamic) fields ?
  97     if(lhsFCount != rhsFCount)
  98         return false;
  99
 100     lhsVisitedSet.insert(lhs);
 101     rhsVisitedSet.insert(rhs);
 102
 103     bool returnValue = true;
 104
 105     for(UInt32 i = 1; i <= lhsFCount && returnValue == true; ++i)
 106     {
 107         GetFieldHandlePtr lhsField = lhs->getField(i);
 108         GetFieldHandlePtr rhsField = rhs->getField(i);
 109
 110         // valid handles ?
 111         if(lhsField == NULL || lhsField->isValid() == false ||
 112            rhsField == NULL || rhsField->isValid() == false   )
 113             continue;
 114
 115         if(lhsField->getType() != rhsField->getType())
 116         {
 117             returnValue = false;
 118             continue;
 119         }
 120
 121         // skip internal and parent fields
 122         if(lhsField->isInternal()            == true                      ||
 123            lhsField->getType   ().getClass() == FieldType::ParentPtrField   )
 124             continue;
 125
 126         SFAttachmentPtrMap::GetHandlePtr  lhsAMHandle =
 127             boost::dynamic_pointer_cast<SFAttachmentPtrMap::GetHandle>(
 128                 lhsField);
 129
 130         if(lhsAMHandle            != NULL &&
 131            lhsAMHandle->isValid() == true &&
 132            ignoreAttachments      == true  )
 133         {
 134             continue;
 135         }
 136
 137         if(compareIdentity == true)
 138         {
 139             if(lhsField->equal(rhsField) == false)
 140                 returnValue = false;
 141         }
 142         else
 143         {
 144             if(lhsField->isPointerField() == true)
 145             {
 146                 returnValue = comparePointerFields(
 147                     lhsField,          rhsField,
 148                     lhsVisitedSet,     rhsVisitedSet,
 149                     ignoreAttachments, compareIdentity);
 150             }
 151             else
 152             {
 153                 if(lhsField->equal(rhsField) == false)
 154                     returnValue = false;
 155             }
 156         }
 157     }
 158
 159     return returnValue;
 160 }
 161
 162 /*! Compares two PointerFields \a lhsField and \a rhsField by recursively
 163     comparing the pointed-to containers.
 164     This function is only used in \c compareContainer below.
 165  */
 166 bool comparePointerFields(
 167     GetFieldHandlePtr  lhsField,
 168     GetFieldHandlePtr  rhsField,
 169     FCSet             &lhsVisitedSet,
 170     FCSet             &rhsVisitedSet,
 171     bool               ignoreAttachments,
 172     bool               compareIdentity   )
 173 {
 174     bool returnValue = true;
 175
 176     if(lhsField->getCardinality() == FieldType::SingleField)
 177     {
 178         FieldContainerPtrSFieldBase::GetHandlePtr lhsSFHandle =
 179             boost::dynamic_pointer_cast<
 180                 FieldContainerPtrSFieldBase::GetHandle>(lhsField);
 181         FieldContainerPtrSFieldBase::GetHandlePtr rhsSFHandle =
 182             boost::dynamic_pointer_cast<
 183                 FieldContainerPtrSFieldBase::GetHandle>(rhsField);
 184
 185         if(lhsSFHandle != NULL && lhsSFHandle->isValid() &&
 186            rhsSFHandle != NULL && rhsSFHandle->isValid()   )
 187         {
 188             if(lhsVisitedSet.count(lhsSFHandle->get()) == 0 ||
 189                rhsVisitedSet.count(rhsSFHandle->get()) == 0   )
 190             {
 191                 returnValue = compareContainerEqualImpl(
 192                     lhsSFHandle->get(), rhsSFHandle->get(),
 193                     lhsVisitedSet,      rhsVisitedSet,
 194                     ignoreAttachments,  compareIdentity     );
 195             }
 196         }
 197         else
 198         {
 199             SFAttachmentPtrMap::GetHandlePtr  lhsAMHandle =
 200                 boost::dynamic_pointer_cast<SFAttachmentPtrMap::GetHandle>(
 201                     lhsField);
 202             SFAttachmentPtrMap::GetHandlePtr  rhsAMHandle =
 203                 boost::dynamic_pointer_cast<SFAttachmentPtrMap::GetHandle>(
 204                     rhsField);
 205
 206             if(lhsAMHandle != NULL && lhsAMHandle->isValid() &&
 207                rhsAMHandle != NULL && rhsAMHandle->isValid()   )
 208             {
 209                 const AttachmentMap &lhsAM = (*lhsAMHandle)->getValue();
 210                 const AttachmentMap &rhsAM = (*rhsAMHandle)->getValue();
 211
 212                 // skip attachments, if the option is set
 213                 if(ignoreAttachments)
 214                 {
 215                     returnValue = true;
 216                 }
 217                 else if(lhsAM.size() != rhsAM.size())
 218                 {
 219                     returnValue = false;
 220                 }
 221                 else
 222                 {
 223                     AttachmentMap::const_iterator lhsAMIt  = lhsAM.begin();
 224                     AttachmentMap::const_iterator lhsAMEnd = lhsAM.end  ();
 225
 226                     AttachmentMap::const_iterator rhsAMIt  = rhsAM.begin();
 227
 228                     for(; lhsAMIt != lhsAMEnd && returnValue == true;
 229                         ++lhsAMIt, ++rhsAMIt)
 230                     {
 231                         if(lhsVisitedSet.count(lhsAMIt->second) == 0 ||
 232                            rhsVisitedSet.count(rhsAMIt->second) == 0   )
 233                         {
 234                             returnValue = compareContainerEqualImpl(
 235                                 lhsAMIt->second,   rhsAMIt->second,
 236                                 lhsVisitedSet,     rhsVisitedSet,
 237                                 ignoreAttachments, compareIdentity );
 238                         }
 239                     }
 240                 }
 241             }
 242         }
 243     }
 244     else
 245     {
 246         FieldContainerPtrMFieldBase::GetHandlePtr lhsMFHandle =
 247             boost::dynamic_pointer_cast<
 248                 FieldContainerPtrMFieldBase::GetHandle>(lhsField);
 249         FieldContainerPtrMFieldBase::GetHandlePtr rhsMFHandle =
 250             boost::dynamic_pointer_cast<
 251                 FieldContainerPtrMFieldBase::GetHandle>(rhsField);
 252
 253         if(lhsMFHandle != NULL && lhsMFHandle->isValid() &&
 254                 rhsMFHandle != NULL && rhsMFHandle->isValid()   )
 255         {
 256             if(lhsMFHandle->size() != rhsMFHandle->size())
 257             {
 258                 returnValue = false;
 259             }
 260             else
 261             {
 262                 for(UInt32 i = 0; i           <  lhsMFHandle->size() &&
 263                                   returnValue == true;                  ++i)
 264                 {
 265                     if(lhsVisitedSet.count(lhsMFHandle->get(i)) == 0 ||
 266                        rhsVisitedSet.count(rhsMFHandle->get(i)) == 0   )
 267                     {
 268                         returnValue = compareContainerEqualImpl(
 269                             lhsMFHandle->get(i), rhsMFHandle->get(i),
 270                             lhsVisitedSet,       rhsVisitedSet,
 271                             ignoreAttachments,   compareIdentity     );
 272                     }
 273                 }
 274             }
 275         }
 276     }
 277
 278     return returnValue;
 279 }
 280
 281 /*! \nohierarchy
 282  */
 283
 284 struct FieldPathEntry
 285 {
 286     std::string szName;
 287     Int32       iIndex;
 288 };
 289
 290 void splitFieldPath(      std::vector<FieldPathEntry> &vSplitPath,
 291                     const Char8                       *szFieldPath)
 292 {
 293     std::string tmpName(szFieldPath);
 294
 295     std::string::size_type sStart    = 0;
 296     std::string::size_type sEnd      = 0;
 297     std::string::size_type sLength   = 0;
 298     std::string::size_type sLastChar = 0;
 299     FieldPathEntry         tmpEntry;
 300
 301     std::string            szIdx;
 302
 303     do
 304     {
 305         sEnd = tmpName.find("/", sStart);
 306
 307         if(sEnd != std::string::npos)
 308         {
 309             sLength = sEnd - sStart;
 310         }
 311         else
 312         {
 313             sLength = tmpName.length() - sStart;
 314         }
 315
 316         sLastChar = sStart + sLength - 1;
 317
 318         vSplitPath.push_back(tmpEntry);
 319
 320         vSplitPath.back().iIndex = -1;
 321
 322         if(tmpName[sLastChar] == ')')
 323         {
 324             std::string::size_type sIdxStart =
 325                 tmpName.rfind('(', sLastChar); //, sLength);
 326
 327             if(sIdxStart == std::string::npos)
 328             {
 329                 vSplitPath.clear();
 330
 331                 return;
 332             }
 333
 334             tmpName[sIdxStart] = '$';
 335             tmpName[sLastChar] = '$';
 336
 337             sLength -= sLastChar - sIdxStart + 1;
 338
 339             ++sIdxStart;
 340
 341             szIdx.assign(tmpName,
 342                          sIdxStart,
 343                          sLastChar - sIdxStart);
 344
 345             vSplitPath.back().iIndex =
 346                 TypeTraits<UInt32>::getFromCString(szIdx.c_str());
 347         }
 348
 349         vSplitPath.back().szName.assign(tmpName, sStart, sLength);
 350
 351         sStart = sEnd + 1;
 352     }
 353     while(sEnd != std::string::npos);
 354 }
 355
 356 FieldContainer *resolveFieldPath(std::vector<FieldPathEntry> &vSplitPath,
 357                                  FieldContainer              *pRoot     )
 358 {
 359     if(pRoot == NULL)
 360         return NULL;
 361
 362     FieldContainer *returnValue = pRoot;
 363
 364     OSG::GetFieldHandlePtr fHandle;
 365
 366     for(UInt32 i = 1; i < vSplitPath.size(); ++i)
 367     {
 368         fHandle = returnValue->getField(vSplitPath[i].szName.c_str());
 369
 370         if(fHandle == NULL || fHandle->isValid() == false)
 371         {
 372             FWARNING(("Unknown field '%s'\n",
 373                       vSplitPath[i].szName.c_str()));
 374
 375             returnValue = NULL;
 376
 377             break;
 378         }
 379
 380         OSG::FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 381             boost::dynamic_pointer_cast<
 382               OSG::FieldContainerPtrSFieldBase::GetHandle>(fHandle);
 383
 384         OSG::FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 385             boost::dynamic_pointer_cast<
 386                 OSG::FieldContainerPtrMFieldBase::GetHandle>(fHandle);
 387
 388         if(sfFCPtr != NULL && sfFCPtr->isValid() == true)
 389         {
 390             returnValue = (*sfFCPtr)->getValue();
 391         }
 392         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 393         {
 394             UInt32 uiIndex =
 395                 vSplitPath[i].iIndex == -1 ? 0 : vSplitPath[i].iIndex;
 396
 397             if(uiIndex >= mfFCPtr->size())
 398             {
 399                 FWARNING(("Unknown index %d to large for field '%s'\n",
 400                           uiIndex,
 401                           vSplitPath[i].szName.c_str()));
 402
 403                 returnValue = NULL;
 404
 405                 break;
 406             }
 407
 408             returnValue = (**mfFCPtr)[uiIndex];
 409         }
 410     }
 411
 412     return returnValue;
 413 }
 414
 415 FieldContainer *resolveFieldPathImpl(const Char8             *szNodeName,
 416                                            ContainerResolver  oResolver )
 417 {
 418     std::vector<FieldPathEntry> vSplitPath;
 419
 420     splitFieldPath(vSplitPath, szNodeName);
 421
 422     if(vSplitPath.size() == 0)
 423         return NULL;
 424
 425     FieldContainer *returnValue = oResolver(vSplitPath[0].szName.c_str());
 426
 427     returnValue = resolveFieldPath(vSplitPath, returnValue);
 428
 429     return returnValue;
 430 }
 431
 432
 433
 434 struct ContainerVisitRecord
 435 {
 436     typedef std::vector<UInt32>::iterator VisitedIt;
 437
 438     std::vector<UInt32> vVisitedIds;
 439
 440     bool visit(UInt32 uiContainerId);
 441 };
 442
 443 bool ContainerVisitRecord::visit(UInt32 uiContainerId)
 444 {
 445     VisitedIt vIt = std::lower_bound(vVisitedIds.begin(),
 446                                      vVisitedIds.end  (),
 447                                      uiContainerId      );
 448
 449     if(vIt != vVisitedIds.end())
 450     {
 451         if(*vIt == uiContainerId)
 452             return false;
 453
 454         vVisitedIds.insert(vIt, uiContainerId);
 455     }
 456     else
 457     {
 458         vVisitedIds.push_back(uiContainerId);
 459     }
 460
 461     return true;
 462 }
 463
 464 FieldContainer *findNamedComponentImpl(      ContainerVisitRecord &oVisited,
 465                                              FieldContainer       *pCnt,
 466                                        const Char8                *szName  )
 467 {
 468     if(pCnt == NULL)
 469         return NULL;
 470
 471     const Char8 *szTmpName = NULL;
 472
 473     const AttachmentContainer *pAC =
 474         dynamic_cast<const AttachmentContainer *>(pCnt);
 475
 476 #if 0
 477     fprintf(stderr, "findNamedComponent::visit %p type %s\n",
 478             pCnt,
 479             pCnt->getType().getCName());
 480 #endif
 481
 482     szTmpName = OSG::getName(pAC);
 483
 484     if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 485     {
 486         return pCnt;
 487     }
 488
 489     if(oVisited.visit(pCnt->getId()) == false)
 490     {
 491         return NULL;
 492     }
 493
 494     const Node *pNode = dynamic_cast<const Node *>(pCnt);
 495
 496     if(pNode != NULL)
 497     {
 498         if(0x0000 == (pNode->getTravMask() &
 499                       TraversalMasks::FindNamedComponentTraversal))
 500         {
 501             return NULL;
 502         }
 503     }
 504
 505     BitVector bvExcludedFields = TypeTraits<BitVector>::BitsSet;
 506
 507     const ControlFindNamedElemInterface *pCFNInterface =
 508         dynamic_cast<ControlFindNamedElemInterface *>(pCnt);
 509
 510     if(pCFNInterface != NULL)
 511     {
 512         bvExcludedFields = pCFNInterface->excludeFields();
 513     }
 514
 515     const FieldContainerType &fcType = pCnt->getType();
 516           UInt32              fCount = fcType.getNumFieldDescs();
 517
 518     for(UInt32 i = 1; i <= fCount; ++i)
 519     {
 520         const FieldDescriptionBase *fDesc = fcType.getFieldDesc(i);
 521
 522         if(fDesc->getFieldType().getClass() == FieldType::ParentPtrField)
 523             continue;
 524
 525         if(0x0000 == (bvExcludedFields & fDesc->getFieldMask()))
 526             continue;
 527
 528         GetFieldHandlePtr srcField = pCnt->getField(i);
 529
 530         FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 531             boost::dynamic_pointer_cast<
 532                       FieldContainerPtrSFieldBase::GetHandle>(srcField);
 533
 534         FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 535             boost::dynamic_pointer_cast<
 536                       FieldContainerPtrMFieldBase::GetHandle>(srcField);
 537
 538         if(  sfFCPtr              != NULL &&
 539              sfFCPtr->isValid()   == true &&
 540            (*sfFCPtr)->getValue() != NULL   )
 541         {
 542             FieldContainer *rc = findNamedComponentImpl(oVisited,
 543                                                         (*sfFCPtr)->getValue(),
 544                                                         szName                );
 545             if(rc != NULL)
 546                 return rc;
 547         }
 548         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 549         {
 550             SizeT mfSize = (*mfFCPtr)->size();
 551
 552             for(SizeT i = 0; i < mfSize; i++)
 553             {
 554                 if((**mfFCPtr)[i] != NULL)
 555                 {
 556                     FieldContainer *rc = findNamedComponentImpl(oVisited,
 557                                                                 (**mfFCPtr)[i],
 558                                                                 szName);
 559
 560                     if(rc != NULL)
 561                         return rc;
 562                 }
 563             }
 564         }
 565     }
 566
 567     return NULL;
 568 }
 569
 570 FieldContainer *findNamedComponentImpl(      FieldContainer *pCnt,
 571                                        const Char8          *szName)
 572 {
 573     ContainerVisitRecord oVisited;
 574
 575     return findNamedComponentImpl(oVisited, pCnt, szName);
 576 }
 577
 578 } // namespace
 579
 580 /*! Compares two FieldContainer \a lhs and \a rhs for equivalence. The meaning
 581     of this comparison can be tweaked with the additional arguments.
 582     If \a ignoreAttachments is \c true, Attachments are excluded from the
 583     comparison.
 584     If \a compareIdentity is \c true, pointers are compared by
 585     address otherwise the pointed-to objects are compared for equivalence.
 586  */
 587 bool compareContainerEqual(
 588     const FieldContainer *lhs,
 589     const FieldContainer *rhs,
 590           bool            ignoreAttachments,
 591           bool            compareIdentity   )
 592 {
 593     FCSet lhsVisitedSet;
 594     FCSet rhsVisitedSet;
 595
 596     return compareContainerEqualImpl(
 597         lhs, rhs, lhsVisitedSet, rhsVisitedSet,
 598         ignoreAttachments, compareIdentity     );
 599 }
 600
 601 //---------------------------------------------------------------------------
 602 //  MemoryConsumption
 603 //---------------------------------------------------------------------------
 604
 605 void MemoryConsumption::scan(void)
 606 {
 607     FieldContainerFactory::the()->lockStore();
 608
 609     FieldContainerFactoryBase::ContainerStoreConstIt sIt  =
 610         FieldContainerFactory::the()->beginStore();
 611     FieldContainerFactoryBase::ContainerStoreConstIt sEnd =
 612         FieldContainerFactory::the()->endStore();
 613
 614     for(; sIt != sEnd; ++sIt)
 615     {
 616         FieldContainer *pFC = (*sIt).second->getPtr();
 617
 618         if(pFC == NULL)
 619             continue;
 620
 621         TypeMemMapIt tmIt    = _memMap.find(pFC->getType().getId());
 622         SizeT        binSize = pFC->getBinSize(TypeTraits<BitVector>::BitsSet);
 623
 624         if(tmIt != _memMap.end())
 625         {
 626             tmIt->second.first  += binSize;
 627             tmIt->second.second += 1;
 628         }
 629         else
 630         {
 631             _memMap[pFC->getType().getId()] = MemCountPair(binSize, 1);
 632         }
 633     }
 634
 635     FieldContainerFactory::the()->unlockStore();
 636 }
 637
 638
 639 void MemoryConsumption::print(std::ostream &os, bool ignoreProto) const
 640 {
 641     TypeMemMapConstIt tmIt  = _memMap.begin();
 642     TypeMemMapConstIt tmEnd = _memMap.end  ();
 643
 644     SizeT         totalMem   = 0;
 645     UInt32        totalCount = 0;
 646     boost::format formatter("%|1$-25| [%|2$8|] Byte [%|3$8.0f|] kByte [%|4$4|]\n");
 647
 648     for(; tmIt != tmEnd; ++tmIt)
 649     {
 650         FieldContainerType *fcType =
 651             FieldContainerFactory::the()->findType(tmIt->first);
 652
 653         if(fcType == NULL)
 654             continue;
 655
 656         if(ignoreProto && tmIt->second.second == 1)
 657             continue;
 658
 659         os << formatter % fcType->getCName()
 660                         % tmIt->second.first
 661                         % (tmIt->second.first / 1024.f)
 662                         % tmIt->second.second;
 663
 664         totalMem   += tmIt->second.first;
 665         totalCount += tmIt->second.second;
 666     }
 667
 668     os << "--------------------------------------------\n";
 669     os << formatter % "Total"
 670                     % totalMem
 671                     % (totalMem / 1024.f)
 672                     % totalCount;
 673 }
 674
 675 MemoryConsumption::TypeMemMapConstIt MemoryConsumption::beginMap(void) const
 676 {
 677     return _memMap.begin();
 678 }
 679
 680 MemoryConsumption::TypeMemMapConstIt MemoryConsumption::endMap(void) const
 681 {
 682     return _memMap.end();
 683 }
 684
 685 ControlFindNamedElemInterface::ControlFindNamedElemInterface(void)
 686 {
 687 }
 688
 689 ControlFindNamedElemInterface::~ControlFindNamedElemInterface(void)
 690 {
 691 }
 692
 693
 694 FieldContainer *resolveFieldPath(const Char8             *szNodeName,
 695                                        ContainerResolver  oResolver )
 696 {
 697     return resolveFieldPathImpl(szNodeName, oResolver);
 698 }
 699
 700 FieldContainer *findNamedComponent(      FieldContainer *pCnt,
 701                                    const Char8          *szName)
 702 {
 703     return findNamedComponentImpl(pCnt, szName);
 704 }
 705
 706
 707
 708 FieldContainer *getFieldContainer(const std::string &szTypeName,
 709                                   const std::string &szName)
 710 {
 711     return getFieldContainer(
 712         FieldContainerFactory::the()->findType(szTypeName.c_str()), szName);
 713 }
 714
 715 FieldContainer *getFieldContainer(const FieldContainerType *pType,
 716                                   const std::string        &szName)
 717 {
 718     if(pType == NULL)
 719     {
 720         SWARNING << "getFieldContainer(): The Field type is not defined."
 721                  << std::endl;
 722
 723         return NULL;
 724     }
 725
 726     const FieldContainerFactoryBase::ContainerStore &oFCStore(
 727         FieldContainerFactory::the()->getFieldContainerStore());
 728
 729     FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 730         oFCStore.begin();
 731
 732     FieldContainerFactoryBase::ContainerPtr                   pCont     = NULL;
 733
 734     for(; fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 735     {
 736 #ifdef OSG_MT_CPTR_ASPECT
 737         pCont = (*fcStoreIt).second->getPtr();
 738 #else
 739         pCont =  *fcStoreIt .second;
 740 #endif
 741
 742         if(pCont != NULL && pCont->getType() == (*pType))
 743         {
 744             const Char8 *szCntName =
 745                 getName(dynamic_cast<AttachmentContainer *>(pCont));
 746
 747             if(szCntName != NULL && szName.compare(szCntName) == 0)
 748             {
 749                 return pCont;
 750             }
 751         }
 752     }
 753
 754     return NULL;
 755 }
 756
 757
 758 FieldContainer *getFieldContainer(const std::string &szName)
 759 {
 760     const FieldContainerFactoryBase::ContainerStore &oFCStore =
 761         FieldContainerFactory::the()->getFieldContainerStore();
 762
 763    FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 764                   oFCStore.begin();
 765
 766    FieldContainerFactoryBase::ContainerPtr                   pCont     = NULL;
 767
 768    for(; fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 769    {
 770        if((*fcStoreIt).second == NULL)
 771        {
 772            continue;
 773        }
 774
 775 #ifdef OSG_MT_CPTR_ASPECT
 776        pCont = (*fcStoreIt).second->getPtr();
 777 #else
 778        pCont =  *fcStoreIt .second;
 779 #endif
 780        const Char8 *szCntName =
 781            getName(dynamic_cast<AttachmentContainer *>(pCont));
 782
 783        if(szCntName != NULL && szName.compare(szCntName) == 0)
 784        {
 785            return pCont;
 786        }
 787    }
 788
 789    return NULL;
 790 }
 791
 792
 793 bool isFieldContentDerivedFrom(const FieldType          &oFieldType,
 794                                const FieldContainerType *pFCType)
 795 {
 796     if(oFieldType.isPtrField())
 797     {
 798         std::string szFieldPtrTypeName(oFieldType.getContentType().getName());
 799
 800         switch(oFieldType.getClass())
 801         {
 802             case FieldType::PtrField:
 803             case FieldType::ParentPtrField:
 804             case FieldType::ChildPtrField:
 805                 szFieldPtrTypeName = szFieldPtrTypeName.substr(
 806                     0,
 807                     szFieldPtrTypeName.size() - 3);
 808                 break;
 809             default:
 810             case FieldType::ValueField:
 811                 return false;
 812                 break;
 813         }
 814
 815         const FieldContainerType *pPtrContentType =
 816             FieldContainerFactory::the()->findType(szFieldPtrTypeName.c_str());
 817
 818         return pFCType->isDerivedFrom(*pPtrContentType);
 819     }
 820     else
 821     {
 822         return false;
 823     }
 824
 825     return false;
 826 }
 827
 828 const FieldContainerType *getFieldContainerTypeFromPtrType(
 829     const DataType &oType)
 830 {
 831     std::string szFCPtrTypeName =
 832         oType.getName().substr(0, oType.getName().size() - 3);
 833
 834     return FieldContainerFactory::the()->findType(szFCPtrTypeName.c_str());
 835 }
 836
 837
 838
 839 const FieldContainerType *getClosestAncestor(
 840     const FieldContainerType                       *pType,
 841           MFUnrecFieldContainerPtr::const_iterator  begin,
 842           MFUnrecFieldContainerPtr::const_iterator  end)
 843 {
 844     if(pType == NULL)
 845     {
 846         return NULL;
 847     }
 848
 849     const FieldContainerType *pAncestorType = NULL;
 850     const FieldContainerType *pFCType       = NULL;
 851
 852     MFUnrecFieldContainerPtr::const_iterator it = begin;
 853
 854     for(; it != end ; ++it)
 855     {
 856         pFCType = &((*it)->getType());
 857
 858         if(pType->isDerivedFrom(*pFCType) &&
 859            (pAncestorType == NULL || pFCType->isDerivedFrom(*pAncestorType)))
 860         {
 861             pAncestorType = pFCType;
 862         }
 863     }
 864
 865     return pAncestorType;
 866 }
 867
 868 std::vector<FieldContainer *> getAllContainersByDerivedType(
 869     const FieldContainerType *pType)
 870 {
 871     std::vector<FieldContainer *> vResult;
 872
 873     const FieldContainerFactoryBase::ContainerStore &oFCStore =
 874         FieldContainerFactory::the()->getFieldContainerStore();
 875
 876     FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 877         oFCStore.begin();
 878
 879     FieldContainerFactoryBase::ContainerPtr                   pCont     =
 880         NULL;
 881
 882     for(;fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 883     {
 884         if((*fcStoreIt).second != NULL)
 885         {
 886 #ifdef OSG_MT_CPTR_ASPECT
 887             pCont = (*fcStoreIt).second->getPtr();
 888 #else
 889             pCont =  *fcStoreIt .second;
 890 #endif
 891         }
 892         else
 893         {
 894             pCont = NULL;
 895         }
 896         if(pCont != NULL && pCont->getType().isDerivedFrom(*pType))
 897         {
 898             vResult.push_back(pCont);
 899         }
 900     }
 901
 902     return vResult;
 903 }
 904
 905 #if 0
 906 std::vector<FieldContainerPtr> getAllContainersByType(const FieldContainerType *szType)
 907 {
 908     std::vector<FieldContainerPtr> Result;
 909
 910     const std::vector<FieldContainerPtr>* FCStore(    FieldContainerFactory::the()->getFieldContainerStore () );
 911
 912     std::vector<FieldContainerPtr>::const_iterator FCStoreIter;
 913     for(FCStoreIter = FCStore->begin() ; FCStoreIter != FCStore->end() ; ++FCStoreIter)
 914     {
 915         if( (*FCStoreIter) != NullFC && (*FCStoreIter)->getType() == (*szType) )
 916         {
 917             Result.push_back(*FCStoreIter);
 918         }
 919     }
 920
 921     return Result;
 922 }
 923
 924
 925 std::vector<FieldContainerPtr> getAllFieldContainers(const std::string &namestring)
 926 {
 927     std::vector<FieldContainerPtr> Result;
 928     std::vector<FieldContainerPtr>::const_iterator FCStoreIter;
 929
 930     const std::vector<FieldContainerPtr>* FCStore(    FieldContainerFactory::the()->getFieldContainerStore () );
 931
 932     for(FCStoreIter = FCStore->begin() ; FCStoreIter != FCStore->end() ; ++FCStoreIter)
 933     {
 934         const Char8 *Name( getName(AttachmentContainerPtr::dcast(*FCStoreIter)) );
 935         if(Name != NULL && namestring.compare(Name) == 0)
 936         {
 937             //Result.push_back(*FCStoreIter);
 938         }
 939     }
 940     return Result;
 941 }
 942
 943 #endif
 944
 945 OSG_END_NAMESPACE