configmgr/source/treemgr/noderef.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: noderef.cxx,v $
  10  * $Revision: 1.34 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "anynoderef.hxx"
  35 #include "valueref.hxx"
  36 #include "noderef.hxx"
  37 #include "tree.hxx"
  38 #include "viewaccess.hxx"
  39 #include "configpath.hxx"
  40 #include "nodechange.hxx"
  41 #include "configexcept.hxx"
  42 #include "configset.hxx"
  43 #include "tracer.hxx"
  44
  45 #ifndef INCLUDED_ALGORITHM
  46 #include <algorithm> // for swap
  47 #define INCLUDED_ALGORITHM
  48 #endif
  49 #ifndef INCLUDED_FUNCTIONAL
  50 #include <functional> // for less
  51 #define INCLUDED_FUNCTIONAL
  52 #endif
  53
  54 namespace configmgr
  55 {
  56     namespace configuration
  57     {
  58 //-----------------------------------------------------------------------------
  59 // local  helpers
  60 //-----------------------------------------------------------------------------
  61
  62 namespace
  63 {
  64 //-----------------------------------------------------------------------------
  65     struct CollectValueIDs : GroupMemberVisitor
  66     {
  67         CollectValueIDs(NodeID const& aParentID, std::vector<SubNodeID>& rValueList)
  68         : m_aParentID(aParentID)
  69         , m_rValueList(rValueList)
  70         {
  71         }
  72
  73         Result visit(ValueMemberNode const& anEntry);
  74
  75         NodeID  m_aParentID;
  76         std::vector<SubNodeID>& m_rValueList;
  77     };
  78
  79     GroupMemberVisitor::Result CollectValueIDs::visit(ValueMemberNode const& aValue)
  80     {
  81         OSL_ASSERT(aValue.isValid());
  82
  83         rtl::OUString aValueName = aValue.getNodeName();
  84
  85         m_rValueList.push_back(SubNodeID( m_aParentID, aValueName));
  86
  87         return CONTINUE;
  88     }
  89 //-----------------------------------------------------------------------------
  90 }
  91
  92 //-----------------------------------------------------------------------------
  93 // class NodeRef
  94 //-----------------------------------------------------------------------------
  95
  96 NodeRef::NodeRef()
  97 : m_nPos(0)
  98 , m_nDepth(0)
  99 {
 100 }
 101 //-----------------------------------------------------------------------------
 102
 103 NodeRef::NodeRef(unsigned int nPos, unsigned int nDepth)
 104 : m_nPos(nPos)
 105 , m_nDepth(nDepth)
 106 {}
 107 //-----------------------------------------------------------------------------
 108
 109 NodeRef::NodeRef(NodeRef const& rOther)
 110 : m_nPos(rOther.m_nPos)
 111 , m_nDepth(rOther.m_nDepth)
 112 {
 113 }
 114 //-----------------------------------------------------------------------------
 115
 116 NodeRef& NodeRef::operator=(NodeRef const& rOther)
 117 {
 118     NodeRef(rOther).swap(*this);
 119     return *this;
 120 }
 121 //-----------------------------------------------------------------------------
 122
 123 void NodeRef::swap(NodeRef& rOther)
 124 {
 125     std::swap(m_nPos,   rOther.m_nPos);
 126     std::swap(m_nDepth, rOther.m_nDepth);
 127 }
 128 //-----------------------------------------------------------------------------
 129
 130 NodeRef::~NodeRef()
 131 {
 132 }
 133
 134 //-----------------------------------------------------------------------------
 135 // class ValueRef
 136 //-----------------------------------------------------------------------------
 137
 138 bool ValueRef::checkValidState() const
 139 {
 140     if (m_nParentPos  == 0)    return false;
 141
 142     // old node semantics for now
 143     if ( m_sNodeName.getLength() == 0 ) return false;
 144
 145     return true;
 146 }
 147 //-----------------------------------------------------------------------------
 148
 149 ValueRef::ValueRef()
 150 : m_sNodeName()
 151 , m_nParentPos(0)
 152 {
 153 }
 154 //-----------------------------------------------------------------------------
 155
 156 ValueRef::ValueRef(rtl::OUString const& aName, unsigned int nParentPos)
 157 : m_sNodeName(aName)
 158 , m_nParentPos(nParentPos)
 159 {
 160     OSL_ENSURE( nParentPos == 0 || checkValidState(), "Constructing invalid ValueRef");
 161 }
 162 //-----------------------------------------------------------------------------
 163
 164 ValueRef::ValueRef(ValueRef const& rOther)
 165 : m_sNodeName(rOther.m_sNodeName)
 166 , m_nParentPos(rOther.m_nParentPos)
 167 {
 168 }
 169 //-----------------------------------------------------------------------------
 170
 171 ValueRef& ValueRef::operator=(ValueRef const& rOther)
 172 {
 173     ValueRef(rOther).swap(*this);
 174     return *this;
 175 }
 176 //-----------------------------------------------------------------------------
 177
 178 void ValueRef::swap(ValueRef& rOther)
 179 {
 180     std::swap(m_sNodeName,      rOther.m_sNodeName);
 181     std::swap(m_nParentPos,     rOther.m_nParentPos);
 182 }
 183 //-----------------------------------------------------------------------------
 184
 185 ValueRef::~ValueRef()
 186 {
 187 }
 188
 189 //-----------------------------------------------------------------------------
 190 // class AnyNodeRef
 191 //-----------------------------------------------------------------------------
 192 #if OSL_DEBUG_LEVEL > 0
 193 bool AnyNodeRef::checkValidState() const
 194 {
 195     if (m_nUsedPos  == 0)    return false;
 196
 197     if ( m_sNodeName.getLength() != 0 ) // it's a local value
 198     {
 199         // not used as runtime check as it should not be dangerous
 200         OSL_ENSURE(m_nDepth ==0, "AnyNodeRef that wraps a ValueRef should have no depth"); // value has no depth
 201     }
 202
 203     return true;
 204 }
 205 #endif
 206 //-----------------------------------------------------------------------------
 207
 208 AnyNodeRef::AnyNodeRef()
 209 : m_sNodeName()
 210 , m_nUsedPos(0)
 211 , m_nDepth(0)
 212 {
 213 }
 214 //-----------------------------------------------------------------------------
 215
 216 AnyNodeRef::AnyNodeRef(unsigned int nPos, unsigned int nDepth)
 217 : m_sNodeName()
 218 , m_nUsedPos(nPos)
 219 , m_nDepth(nDepth)
 220 {}
 221 //-----------------------------------------------------------------------------
 222
 223 AnyNodeRef::AnyNodeRef(rtl::OUString const& aName, unsigned int nParentPos)
 224 : m_sNodeName(aName)
 225 , m_nUsedPos(nParentPos)
 226 , m_nDepth(0)
 227 {}
 228 //-----------------------------------------------------------------------------
 229
 230 AnyNodeRef::AnyNodeRef(AnyNodeRef const& rOther)
 231 : m_sNodeName(rOther.m_sNodeName)
 232 , m_nUsedPos(rOther.m_nUsedPos)
 233 , m_nDepth(rOther.m_nDepth)
 234 {
 235 }
 236 //-----------------------------------------------------------------------------
 237
 238 AnyNodeRef::AnyNodeRef(NodeRef const& aNodeRef)
 239 : m_sNodeName()
 240 , m_nUsedPos(  aNodeRef.m_nPos )
 241 , m_nDepth( aNodeRef.m_nDepth )
 242 {}
 243 //-----------------------------------------------------------------------------
 244
 245 AnyNodeRef::AnyNodeRef(ValueRef const& aValueRef)
 246 : m_sNodeName( aValueRef.m_sNodeName )
 247 , m_nUsedPos(  aValueRef.m_nParentPos )
 248 , m_nDepth( 0 )
 249 {}
 250 //-----------------------------------------------------------------------------
 251
 252 AnyNodeRef& AnyNodeRef::operator=(AnyNodeRef const& rOther)
 253 {
 254     AnyNodeRef(rOther).swap(*this);
 255     return *this;
 256 }
 257 //-----------------------------------------------------------------------------
 258
 259 void AnyNodeRef::swap(AnyNodeRef& rOther)
 260 {
 261     std::swap(m_sNodeName,      rOther.m_sNodeName);
 262     std::swap(m_nUsedPos,       rOther.m_nUsedPos);
 263     std::swap(m_nDepth,     rOther.m_nDepth);
 264 }
 265 //-----------------------------------------------------------------------------
 266
 267 AnyNodeRef::~AnyNodeRef()
 268 {
 269 }
 270
 271 //-----------------------------------------------------------------------------
 272
 273 bool AnyNodeRef::isNode() const
 274 {
 275     OSL_PRECOND( isValid(), "ERROR: Configuration: AnyNodeRef operation requires valid node" );
 276     if (!isValid()) return false;
 277
 278     return m_sNodeName.getLength() == 0;
 279 }
 280 //-----------------------------------------------------------------------------
 281
 282 NodeRef AnyNodeRef::toNode() const
 283 {
 284     OSL_PRECOND( isValid(), "ERROR: Configuration: AnyNodeRef operation requires valid node" );
 285     if (!isValid() || !isNode()) return NodeRef();
 286
 287     return NodeRef(m_nUsedPos,m_nDepth);
 288 }
 289 //-----------------------------------------------------------------------------
 290
 291 ValueRef AnyNodeRef::toValue() const
 292 {
 293     OSL_PRECOND( isValid(), "ERROR: Configuration: AnyNodeRef operation requires valid node" );
 294     if (!isValid() || isNode()) return ValueRef();
 295
 296     return ValueRef(m_sNodeName, m_nUsedPos);
 297 }
 298 //-----------------------------------------------------------------------------
 299
 300 //-----------------------------------------------------------------------------
 301 // hashing any pointer
 302 //-----------------------------------------------------------------------------
 303 static // for now
 304 // should move this to a more public place sometime
 305 // need  this, as STLPORT does not hash sal_(u)Int64 (at least on MSVC)
 306 inline
 307 size_t hash64(sal_uInt64 n)
 308 {
 309     // simple solution (but the same that STLPORT uses for unsigned long long (if enabled))
 310     return static_cast<size_t>(n);
 311 }
 312 //-----------------------------------------------------------------------------
 313
 314 static // for now
 315 // should move this to a more public place sometime
 316 inline
 317 size_t hashAnyPointer(void* p)
 318 {
 319     // most portable quick solution IMHO (we need this cast for UNO tunnels anyway)
 320     sal_uInt64 n = reinterpret_cast<sal_uInt64>(p);
 321
 322     return hash64(n);
 323 }
 324 //-----------------------------------------------------------------------------
 325
 326 //-----------------------------------------------------------------------------
 327 // class NodeID
 328 //-----------------------------------------------------------------------------
 329
 330 NodeID::NodeID(rtl::Reference< Tree > const& rTree, NodeRef const& rNode)
 331 : m_pTree( rTree.get() )
 332 , m_nNode( rNode.getOffset() )
 333 {
 334 }
 335 //-----------------------------------------------------------------------------
 336
 337 NodeID::NodeID(Tree* pImpl, unsigned int nNode)
 338 : m_pTree( pImpl )
 339 , m_nNode( nNode )
 340 {
 341 }
 342 //-----------------------------------------------------------------------------
 343
 344 bool NodeID::isEmpty() const
 345 {
 346     OSL_ENSURE( m_pTree == NULL || m_pTree->isValidNode(m_nNode), "Node does not match tree in NodeID");
 347     return m_pTree == NULL;
 348 }
 349 //-----------------------------------------------------------------------------
 350
 351 bool NodeID::isValidNode() const
 352 {
 353     return m_pTree != NULL && m_pTree->isValidNode(m_nNode);
 354 }
 355 //-----------------------------------------------------------------------------
 356
 357 // hashing
 358 size_t NodeID::hashCode() const
 359 {
 360     return hashAnyPointer(m_pTree) + 5*m_nNode;
 361 }
 362 //-----------------------------------------------------------------------------
 363
 364 unsigned int NodeID::toIndex() const
 365 {
 366     unsigned int n = m_nNode;
 367     if (m_pTree)
 368     {
 369         OSL_ENSURE(m_pTree->isValidNode(n),"Cannot produce valid Index for NodeID");
 370
 371         n -= Tree::ROOT;
 372     }
 373     return n;
 374 }
 375
 376 NodeRef NodeID::getNode() const {
 377     return m_pTree == 0 ? NodeRef() : m_pTree->getNode(m_nNode);
 378 }
 379
 380 //-----------------------------------------------------------------------------
 381 bool operator < (NodeID const& lhs, NodeID const& rhs)
 382 {
 383     if (lhs.m_pTree == rhs.m_pTree)
 384         return lhs.m_nNode < rhs.m_nNode;
 385     else
 386         return std::less<Tree*>()(lhs.m_pTree,rhs.m_pTree);
 387 }
 388
 389 //-----------------------------------------------------------------------------
 390 // class SubNodeID
 391 //-----------------------------------------------------------------------------
 392
 393 SubNodeID::SubNodeID()
 394 : m_sNodeName()
 395 , m_aParentID(0,0)
 396 {
 397 }
 398 //-----------------------------------------------------------------------------
 399
 400 SubNodeID::SubNodeID(rtl::Reference< Tree > const& rTree, NodeRef const& rParentNode, rtl::OUString const& aName)
 401 : m_sNodeName(aName)
 402 , m_aParentID(rTree,rParentNode)
 403 {
 404 }
 405 //-----------------------------------------------------------------------------
 406
 407 SubNodeID::SubNodeID(NodeID const& rParentNodeID, rtl::OUString const& aName)
 408 : m_sNodeName(aName)
 409 , m_aParentID(rParentNodeID)
 410 {
 411 }
 412 //-----------------------------------------------------------------------------
 413
 414 bool SubNodeID::isValidNode() const
 415 {
 416     if (!m_aParentID.isValidNode()) return false;
 417
 418     OSL_ENSURE(m_sNodeName.getLength() != 0,"Invalid subnode ID: Missing name");
 419
 420     rtl::Reference< Tree > aCheck( m_aParentID.getTree() );
 421     return aCheck->hasChild( m_aParentID.getNode(), m_sNodeName );
 422 }
 423 //-----------------------------------------------------------------------------
 424
 425 bool operator < (SubNodeID const& lhs, SubNodeID const& rhs)
 426 {
 427     if (lhs.m_aParentID == rhs.m_aParentID)
 428         return !!(lhs.m_sNodeName < rhs.m_sNodeName);
 429     else
 430         return lhs.m_aParentID < rhs.m_aParentID;
 431 }
 432
 433 //-----------------------------------------------------------------------------
 434 // Free functions
 435 //-----------------------------------------------------------------------------
 436
 437 rtl::OUString validateElementName(rtl::OUString const& sName, rtl::Reference< Tree > const& aTree, NodeRef const& aNode )
 438 {
 439     { (void)aTree; (void)aNode; }
 440     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 441     OSL_PRECOND(  aNode.isValid(), "ERROR: Configuration: Node operation requires a valid NodeRef");
 442     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
 443
 444     OSL_PRECOND(  view::ViewTreeAccess(aTree.get()).isSetNode(aNode), "ERROR: Configuration: Set node expected.");
 445
 446     return validateElementName(sName);
 447 }
 448 //-----------------------------------------------------------------------------
 449
 450 rtl::OUString validateChildName(rtl::OUString const& sName, rtl::Reference< Tree > const& aTree, NodeRef const& aNode )
 451 {
 452     { (void)aTree; (void)aNode; }
 453     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 454     OSL_PRECOND(  aNode.isValid(), "ERROR: Configuration: Node operation requires a valid NodeRef");
 455     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
 456
 457     OSL_PRECOND(  view::ViewTreeAccess(aTree.get()).isGroupNode(aNode), "ERROR: Configuration: Group node expected.");
 458
 459     return validateNodeName(sName);
 460 }
 461 //-----------------------------------------------------------------------------
 462
 463 rtl::OUString validateChildOrElementName(rtl::OUString const& sName, rtl::Reference< Tree > const& aTree, NodeRef const& aNode )
 464 {
 465     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 466     OSL_PRECOND(  aNode.isValid(), "ERROR: Configuration: Node operation requires a valid NodeRef");
 467     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
 468
 469     OSL_PRECOND(  isStructuralNode(aTree,aNode), "ERROR: Configuration: Inner node expected.");
 470
 471     if (view::ViewTreeAccess(aTree.get()).isSetNode(aNode))
 472         return validateElementName(sName);
 473
 474     else
 475         return validateNodeName(sName);
 476 }
 477 //-----------------------------------------------------------------------------
 478
 479 Path::Component validateElementPathComponent(rtl::OUString const& sName, rtl::Reference< Tree > const& aTree, NodeRef const& aNode )
 480 {
 481     rtl::OUString aElementName = validateElementName(sName,aTree,aNode);
 482
 483     rtl::Reference<Template> aTemplate = aTree->extractElementInfo(aNode);
 484     if (aTemplate.is())
 485     {
 486         return Path::makeCompositeName( aElementName, aTemplate->getName() );
 487     }
 488     else
 489     {
 490         OSL_ENSURE(false, "WARNING: Cannot find element type information for building an element name");
 491         return Path::wrapElementName(aElementName);
 492     }
 493 }
 494 //-----------------------------------------------------------------------------
 495
 496 static void implValidateLocalPath(RelativePath& _rPath, rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 497 {
 498     if (_rPath.isEmpty())
 499         throw InvalidName(_rPath.toString(), "is an empty path.");
 500
 501     // FOR NOW: validate only the first component
 502     if (!view::ViewTreeAccess(aTree.get()).isSetNode(aNode))
 503         if (!_rPath.getFirstName().isSimpleName())
 504             throw InvalidName(_rPath.toString(), "is not valid in this context. Predicate expression used to select group member.");
 505 }
 506 //-----------------------------------------------------------------------------
 507
 508 RelativePath validateRelativePath(rtl::OUString const& _sPath, rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 509 {
 510     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 511     OSL_PRECOND(  aNode.isValid(), "ERROR: Configuration: Node operation requires a valid NodeRef");
 512     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
 513
 514     OSL_PRECOND(  isStructuralNode(aTree,aNode), "ERROR: Configuration: Inner node expected.");
 515
 516     if (  Path::isAbsolutePath(_sPath) )
 517     {
 518         OSL_ENSURE(false, "Absolute pathes are not allowed here (compatibility support enabled");
 519         return validateAndReducePath(_sPath,aTree,aNode);
 520     }
 521
 522     RelativePath aResult = RelativePath::parse(_sPath);
 523
 524     implValidateLocalPath(aResult,aTree,aNode);
 525
 526     return aResult;
 527 }
 528 //-----------------------------------------------------------------------------
 529
 530 RelativePath validateAndReducePath(rtl::OUString const& _sPath, rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 531 {
 532     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 533     OSL_PRECOND(  aNode.isValid(), "ERROR: Configuration: Node operation requires a valid NodeRef");
 534     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match Tree");
 535
 536     OSL_PRECOND(  isStructuralNode(aTree,aNode), "ERROR: Configuration: Inner node expected.");
 537
 538     if ( !Path::isAbsolutePath(_sPath) )
 539         return validateRelativePath(_sPath,aTree,aNode);
 540
 541     AbsolutePath aInputPath = AbsolutePath::parse(_sPath);
 542
 543     RelativePath aStrippedPath = Path::stripPrefix( aInputPath, aTree->getAbsolutePath(aNode) );
 544
 545     implValidateLocalPath(aStrippedPath,aTree,aNode);
 546
 547     return aStrippedPath;
 548 }
 549 //-----------------------------------------------------------------------------
 550
 551 bool hasChildOrElement(rtl::Reference< Tree > const& aTree, NodeRef const& aNode, rtl::OUString const& aName)
 552 {
 553     return view::ViewTreeAccess(aTree.get()).isSetNode(aNode) ? aTree->hasElement(aNode,aName) : aTree->hasChild(aNode,aName);
 554 }
 555 //-----------------------------------------------------------------------------
 556
 557 bool hasChildOrElement(rtl::Reference< Tree > const& aTree, NodeRef const& aNode, Path::Component const& aName)
 558 {
 559     return view::ViewTreeAccess(aTree.get()).isSetNode(aNode) ? aTree->hasElement(aNode,aName) : aTree->hasChild(aNode,aName.getName());
 560 }
 561 //-----------------------------------------------------------------------------
 562
 563 bool findInnerChildOrAvailableElement(rtl::Reference< Tree > & aTree, NodeRef& aNode, rtl::OUString const& aName)
 564 {
 565     if ( view::ViewTreeAccess(aTree.get()).isSetNode(aNode) )
 566     {
 567         rtl::Reference< ElementTree > aElement = aTree->getAvailableElement(aNode,aName);
 568         if (aElement.is())
 569         {
 570             aTree = aElement.get();
 571             aNode = aTree->getRootNode();
 572             return true;
 573         }
 574     }
 575     else
 576     {
 577         NodeRef aChild = aTree->getChildNode(aNode,aName);
 578
 579         if ( aChild.isValid() )
 580         {
 581             aNode = aChild;
 582             return true;
 583         }
 584     }
 585
 586     return false;
 587 }
 588 //-----------------------------------------------------------------------------
 589
 590 AnyNodeRef getChildOrElement(rtl::Reference< Tree > & aTree, NodeRef const& aParentNode, rtl::OUString const& aName)
 591 {
 592     if (aTree->hasChildValue(aParentNode,aName))
 593     {
 594         return AnyNodeRef(aTree->getChildValue(aParentNode,aName));
 595     }
 596
 597     else if ( view::ViewTreeAccess(aTree.get()).isSetNode(aParentNode) )
 598     {
 599         rtl::Reference< ElementTree > aElement = aTree->getElement(aParentNode,aName);
 600         if (aElement.is())
 601         {
 602             aTree = aElement.get();
 603             return AnyNodeRef(aTree->getRootNode());
 604         }
 605     }
 606
 607     else
 608     {
 609         NodeRef aChild = aTree->getChildNode(aParentNode,aName);
 610
 611         if ( aChild.isValid() )
 612         {
 613             return AnyNodeRef(aChild);
 614         }
 615     }
 616
 617     return AnyNodeRef();
 618 }
 619 //-----------------------------------------------------------------------------
 620
 621 static
 622 inline
 623 bool findLocalInnerChild(rtl::Reference< Tree > const& aTree, NodeRef& aNode, Path::Component const& aName)
 624 {
 625     NodeRef aChild = aTree->getChildNode(aNode,aName.getName());
 626
 627     if ( !aChild.isValid() ) return false;
 628
 629     OSL_ENSURE( aName.isSimpleName(), "Child of group was found by request using element name format -failing");
 630     if ( !aName.isSimpleName()) return false;
 631
 632     aNode = aChild;
 633
 634     return true;
 635 }
 636 //-----------------------------------------------------------------------------
 637
 638 static
 639 inline
 640 bool findElement(rtl::Reference< Tree > & aTree, NodeRef& aNode, Path::Component const& aName)
 641 {
 642     rtl::Reference< ElementTree > aElement = aTree->getElement(aNode,aName.getName());
 643
 644     if (!aElement.is()) return false;
 645
 646     rtl::Reference< Tree > aFoundTree = aElement.get();
 647
 648     OSL_ENSURE(matches(aFoundTree->getExtendedRootName(),aName), "Element found, but type prefix does not match - failing");
 649     if ( !matches(aFoundTree->getExtendedRootName(),aName) ) return false;
 650
 651     aTree = aFoundTree;
 652     aNode = aTree->getRootNode();
 653
 654     return true;
 655 }
 656 //-----------------------------------------------------------------------------
 657
 658 static
 659 bool findLocalInnerDescendant(rtl::Reference< Tree > const& aTree, NodeRef& aNode, RelativePath& rPath)
 660 {
 661     while ( !rPath.isEmpty() )
 662     {
 663         if (  view::ViewTreeAccess(aTree.get()).isSetNode(aNode) ) return false;
 664
 665         if ( ! findLocalInnerChild(aTree,aNode,rPath.getFirstName()) ) return false;
 666
 667         rPath.dropFirstName();
 668     }
 669
 670     return true;
 671 }
 672 //-----------------------------------------------------------------------------
 673
 674 static
 675 bool findDeepInnerDescendant(rtl::Reference< Tree > & aTree, NodeRef& aNode, RelativePath& rPath)
 676 {
 677     while ( !rPath.isEmpty() )
 678     {
 679         if ( view::ViewTreeAccess(aTree.get()).isSetNode(aNode) )
 680         {
 681             if ( ! findElement(aTree,aNode,rPath.getFirstName()) ) return false;
 682         }
 683         else
 684         {
 685             if ( ! findLocalInnerChild(aTree,aNode,rPath.getFirstName()) ) return false;
 686         }
 687
 688         rPath.dropFirstName();
 689     }
 690
 691     return true;
 692 }
 693 //-----------------------------------------------------------------------------
 694
 695 static
 696 inline
 697 bool identifiesLocalValue(rtl::Reference< Tree > const& aTree, NodeRef const& aNode, RelativePath const& aPath)
 698 {
 699     if ( aPath.getDepth() == 1 )
 700     {
 701         Path::Component const & aLocalName = aPath.getLocalName();
 702         rtl::OUString aName = aLocalName.getName();
 703
 704         if (aTree->hasChildValue(aNode,aName))
 705         {
 706             OSL_ENSURE( aLocalName.isSimpleName(), "Value in group was found by request using element name format");
 707             if ( aLocalName.isSimpleName())
 708                 return true;
 709         }
 710     }
 711     return false;
 712 }
 713 //-----------------------------------------------------------------------------
 714
 715 AnyNodeRef getLocalDescendant(rtl::Reference< Tree > const& aTree, NodeRef const& aNode, RelativePath const& rPath)
 716 {
 717     NodeRef aNestedNode( aNode );
 718     RelativePath aRemainingPath(rPath);
 719
 720     if ( findLocalInnerDescendant(aTree,aNestedNode,aRemainingPath) )
 721     {
 722         OSL_ASSERT(
 723             aNestedNode.isValid() &&
 724             aTree->isValidNode(aNestedNode.getOffset()));
 725         return AnyNodeRef(aNestedNode);
 726     }
 727
 728     if ( identifiesLocalValue(aTree,aNestedNode,aRemainingPath) )
 729     {
 730         ValueRef aValue = aTree->getChildValue(aNestedNode,rPath.getLocalName().getName());
 731         OSL_ASSERT(aTree->isValidValueNode(aValue));
 732         return AnyNodeRef(aValue);
 733     }
 734
 735     return AnyNodeRef();
 736 }
 737 //-----------------------------------------------------------------------------
 738
 739 AnyNodeRef getDeepDescendant(rtl::Reference< Tree > & aTree, NodeRef& aNode, RelativePath& rPath)
 740 {
 741     if ( findDeepInnerDescendant(aTree,aNode,rPath) )
 742     {
 743         OSL_ASSERT(
 744             aNode.isValid() && aTree->isValidNode(aNode.getOffset()));
 745         return AnyNodeRef(aNode);
 746     }
 747
 748     if ( identifiesLocalValue(aTree,aNode,rPath) )
 749     {
 750         ValueRef aValue = aTree->getChildValue(aNode,rPath.getLocalName().getName());
 751         OSL_ASSERT(aTree->isValidValueNode(aValue));
 752         return AnyNodeRef(aValue);
 753     }
 754
 755     return AnyNodeRef();
 756 }
 757 //-----------------------------------------------------------------------------
 758
 759 void getAllContainedNodes(rtl::Reference< Tree > const& aTree, std::vector<NodeID>& aList)
 760 {
 761     aList.clear();
 762
 763     if (Tree* pImpl = aTree.get())
 764     {
 765         unsigned int nCount = pImpl->nodeCount();
 766         aList.reserve(nCount);
 767
 768         unsigned int const nEnd = Tree::ROOT + nCount;
 769
 770         for(unsigned int nOffset = Tree::ROOT;
 771             nOffset < nEnd;
 772             ++nOffset)
 773         {
 774             OSL_ASSERT( pImpl->isValidNode(nOffset) );
 775             aList.push_back( NodeID(pImpl,nOffset) );
 776         }
 777
 778         OSL_ASSERT( aList.size()==nCount );
 779     }
 780 }
 781 //-----------------------------------------------------------------------------
 782
 783 void getAllChildrenHelper(NodeID const& aNode, std::vector<SubNodeID>& aList)
 784 {
 785     aList.clear();
 786
 787     if (Tree* pTreeImpl = aNode.getTree())
 788     {
 789         view::ViewTreeAccess aView(pTreeImpl);
 790
 791         if (unsigned int const nParent = aNode.getOffset())
 792         {
 793             OSL_ASSERT( pTreeImpl->isValidNode(nParent) );
 794
 795             if (aView.isGroupNodeAt(nParent))
 796             {
 797                 view::GroupNode aParent = aView.getGroupNodeAt(nParent);
 798
 799                 {
 800                     CollectValueIDs aCollector(aNode, aList);
 801                     aView.dispatchToValues(aView.getGroupNodeAt(nParent),aCollector);
 802                 }
 803
 804                 for(view::Node aChild = aParent.getFirstChild();
 805                     aChild.is();
 806                     aChild = aParent.getNextChild(aChild))
 807                 {
 808                     OSL_ASSERT( pTreeImpl->isValidNode(aChild.get_offset()) );
 809                     aList.push_back( SubNodeID( aNode, pTreeImpl->getSimpleNodeName(aChild.get_offset())) );
 810                 }
 811             }
 812         }
 813     }
 814 }
 815
 816 //-----------------------------------------------------------------------------
 817 NodeID findNodeFromIndex(rtl::Reference< Tree > const& aTree, unsigned int nIndex)
 818 {
 819     if (Tree* pImpl = aTree.get())
 820     {
 821         unsigned int nNode = nIndex + Tree::ROOT;
 822         if (pImpl->isValidNode(nNode))
 823         {
 824             return NodeID(pImpl,nNode);
 825         }
 826     }
 827     return NodeID(0,0);
 828 }
 829
 830 //-----------------------------------------------------------------------------
 831
 832 static inline bool isRootNode(NodeRef const& aNode)
 833 {
 834     return aNode.getOffset() == Tree::ROOT;
 835 }
 836 //-----------------------------------------------------------------------------
 837 #if OSL_DEBUG_LEVEL > 0
 838 bool isSimpleValueElement(rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 839 {
 840     OSL_PRECOND( !aNode.isValid() || !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 841     OSL_PRECOND( !aNode.isValid() || aTree->isValidNode(aNode.getOffset()), "WARNING: Configuration: NodeRef does not match Tree");
 842
 843     view::ViewTreeAccess aView = view::ViewTreeAccess(aTree.get());
 844
 845     OSL_ASSERT( !aNode.isValid() ||
 846                 aView.isGroupNode(aNode) ||
 847                 aView.isSetNode(aNode) ||
 848                 (aView.isValueNode(aNode) && isRootNode(aNode)) );
 849
 850     return aNode.isValid() && isRootNode(aNode) && aView.isValueNode(aNode);
 851 }
 852 #endif
 853 //-----------------------------------------------------------------------------
 854
 855 bool isStructuralNode(rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 856 {
 857     OSL_PRECOND( !aNode.isValid() || !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 858     OSL_PRECOND( !aNode.isValid() || aTree->isValidNode(aNode.getOffset()), "WARNING: Configuration: NodeRef does not match Tree");
 859
 860     view::ViewTreeAccess aView = view::ViewTreeAccess(aTree.get());
 861
 862     OSL_ASSERT( !aNode.isValid() ||
 863                 aView.isGroupNode(aNode) ||
 864                 aView.isSetNode(aNode) ||
 865                 (aView.isValueNode(aNode) && isRootNode(aNode)) );
 866
 867     return aNode.isValid() && ! aView.isValueNode(aNode);
 868 }
 869 //-----------------------------------------------------------------------------
 870
 871 bool isGroupNode(rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 872 {
 873     OSL_PRECOND( !aNode.isValid() || !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 874     OSL_PRECOND( !aNode.isValid() || aTree->isValidNode(aNode.getOffset()), "WARNING: Configuration: NodeRef does not match Tree");
 875
 876     view::ViewTreeAccess aView = view::ViewTreeAccess(aTree.get());
 877
 878     OSL_ASSERT( !aNode.isValid() ||
 879                 aView.isGroupNode(aNode) ||
 880                 aView.isSetNode(aNode) ||
 881                 (aView.isValueNode(aNode) && isRootNode(aNode)) );
 882
 883     return aNode.isValid() && aView.isGroupNode(aNode);
 884 }
 885 //-----------------------------------------------------------------------------
 886
 887 bool isSetNode(rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 888 {
 889     OSL_PRECOND( !aNode.isValid() || !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 890     OSL_PRECOND( !aNode.isValid() || aTree->isValidNode(aNode.getOffset()), "WARNING: Configuration: NodeRef does not match Tree");
 891
 892     view::ViewTreeAccess aView = view::ViewTreeAccess(aTree.get());
 893
 894     OSL_ASSERT( !aNode.isValid() ||
 895                 aView.isGroupNode(aNode) ||
 896                 aView.isSetNode(aNode) ||
 897                 (aView.isValueNode(aNode) && isRootNode(aNode)) );
 898
 899     return aNode.isValid() && aView.isSetNode(aNode);
 900 }
 901 //-----------------------------------------------------------------------------
 902
 903 com::sun::star::uno::Any getSimpleElementValue(rtl::Reference< Tree > const& aTree, NodeRef const& aNode)
 904 {
 905     OSL_PRECOND( !isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires a valid Tree");
 906     OSL_PRECOND( aNode.isValid(), "ERROR: Configuration: Node operation requires a valid Node");
 907     OSL_PRECOND( aTree->isValidNode(aNode.getOffset()), "WARNING: Configuration: NodeRef does not match Tree");
 908
 909     if (!aNode.isValid()) return com::sun::star::uno::Any();
 910
 911     OSL_PRECOND( isSimpleValueElement(aTree, aNode), "ERROR: Configuration: Getting value is supported only for value nodes");
 912
 913     view::ViewTreeAccess aView = view::ViewTreeAccess(aTree.get());
 914
 915     return aView.getValue(aView.toValueNode(aNode));
 916 }
 917
 918 //-----------------------------------------------------------------------------
 919     }   // namespace configuration
 920 }               // namespace configmgr