configmgr/source/api2/accessimpl.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: accessimpl.cxx,v $
  10  * $Revision: 1.18 $
  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 #include <stdio.h>
  34
  35 #include "accessimpl.hxx"
  36 #include "apinodeaccess.hxx"
  37 #include "valueref.hxx"
  38 #include "anynoderef.hxx"
  39 #include "noderef.hxx"
  40 #include "configset.hxx"
  41 #include "confignotifier.hxx"
  42 #include "propertyinfohelper.hxx"
  43 #include "treeiterators.hxx"
  44 #include "attributes.hxx"
  45 #include "apitypes.hxx"
  46 #include <com/sun/star/lang/DisposedException.hpp>
  47 #include <com/sun/star/lang/WrappedTargetException.hpp>
  48 #include <com/sun/star/beans/PropertyVetoException.hpp>
  49 #include <osl/diagnose.h>
  50 #include <rtl/logfile.hxx>
  51
  52 #define RTL_LOGFILE_OU2A(rtlOUString)   (::rtl::OString((rtlOUString).getStr(), (rtlOUString).getLength(), RTL_TEXTENCODING_ASCII_US).getStr())
  53
  54 namespace configmgr
  55 {
  56     namespace configapi
  57     {
  58 //-----------------------------------------------------------------------------------
  59         namespace lang = css::lang;
  60         namespace util = css::util;
  61
  62 //-----------------------------------------------------------------------------------
  63 // Constructors
  64 //-----------------------------------------------------------------------------------
  65
  66 // Interface methods
  67 //-----------------------------------------------------------------------------------
  68
  69
  70 // XHierarchicalName
  71 //------------------------------------------------------------------------------------------------------------------
  72 rtl::OUString implGetHierarchicalName( NodeAccess& rNode ) throw(uno::RuntimeException)
  73 {
  74     // RTL_LOGFILE_CONTEXT(aLog, "Configmgr::API::implGetHierarchicalName()");
  75
  76     rtl::OUString sRet;
  77     try
  78     {
  79         GuardedNodeData<NodeAccess> lock( rNode );
  80
  81         rtl::Reference< configuration::Tree > aTree( lock.getTree());
  82
  83         configuration::AbsolutePath const aFullPath  = aTree->getAbsolutePath(lock.getNode());
  84         sRet = aFullPath.toString();
  85     }
  86     catch (configuration::Exception& ex)
  87     {
  88         ExceptionMapper e(ex);
  89         e.setContext( rNode.getUnoInstance() );
  90         e.unhandled();
  91     }
  92
  93     return sRet;
  94 }
  95
  96 //------------------------------------------------------------------------------------------------------------------
  97 rtl::OUString implComposeHierarchicalName(NodeGroupInfoAccess& rNode, const rtl::OUString& sRelativeName )
  98     throw(css::lang::IllegalArgumentException, lang::NoSupportException, uno::RuntimeException)
  99 {
 100     rtl::OUString sRet;
 101     try
 102     {
 103         GuardedNodeData<NodeAccess> lock( rNode );
 104         configuration::NodeRef aNode( lock.getNode() );
 105         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 106
 107         configuration::RelativePath const aAddedPath = configuration::validateRelativePath(sRelativeName, aTree, aNode);
 108
 109         // TODO: add (relative) name validation based on node type - may then need provider lock
 110         configuration::AbsolutePath const aFullPath = aTree->getAbsolutePath(aNode).compose(aAddedPath);
 111
 112         sRet = aFullPath.toString();
 113     }
 114     catch (configuration::InvalidName& ex)
 115     {
 116         ExceptionMapper e(ex);
 117         e.setContext( rNode.getUnoInstance() );
 118         e.illegalArgument(1);
 119     }
 120     catch (configuration::Exception& ex)
 121     {
 122         ExceptionMapper e(ex);
 123         e.setContext( rNode.getUnoInstance() );
 124         e.unhandled();
 125     }
 126
 127
 128     return sRet;
 129 }
 130
 131 //------------------------------------------------------------------------------------------------------------------
 132 rtl::OUString implComposeHierarchicalName(NodeSetInfoAccess& rNode, const rtl::OUString& sElementName )
 133     throw(css::lang::IllegalArgumentException, lang::NoSupportException, uno::RuntimeException)
 134 {
 135     rtl::OUString sRet;
 136     try
 137     {
 138         GuardedNodeData<NodeAccess> lock( rNode );
 139         configuration::NodeRef aNode( lock.getNode() );
 140         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 141
 142         configuration::Path::Component const aAddedName = configuration::validateElementPathComponent(sElementName, aTree, aNode);
 143
 144         // TODO: add (relative) name validation based on node type - may then need provider lock
 145         configuration::AbsolutePath const aFullPath = aTree->getAbsolutePath(aNode).compose(aAddedName);
 146
 147         sRet = aFullPath.toString();
 148     }
 149     catch (configuration::InvalidName& ex)
 150     {
 151         ExceptionMapper e(ex);
 152         e.setContext( rNode.getUnoInstance() );
 153         e.illegalArgument(1);
 154     }
 155     catch (configuration::Exception& ex)
 156     {
 157         ExceptionMapper e(ex);
 158         e.setContext( rNode.getUnoInstance() );
 159         e.unhandled();
 160     }
 161
 162
 163     return sRet;
 164 }
 165
 166 //------------------------------------------------------------------------------------------------------------------
 167
 168 // XElementAccess, base class of XNameAccess (and XHierarchicalNameAccess ? )
 169 //-----------------------------------------------------------------------------------
 170
 171
 172 //-----------------------------------------------------------------------------------
 173 // for group nodes
 174 uno::Type implGetElementType(NodeGroupInfoAccess& rNode) throw(uno::RuntimeException)
 175 {
 176     rNode.checkAlive();
 177     // group nodes have a mix of types
 178     // TODO(?): Discover single common type
 179     return ::getCppuType( static_cast< uno::Any const*>(0) );
 180 }
 181
 182 // for set nodes
 183 uno::Type implGetElementType(NodeSetInfoAccess& rNode) throw(uno::RuntimeException)
 184 {
 185     uno::Type aRet;
 186     try
 187     {
 188         GuardedNodeData<NodeSetInfoAccess> lock( rNode );
 189
 190         aRet = rNode.getElementInfo()->getInstanceType();
 191     }
 192     catch (configuration::Exception& ex)
 193     {
 194         ExceptionMapper e(ex);
 195         e.setContext( rNode.getUnoInstance() );
 196         e.unhandled();
 197     }
 198     return aRet;
 199 }
 200
 201 //-----------------------------------------------------------------------------------
 202 // for group nodes
 203 sal_Bool implHasElements(NodeGroupInfoAccess& rNode) throw(uno::RuntimeException)
 204 {
 205     //  rNode.checkAlive();
 206 //      return true;    // group nodes always have children
 207
 208 // Better: cater for the case where we are reaching the depth limit
 209     try
 210     {
 211         GuardedNodeData<NodeAccess> lock( rNode ); // no provider lock needed
 212
 213         rtl::Reference< configuration::Tree > aThisTree( lock.getTree() );
 214         configuration::NodeRef aThisNode( lock.getNode() );
 215         OSL_ASSERT( !aThisTree->hasElements(aThisNode) );
 216         return aThisTree->hasChildren(aThisNode);
 217     }
 218     catch (configuration::Exception& ex)
 219     {
 220         ExceptionMapper e(ex);
 221         e.setContext( rNode.getUnoInstance() );
 222         e.unhandled();
 223     }
 224     // unreachable, but still there to make compiler happy
 225     OSL_ASSERT(!"Unreachable code");
 226     return false;
 227 }
 228
 229 // for set nodes
 230 sal_Bool implHasElements(NodeSetInfoAccess& rNode) throw(uno::RuntimeException)
 231 {
 232     try
 233     {
 234         GuardedNodeData<NodeAccess> lock( rNode ); // provider lock needed
 235
 236         rtl::Reference< configuration::Tree > aThisTree( lock.getTree() );
 237         configuration::NodeRef aThisNode( lock.getNode() );
 238         OSL_ASSERT( !aThisTree->hasChildren(aThisNode) );
 239         return aThisTree->hasElements(aThisNode);
 240     }
 241     catch (configuration::Exception& ex)
 242     {
 243         ExceptionMapper e(ex);
 244         e.setContext( rNode.getUnoInstance() );
 245         e.unhandled();
 246     }
 247     // unreachable, but still there to make compiler happy
 248     OSL_ASSERT(!"Unreachable code");
 249     return false;
 250 }
 251
 252 // XExactName
 253 //-----------------------------------------------------------------------------------
 254
 255
 256 //------------------------------------------------------------------------------------------------------------------
 257 namespace internal
 258 {
 259     struct SearchExactName : private configuration::NodeVisitor
 260     {
 261     protected:
 262         // warning: order dependency
 263         configuration::RelativePath aSearchPath;
 264         std::vector<configuration::Path::Component>::reverse_iterator pSearchComponent;
 265     public:
 266         explicit
 267         SearchExactName(const configuration::RelativePath& aLookFor)
 268         : aSearchPath(aLookFor)
 269         , pSearchComponent(aSearchPath.begin_mutate())
 270         {}
 271
 272         bool complete() { return aSearchPath.end_mutate() == pSearchComponent; }
 273
 274         bool search(configuration::NodeRef const& aNode, rtl::Reference< configuration::Tree > const& aTree);
 275
 276         configuration::RelativePath const& getBestMatch() const { return aSearchPath; }
 277
 278     private:
 279         bool findMatch(configuration::NodeRef& aNode, rtl::Reference< configuration::Tree > & aTree);
 280         virtual Result handle(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const&); // NodeVisitor
 281         virtual Result handle(rtl::Reference< configuration::Tree > const& aTree, configuration::ValueRef const&); // NodeVisitor
 282     };
 283 //..................................................................................................................
 284     bool SearchExactName::findMatch(configuration::NodeRef& aNode, rtl::Reference< configuration::Tree > & aTree)
 285     {
 286         OSL_ASSERT( !complete() );
 287
 288         if ( !aNode.isValid() ) return false;
 289
 290         // exact match ?
 291         if (!configuration::hasChildOrElement(aTree,aNode,*pSearchComponent))
 292         {
 293             if (aTree->dispatchToChildren(aNode,*this) == CONTINUE) // not found there
 294                 return false;
 295         }
 296         OSL_ASSERT(configuration::hasChildOrElement(aTree,aNode,*pSearchComponent));
 297
 298         if (! configuration::findInnerChildOrAvailableElement(aTree,aNode,pSearchComponent->getName()) )
 299             aNode = configuration::NodeRef(); // will stop recursion (value or unloaded element found)
 300         ++pSearchComponent;
 301
 302         return true;
 303     }
 304     //..................................................................................................................
 305     // helper
 306     static configuration::Path::Component getExtendedNodeName(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode, rtl::OUString const& aSimpleNodeName)
 307     {
 308         OSL_PRECOND( !configuration::isEmpty(aTree.get()), "ERROR: Configuration: Tree operation requires valid tree" );
 309         OSL_PRECOND( !aNode.isValid() || aTree->isValidNode(aNode.getOffset()), "ERROR: Configuration: NodeRef does not match tree" );
 310
 311         if (aTree->isRootNode(aNode))
 312             return aTree->getExtendedRootName();
 313
 314         else
 315             return configuration::Path::wrapSimpleName(aSimpleNodeName);
 316     }
 317     //..................................................................................................................
 318     configuration::NodeVisitor::Result SearchExactName::handle(rtl::Reference< configuration::Tree > const& aTree, configuration::NodeRef const& aNode)
 319     {
 320         OSL_ASSERT( aNode.isValid() );
 321         OSL_ASSERT( !complete() );
 322
 323         // find inexact match (the first one, but the order is unspecified)
 324         // TODO: Add support for node-type-specific element names
 325         rtl::OUString aNodeName = aTree->getSimpleNodeName(aNode.getOffset());
 326         rtl::OUString aSearchName = pSearchComponent->getName();
 327         if (aNodeName.equalsIgnoreAsciiCase(aSearchName))
 328         {
 329             *pSearchComponent = getExtendedNodeName(aTree,aNode,aNodeName);
 330             return DONE; // for this level
 331         }
 332         else
 333             return CONTINUE;
 334     }
 335     //..................................................................................................................
 336     configuration::NodeVisitor::Result SearchExactName::handle(rtl::Reference< configuration::Tree > const&, configuration::ValueRef const& aNode)
 337     {
 338         OSL_ASSERT( aNode.isValid() );
 339         OSL_ASSERT( !complete() );
 340
 341         // find inexact match (the first one, but the order is unspecified)
 342         // TODO: Add support for node-type-specific element names
 343         rtl::OUString aNodeName = aNode.m_sNodeName;
 344         OSL_ASSERT( configuration::isSimpleName(aNodeName) );
 345
 346         // value refs are group members and thus have to have simple names
 347         if (aNodeName.equalsIgnoreAsciiCase(pSearchComponent->getName()))
 348         {
 349             *pSearchComponent = configuration::Path::wrapSimpleName(aNodeName);
 350             return DONE; // for this level
 351         }
 352         else
 353             return CONTINUE;
 354     }
 355 //..................................................................................................................
 356     bool SearchExactName::search(configuration::NodeRef const & aNode, rtl::Reference< configuration::Tree > const & aTree)
 357     {
 358         if (!aNode.isValid()) return false;
 359
 360         rtl::Reference< configuration::Tree > aSearchTree(aTree);
 361         configuration::NodeRef aSearchNode(aNode);
 362
 363         while (!complete())
 364             if (! findMatch(aSearchNode, aSearchTree))
 365                 break;
 366
 367         return complete();
 368     }
 369
 370 } // namespace internal
 371
 372 //..................................................................................................................
 373 rtl::OUString implGetExactName(NodeGroupInfoAccess& rNode, const rtl::OUString& rApproximateName ) throw(uno::RuntimeException)
 374 {
 375     // here we try to support both tree-fragment-local pathes and simple names (the latter ones are just an instance of the first)
 376     try
 377     {
 378         GuardedNodeData<NodeAccess> lock( rNode );
 379
 380         rtl::Reference< configuration::Tree > aTree(lock.getTree());
 381         configuration::NodeRef aNode(lock.getNode());
 382
 383         configuration::RelativePath aApproximatePath = configuration::validateRelativePath(rApproximateName,aTree,aNode);
 384
 385         internal::SearchExactName aSearch(aApproximatePath);
 386
 387         aSearch.search(aNode, aTree);
 388
 389         OSL_ENSURE( aSearch.getBestMatch().getDepth() == aApproximatePath.getDepth(),
 390                     "Search for exact names changed number of path components !?");
 391
 392         return aSearch.getBestMatch().toString();
 393     }
 394     catch (configuration::InvalidName& )
 395     {
 396         OSL_TRACE("WARNING: Configuration::getExactName: query uses locally invalid Path");
 397         return rApproximateName;
 398     }
 399     catch (configuration::Exception& ex)
 400     {
 401         ExceptionMapper e(ex);
 402         e.setContext( rNode.getUnoInstance() );
 403         e.unhandled();
 404     }
 405     // unreachable, but still there to make compiler happy
 406     OSL_ASSERT(!"Unreachable code");
 407     return rApproximateName;
 408 }
 409
 410 //..................................................................................................................
 411 rtl::OUString implGetExactName(NodeSetInfoAccess& rNode, const rtl::OUString& rApproximateName ) throw(uno::RuntimeException)
 412 {
 413
 414     // here we can support only local names
 415     try
 416     {
 417         GuardedNodeData<NodeAccess> lock( rNode );
 418
 419         rtl::Reference< configuration::Tree > aTree(lock.getTree());
 420         configuration::NodeRef aNode(lock.getNode());
 421
 422         configuration::Path::Component aApproximateName = configuration::validateElementPathComponent(rApproximateName,aTree,aNode);
 423
 424         internal::SearchExactName aSearch(aApproximateName);
 425
 426         aSearch.search(aNode, aTree);
 427
 428         OSL_ENSURE( aSearch.getBestMatch().getDepth() == 1,
 429                     "Search for exact names changed number of path components !?");
 430
 431         return aSearch.getBestMatch().getLocalName().getName();
 432     }
 433     catch (configuration::InvalidName& )
 434     {
 435         OSL_TRACE("WARNING: Configuration::getExactName: query uses locally invalid Path");
 436         return rApproximateName;
 437     }
 438     catch (configuration::Exception& ex)
 439     {
 440         ExceptionMapper e(ex);
 441         e.setContext( rNode.getUnoInstance() );
 442         e.unhandled();
 443     }
 444     // unreachable, but still there to make compiler happy
 445     OSL_ASSERT(!"Unreachable code");
 446     return rApproximateName;
 447 }
 448
 449 // XProperty
 450 //-----------------------------------------------------------------------------------
 451
 452 //-----------------------------------------------------------------------------------
 453 beans::Property implGetAsProperty(NodeAccess& rNode)
 454     throw(uno::RuntimeException)
 455 {
 456     try
 457     {
 458         GuardedNodeData<NodeAccess> lock( rNode );
 459
 460         rtl::Reference< configuration::Tree > aTree( lock.getTree());
 461         configuration::NodeRef aNode( lock.getNode());
 462
 463         rtl::OUString aName       = aTree->getSimpleNodeName(aNode.getOffset());
 464         node::Attributes        aAttributes = aTree->getAttributes(aNode);
 465         uno::Type       aApiType    = getUnoInterfaceType();
 466
 467         return helperMakeProperty( aName,aAttributes,aApiType, aTree->hasNodeDefault(aNode) );
 468     }
 469     catch (configuration::Exception& ex)
 470     {
 471         ExceptionMapper e(ex);
 472         e.setContext( rNode.getUnoInstance() );
 473         e.unhandled();
 474     }
 475
 476     // unreachable, but still there to make some compilers happy
 477     OSL_ASSERT(!"Unreachable code");
 478     return beans::Property();
 479 }
 480 // XPropertySetInfo
 481 //-----------------------------------------------------------------------------------
 482
 483 //-----------------------------------------------------------------------------------
 484 uno::Sequence< css::beans::Property > implGetProperties( NodeAccess& rNode ) throw (uno::RuntimeException)
 485 {
 486     CollectPropertyInfo aCollect;
 487
 488     try
 489     {
 490         GuardedNodeData<NodeAccess> lock( rNode );
 491
 492         lock.getTree()->dispatchToChildren(lock.getNode(), aCollect);
 493     }
 494     catch (configuration::Exception& ex)
 495     {
 496         ExceptionMapper e(ex);
 497         e.setContext( rNode.getUnoInstance() );
 498         e.unhandled();
 499     }
 500
 501     return makeSequence( aCollect.list() );
 502 }
 503
 504 //-----------------------------------------------------------------------------------
 505 css::beans::Property implGetPropertyByName( NodeAccess& rNode, const rtl::OUString& aName )
 506     throw (css::beans::UnknownPropertyException, uno::RuntimeException)
 507 {
 508     try
 509     {
 510         GuardedNodeData<NodeAccess> lock( rNode );
 511
 512         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 513         configuration::NodeRef const aNode( lock.getNode() );
 514
 515         rtl::OUString aChildName = configuration::validateChildOrElementName(aName,aTree,aNode);
 516
 517         configuration::AnyNodeRef aChildNode = configuration::getChildOrElement(aTree,aNode, aChildName);
 518
 519         if (!aChildNode.isValid())
 520         {
 521             OSL_ENSURE(!configuration::hasChildOrElement(aTree,aNode,aChildName),"ERROR: Configuration: Existing Property not found by implementation");
 522
 523             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Cannot get Property. Property '") );
 524             sMessage += aName;
 525             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' could not be found in ")  );
 526             sMessage += aTree->getAbsolutePath(aNode).toString();
 527
 528             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 529             throw css::beans::UnknownPropertyException( sMessage, xContext );
 530         }
 531
 532         node::Attributes        aChildAttributes = aTree->getAttributes(aChildNode);
 533         uno::Type       aApiType = aChildNode.isNode() ? getUnoInterfaceType() : aTree->getUnoType(aChildNode.toValue());
 534
 535         return helperMakeProperty( aChildName,aChildAttributes,aApiType, aTree->hasNodeDefault(aChildNode) );
 536     }
 537     catch (configuration::InvalidName& ex)
 538     {
 539         ExceptionMapper e(ex);
 540         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 541         throw css::beans::UnknownPropertyException( e.message(), xContext );
 542     }
 543     catch (configuration::Exception& ex)
 544     {
 545         ExceptionMapper e(ex);
 546         e.setContext( rNode.getUnoInstance() );
 547         e.unhandled();
 548     }
 549
 550     // unreachable, but still there to make some compilers happy
 551     OSL_ASSERT(!"Unreachable code");
 552     return css::beans::Property();
 553 }
 554
 555
 556 //-----------------------------------------------------------------------------------
 557 sal_Bool implHasPropertyByName( NodeAccess& rNode, const rtl::OUString& name ) throw (uno::RuntimeException)
 558 {
 559     return implHasByName(rNode, name);
 560 }
 561
 562 // XNameAccess
 563 //-----------------------------------------------------------------------------------
 564
 565 //-----------------------------------------------------------------------------------
 566 // TODO: optimization - cache the node found (for subsequent getByName)
 567 // TODO: optimization - less locking for group nodes
 568 //-----------------------------------------------------------------------------------
 569 sal_Bool implHasByName(NodeAccess& rNode, const rtl::OUString& sName ) throw(uno::RuntimeException)
 570 {
 571     try
 572     {
 573         GuardedNodeData<NodeAccess> lock( rNode );
 574
 575         rtl::OUString aChildName(sName);
 576
 577         return configuration::hasChildOrElement(lock.getTree(), lock.getNode(), aChildName);
 578     }
 579 #if OSL_DEBUG_LEVEL > 0
 580     catch (configuration::InvalidName& ex)
 581     {
 582         ExceptionMapper e(ex);
 583         OSL_ENSURE(false,"configmgr: BasicAccess::hasByName: Unexpected exception <InvalidName>");
 584         e.setContext( rNode.getUnoInstance() );
 585         e.unhandled();
 586     }
 587 #endif
 588     catch (configuration::Exception& ex)
 589     {
 590         ExceptionMapper e(ex);
 591         e.setContext( rNode.getUnoInstance() );
 592         e.unhandled();
 593     }
 594     // unreachable, but still there to make compiler happy
 595     OSL_ASSERT(!"Unreachable code");
 596     return false;
 597 }
 598
 599 //-----------------------------------------------------------------------------------
 600 uno::Any implGetByName(NodeAccess& rNode, const rtl::OUString& sName )
 601     throw(css::container::NoSuchElementException, css::lang::WrappedTargetException, uno::RuntimeException)
 602 {
 603     try
 604     {
 605         GuardedNodeData<NodeAccess> lock( rNode );
 606
 607         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 608         configuration::NodeRef aNode( lock.getNode() );
 609
 610         rtl::OUString aChildName = configuration::validateChildOrElementName(sName,aTree,aNode);
 611
 612         configuration::AnyNodeRef aChildNode = configuration::getChildOrElement(aTree,aNode, aChildName);
 613         if (!aChildNode.isValid())
 614         {
 615             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Child Element '") );
 616             sMessage += sName;
 617             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in ")  );
 618             sMessage += aTree->getAbsolutePath(aNode).toString();
 619
 620             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 621             throw com::sun::star::container::NoSuchElementException( sMessage, xContext );
 622         }
 623         OSL_ASSERT(aNode.isValid());
 624
 625         return configapi::makeElement( rNode.getFactory(), aTree, aChildNode );
 626     }
 627     catch (configuration::InvalidName& ex)
 628     {
 629         ExceptionMapper e(ex);
 630         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 631         throw com::sun::star::container::NoSuchElementException( e.message(), xContext );
 632     }
 633     catch (configuration::Exception& ex)
 634     {
 635         ExceptionMapper e(ex);
 636         e.setContext( rNode.getUnoInstance() );
 637         e.unhandled();
 638     }
 639
 640     // unreachable, but still there to make some compilers happy
 641     OSL_ASSERT(!"Unreachable code");
 642     return uno::Any();
 643 }
 644
 645 //-----------------------------------------------------------------------------------
 646 // TODO: optimization - less locking for group nodes
 647 //-----------------------------------------------------------------------------------
 648 uno::Sequence< rtl::OUString > implGetElementNames( NodeAccess& rNode ) throw( uno::RuntimeException)
 649 {
 650     CollectNodeNames aCollect;
 651
 652     try
 653     {
 654         GuardedNodeData<NodeAccess> lock( rNode );
 655
 656         lock.getTree()->dispatchToChildren(lock.getNode(), aCollect);
 657     }
 658     catch (configuration::Exception& ex)
 659     {
 660         ExceptionMapper e(ex);
 661         e.setContext( rNode.getUnoInstance() );
 662         e.unhandled();
 663     }
 664
 665     return makeSequence( aCollect.list() );
 666 }
 667
 668 // XHierarchicalNameAccess
 669 //-----------------------------------------------------------------------------------
 670
 671 //-----------------------------------------------------------------------------------
 672 // TO DO: optimization - cache the node found for subsequent getByHierarchicalName()
 673 //-----------------------------------------------------------------------------------
 674 sal_Bool implHasByHierarchicalName(NodeAccess& rNode, const rtl::OUString& sHierarchicalName ) throw(uno::RuntimeException)
 675 {
 676     try
 677     {
 678         GuardedNodeData<NodeAccess> lock( rNode );
 679
 680         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 681         configuration::NodeRef aNode( lock.getNode() );
 682
 683         configuration::RelativePath aRelPath = configuration::validateAndReducePath( sHierarchicalName, aTree, aNode );
 684
 685         return configuration::getDeepDescendant(aTree, aNode, aRelPath).isValid();
 686     }
 687     catch (configuration::InvalidName& )
 688     {
 689         OSL_TRACE("WARNING: Configuration::hasByHierarchicalName: query uses locally invalid Path");
 690         return false;
 691     }
 692     catch (configuration::Exception& ex)
 693     {
 694         ExceptionMapper e(ex);
 695         e.setContext( rNode.getUnoInstance() );
 696         e.unhandled();
 697     }
 698     // unreachable, but still there to make some compilers happy
 699     OSL_ASSERT(!"Unreachable code");
 700     return false;
 701 }
 702
 703 //-----------------------------------------------------------------------------------
 704 uno::Any implGetByHierarchicalName(NodeAccess& rNode, const rtl::OUString& sHierarchicalName )
 705     throw(css::container::NoSuchElementException, uno::RuntimeException)
 706 {
 707     // rtl::OUString aTmpStr(implGetHierarchicalName(rNode));
 708     // RTL_LOGFILE_CONTEXT_TRACE2(aLog, "Node: %s HierachicalName: %s",RTL_LOGFILE_OU2A(aTmpStr), RTL_LOGFILE_OU2A(sHierarchicalName));
 709
 710     try
 711     {
 712         GuardedNodeData<NodeAccess> lock( rNode );
 713
 714         rtl::Reference< configuration::Tree > aTree( lock.getTree() );
 715         configuration::NodeRef aNode( lock.getNode() );
 716
 717         configuration::RelativePath aRelPath = configuration::validateAndReducePath( sHierarchicalName, aTree, aNode );
 718
 719         configuration::AnyNodeRef aNestedNode = configuration::getDeepDescendant( aTree, aNode, aRelPath );
 720         if (!aNestedNode.isValid())
 721         {
 722             rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration - Descendant Element '") );
 723             sMessage += aRelPath.toString();
 724             sMessage += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("' not found in Node ")  );
 725             sMessage += aTree->getAbsolutePath(aNode).toString();
 726
 727             uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 728             throw com::sun::star::container::NoSuchElementException( sMessage, xContext );
 729         }
 730
 731         OSL_ASSERT(aNode.isValid());
 732         return configapi::makeElement( rNode.getFactory(), aTree, aNestedNode );
 733     }
 734     catch (configuration::InvalidName& ex)
 735     {
 736         ExceptionMapper e(ex);
 737         uno::Reference<uno::XInterface> xContext( rNode.getUnoInstance() );
 738         throw com::sun::star::container::NoSuchElementException( e.message(), xContext );
 739     }
 740     catch (configuration::Exception& ex)
 741     {
 742         ExceptionMapper e(ex);
 743         e.setContext( rNode.getUnoInstance() );
 744         e.unhandled();
 745     }
 746
 747     // unreachable, but still there to make some compilers happy
 748     OSL_ASSERT(!"Unreachable code");
 749     return uno::Any();
 750 }
 751
 752 // XPropertyWithState
 753 //---------------------------------------------------------------------
 754 css::beans::PropertyState implGetStateAsProperty(NodeAccess& rNode)
 755     throw (uno::RuntimeException)
 756 {
 757     css::beans::PropertyState aRet = css::beans::PropertyState_AMBIGUOUS_VALUE;
 758     try
 759     {
 760         GuardedNodeData<NodeAccess> lock( rNode );
 761
 762         if ( lock.getTree()->isNodeDefault( lock.getNode() ) )
 763             aRet = css::beans::PropertyState_DEFAULT_VALUE;
 764     }
 765     catch (configuration::Exception& ex)
 766     {
 767         ExceptionMapper e(ex);
 768         e.setContext( rNode.getUnoInstance() );
 769         e.unhandled();
 770     }
 771     return aRet;
 772 }
 773
 774 uno::Reference< uno::XInterface > implGetDefaultAsProperty(NodeAccess& )
 775     throw (css::lang::WrappedTargetException, uno::RuntimeException)
 776 {
 777     // not really supported
 778
 779     /* possible, but nor really useful:
 780     GuardedNodeAccess lock( rNode );
 781     if (implGetStateAsProperty(rNode) == PropertyState_DEFAULT_VALUE)
 782         return rNode.getUnoInstance();
 783     */
 784
 785     return uno::Reference< uno::XInterface >();
 786 }
 787
 788
 789 // set-specific Interfaces
 790 //-----------------------------------------------------------------------------------
 791
 792
 793 // XTemplateContainer
 794 //-----------------------------------------------------------------------------------
 795 rtl::OUString SAL_CALL implGetElementTemplateName(NodeSetInfoAccess& rNode)
 796     throw(uno::RuntimeException)
 797 {
 798     GuardedNodeData<NodeSetInfoAccess> lock(rNode);
 799     return rNode.getElementInfo()->getPathString();
 800 }
 801
 802 //-----------------------------------------------------------------------------------
 803     } // namespace configapi
 804
 805 } // namespace configmgr
 806
 807