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