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
 285 struct FieldPathEntry
 286 {
 287     std::string szName;
 288     Int32       iIndex;
 289
 290     FieldPathEntry(void) : szName(), iIndex(0) {}
 291 };
 292
 293 void splitFieldPath(      std::vector<FieldPathEntry> &vSplitPath,
 294                     const Char8                       *szFieldPath)
 295 {
 296     std::string tmpName(szFieldPath);
 297
 298     std::string::size_type sStart    = 0;
 299     std::string::size_type sEnd      = 0;
 300     std::string::size_type sLength   = 0;
 301     std::string::size_type sLastChar = 0;
 302     FieldPathEntry         tmpEntry;
 303
 304     std::string            szIdx;
 305
 306     do
 307     {
 308         sEnd = tmpName.find("/", sStart);
 309
 310         if(sEnd != std::string::npos)
 311         {
 312             sLength = sEnd - sStart;
 313         }
 314         else
 315         {
 316             sLength = tmpName.length() - sStart;
 317         }
 318
 319         sLastChar = sStart + sLength - 1;
 320
 321         vSplitPath.push_back(tmpEntry);
 322
 323         vSplitPath.back().iIndex = -1;
 324
 325         if(tmpName[sLastChar] == ')')
 326         {
 327             std::string::size_type sIdxStart =
 328                 tmpName.rfind('(', sLastChar); //, sLength);
 329
 330             if(sIdxStart == std::string::npos)
 331             {
 332                 vSplitPath.clear();
 333
 334                 return;
 335             }
 336
 337             tmpName[sIdxStart] = '$';
 338             tmpName[sLastChar] = '$';
 339
 340             sLength -= sLastChar - sIdxStart + 1;
 341
 342             ++sIdxStart;
 343
 344             szIdx.assign(tmpName,
 345                          sIdxStart,
 346                          sLastChar - sIdxStart);
 347
 348             vSplitPath.back().iIndex =
 349                 TypeTraits<UInt32>::getFromCString(szIdx.c_str());
 350         }
 351
 352         vSplitPath.back().szName.assign(tmpName, sStart, sLength);
 353
 354         sStart = sEnd + 1;
 355     }
 356     while(sEnd != std::string::npos);
 357 }
 358
 359 FieldContainer *resolveFieldPath(std::vector<FieldPathEntry> &vSplitPath,
 360                                  FieldContainer              *pRoot     )
 361 {
 362     if(pRoot == NULL)
 363         return NULL;
 364
 365     FieldContainer *returnValue = pRoot;
 366
 367     OSG::GetFieldHandlePtr fHandle;
 368
 369     for(UInt32 i = 1; i < vSplitPath.size(); ++i)
 370     {
 371         fHandle = returnValue->getField(vSplitPath[i].szName.c_str());
 372
 373         if(fHandle == NULL || fHandle->isValid() == false)
 374         {
 375             FWARNING(("Unknown field '%s'\n",
 376                       vSplitPath[i].szName.c_str()));
 377
 378             returnValue = NULL;
 379
 380             break;
 381         }
 382
 383         OSG::FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 384             boost::dynamic_pointer_cast<
 385               OSG::FieldContainerPtrSFieldBase::GetHandle>(fHandle);
 386
 387         OSG::FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 388             boost::dynamic_pointer_cast<
 389                 OSG::FieldContainerPtrMFieldBase::GetHandle>(fHandle);
 390
 391         if(sfFCPtr != NULL && sfFCPtr->isValid() == true)
 392         {
 393             returnValue = (*sfFCPtr)->getValue();
 394         }
 395         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 396         {
 397             UInt32 uiIndex =
 398                 vSplitPath[i].iIndex == -1 ? 0 : vSplitPath[i].iIndex;
 399
 400             if(uiIndex >= mfFCPtr->size())
 401             {
 402                 FWARNING(("Unknown index %d to large for field '%s'\n",
 403                           uiIndex,
 404                           vSplitPath[i].szName.c_str()));
 405
 406                 returnValue = NULL;
 407
 408                 break;
 409             }
 410
 411             returnValue = (**mfFCPtr)[uiIndex];
 412         }
 413     }
 414
 415     return returnValue;
 416 }
 417
 418 FieldContainer *resolveFieldPathImpl(const Char8             *szNodeName,
 419                                            ContainerResolver  oResolver )
 420 {
 421     std::vector<FieldPathEntry> vSplitPath;
 422
 423     splitFieldPath(vSplitPath, szNodeName);
 424
 425     if(vSplitPath.size() == 0)
 426         return NULL;
 427
 428     FieldContainer *returnValue = oResolver(vSplitPath[0].szName.c_str());
 429
 430     returnValue = resolveFieldPath(vSplitPath, returnValue);
 431
 432     return returnValue;
 433 }
 434
 435
 436
 437 struct ContainerVisitRecord
 438 {
 439     typedef std::vector<UInt32>::iterator VisitedIt;
 440
 441     std::vector<UInt32> vVisitedIds;
 442
 443     bool visit(UInt32 uiContainerId);
 444
 445     ContainerVisitRecord(void) : vVisitedIds() {}
 446 };
 447
 448 bool ContainerVisitRecord::visit(UInt32 uiContainerId)
 449 {
 450     VisitedIt vIt = std::lower_bound(vVisitedIds.begin(),
 451                                      vVisitedIds.end  (),
 452                                      uiContainerId      );
 453
 454     if(vIt != vVisitedIds.end())
 455     {
 456         if(*vIt == uiContainerId)
 457             return false;
 458
 459         vVisitedIds.insert(vIt, uiContainerId);
 460     }
 461     else
 462     {
 463         vVisitedIds.push_back(uiContainerId);
 464     }
 465
 466     return true;
 467 }
 468
 469 FieldContainer *findNamedComponentImpl(      ContainerVisitRecord &oVisited,
 470                                              FieldContainer       *pCnt,
 471                                        const Char8                *szName  )
 472 {
 473     if(pCnt == NULL)
 474         return NULL;
 475
 476     const Char8 *szTmpName = NULL;
 477
 478     const AttachmentContainer *pAC =
 479         dynamic_cast<const AttachmentContainer *>(pCnt);
 480
 481 #if 0
 482     fprintf(stderr, "findNamedComponent::visit %p type %s\n",
 483             pCnt,
 484             pCnt->getType().getCName());
 485 #endif
 486
 487     szTmpName = OSG::getName(pAC);
 488
 489     if(szTmpName != NULL && osgStringCmp(szTmpName, szName) == 0)
 490     {
 491         return pCnt;
 492     }
 493
 494     if(oVisited.visit(pCnt->getId()) == false)
 495     {
 496         return NULL;
 497     }
 498
 499     const Node *pNode = dynamic_cast<const Node *>(pCnt);
 500
 501     if(pNode != NULL)
 502     {
 503         if(0x0000 == (pNode->getTravMask() &
 504                       TraversalMasks::FindNamedComponentTraversal))
 505         {
 506             return NULL;
 507         }
 508     }
 509
 510     BitVector bvExcludedFields = TypeTraits<BitVector>::BitsSet;
 511
 512     const ControlFindNamedElemInterface *pCFNInterface =
 513         dynamic_cast<ControlFindNamedElemInterface *>(pCnt);
 514
 515     if(pCFNInterface != NULL)
 516     {
 517         bvExcludedFields = pCFNInterface->excludeFields();
 518     }
 519
 520     const FieldContainerType &fcType = pCnt->getType();
 521           UInt32              fCount = fcType.getNumFieldDescs();
 522
 523     for(UInt32 i = 1; i <= fCount; ++i)
 524     {
 525         const FieldDescriptionBase *fDesc = fcType.getFieldDesc(i);
 526
 527         if(fDesc->getFieldType().getClass() == FieldType::ParentPtrField)
 528             continue;
 529
 530         if(0x0000 == (bvExcludedFields & fDesc->getFieldMask()))
 531             continue;
 532
 533         GetFieldHandlePtr srcField = pCnt->getField(i);
 534
 535         FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 536             boost::dynamic_pointer_cast<
 537                       FieldContainerPtrSFieldBase::GetHandle>(srcField);
 538
 539         FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 540             boost::dynamic_pointer_cast<
 541                       FieldContainerPtrMFieldBase::GetHandle>(srcField);
 542
 543         if(  sfFCPtr              != NULL &&
 544              sfFCPtr->isValid()   == true &&
 545            (*sfFCPtr)->getValue() != NULL   )
 546         {
 547             FieldContainer *rc = findNamedComponentImpl(oVisited,
 548                                                         (*sfFCPtr)->getValue(),
 549                                                         szName                );
 550             if(rc != NULL)
 551                 return rc;
 552         }
 553         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 554         {
 555             SizeT mfSize = (*mfFCPtr)->size();
 556
 557             for(SizeT j = 0; j < mfSize; j++)
 558             {
 559                 if((**mfFCPtr)[j] != NULL)
 560                 {
 561                     FieldContainer *rc = findNamedComponentImpl(oVisited,
 562                                                                 (**mfFCPtr)[j],
 563                                                                 szName);
 564
 565                     if(rc != NULL)
 566                         return rc;
 567                 }
 568             }
 569         }
 570     }
 571
 572     return NULL;
 573 }
 574
 575 FieldContainer *findNamedComponentImpl(      FieldContainer *pCnt,
 576                                        const Char8          *szName)
 577 {
 578     ContainerVisitRecord oVisited;
 579
 580     return findNamedComponentImpl(oVisited, pCnt, szName);
 581 }
 582
 583 } // namespace
 584
 585 /*! Compares two FieldContainer \a lhs and \a rhs for equivalence. The meaning
 586     of this comparison can be tweaked with the additional arguments.
 587     If \a ignoreAttachments is \c true, Attachments are excluded from the
 588     comparison.
 589     If \a compareIdentity is \c true, pointers are compared by
 590     address otherwise the pointed-to objects are compared for equivalence.
 591  */
 592 bool compareContainerEqual(
 593     const FieldContainer *lhs,
 594     const FieldContainer *rhs,
 595           bool            ignoreAttachments,
 596           bool            compareIdentity   )
 597 {
 598     FCSet lhsVisitedSet;
 599     FCSet rhsVisitedSet;
 600
 601     return compareContainerEqualImpl(
 602         lhs, rhs, lhsVisitedSet, rhsVisitedSet,
 603         ignoreAttachments, compareIdentity     );
 604 }
 605
 606 //---------------------------------------------------------------------------
 607 //  MemoryConsumption
 608 //---------------------------------------------------------------------------
 609
 610 void MemoryConsumption::scan(void)
 611 {
 612     FieldContainerFactory::the()->lockStore();
 613
 614     FieldContainerFactoryBase::ContainerStoreConstIt sIt  =
 615         FieldContainerFactory::the()->beginStore();
 616     FieldContainerFactoryBase::ContainerStoreConstIt sEnd =
 617         FieldContainerFactory::the()->endStore();
 618
 619     for(; sIt != sEnd; ++sIt)
 620     {
 621         FieldContainer *pFC = (*sIt).second->getPtr();
 622
 623         if(pFC == NULL)
 624             continue;
 625
 626         TypeMemMapIt tmIt    = _memMap.find(pFC->getType().getId());
 627         SizeT        binSize = pFC->getBinSize(TypeTraits<BitVector>::BitsSet);
 628
 629         if(tmIt != _memMap.end())
 630         {
 631             tmIt->second.first  += binSize;
 632             tmIt->second.second += 1;
 633         }
 634         else
 635         {
 636             _memMap[pFC->getType().getId()] = MemCountPair(binSize, 1);
 637         }
 638     }
 639
 640     FieldContainerFactory::the()->unlockStore();
 641 }
 642
 643
 644 void MemoryConsumption::print(std::ostream &os, bool ignoreProto) const
 645 {
 646     TypeMemMapConstIt tmIt  = _memMap.begin();
 647     TypeMemMapConstIt tmEnd = _memMap.end  ();
 648
 649     SizeT         totalMem   = 0;
 650     UInt32        totalCount = 0;
 651     boost::format formatter("%|1$-25| [%|2$8|] Byte [%|3$8.0f|] kByte [%|4$4|]\n");
 652
 653     for(; tmIt != tmEnd; ++tmIt)
 654     {
 655         FieldContainerType *fcType =
 656             FieldContainerFactory::the()->findType(tmIt->first);
 657
 658         if(fcType == NULL)
 659             continue;
 660
 661         if(ignoreProto && tmIt->second.second == 1)
 662             continue;
 663
 664         os << formatter % fcType->getCName()
 665                         % tmIt->second.first
 666                         % (tmIt->second.first / 1024.f)
 667                         % tmIt->second.second;
 668
 669         totalMem   += tmIt->second.first;
 670         totalCount += tmIt->second.second;
 671     }
 672
 673     os << "--------------------------------------------\n";
 674     os << formatter % "Total"
 675                     % totalMem
 676                     % (totalMem / 1024.f)
 677                     % totalCount;
 678 }
 679
 680 MemoryConsumption::TypeMemMapConstIt MemoryConsumption::beginMap(void) const
 681 {
 682     return _memMap.begin();
 683 }
 684
 685 MemoryConsumption::TypeMemMapConstIt MemoryConsumption::endMap(void) const
 686 {
 687     return _memMap.end();
 688 }
 689
 690 ControlFindNamedElemInterface::ControlFindNamedElemInterface(void)
 691 {
 692 }
 693
 694 ControlFindNamedElemInterface::~ControlFindNamedElemInterface(void)
 695 {
 696 }
 697
 698
 699 FieldContainer *resolveFieldPath(const Char8             *szNodeName,
 700                                        ContainerResolver  oResolver )
 701 {
 702     return resolveFieldPathImpl(szNodeName, oResolver);
 703 }
 704
 705 FieldContainer *findNamedComponent(      FieldContainer *pCnt,
 706                                    const Char8          *szName)
 707 {
 708     return findNamedComponentImpl(pCnt, szName);
 709 }
 710
 711
 712
 713 FieldContainer *getFieldContainer(const std::string &szTypeName,
 714                                   const std::string &szName)
 715 {
 716     return getFieldContainer(
 717         FieldContainerFactory::the()->findType(szTypeName.c_str()), szName);
 718 }
 719
 720 FieldContainer *getFieldContainer(const FieldContainerType *pType,
 721                                   const std::string        &szName)
 722 {
 723     if(pType == NULL)
 724     {
 725         SWARNING << "getFieldContainer(): The Field type is not defined."
 726                  << std::endl;
 727
 728         return NULL;
 729     }
 730
 731     const FieldContainerFactoryBase::ContainerStore &oFCStore(
 732         FieldContainerFactory::the()->getFieldContainerStore());
 733
 734     FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 735         oFCStore.begin();
 736
 737     FieldContainerFactoryBase::ContainerPtr                   pCont     = NULL;
 738
 739     for(; fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 740     {
 741 #ifdef OSG_MT_CPTR_ASPECT
 742         pCont = (*fcStoreIt).second->getPtr();
 743 #else
 744         pCont =  *fcStoreIt .second;
 745 #endif
 746
 747         if(pCont != NULL && pCont->getType() == (*pType))
 748         {
 749             const Char8 *szCntName =
 750                 getName(dynamic_cast<AttachmentContainer *>(pCont));
 751
 752             if(szCntName != NULL && szName.compare(szCntName) == 0)
 753             {
 754                 return pCont;
 755             }
 756         }
 757     }
 758
 759     return NULL;
 760 }
 761
 762
 763 FieldContainer *getFieldContainer(const std::string &szName)
 764 {
 765     const FieldContainerFactoryBase::ContainerStore &oFCStore =
 766         FieldContainerFactory::the()->getFieldContainerStore();
 767
 768    FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 769                   oFCStore.begin();
 770
 771    FieldContainerFactoryBase::ContainerPtr                   pCont     = NULL;
 772
 773    for(; fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 774    {
 775        if((*fcStoreIt).second == NULL)
 776        {
 777            continue;
 778        }
 779
 780 #ifdef OSG_MT_CPTR_ASPECT
 781        pCont = (*fcStoreIt).second->getPtr();
 782 #else
 783        pCont =  *fcStoreIt .second;
 784 #endif
 785        const Char8 *szCntName =
 786            getName(dynamic_cast<AttachmentContainer *>(pCont));
 787
 788        if(szCntName != NULL && szName.compare(szCntName) == 0)
 789        {
 790            return pCont;
 791        }
 792    }
 793
 794    return NULL;
 795 }
 796
 797
 798 bool isFieldContentDerivedFrom(const FieldType          &oFieldType,
 799                                const FieldContainerType *pFCType)
 800 {
 801     if(oFieldType.isPtrField())
 802     {
 803         std::string szFieldPtrTypeName(oFieldType.getContentType().getName());
 804
 805         switch(oFieldType.getClass())
 806         {
 807             case FieldType::PtrField:
 808             case FieldType::ParentPtrField:
 809             case FieldType::ChildPtrField:
 810                 szFieldPtrTypeName = szFieldPtrTypeName.substr(
 811                     0,
 812                     szFieldPtrTypeName.size() - 3);
 813                 break;
 814             default:
 815             case FieldType::ValueField:
 816                 return false;
 817                 break;
 818         }
 819
 820         const FieldContainerType *pPtrContentType =
 821             FieldContainerFactory::the()->findType(szFieldPtrTypeName.c_str());
 822
 823         return pFCType->isDerivedFrom(*pPtrContentType);
 824     }
 825     else
 826     {
 827         return false;
 828     }
 829
 830     return false;
 831 }
 832
 833 const FieldContainerType *getFieldContainerTypeFromPtrType(
 834     const DataType &oType)
 835 {
 836     std::string szFCPtrTypeName =
 837         oType.getName().substr(0, oType.getName().size() - 3);
 838
 839     return FieldContainerFactory::the()->findType(szFCPtrTypeName.c_str());
 840 }
 841
 842
 843
 844 const FieldContainerType *getClosestAncestor(
 845     const FieldContainerType                       *pType,
 846           MFUnrecFieldContainerPtr::const_iterator  begin,
 847           MFUnrecFieldContainerPtr::const_iterator  end)
 848 {
 849     if(pType == NULL)
 850     {
 851         return NULL;
 852     }
 853
 854     const FieldContainerType *pAncestorType = NULL;
 855     const FieldContainerType *pFCType       = NULL;
 856
 857     MFUnrecFieldContainerPtr::const_iterator it = begin;
 858
 859     for(; it != end ; ++it)
 860     {
 861         pFCType = &((*it)->getType());
 862
 863         if(pType->isDerivedFrom(*pFCType) &&
 864            (pAncestorType == NULL || pFCType->isDerivedFrom(*pAncestorType)))
 865         {
 866             pAncestorType = pFCType;
 867         }
 868     }
 869
 870     return pAncestorType;
 871 }
 872
 873 std::vector<FieldContainer *> getAllContainersByDerivedType(
 874     const FieldContainerType *pType)
 875 {
 876     std::vector<FieldContainer *> vResult;
 877
 878     const FieldContainerFactoryBase::ContainerStore &oFCStore =
 879         FieldContainerFactory::the()->getFieldContainerStore();
 880
 881     FieldContainerFactoryBase::ContainerStore::const_iterator fcStoreIt =
 882         oFCStore.begin();
 883
 884     FieldContainerFactoryBase::ContainerPtr                   pCont     =
 885         NULL;
 886
 887     for(;fcStoreIt != oFCStore.end() ; ++fcStoreIt)
 888     {
 889         if((*fcStoreIt).second != NULL)
 890         {
 891 #ifdef OSG_MT_CPTR_ASPECT
 892             pCont = (*fcStoreIt).second->getPtr();
 893 #else
 894             pCont =  *fcStoreIt .second;
 895 #endif
 896         }
 897         else
 898         {
 899             pCont = NULL;
 900         }
 901         if(pCont != NULL && pCont->getType().isDerivedFrom(*pType))
 902         {
 903             vResult.push_back(pCont);
 904         }
 905     }
 906
 907     return vResult;
 908 }
 909
 910 #if 0
 911 std::vector<FieldContainerPtr> getAllContainersByType(const FieldContainerType *szType)
 912 {
 913     std::vector<FieldContainerPtr> Result;
 914
 915     const std::vector<FieldContainerPtr>* FCStore(    FieldContainerFactory::the()->getFieldContainerStore () );
 916
 917     std::vector<FieldContainerPtr>::const_iterator FCStoreIter;
 918     for(FCStoreIter = FCStore->begin() ; FCStoreIter != FCStore->end() ; ++FCStoreIter)
 919     {
 920         if( (*FCStoreIter) != NullFC && (*FCStoreIter)->getType() == (*szType) )
 921         {
 922             Result.push_back(*FCStoreIter);
 923         }
 924     }
 925
 926     return Result;
 927 }
 928
 929
 930 std::vector<FieldContainerPtr> getAllFieldContainers(const std::string &namestring)
 931 {
 932     std::vector<FieldContainerPtr> Result;
 933     std::vector<FieldContainerPtr>::const_iterator FCStoreIter;
 934
 935     const std::vector<FieldContainerPtr>* FCStore(    FieldContainerFactory::the()->getFieldContainerStore () );
 936
 937     for(FCStoreIter = FCStore->begin() ; FCStoreIter != FCStore->end() ; ++FCStoreIter)
 938     {
 939         const Char8 *Name( getName(AttachmentContainerPtr::dcast(*FCStoreIter)) );
 940         if(Name != NULL && namestring.compare(Name) == 0)
 941         {
 942             //Result.push_back(*FCStoreIter);
 943         }
 944     }
 945     return Result;
 946 }
 947
 948 #endif
 949
 950 OSG_END_NAMESPACE