configmgr/source/backend/multistratumbackend.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: multistratumbackend.cxx,v $
  10  * $Revision: 1.13 $
  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 "multistratumbackend.hxx"
  35
  36 #ifndef CONFIGMGR_API_FACTORY_HXX_
  37 #include "confapifactory.hxx"
  38 #endif // CONFIGMGR_API_FACTORY_HXX_
  39 #include "serviceinfohelper.hxx"
  40 #include "backendstratalistener.hxx"
  41
  42 #ifndef _CONFIGMGR_BOOTSTRAP_HXX
  43 #include "bootstrap.hxx"
  44 #endif
  45 #include "simpleinteractionrequest.hxx"
  46 #include "configinteractionhandler.hxx"
  47 #include <com/sun/star/configuration/backend/XMultiLayerStratum.hpp>
  48 #include <com/sun/star/configuration/backend/XSingleLayerStratum.hpp>
  49 #include <com/sun/star/configuration/backend/StratumCreationException.hpp>
  50 #include <com/sun/star/task/XInteractionHandler.hpp>
  51 #include <com/sun/star/lang/DisposedException.hpp>
  52 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  53 #include <rtl/ustrbuf.hxx>
  54
  55 #include <cppuhelper/exc_hlp.hxx>
  56
  57 #include <stdio.h>
  58
  59 //==============================================================================
  60 #define OU2A(rtlOUString)       (::rtl::OUStringToOString((rtlOUString), RTL_TEXTENCODING_ASCII_US).getStr())
  61 //==============================================================================
  62
  63 namespace {
  64
  65 namespace css = com::sun::star;
  66
  67 }
  68
  69 namespace configmgr { namespace backend {
  70
  71 //==============================================================================
  72 static const rtl::OUString kSchemaServiceParam(
  73     RTL_CONSTASCII_USTRINGPARAM( CONTEXT_ITEM_PREFIX_ "SchemaSupplier"));
  74
  75 static const rtl::OUString kStrataServiceParam(
  76     RTL_CONSTASCII_USTRINGPARAM( CONTEXT_ITEM_PREFIX_ "Strata"));
  77
  78 static const rtl::OUString kEntity(
  79     RTL_CONSTASCII_USTRINGPARAM(CONTEXT_ITEM_PREFIX_"EntityLayer")) ;
  80
  81 static const rtl::OUString kAdminModeFlag(
  82     RTL_CONSTASCII_USTRINGPARAM(CONTEXT_ITEM_ADMINFLAG)) ;
  83
  84 static const rtl::OUString kThisOwnerEntity(
  85     RTL_CONSTASCII_USTRINGPARAM("<ThisOwnerEntity>")) ;
  86
  87 //------------------------------------------------------------------------------
  88 bool checkOptionalArg(rtl::OUString& aArg)
  89     {
  90         if (aArg.getLength() && aArg[0] == sal_Unicode('?'))
  91         {
  92             aArg = aArg.copy(1);
  93             return true;
  94         }
  95         else
  96         {
  97             return false;
  98         }
  99     }
 100 //------------------------------------------------------------------------------
 101 void parseStrataInfo(const rtl::OUString aServiceList,
 102                      std::vector< std::pair<rtl::OUString, rtl::OUString> >& aServiceInfoList,
 103                      const uno::Reference<uno::XInterface>& pContext)
 104 {
 105     sal_Int32 nNextToken =0;
 106     sal_Int32 nLength = aServiceList.getLength();
 107
 108     do
 109     {
 110         rtl::OUString aServiceName =aServiceList.getToken(0, ':',nNextToken);
 111         if((nNextToken ==-1)||(aServiceName.getLength()==0))
 112         {
 113              throw backenduno::BackendSetupException(
 114                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 115                         "Malformed Strata Service specified")),
 116                         pContext, uno::Any()) ;
 117         }
 118         rtl::OUString aServiceData = aServiceList.getToken(0, ';',nNextToken);
 119
 120         std::pair<rtl::OUString, rtl::OUString> aServiceInfo(aServiceName,aServiceData);
 121         aServiceInfoList.push_back(aServiceInfo);
 122     }
 123     while (nNextToken >= 0 && nNextToken < nLength ) ;
 124 }
 125 //------------------------------------------------------------------------------
 126 MultiStratumBackend::MultiStratumBackend(
 127         const uno::Reference<uno::XComponentContext>& xContext)
 128         : cppu::WeakComponentImplHelper7< backenduno::XBackend, backenduno::XBackendEntities, backenduno::XVersionedSchemaSupplier, backenduno::XBackendChangesNotifier, backenduno::XBackendChangesListener, lang::XInitialization, lang::XServiceInfo >(mMutex), mFactory(xContext->getServiceManager(),uno::UNO_QUERY_THROW)
 129           ,mListenerList()
 130 {
 131
 132 }
 133 //------------------------------------------------------------------------------
 134
 135 MultiStratumBackend::~MultiStratumBackend()
 136 {
 137 }
 138 //------------------------------------------------------------------------------
 139 bool MultiStratumBackend::checkOkState()
 140 {
 141     if (!mSchemaSupplier.is())
 142     {
 143         if(rBHelper.bDisposed)
 144         {
 145             throw lang::DisposedException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 146             "MultiStratumBackend: Backends already disposed")),*this);
 147         }
 148         else
 149         {
 150             throw uno::RuntimeException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 151             "MultiStratumBackend: Object was never Initialised")),*this);
 152         }
 153     }
 154     return true;
 155 }
 156 //------------------------------------------------------------------------------
 157
 158 void SAL_CALL MultiStratumBackend::initialize(
 159         const uno::Sequence<uno::Any>& aParameters)
 160     throw (uno::RuntimeException, uno::Exception,
 161            css::configuration::InvalidBootstrapFileException,
 162            backenduno::BackendSetupException) {
 163
 164     if (aParameters.getLength() == 0) {
 165         throw lang::IllegalArgumentException(
 166                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 167                         "No parameters provided to MultiStratumBackend")),
 168                 *this, 0) ;
 169     }
 170
 171     uno::Reference<uno::XComponentContext> context ;
 172
 173     for (sal_Int32 i = 0 ; i < aParameters.getLength() ; ++ i) {
 174         if (aParameters [i] >>= context) { break ; }
 175     }
 176
 177
 178     try
 179     {
 180         //Initialize Backends
 181         initializeSchemaSupplier (context);
 182         initializeBackendStrata(context);
 183
 184         sal_Bool bAdminMode = false;
 185         context->getValueByName(kAdminModeFlag) >>= bAdminMode;
 186
 187         if (bAdminMode)
 188         {
 189             // find given entity
 190             rtl::OUString sDefaultEntity;
 191             if ( (context->getValueByName(kEntity) >>= sDefaultEntity) && sDefaultEntity.getLength() )
 192             {
 193                 for (sal_uInt32 i = 0; i < mBackendStrata.size(); i++)
 194                 {
 195                     uno::Reference< backenduno::XBackendEntities > xEntities( mBackendStrata[i], uno::UNO_QUERY );
 196                     if (xEntities.is()&& xEntities->supportsEntity(sDefaultEntity))
 197                     {
 198                         mBackendStrata.resize(i+1);
 199                         mOwnerEntity = sDefaultEntity;
 200                         break;
 201                     }
 202                 }
 203             }
 204             else
 205             {
 206                 mBackendStrata.resize(1);
 207             }
 208          }
 209
 210          if(mOwnerEntity.getLength()==0)
 211          {
 212              uno::Reference< backenduno::XBackendEntities > xEntities(
 213                  mBackendStrata[mBackendStrata.size()-1], uno::UNO_QUERY );
 214              if (xEntities.is())
 215              {
 216                  mOwnerEntity = xEntities->getOwnerEntity();
 217              }
 218              else
 219              {
 220                  mOwnerEntity = kThisOwnerEntity;
 221              }
 222          }
 223          mStrataListener = new BackendStrataListener(*this);
 224
 225     }
 226     catch(uno::Exception& )
 227     {
 228         mSchemaSupplier.clear();
 229         mBackendStrata.clear() ;
 230
 231         throw;
 232     }
 233
 234 }
 235 //------------------------------------------------------------------------------
 236 void  MultiStratumBackend::initializeSchemaSupplier(const uno::Reference<uno::XComponentContext>& aContext)
 237 {
 238
 239     rtl::OUString aServiceName;
 240
 241     aContext->getValueByName(kSchemaServiceParam) >>= aServiceName;
 242     uno::Sequence< uno::Any > aInitArgs( 1 );
 243     aInitArgs[0] <<= aContext;
 244     mSchemaSupplier = uno::Reference<backenduno::XSchemaSupplier>::query(mFactory->createInstanceWithArguments(aServiceName,aInitArgs)) ;
 245     if (!mSchemaSupplier.is())
 246     {
 247          throw backenduno::BackendSetupException(
 248                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 249                 "MultiStratumBackend: Could not create Schema Supplier service")),
 250                         *this, uno::Any()) ;
 251
 252     }
 253 }
 254 //------------------------------------------------------------------------------
 255 static
 256 bool approveRecovery(const backenduno::StratumCreationException & aError)
 257 {
 258     sal_uInt32 const k_supported_choices = apihelper::CONTINUATION_APPROVE ; //| apihelper::CONTINUATION_DISAPPROVE;
 259
 260     sal_uInt32 chosen = apihelper::CONTINUATION_UNKNOWN;
 261
 262     apihelper::ConfigurationInteractionHandler handler;
 263     try {
 264         uno::Reference< css::task::XInteractionHandler > h(handler.get());
 265         if (h.is()) {
 266             rtl::Reference< apihelper::SimpleInteractionRequest > req(
 267                 new apihelper::SimpleInteractionRequest(
 268                     uno::makeAny(aError), k_supported_choices));
 269             h->handle(req.get());
 270             chosen = req->getResponse();
 271         }
 272     } catch (uno::Exception & e) {
 273         OSL_TRACE("Warning - Configuration: Interaction handler failed: [%s]\n", OU2A(e.Message));
 274     }
 275
 276     switch (chosen)
 277     {
 278     case apihelper::CONTINUATION_APPROVE:      return true;
 279     case apihelper::CONTINUATION_DISAPPROVE:   return false;
 280     case apihelper::CONTINUATION_UNKNOWN:      break;
 281
 282     default: OSL_ENSURE(false,"Unsolicited continuation chosen"); break;
 283     }
 284     // no choice available - default: disapprove
 285     return false;
 286 }
 287 //------------------------------------------------------------------------------
 288 void MultiStratumBackend::initializeBackendStrata(const uno::Reference<uno::XComponentContext>& aContext)
 289 {
 290
 291     rtl::OUString sStrata;
 292     //Get Strata
 293     aContext->getValueByName(kStrataServiceParam) >>= sStrata;
 294     if(sStrata.getLength()==0)
 295     {
 296         throw backenduno::BackendSetupException(
 297                 rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 298                 "MultiStratumBackend: No Strata Services Specified")),
 299                         *this, uno::Any()) ;
 300
 301     }
 302
 303     //need to parse the Strata to extract service names and data location
 304     std::vector< std::pair<rtl::OUString, rtl::OUString> > aServiceInfoList;
 305     parseStrataInfo(sStrata,aServiceInfoList,*this);
 306
 307     for (std::vector< std::pair<rtl::OUString, rtl::OUString> >::const_iterator it = aServiceInfoList.begin(); it != aServiceInfoList.end(); ++it)
 308     {
 309         uno::Sequence< uno::Any > aInitArgs( 1 );
 310         rtl::OUString sServiceName = it->first;
 311         const rtl::OUString& sServiceData = it->second;
 312         aInitArgs[0] <<= sServiceData;
 313         uno::Reference <uno::XInterface> xBackend;
 314         bool bOptional = checkOptionalArg(sServiceName);
 315
 316         try
 317         {
 318             xBackend= mFactory->createInstanceWithArguments(sServiceName,aInitArgs);
 319         }
 320         catch (uno::Exception& exception)
 321         {
 322             if(!bOptional)
 323             {
 324                 static const sal_Char sErrContext[] = "MultiStratumBackend: Could not create Backend Stratum Service: ";
 325                 rtl::OUString const sContext(RTL_CONSTASCII_USTRINGPARAM(sErrContext));
 326                 rtl::OUString const sMessage = sContext.concat(exception.Message);
 327
 328                 backenduno::StratumCreationException error(sMessage,*this,
 329                                                             ::cppu::getCaughtException(),
 330                                                             sServiceName,sServiceData);
 331                 if (!approveRecovery(error))
 332                     throw error;
 333             }
 334
 335         }
 336         if (xBackend.is())
 337         {
 338             mBackendStrata.push_back(xBackend) ;
 339         }
 340     }
 341 }
 342 //---------------------------------------------------------------------------------------------
 343 // XBackendEntities
 344 rtl::OUString SAL_CALL
 345     MultiStratumBackend::getOwnerEntity(  )
 346         throw (uno::RuntimeException)
 347 {
 348
 349     if (checkOkState())
 350     {
 351         return mOwnerEntity;
 352     }
 353     return rtl::OUString();
 354 }
 355 //------------------------------------------------------------------------------
 356
 357 rtl::OUString SAL_CALL
 358     MultiStratumBackend::getAdminEntity()
 359         throw (uno::RuntimeException)
 360 {
 361     osl::MutexGuard aGuard(mMutex);
 362     if (checkOkState())
 363     {
 364         uno::Reference< backenduno::XBackendEntities > xEntities( mBackendStrata[0], uno::UNO_QUERY );
 365         if(xEntities.is())
 366         {
 367             return xEntities->getAdminEntity();
 368         }
 369         else
 370         {
 371             return rtl::OUString();
 372         }
 373     }
 374     return rtl::OUString();
 375 }
 376 //------------------------------------------------------------------------------
 377
 378 sal_Bool SAL_CALL
 379     MultiStratumBackend::supportsEntity( const rtl::OUString& aEntity )
 380     throw (backenduno::BackendAccessException, uno::RuntimeException)
 381 {
 382
 383     osl::MutexGuard aGuard(mMutex);
 384     if (checkOkState())
 385     {
 386         for (std::vector< uno::Reference <uno::XInterface> >::const_iterator it =  mBackendStrata.begin(); it !=  mBackendStrata.end(); ++it)
 387         {
 388             uno::Reference< backenduno::XBackendEntities > xEntities( *it, uno::UNO_QUERY );
 389             if (xEntities.is())
 390             {
 391                 if( xEntities->supportsEntity(aEntity))
 392                     return true;
 393             }
 394         }
 395         return false;
 396     }
 397     return false;
 398 }
 399 //------------------------------------------------------------------------------
 400
 401 sal_Bool SAL_CALL
 402     MultiStratumBackend::isEqualEntity( const rtl::OUString& aEntity, const rtl::OUString& aOtherEntity )
 403         throw (backenduno::BackendAccessException,
 404                 lang::IllegalArgumentException,
 405                 uno::RuntimeException)
 406 {
 407     osl::MutexGuard aGuard(mMutex);
 408     if (aEntity.getLength() == 0)
 409     {
 410         rtl::OUString const sMsg(RTL_CONSTASCII_USTRINGPARAM(
 411                 "LocalSingleBackend - Invalid empty entity."));
 412
 413         throw lang::IllegalArgumentException(sMsg, *this, 1);
 414     }
 415     if (aOtherEntity.getLength() == 0)
 416     {
 417         rtl::OUString const sMsg(RTL_CONSTASCII_USTRINGPARAM(
 418                 "LocalSingleBackend - Invalid empty entity."));
 419
 420         throw lang::IllegalArgumentException(sMsg, *this, 2);
 421     }
 422
 423
 424     if (aEntity.equals(aOtherEntity))
 425     {
 426         return true;
 427     }
 428
 429     if (checkOkState())
 430     {
 431         for (std::vector< uno::Reference <uno::XInterface> >::const_iterator it =  mBackendStrata.begin(); it !=  mBackendStrata.end(); ++it)
 432         {
 433             uno::Reference< backenduno::XBackendEntities > xEntities( *it, uno::UNO_QUERY );
 434             if (xEntities.is())
 435             {
 436                 if( xEntities->supportsEntity(aEntity))
 437                     return  xEntities->isEqualEntity(aEntity,aOtherEntity);
 438             }
 439         }
 440         return false;
 441     }
 442     return false;
 443 }
 444 //------------------------------------------------------------------------------
 445
 446 rtl::OUString SAL_CALL
 447     MultiStratumBackend::getSchemaVersion(const rtl::OUString& aComponent)
 448         throw (backenduno::BackendAccessException,
 449                 lang::IllegalArgumentException,
 450                 uno::RuntimeException)
 451 {
 452     osl::MutexGuard aGuard(mMutex);
 453
 454     if (checkOkState())
 455     {
 456         uno::Reference<backenduno::XVersionedSchemaSupplier> xVersionSupplier(mSchemaSupplier,uno::UNO_QUERY);
 457         if (xVersionSupplier.is())
 458             return xVersionSupplier->getSchemaVersion(aComponent) ;
 459     }
 460     return rtl::OUString();
 461 }
 462 //------------------------------------------------------------------------------
 463
 464 uno::Reference<backenduno::XSchema> SAL_CALL
 465     MultiStratumBackend::getComponentSchema(const rtl::OUString& aComponent)
 466         throw (backenduno::BackendAccessException,
 467                 lang::IllegalArgumentException,
 468                 uno::RuntimeException)
 469 {
 470     osl::MutexGuard aGuard(mMutex);
 471
 472     if (checkOkState())
 473     {
 474         return mSchemaSupplier->getComponentSchema(aComponent) ;
 475     }
 476     return NULL;
 477 }
 478 //------------------------------------------------------------------------------
 479
 480 uno::Sequence<uno::Reference<backenduno::XLayer> > SAL_CALL
 481     MultiStratumBackend::listOwnLayers(const rtl::OUString& aComponent)
 482         throw (backenduno::BackendAccessException,
 483                 lang::IllegalArgumentException,
 484                 uno::RuntimeException)
 485 {
 486     if (checkOkState())
 487     {
 488         return listLayers(aComponent, mOwnerEntity ) ;
 489     }
 490     return uno::Sequence<uno::Reference<backenduno::XLayer> >() ;
 491 }
 492 //------------------------------------------------------------------------------
 493
 494 uno::Reference<backenduno::XUpdateHandler> SAL_CALL
 495     MultiStratumBackend::getOwnUpdateHandler(const rtl::OUString& aComponent)
 496         throw (backenduno::BackendAccessException,
 497                 lang::NoSupportException,
 498                 lang::IllegalArgumentException,
 499                 uno::RuntimeException)
 500 {
 501     if (checkOkState())
 502     {
 503         return getUpdateHandler(aComponent, mOwnerEntity) ;
 504     }
 505     return NULL;
 506 }
 507 //------------------------------------------------------------------------------
 508
 509 uno::Sequence<uno::Reference<backenduno::XLayer> > SAL_CALL
 510     MultiStratumBackend::listLayers(const rtl::OUString& aComponent,
 511                                     const rtl::OUString& aEntity)
 512         throw (backenduno::BackendAccessException,
 513                 lang::IllegalArgumentException,
 514                 uno::RuntimeException)
 515 {
 516
 517     osl::MutexGuard aGuard(mMutex);
 518     if (checkOkState())
 519     {
 520         sal_Int32 nNumSupportedLayers = mBackendStrata.size();
 521         if(aEntity != mOwnerEntity)
 522         {
 523             nNumSupportedLayers = findSupportingStratum(aEntity);
 524         }
 525         return searchSupportingStrata(nNumSupportedLayers,aEntity,aComponent);
 526     }
 527     return uno::Sequence<uno::Reference<backenduno::XLayer> >();
 528 }
 529 //------------------------------------------------------------------------------
 530 sal_Int32 MultiStratumBackend::findSupportingStratum(const rtl::OUString& aEntity)
 531 {
 532     sal_Int32 nNumLayers = mBackendStrata.size();
 533     for (std::vector< uno::Reference <uno::XInterface> >::reverse_iterator it = mBackendStrata.rbegin(); it != mBackendStrata.rend(); ++it)
 534     {
 535         uno::Reference< backenduno::XBackendEntities > xEntities( *it, uno::UNO_QUERY );
 536         if (xEntities.is())
 537         {
 538             if( xEntities->supportsEntity(aEntity))
 539             {
 540                 return nNumLayers;
 541             }
 542         }
 543         nNumLayers--;
 544     }
 545     rtl::OUStringBuffer sMsg;
 546     sMsg.appendAscii("\n MultiStratumBackend: No Backend supports Entity: \"");
 547     sMsg.append(aEntity);
 548     throw lang::IllegalArgumentException(sMsg.makeStringAndClear(),
 549                                          *this, 0) ;
 550 }
 551 //------------------------------------------------------------------------------
 552 uno::Sequence<uno::Reference<backenduno::XLayer> >
 553     MultiStratumBackend::searchSupportingStrata(sal_Int32 nNumLayers,
 554                                                 rtl::OUString aEntity,
 555                                                 const rtl::OUString& aComponent)
 556 {
 557     uno::Sequence<uno::Reference<backenduno::XLayer> > aLayers;
 558     std::vector<uno::Reference<backenduno::XLayer> > aBackendLayers;
 559     for (sal_Int32 i = 0 ; i < nNumLayers ; ++ i)
 560     {
 561         uno::Sequence<uno::Reference<backenduno::XLayer> > aMultiLayers;
 562         uno::Reference< backenduno::XBackendEntities > xEntities(mBackendStrata[i], uno::UNO_QUERY );
 563
 564         uno::Reference<backenduno::XBackend> xBackend(mBackendStrata[i], uno::UNO_QUERY) ;
 565         if (xBackend.is())
 566         {
 567             if (xEntities.is())
 568             {
 569                 if( !xEntities->supportsEntity(aEntity))
 570                 {
 571                     aEntity = xEntities->getOwnerEntity();
 572                 }
 573                 aMultiLayers = xBackend->listLayers(aComponent, aEntity) ;
 574             }
 575             else
 576             {
 577                 aMultiLayers = xBackend->listOwnLayers(aComponent);
 578             }
 579         }
 580         else
 581         {
 582             uno::Reference<backenduno::XMultiLayerStratum> xMultiLayerStratum(
 583                     mBackendStrata[i], uno::UNO_QUERY) ;
 584
 585             if (xMultiLayerStratum.is())
 586             {
 587                 if (xEntities.is())
 588                 {
 589                     if( !xEntities->supportsEntity(aEntity))
 590                     {
 591                         aEntity = xEntities->getOwnerEntity();
 592                     }
 593                     aMultiLayers = xMultiLayerStratum->getLayers(
 594                         xMultiLayerStratum->listLayerIds(aComponent, aEntity),
 595                         rtl::OUString()) ;
 596
 597                 }
 598                 else
 599                 {
 600                      throw backenduno::BackendSetupException(
 601                         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 602                         "MultiStratumBackend: XMultiLayerStratum must support XBackendEntities")),
 603                         *this, uno::Any()) ;
 604                 }
 605
 606             }
 607             else
 608             {
 609                 uno::Reference<backenduno::XSingleLayerStratum> xSingleLayerStratum(
 610                     mBackendStrata[i], uno::UNO_REF_QUERY_THROW) ;
 611                 if (xSingleLayerStratum.is())
 612                 {
 613                     uno::Reference<backenduno::XLayer> xLayer = xSingleLayerStratum->getLayer( aComponent, rtl::OUString());
 614                     //Could be an empty layer
 615                     if (xLayer.is())
 616                     {
 617                         aBackendLayers.push_back(xLayer);
 618                     }
 619                 }
 620             }
 621         }
 622         // There might be non-existent layers in the list if there's no
 623         // actual data associated to a given layer id. Hence we have to
 624         // compress the list.
 625         for (sal_Int32 j = 0 ; j < aMultiLayers.getLength() ; ++j)
 626         {
 627             if (aMultiLayers [j].is())
 628             {
 629                 aBackendLayers.push_back( aMultiLayers[j]);
 630             }
 631         }
 632     }
 633     aLayers.realloc(aBackendLayers.size());
 634     for (sal_uInt32 k =0; k < aBackendLayers.size();k++)
 635     {
 636         aLayers[k] = aBackendLayers[k];
 637     }
 638     return aLayers;
 639 }
 640 //------------------------------------------------------------------------------
 641 uno::Reference<backenduno::XUpdateHandler> SAL_CALL
 642     MultiStratumBackend::getUpdateHandler(const rtl::OUString& aComponent,
 643                                           const rtl::OUString& aEntity)
 644         throw (backenduno::BackendAccessException,
 645                 lang::NoSupportException,
 646                 lang::IllegalArgumentException,
 647                 uno::RuntimeException)
 648 {
 649     osl::MutexGuard aGuard(mMutex);
 650
 651     if (checkOkState())
 652     {
 653
 654         sal_Int32 nNumSupportedLayers = mBackendStrata.size();
 655         rtl::OUString aUsedEntity;
 656
 657         if(aEntity != mOwnerEntity)
 658         {
 659             nNumSupportedLayers = findSupportingStratum(aEntity);
 660             aUsedEntity = aEntity;
 661         }
 662         else
 663         {
 664             uno::Reference< backenduno::XBackendEntities > xEntities( mBackendStrata[mBackendStrata.size()-1], uno::UNO_QUERY );
 665             if  (xEntities.is())
 666             {
 667                 aUsedEntity = xEntities->getOwnerEntity();
 668             }
 669         }
 670         sal_Int32 nStrataIndex = nNumSupportedLayers -1;
 671
 672         uno::Reference<backenduno::XBackend> xBackend(
 673            mBackendStrata[nStrataIndex], uno::UNO_QUERY) ;
 674            uno::Reference< uno::XInterface > xHandler;
 675         if(xBackend.is())
 676         {
 677             if (aUsedEntity.getLength()==0)
 678             {
 679                 xHandler = xBackend->getOwnUpdateHandler(aComponent) ;
 680                 return uno::Reference<backenduno::XUpdateHandler>(xHandler,uno::UNO_REF_QUERY_THROW);
 681             }
 682             else
 683             {
 684                 xHandler = xBackend->getUpdateHandler(aComponent, aUsedEntity) ;
 685                 return uno::Reference<backenduno::XUpdateHandler>(xHandler,uno::UNO_REF_QUERY_THROW);
 686             }
 687         }
 688         else
 689         {
 690
 691             uno::Sequence<uno::Any> arguments(1) ;
 692
 693             uno::Reference< backenduno::XMultiLayerStratum > xMultiLayerStratum
 694                 (mBackendStrata[nStrataIndex], uno::UNO_QUERY );
 695             if(xMultiLayerStratum.is())
 696             {
 697                 arguments [0] <<= xMultiLayerStratum->getUpdatableLayer(
 698                     xMultiLayerStratum->getUpdateLayerId(aComponent,aUsedEntity));
 699             }
 700             else
 701             {
 702                 uno::Reference< backenduno::XSingleLayerStratum > xSingleLayerStratum(
 703                     mBackendStrata[nStrataIndex], uno::UNO_REF_QUERY_THROW );
 704
 705                 arguments [0] <<= xSingleLayerStratum->getUpdatableLayer(aComponent);
 706
 707             }
 708
 709             if(!xHandler.is())
 710             {
 711                 try
 712                 {
 713                     const rtl::OUString kUpdateMerger(RTL_CONSTASCII_USTRINGPARAM(
 714                             "com.sun.star.configuration.backend.LayerUpdateMerger")) ;
 715
 716
 717                     if(!mFactory.is())
 718                     {
 719                         throw lang::DisposedException(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
 720                             "MultiStratumBackend: Service Factory already dispoed")),*this);
 721                     }
 722
 723                     xHandler = mFactory->createInstanceWithArguments(kUpdateMerger, arguments);
 724                 }
 725                 catch (uno::RuntimeException & )
 726                 {throw;}
 727                 catch (uno::Exception & e)
 728                 {
 729                     const rtl::OUString sMessage(RTL_CONSTASCII_USTRINGPARAM(
 730                             "Configuration MultiStratumBackend: Cannot create UpdateMerger - error message: ")) ;
 731                     throw uno::RuntimeException(sMessage.concat(e.Message),*this);
 732                 }
 733             }
 734             return uno::Reference<backenduno::XUpdateHandler>(xHandler, uno::UNO_REF_QUERY_THROW) ;
 735         }
 736     }
 737     return NULL;
 738 }
 739 // ---------------------------------------------------------------------------
 740 // ComponentHelper
 741 void SAL_CALL MultiStratumBackend::disposing()
 742 {
 743     osl::MutexGuard aGuard(mMutex);
 744     if (mFactory.is())
 745     {
 746         mFactory.clear();
 747     }
 748     if (mSchemaSupplier.is())
 749     {
 750         uno::Reference< lang::XComponent> xComp( mSchemaSupplier, uno::UNO_QUERY);
 751         if (xComp.is())
 752         {
 753             xComp->dispose();
 754         }
 755         if (mSchemaSupplier.is())
 756         {
 757             mSchemaSupplier.clear();
 758         }
 759     }
 760     if (!mBackendStrata.empty())
 761     {
 762         for (std::vector< uno::Reference <uno::XInterface> >::const_iterator it =  mBackendStrata.begin(); it !=  mBackendStrata.end(); ++it)
 763         {
 764             uno::Reference<  lang::XComponent> xComp( *it, uno::UNO_QUERY );
 765             if (xComp.is())
 766             {
 767                 try
 768                 {
 769                     xComp->dispose();
 770                 }
 771                 catch(uno::Exception &){}
 772             }
 773         }
 774         mBackendStrata.clear();
 775
 776     }
 777
 778  }
 779 //------------------------------------------------------------------------------
 780
 781 static const sal_Char * const kBackendService = "com.sun.star.configuration.backend.Backend" ;
 782
 783 static const sal_Char * const kImplementation =
 784                 "com.sun.star.comp.configuration.backend.MultiStratumBackend" ;
 785
 786 static sal_Char const * const kServiceNames [] =
 787 {
 788     kBackendService,
 789     0
 790 } ;
 791 static const ServiceImplementationInfo kServiceInfo =
 792 {
 793     kImplementation,
 794     kServiceNames,
 795     0
 796 } ;
 797
 798 const ServiceRegistrationInfo *getMultiStratumBackendServiceInfo()
 799 {
 800     return getRegistrationInfo(&kServiceInfo) ;
 801 }
 802
 803 uno::Reference<uno::XInterface> SAL_CALL
 804     instantiateMultiStratumBackend(const uno::Reference< uno::XComponentContext >& xContext)
 805 {
 806     return *new MultiStratumBackend(xContext) ;
 807 }
 808 //------------------------------------------------------------------------------
 809
 810 static const rtl::OUString kImplementationName(
 811                                 RTL_CONSTASCII_USTRINGPARAM(kImplementation)) ;
 812 //------------------------------------------------------------------------------
 813
 814 rtl::OUString SAL_CALL
 815     MultiStratumBackend::getImplementationName(void)
 816         throw (uno::RuntimeException)
 817 {
 818     return ServiceInfoHelper(&kServiceInfo).getImplementationName() ;
 819 }
 820 //------------------------------------------------------------------------------
 821
 822 sal_Bool SAL_CALL
 823     MultiStratumBackend::supportsService(const rtl::OUString& aServiceName)
 824         throw (uno::RuntimeException)
 825 {
 826     return  ServiceInfoHelper(&kServiceInfo).supportsService(aServiceName) ;
 827 }
 828 //------------------------------------------------------------------------------
 829 uno::Sequence<rtl::OUString> SAL_CALL
 830     MultiStratumBackend::getSupportedServiceNames(void)
 831         throw (uno::RuntimeException)
 832 {
 833     return ServiceInfoHelper(&kServiceInfo).getSupportedServiceNames() ;
 834 }
 835 //------------------------------------------------------------------------------
 836 void SAL_CALL MultiStratumBackend::addChangesListener( const uno::Reference<backenduno::XBackendChangesListener>& xListener,
 837                                                        const rtl::OUString& aComponent)
 838     throw (::com::sun::star::uno::RuntimeException)
 839 {
 840     osl::MutexGuard aGuard(mMutex);
 841     if(checkOkState())
 842     {
 843
 844         mListenerList.insert( ListenerList::value_type(aComponent, xListener));
 845         //Now register with lower layers
 846         for (sal_uInt32 i = 0 ; i < mBackendStrata.size()  ; ++ i)
 847         {
 848             uno::Reference<backenduno::XBackendChangesNotifier> xBackend(mBackendStrata[i], uno::UNO_QUERY) ;
 849             if (xBackend.is())
 850             {
 851                 xBackend->addChangesListener(mStrataListener, aComponent);
 852             }
 853         }
 854     }
 855 }
 856 //------------------------------------------------------------------------------
 857 void SAL_CALL MultiStratumBackend::removeChangesListener( const uno::Reference<backenduno::XBackendChangesListener>& /*xListner*/,
 858                                                           const rtl::OUString& aComponent)
 859     throw (::com::sun::star::uno::RuntimeException)
 860 {
 861     osl::MutexGuard aGuard(mMutex);
 862     if(checkOkState())
 863     {
 864         sal_Int32 nCount =  mListenerList.count(aComponent);
 865         if (nCount == 0)
 866         {
 867             OSL_TRACE("MultiStratumBackend: removeListener: no listener registered for component %s"
 868                       , aComponent.getStr());
 869         }
 870         else
 871         {
 872             ListenerList::iterator aIter;
 873             aIter = mListenerList.find(aComponent);
 874             mListenerList.erase(aIter);
 875             if (nCount == 1)
 876             {
 877                 //Deregister Listener from strata backend if they support notification
 878                 for (sal_uInt32 i = 0 ; i < mBackendStrata.size(); ++ i)
 879                 {
 880                     uno::Reference<backenduno::XBackendChangesNotifier> xBackend(mBackendStrata[i], uno::UNO_QUERY) ;
 881                     if (xBackend.is())
 882                     {
 883                         xBackend->removeChangesListener(mStrataListener, aComponent);
 884                     }
 885                 }
 886             }
 887         }
 888     }
 889 }
 890 //------------------------------------------------------------------------------
 891 void MultiStratumBackend::componentDataChanged(const backenduno::ComponentChangeEvent& aEvent)
 892     throw (::com::sun::star::uno::RuntimeException)
 893 {
 894      try
 895      {
 896          notifyListeners( aEvent);
 897
 898      }
 899      catch (uno::RuntimeException& ) { throw; }
 900      catch (uno::Exception& e)
 901      {
 902             throw lang::WrappedTargetRuntimeException(e.Message, *this, uno::makeAny(e));
 903      }
 904 }
 905 //------------------------------------------------------------------------------
 906 void MultiStratumBackend::disposing( lang::EventObject const & /*rSource*/ )
 907     throw (::com::sun::star::uno::RuntimeException)
 908 {}
 909 //------------------------------------------------------------------------------
 910 void MultiStratumBackend::notifyListeners(const backenduno::ComponentChangeEvent& aEvent)const
 911 {
 912     //fire off notification to all registered listeners for specific Component
 913     ListenerList::const_iterator aIter;
 914     rtl::OUString aComponentName = aEvent.Component;
 915     if (mListenerList.empty())
 916     {
 917         OSL_TRACE("MultiStratumBackend: notifyListeners: no listeners registered for component %s",
 918                    aComponentName.getStr());
 919     }
 920     else
 921     {
 922         aIter = mListenerList.begin();
 923         do{
 924             if (aIter->first == aComponentName)
 925             {
 926                 aIter->second->componentDataChanged(aEvent);
 927             }
 928             aIter++;
 929         }while (aIter != mListenerList.end());
 930     }
 931  }
 932 //------------------------------------------------------------------------------
 933 } } // configmgr.backend
 934