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         throw InvalidRegistryException();
 268
 269    return m_localKey->isReadOnly();
 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         throw InvalidRegistryException();
 731     }
 732
 733     OUString resolvedName = computeName(rKeyName);
 734
 735     if ( resolvedName.isEmpty() )
 736     {
 737         throw InvalidRegistryException();
 738     }
 739
 740     m_xRegistry->m_localReg->getRootKey()->deleteKey(resolvedName);
 741 }
 742
 743
 744 Sequence< Reference< XRegistryKey > > SAL_CALL NestedKeyImpl::openKeys(  )
 745 {
 746     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
 747     if ( !m_localKey.is() && !m_defaultKey.is() )
 748     {
 749         throw InvalidRegistryException();
 750     }
 751
 752     Sequence<OUString> localSeq, defaultSeq;
 753
 754     if ( m_localKey.is() && m_localKey->isValid() )
 755     {
 756         localSeq = m_localKey->getKeyNames();
 757     }
 758     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 759     {
 760         defaultSeq = m_defaultKey->getKeyNames();
 761     }
 762
 763     sal_uInt32 local = localSeq.getLength();
 764     sal_uInt32 def = defaultSeq.getLength();
 765     sal_uInt32 len = 0;
 766
 767     sal_uInt32 i, j;
 768     for (i=0; i < local; i++)
 769     {
 770         for (j=0 ; j < def; j++)
 771         {
 772             if ( localSeq.getConstArray()[i] == defaultSeq.getConstArray()[j] )
 773             {
 774                 len++;
 775                 break;
 776             }
 777         }
 778     }
 779
 780     Sequence< Reference<XRegistryKey> > retSeq(local + def - len);
 781     OUString                            name;
 782     sal_Int32                           lastIndex;
 783
 784     for (i=0; i < local; i++)
 785     {
 786         name = localSeq.getConstArray()[i];
 787         lastIndex = name.lastIndexOf('/');
 788         name = name.copy(lastIndex);
 789         retSeq.getArray()[i] =
 790             static_cast<XRegistryKey*>(new NestedKeyImpl(name, this));
 791     }
 792
 793     sal_uInt32 k = local;
 794     for (i=0; i < def; i++)
 795     {
 796         bool insert = true;
 797
 798         for (j=0 ; j < local; j++)
 799         {
 800             if ( retSeq.getConstArray()[j]->getKeyName()
 801                     == defaultSeq.getConstArray()[i] )
 802             {
 803                 insert = false;
 804                 break;
 805             }
 806         }
 807
 808         if ( insert )
 809         {
 810             name = defaultSeq.getConstArray()[i];
 811             lastIndex = name.lastIndexOf('/');
 812             name = name.copy(lastIndex);
 813             retSeq.getArray()[k++] =
 814                 static_cast<XRegistryKey*>(new NestedKeyImpl(name, this));
 815         }
 816     }
 817
 818     return retSeq;
 819 }
 820
 821
 822 Sequence< OUString > SAL_CALL NestedKeyImpl::getKeyNames(  )
 823 {
 824     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
 825     if ( !m_localKey.is() && !m_defaultKey.is() )
 826     {
 827         throw InvalidRegistryException();
 828     }
 829
 830     Sequence<OUString> localSeq, defaultSeq;
 831
 832     if ( m_localKey.is() && m_localKey->isValid() )
 833     {
 834         localSeq = m_localKey->getKeyNames();
 835     }
 836     if ( m_defaultKey.is() && m_defaultKey->isValid() )
 837     {
 838         defaultSeq = m_defaultKey->getKeyNames();
 839     }
 840
 841     sal_uInt32 local = localSeq.getLength();
 842     sal_uInt32 def = defaultSeq.getLength();
 843     sal_uInt32 len = 0;
 844
 845     sal_uInt32 i, j;
 846     for (i=0; i < local; i++)
 847     {
 848         for (j=0 ; j < def; j++)
 849         {
 850             if ( localSeq.getConstArray()[i] == defaultSeq.getConstArray()[j] )
 851             {
 852                 len++;
 853                 break;
 854             }
 855         }
 856     }
 857
 858     Sequence<OUString>  retSeq(local + def - len);
 859
 860     for (i=0; i < local; i++)
 861     {
 862         retSeq.getArray()[i] = localSeq.getConstArray()[i];
 863     }
 864
 865     sal_uInt32 k = local;
 866     for (i=0; i < def; i++)
 867     {
 868         bool insert = true;
 869
 870         for (j=0 ; j < local; j++)
 871         {
 872             if ( retSeq.getConstArray()[j] == defaultSeq.getConstArray()[i] )
 873             {
 874                 insert = false;
 875                 break;
 876             }
 877         }
 878
 879         if ( insert )
 880             retSeq.getArray()[k++] = defaultSeq.getConstArray()[i];
 881     }
 882
 883     return retSeq;
 884 }
 885
 886
 887 sal_Bool SAL_CALL NestedKeyImpl::createLink( const OUString& aLinkName, const OUString& aLinkTarget )
 888 {
 889     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
 890
 891     bool isCreated = false;
 892     if ( !m_localKey.is() && !m_defaultKey.is() )
 893     {
 894         throw InvalidRegistryException();
 895     }
 896
 897     OUString    linkName;
 898     OUString    resolvedName;
 899     sal_Int32   lastIndex = aLinkName.lastIndexOf('/');
 900
 901     if ( lastIndex > 0 )
 902     {
 903         linkName = aLinkName.copy(0, lastIndex);
 904
 905         resolvedName = computeName(linkName);
 906
 907         if ( resolvedName.isEmpty() )
 908         {
 909             throw InvalidRegistryException();
 910         }
 911
 912         resolvedName = resolvedName + aLinkName.copy(lastIndex);
 913     }
 914     else
 915     {
 916         if ( lastIndex == 0 )
 917             resolvedName = m_name + aLinkName;
 918         else
 919             resolvedName = m_name + "/" + aLinkName;
 920     }
 921
 922     if ( m_localKey.is() && m_localKey->isValid() )
 923     {
 924         isCreated = m_xRegistry->m_localReg->getRootKey()->createLink(resolvedName, aLinkTarget);
 925     }
 926     else
 927     {
 928         if ( m_defaultKey.is() && m_defaultKey->isValid() )
 929         {
 930             Reference<XRegistryKey> rootKey(m_xRegistry->m_localReg->getRootKey());
 931             m_localKey = rootKey->createKey(m_name);
 932
 933             isCreated = m_xRegistry->m_localReg->getRootKey()->createLink(resolvedName, aLinkTarget);
 934         }
 935     }
 936
 937     if ( isCreated )
 938         m_state = m_xRegistry->m_state++;
 939
 940     return isCreated;
 941 }
 942
 943
 944 void SAL_CALL NestedKeyImpl::deleteLink( const OUString& rLinkName )
 945 {
 946     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
 947     if ( !m_localKey.is() && !m_defaultKey.is() )
 948     {
 949         throw InvalidRegistryException();
 950     }
 951
 952     OUString    linkName;
 953     OUString    resolvedName;
 954     sal_Int32   lastIndex = rLinkName.lastIndexOf('/');
 955
 956     if ( lastIndex > 0 )
 957     {
 958         linkName = rLinkName.copy(0, lastIndex);
 959
 960         resolvedName = computeName(linkName);
 961
 962         if ( resolvedName.isEmpty() )
 963         {
 964             throw InvalidRegistryException();
 965         }
 966
 967         resolvedName = resolvedName + rLinkName.copy(lastIndex);
 968     }
 969     else
 970     {
 971         if ( lastIndex == 0 )
 972             resolvedName = m_name + rLinkName;
 973         else
 974             resolvedName = m_name + "/" + rLinkName;
 975     }
 976
 977     if ( !m_localKey.is() || !m_localKey->isValid() ||
 978          m_localKey->isReadOnly() )
 979     {
 980         throw InvalidRegistryException();
 981     }
 982
 983     m_xRegistry->m_localReg->getRootKey()->deleteLink(resolvedName);
 984 }
 985
 986
 987 OUString SAL_CALL NestedKeyImpl::getLinkTarget( const OUString& rLinkName )
 988 {
 989     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
 990     if ( !m_localKey.is() && !m_defaultKey.is() )
 991     {
 992         throw InvalidRegistryException();
 993     }
 994
 995     OUString    linkName;
 996     OUString    resolvedName;
 997     sal_Int32   lastIndex = rLinkName.lastIndexOf('/');
 998
 999     if ( lastIndex > 0 )
1000     {
1001         linkName = rLinkName.copy(0, lastIndex);
1002
1003         resolvedName = computeName(linkName);
1004
1005         if ( resolvedName.isEmpty() )
1006         {
1007             throw InvalidRegistryException();
1008         }
1009
1010         resolvedName = resolvedName + rLinkName.copy(lastIndex);
1011     }
1012     else
1013     {
1014         if ( lastIndex == 0 )
1015             resolvedName = m_name + rLinkName;
1016         else
1017             resolvedName = m_name + "/" + rLinkName;
1018     }
1019
1020     OUString linkTarget;
1021     if ( m_localKey.is() && m_localKey->isValid() )
1022     {
1023         try
1024         {
1025             linkTarget = m_xRegistry->m_localReg->getRootKey()->getLinkTarget(resolvedName);
1026             return linkTarget;
1027         }
1028         catch(InvalidRegistryException& )
1029         {
1030         }
1031     }
1032
1033     if ( m_defaultKey.is() && m_defaultKey->isValid() )
1034         linkTarget = m_xRegistry->m_defaultReg->getRootKey()->getLinkTarget(resolvedName);
1035
1036     return linkTarget;
1037 }
1038
1039
1040 OUString SAL_CALL NestedKeyImpl::getResolvedName( const OUString& aKeyName )
1041 {
1042     Guard< Mutex > aGuard( m_xRegistry->m_mutex );
1043     if ( !m_localKey.is() && !m_defaultKey.is() )
1044     {
1045         throw InvalidRegistryException();
1046     }
1047
1048     OUString resolvedName = computeName(aKeyName);
1049
1050     if ( resolvedName.isEmpty() )
1051     {
1052         throw InvalidRegistryException();
1053     }
1054
1055     return resolvedName;
1056 }
1057
1058
1059 // DefaultRegistry Implementation
1060
1061
1062 NestedRegistryImpl::NestedRegistryImpl( )
1063     : m_state(0)
1064 {}
1065
1066 class RegistryEnumueration : public WeakImplHelper< XEnumeration >
1067 {
1068 public:
1069     RegistryEnumueration(
1070         const Reference< XSimpleRegistry > &r1,
1071         const Reference< XSimpleRegistry > &r2 )
1072         : m_xReg1( r1 ) , m_xReg2( r2 )
1073         {}
1074 public:
1075     virtual sal_Bool SAL_CALL hasMoreElements(  ) override;
1076     virtual Any SAL_CALL nextElement(  ) override;
1077
1078 private:
1079     Reference< XSimpleRegistry > m_xReg1;
1080     Reference< XSimpleRegistry > m_xReg2;
1081 };
1082
1083 sal_Bool RegistryEnumueration::hasMoreElements(  )
1084 {
1085     return m_xReg1.is() || m_xReg2.is();
1086 }
1087
1088 Any RegistryEnumueration::nextElement(  )
1089 {
1090     Any a;
1091     if( m_xReg1.is() )
1092     {
1093         a <<= m_xReg1;
1094         m_xReg1.clear();
1095     }
1096     else if( m_xReg2.is() )
1097     {
1098         a <<= m_xReg2;
1099         m_xReg2.clear();
1100     }
1101     else
1102     {
1103         throw NoSuchElementException( "NestedRegistry: no nextElement() !" );
1104     }
1105     return a;
1106 }
1107
1108
1109 Reference< XEnumeration > NestedRegistryImpl::createEnumeration(  )
1110 {
1111     MutexGuard guard( m_mutex );
1112     return new RegistryEnumueration( m_localReg, m_defaultReg );
1113 }
1114
1115 Type NestedRegistryImpl::getElementType(  )
1116 {
1117     return cppu::UnoType<decltype(m_localReg)>::get();
1118 }
1119
1120 sal_Bool SAL_CALL NestedRegistryImpl::hasElements(  )
1121 {
1122     MutexGuard guard( m_mutex );
1123     return m_localReg.is() || m_defaultReg.is();
1124 }
1125
1126
1127 OUString SAL_CALL NestedRegistryImpl::getImplementationName(  )
1128 {
1129     return OUString("com.sun.star.comp.stoc.NestedRegistry");
1130 }
1131
1132 sal_Bool SAL_CALL NestedRegistryImpl::supportsService( const OUString& ServiceName )
1133 {
1134     return cppu::supportsService(this, ServiceName);
1135 }
1136
1137 Sequence<OUString> SAL_CALL NestedRegistryImpl::getSupportedServiceNames(  )
1138 {
1139     Sequence< OUString > seqNames { "com.sun.star.registry.NestedRegistry" };
1140     return seqNames;
1141 }
1142
1143
1144 void SAL_CALL NestedRegistryImpl::initialize( const Sequence< Any >& aArguments )
1145 {
1146     Guard< Mutex > aGuard( m_mutex );
1147     if ( (aArguments.getLength() == 2) &&
1148          (aArguments[0].getValueType().getTypeClass() == TypeClass_INTERFACE) &&
1149          (aArguments[1].getValueType().getTypeClass() == TypeClass_INTERFACE) )
1150     {
1151         aArguments[0] >>= m_localReg;
1152         aArguments[1] >>= m_defaultReg;
1153         if ( m_localReg == m_defaultReg )
1154             m_defaultReg.clear();
1155     }
1156 }
1157
1158
1159 OUString SAL_CALL NestedRegistryImpl::getURL()
1160 {
1161     Guard< Mutex > aGuard( m_mutex );
1162     try
1163     {
1164         if ( m_localReg.is() && m_localReg->isValid() )
1165             return m_localReg->getURL();
1166     }
1167     catch(InvalidRegistryException& )
1168     {
1169     }
1170
1171     return OUString();
1172 }
1173
1174
1175 void SAL_CALL NestedRegistryImpl::open( const OUString&, sal_Bool, sal_Bool )
1176 {
1177     throw InvalidRegistryException(
1178             "the 'open' method is not specified for a nested registry" );
1179 }
1180
1181
1182 sal_Bool SAL_CALL NestedRegistryImpl::isValid(  )
1183 {
1184     Guard< Mutex > aGuard( m_mutex );
1185     try
1186     {
1187         if ( (m_localReg.is() && m_localReg->isValid()) ||
1188              (m_defaultReg.is() && m_defaultReg->isValid()) )
1189             return true;
1190     }
1191     catch(InvalidRegistryException& )
1192     {
1193     }
1194
1195     return false;
1196 }
1197
1198
1199 void SAL_CALL NestedRegistryImpl::close(  )
1200 {
1201     Guard< Mutex > aGuard( m_mutex );
1202     if ( m_localReg.is() && m_localReg->isValid() )
1203     {
1204         m_localReg->close();
1205     }
1206     if ( m_defaultReg.is() && m_defaultReg->isValid() )
1207     {
1208         m_defaultReg->close();
1209     }
1210 }
1211
1212
1213 void SAL_CALL NestedRegistryImpl::destroy(  )
1214 {
1215     throw InvalidRegistryException(
1216             "the 'destroy' method is not specified for a nested registry" );
1217 }
1218
1219
1220 Reference< XRegistryKey > SAL_CALL NestedRegistryImpl::getRootKey(  )
1221 {
1222     Guard< Mutex > aGuard( m_mutex );
1223     if ( !m_localReg.is() || !m_localReg->isValid() )
1224     {
1225         throw InvalidRegistryException();
1226     }
1227
1228     Reference<XRegistryKey> localKey, defaultKey;
1229
1230     localKey = m_localReg->getRootKey();
1231
1232     if ( localKey.is() )
1233     {
1234         if ( m_defaultReg.is() && m_defaultReg->isValid() )
1235         {
1236             defaultKey = m_defaultReg->getRootKey();
1237         }
1238
1239         return static_cast<XRegistryKey*>(new NestedKeyImpl(this, localKey, defaultKey));
1240     }
1241
1242     return Reference<XRegistryKey>();
1243 }
1244
1245
1246 sal_Bool SAL_CALL NestedRegistryImpl::isReadOnly(  )
1247 {
1248     Guard< Mutex > aGuard( m_mutex );
1249     try
1250     {
1251         if ( m_localReg.is() && m_localReg->isValid() )
1252             return m_localReg->isReadOnly();
1253     }
1254     catch(InvalidRegistryException& )
1255     {
1256     }
1257
1258     return false;
1259 }
1260
1261
1262 void SAL_CALL NestedRegistryImpl::mergeKey( const OUString& aKeyName, const OUString& aUrl )
1263 {
1264     Guard< Mutex > aGuard( m_mutex );
1265     if ( m_localReg.is() && m_localReg->isValid() )
1266     {
1267         m_localReg->mergeKey(aKeyName, aUrl);
1268
1269         m_state++;
1270     }
1271 }
1272
1273 } // namespace
1274
1275 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
1276 com_sun_star_comp_stoc_NestedRegistry_get_implementation(
1277     SAL_UNUSED_PARAMETER css::uno::XComponentContext *,
1278     css::uno::Sequence<css::uno::Any> const &)
1279 {
1280     return cppu::acquire(new NestedRegistryImpl);
1281 }
1282
1283 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */