stoc/source/defaultregistry/defaultregistry.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <osl/mutex.hxx>
  21 #include <osl/diagnose.h>
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <cppuhelper/weak.hxx>
  24 #include <cppuhelper/implbase1.hxx>
  25 #include <cppuhelper/implbase4.hxx>
  26 #include <cppuhelper/implbase3.hxx>
  27 #include <cppuhelper/implementationentry.hxx>
  28 #include <cppuhelper/supportsservice.hxx>
  29 #include <registry/registry.hxx>
  30 #include <rtl/ref.hxx>
  31
  32 #include <com/sun/star/registry/XSimpleRegistry.hpp>
  33 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  34 #include <com/sun/star/lang/XServiceInfo.hpp>
  35 #include <com/sun/star/lang/XTypeProvider.hpp>
  36 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  37 #include <com/sun/star/lang/XInitialization.hpp>
  38 #include <com/sun/star/container/XEnumerationAccess.hpp>
  39
  40 using namespace css::uno;
  41 using namespace css::registry;
  42 using namespace css::lang;
  43 using namespace css::container;
  44 using namespace cppu;
  45 using namespace osl;
  46
  47 namespace {
  48
  49 class NestedKeyImpl;
  50
  51 class NestedRegistryImpl    : public WeakAggImplHelper4 < XSimpleRegistry, XInitialization, XServiceInfo, XEnumerationAccess >
  52 {
  53 public:
  54     NestedRegistryImpl( );
  55
  56     virtual ~NestedRegistryImpl();
  57
  58     // XServiceInfo
  59     virtual OUString SAL_CALL getImplementationName(  ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
  60     virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
  61     virtual Sequence< OUString > SAL_CALL getSupportedServiceNames(  ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
  62
  63     // XInitialization
  64     virtual void SAL_CALL initialize( const Sequence< Any >& aArguments )
  65         throw(Exception, RuntimeException, std::exception) SAL_OVERRIDE;
  66
  67     // XSimpleRegistry
  68     virtual OUString SAL_CALL getURL() throw(RuntimeException, std::exception) SAL_OVERRIDE;
  69     virtual void SAL_CALL open( const OUString& rURL, sal_Bool bReadOnly, sal_Bool bCreate ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
  70     virtual sal_Bool SAL_CALL isValid(  ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
  71     virtual void SAL_CALL close(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
  72     virtual void SAL_CALL destroy(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
  73     virtual Reference< XRegistryKey > SAL_CALL getRootKey(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
  74     virtual sal_Bool SAL_CALL isReadOnly(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
  75     virtual void SAL_CALL mergeKey( const OUString& aKeyName, const OUString& aUrl ) throw(InvalidRegistryException, MergeConflictException, RuntimeException, std::exception) SAL_OVERRIDE;
  76
  77     // XEnumerationAccess
  78     virtual Reference< XEnumeration > SAL_CALL createEnumeration(  ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
  79     virtual Type SAL_CALL getElementType(  ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
  80     virtual sal_Bool SAL_CALL hasElements(  ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
  81
  82     friend class NestedKeyImpl;
  83 protected:
  84     Mutex                       m_mutex;
  85     sal_uInt32                  m_state;
  86     Reference<XSimpleRegistry>  m_localReg;
  87     Reference<XSimpleRegistry>  m_defaultReg;
  88
  89 };
  90
  91
  92 // class NestedKeyImpl the implenetation of interface XRegistryKey
  93
  94 class NestedKeyImpl : public WeakImplHelper1< XRegistryKey >
  95 {
  96 public:
  97     NestedKeyImpl( NestedRegistryImpl* pDefaultRegistry,
  98                    Reference<XRegistryKey>& localKey,
  99                    Reference<XRegistryKey>& defaultKey);
 100
 101     NestedKeyImpl( const OUString& aKeyName,
 102                     NestedKeyImpl* pKey);
 103
 104     virtual ~NestedKeyImpl();
 105
 106     // XRegistryKey
 107     virtual OUString SAL_CALL getKeyName() throw(RuntimeException, std::exception) SAL_OVERRIDE;
 108     virtual sal_Bool SAL_CALL isReadOnly(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 109     virtual sal_Bool SAL_CALL isValid(  ) throw(RuntimeException, std::exception) SAL_OVERRIDE;
 110     virtual RegistryKeyType SAL_CALL getKeyType( const OUString& rKeyName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 111     virtual RegistryValueType SAL_CALL getValueType(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 112     virtual sal_Int32 SAL_CALL getLongValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 113     virtual void SAL_CALL setLongValue( sal_Int32 value ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 114     virtual Sequence< sal_Int32 > SAL_CALL getLongListValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 115     virtual void SAL_CALL setLongListValue( const css::uno::Sequence< sal_Int32 >& seqValue ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 116     virtual OUString SAL_CALL getAsciiValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 117     virtual void SAL_CALL setAsciiValue( const OUString& value ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 118     virtual Sequence< OUString > SAL_CALL getAsciiListValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 119     virtual void SAL_CALL setAsciiListValue( const css::uno::Sequence< OUString >& seqValue ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 120     virtual OUString SAL_CALL getStringValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 121     virtual void SAL_CALL setStringValue( const OUString& value ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 122     virtual Sequence< OUString > SAL_CALL getStringListValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 123     virtual void SAL_CALL setStringListValue( const css::uno::Sequence< OUString >& seqValue ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 124     virtual Sequence< sal_Int8 > SAL_CALL getBinaryValue(  ) throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception) SAL_OVERRIDE;
 125     virtual void SAL_CALL setBinaryValue( const css::uno::Sequence< sal_Int8 >& value ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 126     virtual Reference< XRegistryKey > SAL_CALL openKey( const OUString& aKeyName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 127     virtual Reference< XRegistryKey > SAL_CALL createKey( const OUString& aKeyName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 128     virtual void SAL_CALL closeKey(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 129     virtual void SAL_CALL deleteKey( const OUString& rKeyName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 130     virtual Sequence< Reference< XRegistryKey > > SAL_CALL openKeys(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 131     virtual Sequence< OUString > SAL_CALL getKeyNames(  ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 132     virtual sal_Bool SAL_CALL createLink( const OUString& aLinkName, const OUString& aLinkTarget ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 133     virtual void SAL_CALL deleteLink( const OUString& rLinkName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 134     virtual OUString SAL_CALL getLinkTarget( const OUString& rLinkName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 135     virtual OUString SAL_CALL getResolvedName( const OUString& aKeyName ) throw(InvalidRegistryException, RuntimeException, std::exception) SAL_OVERRIDE;
 136
 137 protected:
 138     void        computeChanges();
 139     OUString    computeName(const OUString& name);
 140
 141     OUString                    m_name;
 142     sal_uInt32                  m_state;
 143     NestedRegistryImpl*         m_pRegistry;
 144     Reference<XRegistryKey>     m_localKey;
 145     Reference<XRegistryKey>     m_defaultKey;
 146 };
 147
 148
 149
 150 NestedKeyImpl::NestedKeyImpl( NestedRegistryImpl* pDefaultRegistry,
 151                               Reference<XRegistryKey>& localKey,
 152                               Reference<XRegistryKey>& defaultKey )
 153     : m_pRegistry(pDefaultRegistry)
 154 {
 155     m_pRegistry->acquire();
 156
 157     m_localKey = localKey;
 158     m_defaultKey = defaultKey;
 159
 160     if (m_localKey.is())
 161     {
 162         m_name = m_localKey->getKeyName();
 163     }
 164     else if (m_defaultKey.is())
 165     {
 166         m_name = m_defaultKey->getKeyName();
 167     }
 168
 169     m_state = m_pRegistry->m_state;
 170 }
 171
 172
 173 NestedKeyImpl::NestedKeyImpl( const OUString& rKeyName,
 174                               NestedKeyImpl* pKey)
 175     : m_pRegistry(pKey->m_pRegistry)
 176 {
 177     m_pRegistry->acquire();
 178
 179     if (pKey->m_localKey.is() && pKey->m_localKey->isValid())
 180     {
 181         m_localKey = pKey->m_localKey->openKey(rKeyName);
 182     }
 183     if (pKey->m_defaultKey.is() && pKey->m_defaultKey->isValid())
 184     {
 185         m_defaultKey = pKey->m_defaultKey->openKey(rKeyName);
 186     }
 187
 188     if (m_localKey.is())
 189     {
 190         m_name = m_localKey->getKeyName();
 191     }
 192     else if (m_defaultKey.is())
 193     {
 194         m_name = m_defaultKey->getKeyName();
 195     }
 196
 197     m_state = m_pRegistry->m_state;
 198 }
 199
 200
 201 NestedKeyImpl::~NestedKeyImpl()
 202 {
 203     if ( m_pRegistry )
 204         m_pRegistry->release();
 205 }
 206
 207
 208 void NestedKeyImpl::computeChanges()
 209 {
 210     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 211     if ( m_state != m_pRegistry->m_state )
 212     {
 213         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 214
 215         Reference<XRegistryKey> tmpKey = rootKey->openKey(m_name);
 216
 217         if ( tmpKey.is() )
 218         {
 219             m_localKey = rootKey->openKey(m_name);
 220         }
 221
 222         m_state = m_pRegistry->m_state;
 223     }
 224 }
 225
 226
 227 // NestedKey_Impl::computeName()
 228
 229 OUString NestedKeyImpl::computeName(const OUString& name)
 230 {
 231     OUString resLocalName, resDefaultName;
 232
 233     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 234     try
 235     {
 236         if ( m_localKey.is() && m_localKey->isValid() )
 237         {
 238             resLocalName = m_localKey->getResolvedName(name);
 239         }
 240         else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 241         {
 242             return m_defaultKey->getResolvedName(name);
 243         }
 244
 245         if ( !resLocalName.isEmpty() && m_pRegistry->m_defaultReg->isValid() )
 246         {
 247             Reference<XRegistryKey> localRoot(m_pRegistry->m_localReg->getRootKey());
 248             Reference<XRegistryKey> defaultRoot(m_pRegistry->m_defaultReg->getRootKey());
 249
 250             resDefaultName = defaultRoot->getResolvedName(resLocalName);
 251
 252             sal_uInt32 count = 100;
 253
 254             while (resLocalName != resDefaultName && count > 0)
 255             {
 256                 count--;
 257
 258                 if (resLocalName.isEmpty() || resDefaultName.isEmpty())
 259                     throw InvalidRegistryException();
 260
 261                 resLocalName = localRoot->getResolvedName(resDefaultName);
 262                 resDefaultName = defaultRoot->getResolvedName(resLocalName);
 263             }
 264         }
 265     }
 266     catch(InvalidRegistryException& )
 267     {
 268     }
 269
 270     return resLocalName;
 271 }
 272
 273
 274 OUString SAL_CALL NestedKeyImpl::getKeyName() throw(RuntimeException, std::exception)
 275 {
 276     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 277     return m_name;
 278 }
 279
 280
 281 sal_Bool SAL_CALL NestedKeyImpl::isReadOnly(  )
 282     throw(InvalidRegistryException, RuntimeException, std::exception)
 283 {
 284     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 285     computeChanges();
 286
 287     if ( m_localKey.is() && m_localKey->isValid() )
 288            return m_localKey->isReadOnly();
 289     else
 290         throw InvalidRegistryException();
 291 }
 292
 293
 294 sal_Bool SAL_CALL NestedKeyImpl::isValid(  ) throw(RuntimeException, std::exception)
 295 {
 296     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 297     return ((m_localKey.is() && m_localKey->isValid()) ||
 298             (m_defaultKey.is() && m_defaultKey->isValid()) );
 299 }
 300
 301
 302 RegistryKeyType SAL_CALL NestedKeyImpl::getKeyType( const OUString& rKeyName )
 303     throw(InvalidRegistryException, RuntimeException, std::exception)
 304 {
 305     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 306     computeChanges();
 307
 308     if ( m_localKey.is() && m_localKey->isValid() )
 309     {
 310         return m_localKey->getKeyType(rKeyName);
 311     }
 312     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 313     {
 314         return m_defaultKey->getKeyType(rKeyName);
 315     }
 316
 317     return RegistryKeyType_KEY;
 318 }
 319
 320
 321 RegistryValueType SAL_CALL NestedKeyImpl::getValueType(  )
 322     throw(InvalidRegistryException, RuntimeException, std::exception)
 323 {
 324     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 325     computeChanges();
 326
 327     if ( m_localKey.is() && m_localKey->isValid() )
 328     {
 329         return m_localKey->getValueType();
 330     }
 331     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 332     {
 333         return m_defaultKey->getValueType();
 334     }
 335
 336     return RegistryValueType_NOT_DEFINED;
 337 }
 338
 339
 340 sal_Int32 SAL_CALL NestedKeyImpl::getLongValue(  )
 341     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 342 {
 343     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 344     computeChanges();
 345
 346     if ( m_localKey.is() && m_localKey->isValid() )
 347     {
 348         return m_localKey->getLongValue();
 349     }
 350     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 351     {
 352         return m_defaultKey->getLongValue();
 353     }
 354     else
 355     {
 356         throw InvalidRegistryException();
 357     }
 358 }
 359
 360
 361 void SAL_CALL NestedKeyImpl::setLongValue( sal_Int32 value )
 362     throw(InvalidRegistryException, RuntimeException, std::exception)
 363 {
 364     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 365     computeChanges();
 366
 367     if ( m_localKey.is() && m_localKey->isValid() )
 368     {
 369         m_localKey->setLongValue(value);
 370     }
 371     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 372     {
 373         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 374         m_localKey = rootKey->createKey(m_name);
 375         m_localKey->setLongValue(value);
 376         m_state = m_pRegistry->m_state++;
 377     }
 378     else
 379     {
 380         throw InvalidRegistryException();
 381     }
 382 }
 383
 384
 385 Sequence< sal_Int32 > SAL_CALL NestedKeyImpl::getLongListValue(  )
 386     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 387 {
 388     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 389     computeChanges();
 390
 391     if ( m_localKey.is() && m_localKey->isValid() )
 392     {
 393         return m_localKey->getLongListValue();
 394     }
 395     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 396     {
 397         return m_defaultKey->getLongListValue();
 398     }
 399     else
 400     {
 401         throw InvalidRegistryException();
 402     }
 403 }
 404
 405
 406 void SAL_CALL NestedKeyImpl::setLongListValue( const Sequence< sal_Int32 >& seqValue )
 407     throw(InvalidRegistryException, RuntimeException, std::exception)
 408 {
 409     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 410     computeChanges();
 411
 412     if ( m_localKey.is() && m_localKey->isValid() )
 413     {
 414         m_localKey->setLongListValue(seqValue);
 415     }
 416     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 417     {
 418         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 419         m_localKey = rootKey->createKey(m_name);
 420         m_localKey->setLongListValue(seqValue);
 421         m_state = m_pRegistry->m_state++;
 422     }
 423     else
 424     {
 425         throw InvalidRegistryException();
 426     }
 427 }
 428
 429
 430 OUString SAL_CALL NestedKeyImpl::getAsciiValue(  )
 431     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 432 {
 433     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 434     computeChanges();
 435
 436     if ( m_localKey.is() && m_localKey->isValid() )
 437     {
 438         return m_localKey->getAsciiValue();
 439     }
 440     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 441     {
 442         return m_defaultKey->getAsciiValue();
 443     }
 444     else
 445     {
 446         throw InvalidRegistryException();
 447     }
 448 }
 449
 450
 451 void SAL_CALL NestedKeyImpl::setAsciiValue( const OUString& value )
 452     throw(InvalidRegistryException, RuntimeException, std::exception)
 453 {
 454     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 455     computeChanges();
 456
 457     if ( m_localKey.is() && m_localKey->isValid() )
 458     {
 459         m_localKey->setAsciiValue(value);
 460     }
 461     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 462     {
 463         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 464         m_localKey = rootKey->createKey(m_name);
 465         m_localKey->setAsciiValue(value);
 466         m_state = m_pRegistry->m_state++;
 467     }
 468     else
 469     {
 470         throw InvalidRegistryException();
 471     }
 472 }
 473
 474
 475 Sequence< OUString > SAL_CALL NestedKeyImpl::getAsciiListValue(  )
 476     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 477 {
 478     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 479     computeChanges();
 480
 481     if ( m_localKey.is() && m_localKey->isValid() )
 482     {
 483         return m_localKey->getAsciiListValue();
 484     }
 485     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 486     {
 487         return m_defaultKey->getAsciiListValue();
 488     }
 489     else
 490     {
 491         throw InvalidRegistryException();
 492     }
 493 }
 494
 495
 496 void SAL_CALL NestedKeyImpl::setAsciiListValue( const Sequence< OUString >& seqValue )
 497     throw(InvalidRegistryException, RuntimeException, std::exception)
 498 {
 499     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 500     computeChanges();
 501
 502     if ( m_localKey.is() && m_localKey->isValid() )
 503     {
 504         m_localKey->setAsciiListValue(seqValue);
 505     }
 506     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 507     {
 508         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 509         m_localKey = rootKey->createKey(m_name);
 510         m_localKey->setAsciiListValue(seqValue);
 511         m_state = m_pRegistry->m_state++;
 512     }
 513     else
 514     {
 515         throw InvalidRegistryException();
 516     }
 517 }
 518
 519
 520 OUString SAL_CALL NestedKeyImpl::getStringValue(  )
 521     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 522 {
 523     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 524     computeChanges();
 525
 526     if ( m_localKey.is() && m_localKey->isValid() )
 527     {
 528         return m_localKey->getStringValue();
 529     }
 530     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 531     {
 532         return m_defaultKey->getStringValue();
 533     }
 534     else
 535     {
 536         throw InvalidRegistryException();
 537     }
 538 }
 539
 540
 541 void SAL_CALL NestedKeyImpl::setStringValue( const OUString& value )
 542     throw(InvalidRegistryException, RuntimeException, std::exception)
 543 {
 544     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 545     computeChanges();
 546
 547     if ( m_localKey.is() && m_localKey->isValid() )
 548     {
 549         m_localKey->setStringValue(value);
 550     }
 551     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 552     {
 553         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 554         m_localKey = rootKey->createKey(m_name);
 555         m_localKey->setStringValue(value);
 556         m_state = m_pRegistry->m_state++;
 557     }
 558     else
 559     {
 560         throw InvalidRegistryException();
 561     }
 562 }
 563
 564
 565 Sequence< OUString > SAL_CALL NestedKeyImpl::getStringListValue(  )
 566     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 567 {
 568     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 569     computeChanges();
 570
 571     if ( m_localKey.is() && m_localKey->isValid() )
 572     {
 573         return m_localKey->getStringListValue();
 574     }
 575     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 576     {
 577         return m_defaultKey->getStringListValue();
 578     }
 579     else
 580     {
 581         throw InvalidRegistryException();
 582     }
 583 }
 584
 585
 586 void SAL_CALL NestedKeyImpl::setStringListValue( const Sequence< OUString >& seqValue )
 587     throw(InvalidRegistryException, RuntimeException, std::exception)
 588 {
 589     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 590     computeChanges();
 591
 592     if ( m_localKey.is() && m_localKey->isValid() )
 593     {
 594         m_localKey->setStringListValue(seqValue);
 595     }
 596     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 597     {
 598         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 599         m_localKey = rootKey->createKey(m_name);
 600         m_localKey->setStringListValue(seqValue);
 601         m_state = m_pRegistry->m_state++;
 602     }
 603     else
 604     {
 605         throw InvalidRegistryException();
 606     }
 607 }
 608
 609
 610 Sequence< sal_Int8 > SAL_CALL NestedKeyImpl::getBinaryValue(  )
 611     throw(InvalidRegistryException, InvalidValueException, RuntimeException, std::exception)
 612 {
 613     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 614     computeChanges();
 615
 616     if ( m_localKey.is() && m_localKey->isValid() )
 617     {
 618         return m_localKey->getBinaryValue();
 619     }
 620     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 621     {
 622         return m_defaultKey->getBinaryValue();
 623     }
 624     else
 625     {
 626         throw InvalidRegistryException();
 627     }
 628 }
 629
 630
 631 void SAL_CALL NestedKeyImpl::setBinaryValue( const Sequence< sal_Int8 >& value )
 632     throw(InvalidRegistryException, RuntimeException, std::exception)
 633 {
 634     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 635     computeChanges();
 636
 637     if ( m_localKey.is() && m_localKey->isValid() )
 638     {
 639         m_localKey->setBinaryValue(value);
 640     }
 641     else if ( m_defaultKey.is() && m_defaultKey->isValid() )
 642     {
 643         Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 644         m_localKey = rootKey->createKey(m_name);
 645         m_localKey->setBinaryValue(value);
 646         m_state = m_pRegistry->m_state++;
 647     }
 648     else
 649     {
 650         throw InvalidRegistryException();
 651     }
 652 }
 653
 654
 655 Reference< XRegistryKey > SAL_CALL NestedKeyImpl::openKey( const OUString& aKeyName )
 656     throw(InvalidRegistryException, RuntimeException, std::exception)
 657 {
 658     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 659     if ( !m_localKey.is() && !m_defaultKey.is() )
 660     {
 661         throw InvalidRegistryException();
 662     }
 663
 664     OUString resolvedName = computeName(aKeyName);
 665
 666     if ( resolvedName.isEmpty() )
 667         throw InvalidRegistryException();
 668
 669     Reference<XRegistryKey> localKey, defaultKey;
 670
 671     if ( m_localKey.is() && m_localKey->isValid() )
 672     {
 673         localKey = m_pRegistry->m_localReg->getRootKey()->openKey(resolvedName);
 674     }
 675     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 676     {
 677         defaultKey = m_pRegistry->m_defaultReg->getRootKey()->openKey(resolvedName);
 678     }
 679
 680     if ( localKey.is() || defaultKey.is() )
 681     {
 682         return ((XRegistryKey*)new NestedKeyImpl(m_pRegistry, localKey, defaultKey));
 683     }
 684     else
 685     {
 686         return Reference<XRegistryKey>();
 687     }
 688 }
 689
 690
 691 Reference< XRegistryKey > SAL_CALL NestedKeyImpl::createKey( const OUString& aKeyName )
 692     throw(InvalidRegistryException, RuntimeException, std::exception)
 693 {
 694     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 695     if ( (!m_localKey.is() && !m_defaultKey.is()) ||
 696          (m_localKey.is() && m_localKey->isReadOnly()) )
 697     {
 698         throw InvalidRegistryException();
 699     }
 700
 701     OUString resolvedName = computeName(aKeyName);
 702
 703     if ( resolvedName.isEmpty() )
 704         throw InvalidRegistryException();
 705
 706     if ( m_localKey.is() && m_localKey->isValid() )
 707     {
 708         Reference<XRegistryKey> localKey, defaultKey;
 709
 710         localKey = m_pRegistry->m_localReg->getRootKey()->createKey(resolvedName);
 711         if ( localKey.is() )
 712         {
 713             if ( m_defaultKey.is() && m_defaultKey->isValid() )
 714             {
 715                 defaultKey = m_pRegistry->m_defaultReg->getRootKey()->openKey(resolvedName);
 716             }
 717
 718             m_state = m_pRegistry->m_state++;
 719
 720             return ((XRegistryKey*)new NestedKeyImpl(m_pRegistry, localKey, defaultKey));
 721         }
 722     }
 723     else
 724     {
 725         Reference<XRegistryKey> localKey, defaultKey;
 726
 727         if ( m_defaultKey.is() && m_defaultKey->isValid() )
 728         {
 729             Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 730             m_localKey = rootKey->createKey(m_name);
 731
 732             localKey = m_pRegistry->m_localReg->getRootKey()->createKey(resolvedName);
 733
 734             if ( localKey.is() )
 735             {
 736                 defaultKey = m_pRegistry->m_defaultReg->getRootKey()->openKey(resolvedName);
 737
 738                 m_state = m_pRegistry->m_state++;
 739
 740                 return ((XRegistryKey*)new NestedKeyImpl(m_pRegistry, localKey, defaultKey));
 741             }
 742         }
 743     }
 744
 745     return Reference<XRegistryKey>();
 746 }
 747
 748
 749 void SAL_CALL NestedKeyImpl::closeKey(  )
 750     throw(InvalidRegistryException, RuntimeException, std::exception)
 751 {
 752     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 753     if ( m_localKey.is() && m_localKey->isValid() )
 754     {
 755         m_localKey->closeKey();
 756     }
 757     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 758     {
 759         m_defaultKey->closeKey();
 760     }
 761 }
 762
 763
 764 void SAL_CALL NestedKeyImpl::deleteKey( const OUString& rKeyName )
 765     throw(InvalidRegistryException, RuntimeException, std::exception)
 766 {
 767     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 768     if ( m_localKey.is() && m_localKey->isValid() &&
 769          !m_localKey->isReadOnly() )
 770     {
 771         OUString resolvedName = computeName(rKeyName);
 772
 773         if ( resolvedName.isEmpty() )
 774         {
 775             throw InvalidRegistryException();
 776         }
 777
 778         m_pRegistry->m_localReg->getRootKey()->deleteKey(resolvedName);
 779     }
 780     else
 781     {
 782         throw InvalidRegistryException();
 783     }
 784 }
 785
 786
 787 Sequence< Reference< XRegistryKey > > SAL_CALL NestedKeyImpl::openKeys(  )
 788     throw(InvalidRegistryException, RuntimeException, std::exception)
 789 {
 790     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 791     if ( !m_localKey.is() && !m_defaultKey.is() )
 792     {
 793         throw InvalidRegistryException();
 794     }
 795
 796     Sequence<OUString> localSeq, defaultSeq;
 797
 798     if ( m_localKey.is() && m_localKey->isValid() )
 799     {
 800         localSeq = m_localKey->getKeyNames();
 801     }
 802     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 803     {
 804         defaultSeq = m_defaultKey->getKeyNames();
 805     }
 806
 807     sal_uInt32 local = localSeq.getLength();
 808     sal_uInt32 def = defaultSeq.getLength();
 809     sal_uInt32 len = 0;
 810
 811     sal_uInt32 i, j;
 812     for (i=0; i < local; i++)
 813     {
 814         for (j=0 ; j < def; j++)
 815         {
 816             if ( localSeq.getConstArray()[i] == defaultSeq.getConstArray()[j] )
 817             {
 818                 len++;
 819                 break;
 820             }
 821         }
 822     }
 823
 824     Sequence< Reference<XRegistryKey> > retSeq(local + def - len);
 825     OUString                            name;
 826     sal_Int32                           lastIndex;
 827
 828     for (i=0; i < local; i++)
 829     {
 830         name = localSeq.getConstArray()[i];
 831         lastIndex = name.lastIndexOf('/');
 832         name = name.copy(lastIndex);
 833         retSeq.getArray()[i] =
 834             (XRegistryKey*)new NestedKeyImpl(name, this);
 835     }
 836
 837     sal_uInt32 k = local;
 838     for (i=0; i < def; i++)
 839     {
 840         bool insert = true;
 841
 842         for (j=0 ; j < local; j++)
 843         {
 844             if ( retSeq.getConstArray()[j]->getKeyName()
 845                     == defaultSeq.getConstArray()[i] )
 846             {
 847                 insert = false;
 848                 break;
 849             }
 850         }
 851
 852         if ( insert )
 853         {
 854             name = defaultSeq.getConstArray()[i];
 855             lastIndex = name.lastIndexOf('/');
 856             name = name.copy(lastIndex);
 857             retSeq.getArray()[k++] =
 858                 (XRegistryKey*)new NestedKeyImpl(name, this);
 859         }
 860     }
 861
 862     return retSeq;
 863 }
 864
 865
 866 Sequence< OUString > SAL_CALL NestedKeyImpl::getKeyNames(  )
 867     throw(InvalidRegistryException, RuntimeException, std::exception)
 868 {
 869     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 870     if ( !m_localKey.is() && !m_defaultKey.is() )
 871     {
 872         throw InvalidRegistryException();
 873     }
 874
 875     Sequence<OUString> localSeq, defaultSeq;
 876
 877     if ( m_localKey.is() && m_localKey->isValid() )
 878     {
 879         localSeq = m_localKey->getKeyNames();
 880     }
 881     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 882     {
 883         defaultSeq = m_defaultKey->getKeyNames();
 884     }
 885
 886     sal_uInt32 local = localSeq.getLength();
 887     sal_uInt32 def = defaultSeq.getLength();
 888     sal_uInt32 len = 0;
 889
 890     sal_uInt32 i, j;
 891     for (i=0; i < local; i++)
 892     {
 893         for (j=0 ; j < def; j++)
 894         {
 895             if ( localSeq.getConstArray()[i] == defaultSeq.getConstArray()[j] )
 896             {
 897                 len++;
 898                 break;
 899             }
 900         }
 901     }
 902
 903     Sequence<OUString>  retSeq(local + def - len);
 904
 905     for (i=0; i < local; i++)
 906     {
 907         retSeq.getArray()[i] = localSeq.getConstArray()[i];
 908     }
 909
 910     sal_uInt32 k = local;
 911     for (i=0; i < def; i++)
 912     {
 913         bool insert = true;
 914
 915         for (j=0 ; j < local; j++)
 916         {
 917             if ( retSeq.getConstArray()[j] == defaultSeq.getConstArray()[i] )
 918             {
 919                 insert = false;
 920                 break;
 921             }
 922         }
 923
 924         if ( insert )
 925             retSeq.getArray()[k++] = defaultSeq.getConstArray()[i];
 926     }
 927
 928     return retSeq;
 929 }
 930
 931
 932 sal_Bool SAL_CALL NestedKeyImpl::createLink( const OUString& aLinkName, const OUString& aLinkTarget )
 933     throw(InvalidRegistryException, RuntimeException, std::exception)
 934 {
 935     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 936
 937     bool isCreated = false;
 938     if ( !m_localKey.is() && !m_defaultKey.is() )
 939     {
 940         throw InvalidRegistryException();
 941     }
 942
 943     OUString    linkName;
 944     OUString    resolvedName;
 945     sal_Int32   lastIndex = aLinkName.lastIndexOf('/');
 946
 947     if ( lastIndex > 0 )
 948     {
 949         linkName = aLinkName.copy(0, lastIndex);
 950
 951         resolvedName = computeName(linkName);
 952
 953         if ( resolvedName.isEmpty() )
 954         {
 955             throw InvalidRegistryException();
 956         }
 957
 958         resolvedName = resolvedName + aLinkName.copy(lastIndex);
 959     }
 960     else
 961     {
 962         if ( lastIndex == 0 )
 963             resolvedName = m_name + aLinkName;
 964         else
 965             resolvedName = m_name + "/" + aLinkName;
 966     }
 967
 968     if ( m_localKey.is() && m_localKey->isValid() )
 969     {
 970         isCreated = m_pRegistry->m_localReg->getRootKey()->createLink(resolvedName, aLinkTarget);
 971     }
 972     else
 973     {
 974         if ( m_defaultKey.is() && m_defaultKey->isValid() )
 975         {
 976             Reference<XRegistryKey> rootKey(m_pRegistry->m_localReg->getRootKey());
 977             m_localKey = rootKey->createKey(m_name);
 978
 979             isCreated = m_pRegistry->m_localReg->getRootKey()->createLink(resolvedName, aLinkTarget);
 980         }
 981     }
 982
 983     if ( isCreated )
 984         m_state = m_pRegistry->m_state++;
 985
 986     return isCreated;
 987 }
 988
 989
 990 void SAL_CALL NestedKeyImpl::deleteLink( const OUString& rLinkName )
 991     throw(InvalidRegistryException, RuntimeException, std::exception)
 992 {
 993     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
 994     if ( !m_localKey.is() && !m_defaultKey.is() )
 995     {
 996         throw InvalidRegistryException();
 997     }
 998
 999     OUString    linkName;
1000     OUString    resolvedName;
1001     sal_Int32   lastIndex = rLinkName.lastIndexOf('/');
1002
1003     if ( lastIndex > 0 )
1004     {
1005         linkName = rLinkName.copy(0, lastIndex);
1006
1007         resolvedName = computeName(linkName);
1008
1009         if ( resolvedName.isEmpty() )
1010         {
1011             throw InvalidRegistryException();
1012         }
1013
1014         resolvedName = resolvedName + rLinkName.copy(lastIndex);
1015     }
1016     else
1017     {
1018         if ( lastIndex == 0 )
1019             resolvedName = m_name + rLinkName;
1020         else
1021             resolvedName = m_name + "/" + rLinkName;
1022     }
1023
1024     if ( m_localKey.is() && m_localKey->isValid() &&
1025          !m_localKey->isReadOnly() )
1026     {
1027         m_pRegistry->m_localReg->getRootKey()->deleteLink(resolvedName);
1028     }
1029     else
1030     {
1031         throw InvalidRegistryException();
1032     }
1033 }
1034
1035
1036 OUString SAL_CALL NestedKeyImpl::getLinkTarget( const OUString& rLinkName )
1037     throw(InvalidRegistryException, RuntimeException, std::exception)
1038 {
1039     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
1040     if ( !m_localKey.is() && !m_defaultKey.is() )
1041     {
1042         throw InvalidRegistryException();
1043     }
1044
1045     OUString    linkName;
1046     OUString    resolvedName;
1047     sal_Int32   lastIndex = rLinkName.lastIndexOf('/');
1048
1049     if ( lastIndex > 0 )
1050     {
1051         linkName = rLinkName.copy(0, lastIndex);
1052
1053         resolvedName = computeName(linkName);
1054
1055         if ( resolvedName.isEmpty() )
1056         {
1057             throw InvalidRegistryException();
1058         }
1059
1060         resolvedName = resolvedName + rLinkName.copy(lastIndex);
1061     }
1062     else
1063     {
1064         if ( lastIndex == 0 )
1065             resolvedName = m_name + rLinkName;
1066         else
1067             resolvedName = m_name + "/" + rLinkName;
1068     }
1069
1070     OUString linkTarget;
1071     if ( m_localKey.is() && m_localKey->isValid() )
1072     {
1073         try
1074         {
1075             linkTarget = m_pRegistry->m_localReg->getRootKey()->getLinkTarget(resolvedName);
1076             return linkTarget;
1077         }
1078         catch(InvalidRegistryException& )
1079         {
1080         }
1081     }
1082
1083     if ( m_defaultKey.is() && m_defaultKey->isValid() )
1084         linkTarget = m_pRegistry->m_defaultReg->getRootKey()->getLinkTarget(resolvedName);
1085
1086     return linkTarget;
1087 }
1088
1089
1090 OUString SAL_CALL NestedKeyImpl::getResolvedName( const OUString& aKeyName )
1091     throw(InvalidRegistryException, RuntimeException, std::exception)
1092 {
1093     Guard< Mutex > aGuard( m_pRegistry->m_mutex );
1094     if ( !m_localKey.is() && !m_defaultKey.is() )
1095     {
1096         throw InvalidRegistryException();
1097     }
1098
1099     OUString resolvedName = computeName(aKeyName);
1100
1101     if ( resolvedName.isEmpty() )
1102     {
1103         throw InvalidRegistryException();
1104     }
1105
1106     return resolvedName;
1107 }
1108
1109
1110
1111 // DefaultRegistry Implementation
1112
1113
1114 NestedRegistryImpl::NestedRegistryImpl( )
1115     : m_state(0)
1116 {}
1117
1118
1119 NestedRegistryImpl::~NestedRegistryImpl() {}
1120
1121 class RegistryEnumueration : public WeakImplHelper1< XEnumeration >
1122 {
1123 public:
1124     RegistryEnumueration(
1125         const Reference< XSimpleRegistry > &r1,
1126         const Reference< XSimpleRegistry > &r2 )
1127         : m_xReg1( r1 ) , m_xReg2( r2 )
1128         {}
1129 public:
1130     virtual sal_Bool SAL_CALL hasMoreElements(  ) throw (RuntimeException, std::exception) SAL_OVERRIDE;
1131     virtual Any SAL_CALL nextElement(  ) throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
1132
1133 private:
1134     Reference< XSimpleRegistry > m_xReg1;
1135     Reference< XSimpleRegistry > m_xReg2;
1136 };
1137
1138 sal_Bool RegistryEnumueration::hasMoreElements(  ) throw (RuntimeException, std::exception)
1139 {
1140     return m_xReg1.is() || m_xReg2.is();
1141 }
1142
1143 Any RegistryEnumueration::nextElement(  )
1144     throw (NoSuchElementException, WrappedTargetException, RuntimeException, std::exception)
1145 {
1146     Any a;
1147     if( m_xReg1.is() )
1148     {
1149         a <<= m_xReg1;
1150         m_xReg1.clear();
1151     }
1152     else if( m_xReg2.is() )
1153     {
1154         a <<= m_xReg2;
1155         m_xReg2.clear();
1156     }
1157     else
1158     {
1159         throw NoSuchElementException( "NestedRegistry: no nextElement() !" );
1160     }
1161     return a;
1162 }
1163
1164
1165 Reference< XEnumeration > NestedRegistryImpl::createEnumeration(  ) throw (RuntimeException, std::exception)
1166 {
1167     MutexGuard guard( m_mutex );
1168     return new RegistryEnumueration( m_localReg, m_defaultReg );
1169 }
1170
1171 Type NestedRegistryImpl::getElementType(  ) throw (RuntimeException, std::exception)
1172 {
1173     return cppu::UnoType<decltype(m_localReg)>::get();
1174 }
1175
1176 sal_Bool SAL_CALL NestedRegistryImpl::hasElements(  ) throw (RuntimeException, std::exception)
1177 {
1178     MutexGuard guard( m_mutex );
1179     return m_localReg.is() || m_defaultReg.is();
1180 }
1181
1182
1183
1184
1185 OUString SAL_CALL NestedRegistryImpl::getImplementationName(  )
1186     throw(RuntimeException, std::exception)
1187 {
1188     return OUString("com.sun.star.comp.stoc.NestedRegistry");
1189 }
1190
1191 sal_Bool SAL_CALL NestedRegistryImpl::supportsService( const OUString& ServiceName )
1192     throw(RuntimeException, std::exception)
1193 {
1194     return cppu::supportsService(this, ServiceName);
1195 }
1196
1197 Sequence<OUString> SAL_CALL NestedRegistryImpl::getSupportedServiceNames(  )
1198     throw(RuntimeException, std::exception)
1199 {
1200     Sequence< OUString > seqNames(1);
1201     seqNames[0] = "com.sun.star.registry.NestedRegistry";
1202     return seqNames;
1203 }
1204
1205
1206 void SAL_CALL NestedRegistryImpl::initialize( const Sequence< Any >& aArguments )
1207     throw( Exception, RuntimeException, std::exception )
1208 {
1209     Guard< Mutex > aGuard( m_mutex );
1210     if ( (aArguments.getLength() == 2) &&
1211          (aArguments[0].getValueType().getTypeClass() == TypeClass_INTERFACE) &&
1212          (aArguments[1].getValueType().getTypeClass() == TypeClass_INTERFACE) )
1213     {
1214         aArguments[0] >>= m_localReg;
1215         aArguments[1] >>= m_defaultReg;
1216         if ( m_localReg == m_defaultReg )
1217             m_defaultReg.clear();
1218     }
1219 }
1220
1221
1222 OUString SAL_CALL NestedRegistryImpl::getURL() throw(RuntimeException, std::exception)
1223 {
1224     Guard< Mutex > aGuard( m_mutex );
1225     try
1226     {
1227         if ( m_localReg.is() && m_localReg->isValid() )
1228             return m_localReg->getURL();
1229     }
1230     catch(InvalidRegistryException& )
1231     {
1232     }
1233
1234     return OUString();
1235 }
1236
1237
1238 void SAL_CALL NestedRegistryImpl::open( const OUString&, sal_Bool, sal_Bool )
1239     throw(InvalidRegistryException, RuntimeException, std::exception)
1240 {
1241     throw InvalidRegistryException(
1242             "the 'open' method is not specified for a nested registry" );
1243 }
1244
1245
1246 sal_Bool SAL_CALL NestedRegistryImpl::isValid(  ) throw(RuntimeException, std::exception)
1247 {
1248     Guard< Mutex > aGuard( m_mutex );
1249     try
1250     {
1251         if ( (m_localReg.is() && m_localReg->isValid()) ||
1252              (m_defaultReg.is() && m_defaultReg->isValid()) )
1253             return sal_True;
1254     }
1255     catch(InvalidRegistryException& )
1256     {
1257     }
1258
1259     return sal_False;
1260 }
1261
1262
1263 void SAL_CALL NestedRegistryImpl::close(  )
1264     throw(InvalidRegistryException, RuntimeException, std::exception)
1265 {
1266     Guard< Mutex > aGuard( m_mutex );
1267     if ( m_localReg.is() && m_localReg->isValid() )
1268     {
1269         m_localReg->close();
1270     }
1271     if ( m_defaultReg.is() && m_defaultReg->isValid() )
1272     {
1273         m_defaultReg->close();
1274     }
1275 }
1276
1277
1278 void SAL_CALL NestedRegistryImpl::destroy(  )
1279     throw(InvalidRegistryException, RuntimeException, std::exception)
1280 {
1281     throw InvalidRegistryException(
1282             "the 'destroy' method is not specified for a nested registry" );
1283 }
1284
1285
1286 Reference< XRegistryKey > SAL_CALL NestedRegistryImpl::getRootKey(  )
1287     throw(InvalidRegistryException, RuntimeException, std::exception)
1288 {
1289     Reference<XRegistryKey> tmpKey;
1290
1291     Guard< Mutex > aGuard( m_mutex );
1292     if ( m_localReg.is() && m_localReg->isValid() )
1293     {
1294         Reference<XRegistryKey> localKey, defaultKey;
1295
1296         localKey = m_localReg->getRootKey();
1297
1298         if ( localKey.is() )
1299         {
1300             if ( m_defaultReg.is() && m_defaultReg->isValid() )
1301             {
1302                 defaultKey = m_defaultReg->getRootKey();
1303             }
1304
1305             return ((XRegistryKey*)new NestedKeyImpl(this, localKey, defaultKey));
1306         }
1307     }
1308     else
1309     {
1310         throw InvalidRegistryException();
1311     }
1312
1313     return Reference<XRegistryKey>();
1314 }
1315
1316
1317 sal_Bool SAL_CALL NestedRegistryImpl::isReadOnly(  )
1318     throw(InvalidRegistryException, RuntimeException, std::exception)
1319 {
1320     Guard< Mutex > aGuard( m_mutex );
1321     try
1322     {
1323         if ( m_localReg.is() && m_localReg->isValid() )
1324             return m_localReg->isReadOnly();
1325     }
1326     catch(InvalidRegistryException& )
1327     {
1328     }
1329
1330     return sal_False;
1331 }
1332
1333
1334 void SAL_CALL NestedRegistryImpl::mergeKey( const OUString& aKeyName, const OUString& aUrl )
1335     throw(InvalidRegistryException, MergeConflictException, RuntimeException, std::exception)
1336 {
1337     Guard< Mutex > aGuard( m_mutex );
1338     if ( m_localReg.is() && m_localReg->isValid() )
1339     {
1340         m_localReg->mergeKey(aKeyName, aUrl);
1341
1342         m_state++;
1343     }
1344 }
1345
1346 } // namespace
1347
1348 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * SAL_CALL
1349 com_sun_star_comp_stoc_NestedRegistry_get_implementation(
1350     SAL_UNUSED_PARAMETER css::uno::XComponentContext *,
1351     css::uno::Sequence<css::uno::Any> const &)
1352 {
1353     return cppu::acquire(new NestedRegistryImpl);
1354 }
1355
1356 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */