configmgr/source/api2/elementimpl.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: elementimpl.cxx,v $
  10  * $Revision: 1.17.14.1 $
  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 "elementimpl.hxx"
  35 #include "apitreeaccess.hxx"
  36 #include "apinodeaccess.hxx"
  37 #include "apifactory.hxx"
  38 #include "noderef.hxx"
  39 #include "nodechange.hxx"
  40 #include "nodechangeinfo.hxx"
  41 #include "translatechanges.hxx"
  42 #include "apitypes.hxx"
  43 #include "configset.hxx"
  44 #include "confignotifier.hxx"
  45 #include "confsvccomponent.hxx"
  46 #include "committer.hxx"
  47 #include <com/sun/star/lang/DisposedException.hpp>
  48 #include <com/sun/star/container/XNameContainer.hpp>
  49 #include <com/sun/star/configuration/XTemplateContainer.hpp>
  50 #include <osl/diagnose.h>
  51
  52 namespace configmgr
  53 {
  54     namespace configapi
  55     {
  56 //-----------------------------------------------------------------------------------
  57         namespace lang = css::lang;
  58         namespace util = css::util;
  59
  60 //-----------------------------------------------------------------------------------
  61
  62 // Interface methods
  63 //-----------------------------------------------------------------------------------
  64
  65 // XChild
  66 //-----------------------------------------------------------------------------------
  67
  68 uno::Reference< uno::XInterface > implGetParent(NodeAccess& rNode, InnerElement&) throw(uno::RuntimeException)
  69 {
  70     uno::Reference<uno::XInterface> xRet;
  71
  72     try
  73     {
  74         GuardedNodeData<NodeAccess> impl( rNode ); // no provider lock needed - tree must be prebuilt already
  75
  76         rtl::Reference< configuration::Tree > aTree(impl.getTree());
  77         configuration::NodeRef aParentNode = aTree->getParent(impl.getNode());
  78
  79         uno::Any aAny = configapi::makeInnerElement( rNode.getFactory(), aTree, aParentNode );
  80
  81         if (!(aAny >>= xRet)) // no parent available
  82         {
  83             OSL_ASSERT(!xRet.is()); // make sure we return NULL
  84             OSL_ENSURE(!aAny.hasValue(), "configmgr: BasicElement::getParent: could not extract parent - node is not an object");
  85         }
  86     }
  87     catch (configuration::Exception& ex)
  88     {
  89         ExceptionMapper e(ex);
  90         e.setContext( rNode.getUnoInstance() );
  91         e.unhandled();
  92     }
  93
  94     return xRet;
  95 }
  96
  97 //-----------------------------------------------------------------------------------
  98
  99 uno::Reference< uno::XInterface > implGetParent(NodeAccess& rNode, SetElement& /*rElement*/) throw(uno::RuntimeException)
 100 {
 101     uno::Reference<uno::XInterface> xRet;
 102
 103     try
 104     {
 105         // assume shared lock for connected trees
 106         GuardedNodeData<NodeAccess> impl( rNode ); // no provider lock needed - tree must be prebuilt already
 107
 108         rtl::Reference< configuration::Tree > aTree(impl.getTree());
 109
 110         rtl::Reference< configuration::Tree > aParentTree( aTree->getContextTree() );
 111
 112         if (!configuration::isEmpty(aParentTree.get()))
 113         {
 114             configuration::NodeRef aParentNode( aTree->getContextNodeRef() );
 115
 116             // assume shared factory for connected trees
 117             uno::Any aAny = configapi::makeInnerElement( rNode.getFactory(), aParentTree, aParentNode );
 118
 119             if (!(aAny >>= xRet)) // no parent available
 120             {
 121                 // should occur only if the any is void
 122                 OSL_ENSURE(!aAny.hasValue(), "configmgr: BasicSetElement::getParent: could not extract parent - node is not an object");
 123                 OSL_ASSERT(!xRet.is()); // make sure we return NULL
 124             }
 125         }
 126         else
 127         {
 128             OSL_ASSERT(!xRet.is()); // make sure we return NULL
 129         }
 130     }
 131     catch (configuration::Exception& ex)
 132     {
 133         ExceptionMapper e(ex);
 134         e.setContext( rNode.getUnoInstance() );
 135         e.unhandled();
 136     }
 137
 138     return xRet;
 139 }
 140 //-----------------------------------------------------------------------------------
 141
 142 // UNSUPPORTED method
 143 void implSetParent(NodeAccess& rNode, InnerElement& /*rElement*/, const uno::Reference< uno::XInterface >& /*xParent*/ )
 144     throw(lang::NoSupportException, uno::RuntimeException)
 145 {
 146     UnoApiLock aLock;
 147
 148     rNode.checkAlive(); // Does locking internally, checks for disposed nodes
 149
 150     // TODO(?): allow for xParent == getParent()
 151     throw lang::NoSupportException(
 152             rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("configmgr: BasicElement::setParent: cannot move Entry")),
 153             rNode.getUnoInstance() );
 154 }
 155 //-----------------------------------------------------------------------------------
 156
 157 // preliminary implementation
 158 void implSetParent(NodeAccess& rNode, SetElement& rElement, const uno::Reference< uno::XInterface >& xParent )
 159     throw(lang::NoSupportException, uno::RuntimeException)
 160 {
 161     UnoApiLock aLock;
 162
 163     //implSetParent(rNode,xParent);
 164     // TODO: lock the whole transaction ???? - would need Uno Tunneling ?
 165     uno::Reference< uno::XInterface > xGotParent( implGetParent(rNode,rElement) );
 166     uno::Reference< css::container::XNameContainer > xOldParent( xGotParent, uno::UNO_QUERY );
 167     uno::Reference< css::container::XNameContainer > xNewParent( xParent, uno::UNO_QUERY );
 168
 169     if (xGotParent.is() && !xOldParent.is())
 170     {
 171         throw lang::NoSupportException(
 172                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: this is not element of a container")),
 173                 rNode.getUnoInstance() );
 174     }
 175     if (xParent.is() && !xNewParent.is())
 176     {
 177         throw lang::NoSupportException(
 178                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: new parent is no container")),
 179                 rNode.getUnoInstance() );
 180     }
 181
 182     uno::Reference< uno::XInterface > xThis(rNode.getUnoInstance());
 183     OSL_ASSERT(xThis.is());
 184
 185     if (xOldParent != xNewParent)
 186     {
 187         rtl::OUString const sName( implGetName(rNode,rElement) );
 188
 189         if (xParent.is())
 190         {
 191             rtl::OUString const sTemplate( implGetTemplateName(rElement) );
 192
 193             if (sTemplate.getLength() == 0)
 194             {
 195                 throw lang::NoSupportException(
 196                         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: object has no recognizable type")),
 197                         xThis );
 198             }
 199
 200             uno::Reference< css::configuration::XTemplateContainer > xNewTemplate( xParent, uno::UNO_QUERY );
 201             if (!xNewTemplate.is())
 202             {
 203                 throw lang::NoSupportException(
 204                         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: new parent has no element template")),
 205                         xThis );
 206             }
 207
 208             if ( sTemplate != xNewTemplate->getElementTemplateName())
 209             {
 210                 throw lang::NoSupportException(
 211                         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: object has wrong type")),
 212                         xThis );
 213             }
 214
 215             if ( xNewParent->hasByName( sName ) )
 216             {
 217                 throw lang::NoSupportException(
 218                         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: an object of this name already exists in new parent")),
 219                         xThis );
 220             }
 221
 222             // TODO: check for circularity (i.e. that This is not one of new parent's ancestors) !!
 223         }
 224
 225         // now do it
 226
 227         try
 228         {
 229             if ( xOldParent.is()) xOldParent->removeByName(sName);
 230             if ( xNewParent.is()) xNewParent->insertByName(sName, uno::makeAny(xThis));
 231         }
 232         catch (uno::Exception& e)
 233         {
 234             e.Message = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Config API: implSetParent: changing parent failed: "))
 235                 += e.Message;
 236
 237             if (xOldParent.is())
 238             try
 239             {
 240                 xOldParent->insertByName(sName, uno::makeAny(xThis));
 241             }
 242             catch(uno::Exception& bad)
 243             {
 244                 e.Message += rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("\n\t ! Could not restore old parent: ")) += bad.Message;
 245             }
 246
 247             throw uno::RuntimeException(e.Message,xThis);
 248         }
 249
 250     }
 251 }
 252 //-----------------------------------------------------------------------------
 253
 254
 255 // XNamed
 256 //-----------------------------------------------------------------------------
 257 rtl::OUString implGetName(NodeAccess& rNode, NodeElement& ) throw(uno::RuntimeException)
 258 {
 259     rtl::OUString sRet;
 260     try
 261     {
 262         GuardedNodeData<NodeAccess> impl( rNode ); // maybe passive only ?
 263
 264         rtl::Reference< configuration::Tree > aTree(impl.getTree());
 265         configuration::NodeRef aNode(impl.getNode());
 266
 267         sRet = aTree->getSimpleNodeName(aNode.getOffset());
 268     }
 269     catch (configuration::Exception& ex)
 270     {
 271         ExceptionMapper e(ex);
 272         e.setContext( rNode.getUnoInstance() );
 273         e.unhandled();
 274     }
 275
 276     return sRet;
 277 }
 278 //-----------------------------------------------------------------------------
 279
 280 // UNSUPPORTED method
 281 void implSetName(NodeAccess & rNode, NodeElement& /*rElement*/, const rtl::OUString& /*aName*/ ) throw(uno::RuntimeException)
 282 {
 283     UnoApiLock aLock;
 284
 285     rNode.checkAlive(); // Does locking internally, checks for disposed nodes
 286
 287     // TODO(?): allow for aName == getName()
 288     throw uno::RuntimeException(
 289         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("configmgr: BasicElement::setName: cannot rename Entry")),
 290         rNode.getUnoInstance() );
 291 }
 292 //-----------------------------------------------------------------------------
 293
 294 // TODO: Implementations for elements to be added to a container node
 295 void implSetName(NodeAccess& rNode, SetElement& rElement, const rtl::OUString& aName ) throw(uno::RuntimeException)
 296 {
 297     UnoApiLock aLock;
 298
 299     // TODO: Implement
 300     NodeElement& rDelegate = rElement;
 301     implSetName(rNode,rDelegate,aName); // delegate to unsupported version
 302 }
 303 //-----------------------------------------------------------------------------
 304
 305 // XComponent & XInterface
 306 //-----------------------------------------------------------------------------
 307
 308 //-----------------------------------------------------------------------------
 309
 310 void implDispose( SetElement& rElement) throw(uno::RuntimeException)
 311 {
 312     UnoApiLock aLock;
 313
 314     if (!rElement.disposeTree(false))
 315     {
 316         throw uno::RuntimeException(
 317                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONFIGURATION: Can't dispose an object that has an owner")),
 318                 rElement.getUnoInstance() );
 319     }
 320 }
 321 //-----------------------------------------------------------------------------
 322
 323 void implDispose( RootElement& rElement) throw(uno::RuntimeException)
 324 {
 325     UnoApiLock aLock;
 326
 327     if (!rElement.disposeTree())
 328     {
 329         throw lang::DisposedException(
 330                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONFIGURATION: Can't dispose an object that already was disposed")),
 331                 rElement.getUnoInstance() );
 332     }
 333 }
 334 //-----------------------------------------------------------------------------
 335
 336 void implDisposeObject( NodeAccess& ,SetElement& rElement) throw(uno::RuntimeException)
 337 {
 338     UnoApiLock aLock;
 339 // FIXME: should we hold a ref on the element over this ?
 340 // call apitreeaccess.hxx (doGetUnoInterface) & hold a ref / unref ?
 341 // [or!] - call getApiTree & ref/unref on that ?
 342 // [or!] - hold the ref inside the dispose method itself ...
 343     rElement.disposeTree(true);
 344 }
 345 //-----------------------------------------------------------------------------
 346
 347 void implDisposeObject( NodeAccess& , RootElement& rElement) throw(uno::RuntimeException)
 348 {
 349     UnoApiLock aLock;
 350
 351     rElement.disposeTree();
 352 }
 353 //-----------------------------------------------------------------------------
 354
 355 void implDisposeObject( NodeAccess& rNode, InnerElement& ) throw(uno::RuntimeException)
 356 {
 357     UnoApiLock aLock;
 358
 359     rNode.disposeNode();
 360 }
 361 //-----------------------------------------------------------------------------
 362
 363
 364 // XTypeProvider
 365 //-----------------------------------------------------------------------------
 366
 367 uno::Sequence<sal_Int8> implGetImplementationId(NodeAccess& rNode, NodeElement& rElement)
 368     throw(uno::RuntimeException)
 369 {
 370     DisposeGuard aLock(rNode);
 371     ServiceImplementationInfo const* pInfo = rElement.getServiceInfo();
 372
 373     OSL_ENSURE(pInfo, "Configuration: Object has no implementation (service) info - cannot get implementation id");
 374     if (!pInfo)
 375         throw uno::RuntimeException( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONFIGURATION: Object has no implementation information - cannot get implementation id")),rElement.getUnoInstance() );
 376
 377     return ServiceComponentImpl::getStaticImplementationId(pInfo);
 378 }
 379 //-----------------------------------------------------------------------------
 380
 381 // XServiceInfo
 382 //-----------------------------------------------------------------------------
 383
 384 rtl::OUString implGetImplementationName( NodeAccess& rNode, NodeElement& rElement ) throw(uno::RuntimeException)
 385 {
 386     DisposeGuard aLock(rNode);
 387     ServiceImplementationInfo const* pInfo = rElement.getServiceInfo();
 388     OSL_ENSURE(pInfo, "Configuration: Object has no service info");
 389
 390     return ServiceInfoHelper(pInfo).getImplementationName();
 391 }
 392 //-----------------------------------------------------------------------------
 393
 394 sal_Bool implSupportsService( NodeAccess& rNode, NodeElement& rElement, const rtl::OUString& ServiceName ) throw(uno::RuntimeException)
 395 {
 396     DisposeGuard aLock(rNode);
 397     ServiceImplementationInfo const* pInfo = rElement.getServiceInfo();
 398     OSL_ENSURE(pInfo, "Configuration: Object has no service info");
 399
 400     return ServiceInfoHelper(pInfo).supportsService(ServiceName);
 401 }
 402 //-----------------------------------------------------------------------------
 403
 404 uno::Sequence< rtl::OUString > implGetSupportedServiceNames( NodeAccess& rNode, NodeElement& rElement ) throw(uno::RuntimeException)
 405 {
 406     DisposeGuard aLock(rNode);
 407     ServiceImplementationInfo const* pInfo = rElement.getServiceInfo();
 408     OSL_ENSURE(pInfo, "Configuration: Object has no service info");
 409
 410     return ServiceInfoHelper(pInfo).getSupportedServiceNames();
 411 }
 412 //-----------------------------------------------------------------------------
 413
 414 // Root only ------------------------------------------------------------------
 415
 416 // XLocalizable
 417 // TODO: Implement locale support
 418 //-----------------------------------------------------------------------------
 419
 420 lang::Locale implGetLocale( RootElement& rElement ) throw(uno::RuntimeException)
 421 {
 422     GuardedRootElement aLocked(rElement);
 423
 424     OSL_ENSURE(false,"CONFIGURATION: Locale information is not yetsupported.");
 425     return lang::Locale();
 426 }
 427 //-----------------------------------------------------------------------------
 428
 429 void implSetLocale( RootElement& rElement, const css::lang::Locale& /*eLocale*/ ) throw(uno::RuntimeException)
 430 {
 431     UnoApiLock aLock;
 432     // TODO: Implement if possible
 433     rElement.checkAlive();
 434
 435     OSL_ENSURE(false,"CONFIGURATION: Changing the set Locale is not supported.");
 436     throw uno::RuntimeException(
 437         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("CONFIGURATION: Changing the locale is currently not supported")),
 438         rElement.getUnoInstance()
 439     );
 440 }
 441 //-----------------------------------------------------------------------------
 442
 443 // XChangesBatch
 444 //-----------------------------------------------------------------------------
 445
 446 void implCommitChanges( UpdateRootElement& rElement ) throw(css::lang::WrappedTargetException, uno::RuntimeException)
 447 {
 448     UnoApiLock aLock;
 449
 450     // quick check to avoid big locks for nothing (has its own locking)
 451     if (!implHasPendingChanges(rElement)) return;
 452
 453     try
 454     {
 455         rElement.getCommitter().commit();
 456     }
 457
 458     catch (configuration::Exception& ex)
 459     {
 460         ExceptionMapper e(ex);
 461         e.setContext( rElement.getUnoInstance() );
 462         e.unhandled();
 463     }
 464
 465     // filter/wrap uno::Exceptions
 466     catch (lang::WrappedTargetException& )      { throw; }
 467     catch (uno::RuntimeException& )                     { throw; }
 468     catch (uno::Exception& ex)
 469     {
 470         uno::Reference<uno::XInterface> xContext( rElement.getUnoInstance() );
 471         rtl::OUString sMessage( RTL_CONSTASCII_USTRINGPARAM("Configuration: can't commit Changes: ") );
 472         throw lang::WrappedTargetException( sMessage += ex.Message, xContext, uno::makeAny(ex));
 473     }
 474 }
 475 //-----------------------------------------------------------------------------
 476
 477 sal_Bool implHasPendingChanges( RootElement& rElement ) throw(uno::RuntimeException)
 478 {
 479     try
 480     {
 481         GuardedRootElement aLocked(rElement);
 482         return aLocked.get().getTree()->hasChanges();
 483     }
 484     catch (configuration::Exception& ex)
 485     {
 486         ExceptionMapper e(ex);
 487         e.setContext( rElement.getUnoInstance() );
 488         e.unhandled();
 489     }
 490
 491     OSL_ENSURE(false,"Unreachable Code");
 492     return false;
 493 }
 494 //-----------------------------------------------------------------------------
 495
 496 uno::Sequence< css::util::ElementChange > implGetPendingChanges( RootElement& rElement )
 497         throw(uno::RuntimeException)
 498 {
 499     std::vector<css::util::ElementChange> aResult;
 500     try
 501     {
 502         GuardedRootElement aLocked(rElement);
 503
 504         rtl::Reference< configuration::Tree > aTree( aLocked.get().getTree() );
 505
 506         configuration::NodeChangesInformation aInfos;
 507
 508         {
 509             configuration::NodeChanges aChanges;
 510             if (aTree->collectChanges(aChanges))
 511             {
 512                 aChanges.getChangesInfos(aInfos);
 513             }
 514         }
 515
 516         Factory& rFactory = rElement.getFactory();
 517
 518         for(std::vector< configuration::NodeChangeInformation >::const_iterator it = aInfos.begin(), stop = aInfos.end();
 519             it != stop;
 520             ++it)
 521         {
 522             css::util::ElementChange aChange;
 523             fillChange(aChange,*it,aTree,rFactory);
 524             aResult.push_back(aChange);
 525         }
 526     }
 527     catch (configuration::Exception& ex)
 528     {
 529         ExceptionMapper e(ex);
 530         e.setContext( rElement.getUnoInstance() );
 531         e.unhandled();
 532     }
 533
 534     return makeSequence(aResult);
 535 }
 536 //-----------------------------------------------------------------------------
 537
 538 // Set only -------------------------------------------------------------------------
 539
 540 // XTemplateInstance
 541 //-----------------------------------------------------------------------------------
 542
 543 rtl::OUString implGetTemplateName(SetElement& rElement)
 544     throw(uno::RuntimeException)
 545 {
 546     try
 547     {
 548         GuardedTreeElement aLocked(rElement);
 549         return rElement.getTemplateInfo()->getPathString();
 550     }
 551     catch (configuration::Exception& ex)
 552     {
 553         ExceptionMapper e(ex);
 554         e.setContext( rElement.getUnoInstance() );
 555         e.unhandled();
 556     }
 557
 558     OSL_ENSURE(false,"Unreachable Code");
 559     return rtl::OUString();
 560 }
 561 //-----------------------------------------------------------------------------------
 562
 563 // XUnoTunnel
 564 //-----------------------------------------------------------------------------------
 565 sal_Int64 implGetSomething(SetElement& rElement, const uno::Sequence< sal_Int8 >& aIdentifier )
 566     throw(uno::RuntimeException)
 567 {
 568     sal_Int64 nSomething = 0;
 569     try
 570     {
 571         GuardedTreeElement aLocked(rElement);
 572
 573         if (!rElement.getFactory().tunnelSetElement(nSomething, rElement, aIdentifier))
 574             OSL_ASSERT(nSomething == 0);
 575     }
 576     catch (configuration::Exception& ex)
 577     {
 578         ExceptionMapper e(ex);
 579         e.setContext( rElement.getUnoInstance() );
 580         e.unhandled();
 581     }
 582
 583     return nSomething;
 584 }
 585 //-----------------------------------------------------------------------------------
 586
 587     } // namespace configapi
 588
 589 } // namespace configmgr
 590
 591