LCOV - code coverage report
Current view: top level - stoc/source/defaultregistry - defaultregistry.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 558 0.0 %
Date: 2014-11-03 Functions: 0 59 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10