diff options
Diffstat (limited to '')
-rw-r--r-- | ucb/source/core/ucbstore.cxx | 2205 |
1 files changed, 2205 insertions, 0 deletions
diff --git a/ucb/source/core/ucbstore.cxx b/ucb/source/core/ucbstore.cxx new file mode 100644 index 000000000..01f7c70b5 --- /dev/null +++ b/ucb/source/core/ucbstore.cxx @@ -0,0 +1,2205 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + + +/************************************************************************** + TODO + ************************************************************************** + + *************************************************************************/ + +#include <optional> +#include <unordered_map> +#include <sal/log.hxx> +#include <tools/diagnose_ex.h> +#include <rtl/ustrbuf.hxx> +#include <rtl/ref.hxx> +#include <comphelper/interfacecontainer2.hxx> +#include <comphelper/propertysequence.hxx> +#include <com/sun/star/beans/IllegalTypeException.hpp> +#include <com/sun/star/beans/NotRemoveableException.hpp> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/beans/PropertySetInfoChange.hpp> +#include <com/sun/star/configuration/theDefaultProvider.hpp> +#include <com/sun/star/container/XHierarchicalNameAccess.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/container/XNameReplace.hpp> +#include <com/sun/star/util/XChangesBatch.hpp> +#include <com/sun/star/lang/XSingleServiceFactory.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <cppuhelper/implbase.hxx> +#include <cppuhelper/weak.hxx> +#include "ucbstore.hxx" + +using namespace com::sun::star::beans; +using namespace com::sun::star::configuration; +using namespace com::sun::star::container; +using namespace com::sun::star::lang; +using namespace com::sun::star::ucb; +using namespace com::sun::star::uno; +using namespace com::sun::star::util; +using namespace comphelper; +using namespace cppu; + +static OUString makeHierarchalNameSegment( const OUString & rIn ) +{ + OUStringBuffer aBuffer; + aBuffer.append( "['" ); + + sal_Int32 nCount = rIn.getLength(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + const sal_Unicode c = rIn[ n ]; + switch ( c ) + { + case '&': + aBuffer.append( "&" ); + break; + + case '"': + aBuffer.append( """ ); + break; + + case '\'': + aBuffer.append( "'" ); + break; + + case '<': + aBuffer.append( "<" ); + break; + + case '>': + aBuffer.append( ">" ); + break; + + default: + aBuffer.append( c ); + break; + } + } + + aBuffer.append( "']" ); + return aBuffer.makeStringAndClear(); +} + +constexpr OUStringLiteral STORE_CONTENTPROPERTIES_KEY = u"/org.openoffice.ucb.Store/ContentProperties"; + +// describe path of cfg entry +constexpr OUStringLiteral CFGPROPERTY_NODEPATH = u"nodepath"; + +class PropertySetInfo_Impl : public cppu::WeakImplHelper < XPropertySetInfo > +{ + std::optional<Sequence< Property >> + m_xProps; + PersistentPropertySet* m_pOwner; + +public: + explicit PropertySetInfo_Impl(PersistentPropertySet* pOwner); + + // XPropertySetInfo + virtual Sequence< Property > SAL_CALL getProperties() override; + virtual Property SAL_CALL getPropertyByName( const OUString& aName ) override; + virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override; + + // Non-interface methods. + void reset() { m_xProps.reset(); } +}; + + +// UcbStore Implementation. + + +UcbStore::UcbStore( const Reference< XComponentContext >& xContext ) +: m_xContext( xContext ) +{ +} + + +// virtual +UcbStore::~UcbStore() +{ +} + +OUString SAL_CALL UcbStore::getImplementationName() +{ + return "com.sun.star.comp.ucb.UcbStore"; +} +sal_Bool SAL_CALL UcbStore::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} +css::uno::Sequence< OUString > SAL_CALL UcbStore::getSupportedServiceNames() +{ + return { "com.sun.star.ucb.Store" }; +} + +// Service factory implementation. + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +ucb_UcbStore_get_implementation( + css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&) +{ + return cppu::acquire(new UcbStore(context)); +} + + +// XPropertySetRegistryFactory methods. + + +// virtual +Reference< XPropertySetRegistry > SAL_CALL +UcbStore::createPropertySetRegistry( const OUString& ) +{ + // The URL parameter is ignored by this interface implementation. It always + // uses the configuration server as storage medium. + + if ( !m_xTheRegistry.is() ) + { + std::unique_lock aGuard( m_aMutex ); + if ( !m_xTheRegistry.is() ) + m_xTheRegistry = new PropertySetRegistry( m_xContext, m_aInitArgs ); + } + + return m_xTheRegistry; +} + + +// XInitialization methods. + + +// virtual +void SAL_CALL UcbStore::initialize( const Sequence< Any >& aArguments ) +{ + std::unique_lock aGuard( m_aMutex ); + m_aInitArgs = aArguments; +} + + + +// PropertySetRegistry Implementation. + + +PropertySetRegistry::PropertySetRegistry( + const Reference< XComponentContext >& xContext, + const Sequence< Any > &rInitArgs ) +: m_xContext( xContext ) +, m_aInitArgs(rInitArgs) +, m_bTriedToGetRootReadAccess(false) +, m_bTriedToGetRootWriteAccess(false) +{ +} + + +// virtual +PropertySetRegistry::~PropertySetRegistry() +{ +} + + +// XServiceInfo methods. + + +OUString SAL_CALL PropertySetRegistry::getImplementationName() +{ + return "com.sun.star.comp.ucb.PropertySetRegistry"; +} + +sal_Bool SAL_CALL PropertySetRegistry::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL PropertySetRegistry::getSupportedServiceNames() +{ + return { "com.sun.star.ucb.PropertySetRegistry" }; +} + + +// XPropertySetRegistry methods. + + +// virtual +Reference< XPersistentPropertySet > SAL_CALL +PropertySetRegistry::openPropertySet( const OUString& key, sal_Bool create ) +{ + if ( !key.isEmpty() ) + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + PropertySetMap_Impl& rSets = m_aPropSets; + + PropertySetMap_Impl::const_iterator it = rSets.find( key ); + if ( it != rSets.end() ) + { + // Already instantiated. + return Reference< XPersistentPropertySet >( (*it).second ); + } + else + { + // Create new instance. + Reference< XNameAccess > xRootNameAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootNameAccess.is() ) + { + // Propertyset in registry? + if ( xRootNameAccess->hasByName( key ) ) + { + // Yep! + return Reference< XPersistentPropertySet >( + new PersistentPropertySet( + *this, key ) ); + } + else if ( create ) + { + // No. Create entry for propertyset. + + Reference< XSingleServiceFactory > xFac( + getConfigWriteAccess( OUString() ), UNO_QUERY ); + Reference< XChangesBatch > xBatch( xFac, UNO_QUERY ); + Reference< XNameContainer > xContainer( xFac, UNO_QUERY ); + + OSL_ENSURE( xFac.is(), + "PropertySetRegistry::openPropertySet - " + "No factory!" ); + + OSL_ENSURE( xBatch.is(), + "PropertySetRegistry::openPropertySet - " + "No batch!" ); + + OSL_ENSURE( xContainer.is(), + "PropertySetRegistry::openPropertySet - " + "No container!" ); + + if ( xFac.is() && xBatch.is() && xContainer.is() ) + { + try + { + // Create new "Properties" config item. + Reference< XNameReplace > xNameReplace( + xFac->createInstance(), UNO_QUERY ); + + if ( xNameReplace.is() ) + { + // Fill new item... + + // Insert new item. + xContainer->insertByName( + key, Any( xNameReplace ) ); + // Commit changes. + xBatch->commitChanges(); + + return Reference< XPersistentPropertySet >( + new PersistentPropertySet( + *this, key ) ); + } + } + catch (const IllegalArgumentException&) + { + // insertByName + + OSL_FAIL( "PropertySetRegistry::openPropertySet - " + "caught IllegalArgumentException!" ); + } + catch (const ElementExistException&) + { + // insertByName + + OSL_FAIL( "PropertySetRegistry::openPropertySet - " + "caught ElementExistException!" ); + } + catch (const WrappedTargetException&) + { + // insertByName, commitChanges + + OSL_FAIL( "PropertySetRegistry::openPropertySet - " + "caught WrappedTargetException!" ); + } + catch (const RuntimeException&) + { + OSL_FAIL( "PropertySetRegistry::openPropertySet - " + "caught RuntimeException!" ); + } + catch (const Exception&) + { + // createInstance + + OSL_FAIL( "PropertySetRegistry::openPropertySet - " + "caught Exception!" ); + } + } + } + else + { + // No entry. Fail, but no error. + return Reference< XPersistentPropertySet >(); + } + } + + SAL_WARN( "ucb", "no root access" ); + } + } + + return Reference< XPersistentPropertySet >(); +} + + +// virtual +void SAL_CALL PropertySetRegistry::removePropertySet( const OUString& key ) +{ + if ( key.isEmpty() ) + return; + + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XNameAccess > xRootNameAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootNameAccess.is() ) + { + // Propertyset in registry? + if ( !xRootNameAccess->hasByName( key ) ) + return; + Reference< XChangesBatch > xBatch( + getConfigWriteAccess( OUString() ), UNO_QUERY ); + Reference< XNameContainer > xContainer( xBatch, UNO_QUERY ); + + if ( xBatch.is() && xContainer.is() ) + { + try + { + // Remove item. + xContainer->removeByName( key ); + // Commit changes. + xBatch->commitChanges(); + + // Success. + return; + } + catch (const NoSuchElementException&) + { + // removeByName + + OSL_FAIL( "PropertySetRegistry::removePropertySet - " + "caught NoSuchElementException!" ); + return; + } + catch (const WrappedTargetException&) + { + // commitChanges + + OSL_FAIL( "PropertySetRegistry::removePropertySet - " + "caught WrappedTargetException!" ); + return; + } + } + + return; + } + + SAL_WARN( "ucb", "no root access" ); +} + + +// XElementAccess methods. + + +// virtual +css::uno::Type SAL_CALL PropertySetRegistry::getElementType() +{ + return cppu::UnoType<XPersistentPropertySet>::get(); +} + + +// virtual +sal_Bool SAL_CALL PropertySetRegistry::hasElements() +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XElementAccess > xElemAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xElemAccess.is() ) + return xElemAccess->hasElements(); + + return false; +} + + +// XNameAccess methods. + + +// virtual +Any SAL_CALL PropertySetRegistry::getByName( const OUString& aName ) +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XNameAccess > xNameAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xNameAccess.is() ) + { + + try + { + return xNameAccess->getByName( aName ); + } + catch (const NoSuchElementException&) + { + // getByName + } + catch (const WrappedTargetException&) + { + // getByName + } + } + + return Any(); +} + + +// virtual +Sequence< OUString > SAL_CALL PropertySetRegistry::getElementNames() +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XNameAccess > xNameAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xNameAccess.is() ) + { + return xNameAccess->getElementNames(); + } + return Sequence< OUString >( 0 ); +} + + +// virtual +sal_Bool SAL_CALL PropertySetRegistry::hasByName( const OUString& aName ) +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XNameAccess > xNameAccess( + getRootConfigReadAccess(), UNO_QUERY ); + if ( xNameAccess.is() ) + { + return xNameAccess->hasByName( aName ); + } + + return false; +} + + +void PropertySetRegistry::add( PersistentPropertySet* pSet ) +{ + OUString key( pSet->getKey() ); + + if ( !key.isEmpty() ) + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + m_aPropSets[ key ] = pSet; + } +} + + +void PropertySetRegistry::remove( PersistentPropertySet* pSet ) +{ + OUString key( pSet->getKey() ); + + if ( key.isEmpty() ) + return; + + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + PropertySetMap_Impl& rSets = m_aPropSets; + + PropertySetMap_Impl::iterator it = rSets.find( key ); + if ( it != rSets.end() ) + { + // Found. + rSets.erase( it ); + } +} + + +void PropertySetRegistry::renamePropertySet( const OUString& rOldKey, + const OUString& rNewKey ) +{ + if ( rOldKey == rNewKey ) + return; + + Reference< XNameAccess > xRootNameAccess( + getConfigWriteAccess( OUString() ), UNO_QUERY ); + if ( xRootNameAccess.is() ) + { + // Old key present? + if ( xRootNameAccess->hasByName( rOldKey ) ) + { + // New key not present? + if ( xRootNameAccess->hasByName( rNewKey ) ) + { + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "New key exists!" ); + return; + } + Reference< XSingleServiceFactory > xFac( + xRootNameAccess, UNO_QUERY ); + Reference< XChangesBatch > xBatch( xFac, UNO_QUERY ); + Reference< XNameContainer > xContainer( xFac, UNO_QUERY ); + + OSL_ENSURE( xFac.is(), + "PropertySetRegistry::renamePropertySet - " + "No factory!" ); + + OSL_ENSURE( xBatch.is(), + "PropertySetRegistry::renamePropertySet - " + "No batch!" ); + + OSL_ENSURE( xContainer.is(), + "PropertySetRegistry::renamePropertySet - " + "No container!" ); + + if ( xFac.is() && xBatch.is() && xContainer.is() ) + { + + // Create new "Properties" config item. + + + try + { + Reference< XNameReplace > xNameReplace( + xFac->createInstance(), UNO_QUERY ); + + if ( xNameReplace.is() ) + { + // Insert new item. + xContainer->insertByName( + rNewKey, Any( xNameReplace ) ); + // Commit changes. + xBatch->commitChanges(); + } + } + catch (const IllegalArgumentException&) + { + // insertByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught IllegalArgumentException!" ); + return; + } + catch (const ElementExistException&) + { + // insertByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught ElementExistException!" ); + return; + } + catch (const WrappedTargetException&) + { + // insertByName, commitChanges + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught WrappedTargetException!" ); + return; + } + catch (const RuntimeException&) + { + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught RuntimeException!" ); + return; + } + catch (const Exception&) + { + // createInstance + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught Exception!" ); + return; + } + + + // Copy data... + + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + xRootNameAccess, UNO_QUERY ); + if ( !xRootHierNameAccess.is() ) + { + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "No hierarchical name access!" ); + return; + } + + try + { + OUString aOldValuesKey + = makeHierarchalNameSegment( rOldKey ) + "/Values"; + + Reference< XNameAccess > xOldNameAccess; + xRootHierNameAccess->getByHierarchicalName( + aOldValuesKey ) + >>= xOldNameAccess; + if ( !xOldNameAccess.is() ) + { + OSL_FAIL( "PersistentPropertySet::renamePropertySet - " + "No old name access!" ); + return; + } + + // Obtain property names. + const Sequence< OUString > aElems + = xOldNameAccess->getElementNames(); + if ( aElems.hasElements() ) + { + OUString aNewValuesKey + = makeHierarchalNameSegment( rNewKey ) + "/Values"; + + Reference< XSingleServiceFactory > xNewFac; + xRootHierNameAccess->getByHierarchicalName( + aNewValuesKey ) + >>= xNewFac; + if ( !xNewFac.is() ) + { + OSL_FAIL( "PersistentPropertySet::renamePropertySet - " + "No new factory!" ); + return; + } + + Reference< XNameContainer > xNewContainer( + xNewFac, UNO_QUERY ); + if ( !xNewContainer.is() ) + { + OSL_FAIL( "PersistentPropertySet::renamePropertySet - " + "No new container!" ); + return; + } + + aOldValuesKey += "/"; + + OUString const aHandleKey("/Handle"); + OUString const aValueKey("/Value"); + OUString const aStateKey("/State"); + OUString const aAttrKey("/Attributes"); + + for ( const OUString& rPropName : aElems ) + { + // Create new item. + Reference< XNameReplace > xNewPropNameReplace( + xNewFac->createInstance(), UNO_QUERY ); + + if ( !xNewPropNameReplace.is() ) + { + OSL_FAIL( "PersistentPropertySet::renamePropertySet - " + "No new prop name replace!" ); + return; + } + + // Fill new item... + + // Set Values + OUString aKey = aOldValuesKey; + aKey += makeHierarchalNameSegment( rPropName ); + + // ... handle + OUString aNewKey1 = aKey + aHandleKey; + Any aAny = + xRootHierNameAccess->getByHierarchicalName( + aNewKey1 ); + xNewPropNameReplace->replaceByName( "Handle", aAny ); + + // ... value + aNewKey1 = aKey + aValueKey; + aAny = + xRootHierNameAccess->getByHierarchicalName( + aNewKey1 ); + xNewPropNameReplace->replaceByName( "Value", aAny ); + + // ... state + aNewKey1 = aKey + aStateKey; + aAny = + xRootHierNameAccess->getByHierarchicalName( + aNewKey1 ); + xNewPropNameReplace->replaceByName( "State", aAny ); + + // ... attributes + aNewKey1 = aKey + aAttrKey; + aAny = + xRootHierNameAccess->getByHierarchicalName( + aNewKey1 ); + xNewPropNameReplace->replaceByName( "Attributes", aAny ); + + // Insert new item. + xNewContainer->insertByName( + rPropName, Any( xNewPropNameReplace ) ); + + // Commit changes. + xBatch->commitChanges(); + } + } + } + catch (const IllegalArgumentException&) + { + // insertByName, replaceByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught IllegalArgumentException!" ); + return; + } + catch (const ElementExistException&) + { + // insertByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught ElementExistException!" ); + return; + } + catch (const WrappedTargetException&) + { + // insertByName, replaceByName, commitChanges + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught WrappedTargetException!" ); + return; + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName, replaceByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught NoSuchElementException!" ); + return; + } + catch (const RuntimeException&) + { + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught RuntimeException!" ); + return; + } + catch (const Exception&) + { + // createInstance + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught Exception!" ); + return; + } + + + // Remove old entry... + + + try + { + // Remove item. + xContainer->removeByName( rOldKey ); + // Commit changes. + xBatch->commitChanges(); + + // Success. + return; + } + catch (const NoSuchElementException&) + { + // removeByName + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught NoSuchElementException!" ); + return; + } + catch (const WrappedTargetException&) + { + // commitChanges + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - " + "caught WrappedTargetException!" ); + return; + } + } + } + } + + OSL_FAIL( "PropertySetRegistry::renamePropertySet - Error!" ); +} + + +Reference< XMultiServiceFactory > PropertySetRegistry::getConfigProvider() +{ + if ( !m_xConfigProvider.is() ) + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + if ( !m_xConfigProvider.is() ) + { + const Sequence< Any >& rInitArgs = m_aInitArgs; + + if ( rInitArgs.hasElements() ) + { + // Extract config provider from service init args. + rInitArgs[ 0 ] >>= m_xConfigProvider; + + OSL_ENSURE( m_xConfigProvider.is(), + "PropertySetRegistry::getConfigProvider - " + "No config provider!" ); + } + else + { + try + { + m_xConfigProvider = theDefaultProvider::get( m_xContext ); + } + catch (const Exception&) + { + TOOLS_WARN_EXCEPTION( "ucb", ""); + } + } + } + } + + return m_xConfigProvider; +} + + +Reference< XInterface > PropertySetRegistry::getRootConfigReadAccess() +{ + try + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + if ( !m_xRootReadAccess.is() ) + { + if ( m_bTriedToGetRootReadAccess ) + { + OSL_FAIL( "PropertySetRegistry::getRootConfigReadAccess - " + "Unable to read any config data! -> #82494#" ); + return Reference< XInterface >(); + } + + getConfigProvider(); + + if ( m_xConfigProvider.is() ) + { + Sequence<Any> aArguments(comphelper::InitAnyPropertySequence( + { + {CFGPROPERTY_NODEPATH, Any(OUString( STORE_CONTENTPROPERTIES_KEY ))} + })); + + m_bTriedToGetRootReadAccess = true; + + m_xRootReadAccess = + m_xConfigProvider->createInstanceWithArguments( + "com.sun.star.configuration.ConfigurationAccess", + aArguments ); + + if ( m_xRootReadAccess.is() ) + return m_xRootReadAccess; + } + } + else + return m_xRootReadAccess; + } + catch (const RuntimeException&) + { + throw; + } + catch (const Exception&) + { + // createInstance, createInstanceWithArguments + + TOOLS_WARN_EXCEPTION("ucb", ""); + return Reference< XInterface >(); + } + + SAL_WARN( "ucb", "Error!" ); + return Reference< XInterface >(); +} + + +Reference< XInterface > PropertySetRegistry::getConfigWriteAccess( + const OUString& rPath ) +{ + try + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + if ( !m_xRootWriteAccess.is() ) + { + if ( m_bTriedToGetRootWriteAccess ) + { + OSL_FAIL( "PropertySetRegistry::getConfigWriteAccess - " + "Unable to write any config data! -> #82494#" ); + return Reference< XInterface >(); + } + + getConfigProvider(); + + if ( m_xConfigProvider.is() ) + { + Sequence<Any> aArguments(comphelper::InitAnyPropertySequence( + { + {CFGPROPERTY_NODEPATH, Any(OUString( STORE_CONTENTPROPERTIES_KEY ))} + })); + + m_bTriedToGetRootWriteAccess = true; + + m_xRootWriteAccess = + m_xConfigProvider->createInstanceWithArguments( + "com.sun.star.configuration.ConfigurationUpdateAccess", + aArguments ); + + OSL_ENSURE( m_xRootWriteAccess.is(), + "PropertySetRegistry::getConfigWriteAccess - " + "No config update access!" ); + } + } + + if ( m_xRootWriteAccess.is() ) + { + if ( !rPath.isEmpty() ) + { + Reference< XHierarchicalNameAccess > xNA( + m_xRootWriteAccess, UNO_QUERY ); + if ( xNA.is() ) + { + Reference< XInterface > xInterface; + xNA->getByHierarchicalName( rPath ) >>= xInterface; + + if ( xInterface.is() ) + return xInterface; + } + } + else + return m_xRootWriteAccess; + } + } + catch (const RuntimeException&) + { + throw; + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PropertySetRegistry::getConfigWriteAccess - " + "caught NoSuchElementException!" ); + return Reference< XInterface >(); + } + catch (const Exception&) + { + // createInstance, createInstanceWithArguments + + OSL_FAIL( "PropertySetRegistry::getConfigWriteAccess - " + "caught Exception!" ); + return Reference< XInterface >(); + } + + OSL_FAIL( "PropertySetRegistry::getConfigWriteAccess - Error!" ); + return Reference< XInterface >(); +} + + +// PersistentPropertySet Implementation. + + +PersistentPropertySet::PersistentPropertySet( + PropertySetRegistry& rCreator, + const OUString& rKey ) +: m_pCreator( &rCreator ), m_aKey( rKey ) +{ + // register at creator. + rCreator.add( this ); +} + + +// virtual +PersistentPropertySet::~PersistentPropertySet() +{ + // deregister at creator. + m_pCreator->remove( this ); +} + +// XServiceInfo methods. + +OUString SAL_CALL PersistentPropertySet::getImplementationName() +{ + return "com.sun.star.comp.ucb.PersistentPropertySet"; +} + +sal_Bool SAL_CALL PersistentPropertySet::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL PersistentPropertySet::getSupportedServiceNames() +{ + return { "com.sun.star.ucb.PersistentPropertySet" }; +} + + +// XComponent methods. + + +// virtual +void SAL_CALL PersistentPropertySet::dispose() +{ + if ( m_pDisposeEventListeners && + m_pDisposeEventListeners->getLength() ) + { + EventObject aEvt; + aEvt.Source = static_cast< XComponent * >( this ); + m_pDisposeEventListeners->disposeAndClear( aEvt ); + } + + if ( m_pPropSetChangeListeners && + m_pPropSetChangeListeners->getLength() ) + { + EventObject aEvt; + aEvt.Source = static_cast< XPropertySetInfoChangeNotifier * >( this ); + m_pPropSetChangeListeners->disposeAndClear( aEvt ); + } + + if ( m_pPropertyChangeListeners ) + { + EventObject aEvt; + aEvt.Source = static_cast< XPropertySet * >( this ); + m_pPropertyChangeListeners->disposeAndClear( aEvt ); + } +} + + +// virtual +void SAL_CALL PersistentPropertySet::addEventListener( + const Reference< XEventListener >& Listener ) +{ + if ( !m_pDisposeEventListeners ) + m_pDisposeEventListeners.reset( + new OInterfaceContainerHelper3<css::lang::XEventListener>( m_aMutex ) ); + + m_pDisposeEventListeners->addInterface( Listener ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::removeEventListener( + const Reference< XEventListener >& Listener ) +{ + if ( m_pDisposeEventListeners ) + m_pDisposeEventListeners->removeInterface( Listener ); + + // Note: Don't want to delete empty container here -> performance. +} + + +// XPropertySet methods. + + +// virtual +Reference< XPropertySetInfo > SAL_CALL PersistentPropertySet::getPropertySetInfo() +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + if ( !m_pInfo.is() ) + { + m_pInfo = new PropertySetInfo_Impl( this ); + } + return m_pInfo; +} + + +// virtual +void SAL_CALL PersistentPropertySet::setPropertyValue( const OUString& aPropertyName, + const Any& aValue ) +{ + osl::ClearableGuard< osl::Mutex > aCGuard( m_aMutex ); + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + OUString aFullPropName( getFullKey() + "/" ); + aFullPropName += makeHierarchalNameSegment( aPropertyName ); + + // Does property exist? + if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) ) + { + Reference< XNameReplace > xNameReplace( + m_pCreator->getConfigWriteAccess( + aFullPropName ), UNO_QUERY ); + Reference< XChangesBatch > xBatch( + m_pCreator->getConfigWriteAccess( + OUString() ), UNO_QUERY ); + + if ( xNameReplace.is() && xBatch.is() ) + { + try + { + // Obtain old value + OUString aValueName = aFullPropName + "/Value"; + Any aOldValue + = xRootHierNameAccess->getByHierarchicalName( + aValueName ); + // Check value type. + if ( aOldValue.getValueType() != aValue.getValueType() ) + { + aCGuard.clear(); + throw IllegalArgumentException(); + } + + // Write value + xNameReplace->replaceByName( "Value", aValue ); + + // Write state ( Now it is a directly set value ) + xNameReplace->replaceByName( + "State", + Any( + sal_Int32( + PropertyState_DIRECT_VALUE ) ) ); + + // Commit changes. + xBatch->commitChanges(); + + PropertyChangeEvent aEvt; + if ( m_pPropertyChangeListeners ) + { + // Obtain handle + aValueName = aFullPropName + "/Handle"; + sal_Int32 nHandle = -1; + xRootHierNameAccess->getByHierarchicalName( aValueName ) + >>= nHandle; + + aEvt.Source = static_cast<OWeakObject*>(this); + aEvt.PropertyName = aPropertyName; + aEvt.PropertyHandle = nHandle; + aEvt.Further = false; + aEvt.OldValue = aOldValue; + aEvt.NewValue = aValue; + + // Callback follows! + aCGuard.clear(); + + notifyPropertyChangeEvent( aEvt ); + } + return; + } + catch (const IllegalArgumentException&) + { + // replaceByName + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName, replaceByName + } + catch (const WrappedTargetException&) + { + // replaceByName, commitChanges + } + } + } + } + + throw UnknownPropertyException(aPropertyName); +} + + +// virtual +Any SAL_CALL PersistentPropertySet::getPropertyValue( + const OUString& PropertyName ) +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XHierarchicalNameAccess > xNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xNameAccess.is() ) + { + OUString aFullPropName( getFullKey() + "/" ); + aFullPropName += makeHierarchalNameSegment( PropertyName ) + "/Value"; + try + { + return xNameAccess->getByHierarchicalName( aFullPropName ); + } + catch (const NoSuchElementException&) + { + throw UnknownPropertyException(aFullPropName); + } + } + + throw UnknownPropertyException(PropertyName); +} + + +// virtual +void SAL_CALL PersistentPropertySet::addPropertyChangeListener( + const OUString& aPropertyName, + const Reference< XPropertyChangeListener >& xListener ) +{ +// load(); + + if ( !m_pPropertyChangeListeners ) + m_pPropertyChangeListeners.reset( + new PropertyListeners_Impl( m_aMutex ) ); + + m_pPropertyChangeListeners->addInterface( + aPropertyName, xListener ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::removePropertyChangeListener( + const OUString& aPropertyName, + const Reference< XPropertyChangeListener >& aListener ) +{ +// load(); + + if ( m_pPropertyChangeListeners ) + m_pPropertyChangeListeners->removeInterface( + aPropertyName, aListener ); + + // Note: Don't want to delete empty container here -> performance. +} + + +// virtual +void SAL_CALL PersistentPropertySet::addVetoableChangeListener( + const OUString&, + const Reference< XVetoableChangeListener >& ) +{ +// load(); +// OSL_FAIL( // "PersistentPropertySet::addVetoableChangeListener - N.Y.I." ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::removeVetoableChangeListener( + const OUString&, + const Reference< XVetoableChangeListener >& ) +{ +// load(); +// OSL_FAIL( // "PersistentPropertySet::removeVetoableChangeListener - N.Y.I." ); +} + + +// XPersistentPropertySet methods. + + +// virtual +Reference< XPropertySetRegistry > SAL_CALL PersistentPropertySet::getRegistry() +{ + return m_pCreator; +} + + +// virtual +OUString SAL_CALL PersistentPropertySet::getKey() +{ + return m_aKey; +} + + +// XNamed methods. + + +// virtual +OUString SAL_CALL PersistentPropertySet::getName() +{ + // same as getKey() + return m_aKey; +} + + +// virtual +void SAL_CALL PersistentPropertySet::setName( const OUString& aName ) +{ + if ( aName != m_aKey ) + m_pCreator->renamePropertySet( m_aKey, aName ); +} + + +// XPropertyContainer methods. + + +// virtual +void SAL_CALL PersistentPropertySet::addProperty( + const OUString& Name, sal_Int16 Attributes, const Any& DefaultValue ) +{ + if ( Name.isEmpty() ) + throw IllegalArgumentException(); + + // @@@ What other types can't be written to config server? + + // Check type class ( Not all types can be written to storage ) + TypeClass eTypeClass = DefaultValue.getValueTypeClass(); + if ( eTypeClass == TypeClass_INTERFACE ) + throw IllegalTypeException(); + + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + // Property already in set? + + OUString aFullValuesName; + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + aFullValuesName = getFullKey(); + OUString aFullPropName = aFullValuesName + "/"; + aFullPropName += makeHierarchalNameSegment( Name ); + + if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) ) + { + // Already in set. + throw PropertyExistException(); + } + } + + // Property is always removable. + Attributes |= PropertyAttribute::REMOVABLE; + + // Add property. + + Reference< XSingleServiceFactory > xFac( + m_pCreator->getConfigWriteAccess( aFullValuesName ), + UNO_QUERY ); + Reference< XNameContainer > xContainer( xFac, UNO_QUERY ); + Reference< XChangesBatch > xBatch( + m_pCreator->getConfigWriteAccess( OUString() ), + UNO_QUERY ); + + OSL_ENSURE( xFac.is(), + "PersistentPropertySet::addProperty - No factory!" ); + + OSL_ENSURE( xBatch.is(), + "PersistentPropertySet::addProperty - No batch!" ); + + OSL_ENSURE( xContainer.is(), + "PersistentPropertySet::addProperty - No container!" ); + + if ( xFac.is() && xBatch.is() && xContainer.is() ) + { + try + { + // Create new "PropertyValue" config item. + Reference< XNameReplace > xNameReplace( + xFac->createInstance(), UNO_QUERY ); + + if ( xNameReplace.is() ) + { + // Fill new item... + + // Set handle + xNameReplace->replaceByName( + "Handle", + Any( sal_Int32( -1 ) ) ); + + // Set default value + xNameReplace->replaceByName( + "Value", + DefaultValue ); + + // Set state ( always "default" ) + xNameReplace->replaceByName( + "State", + Any( + sal_Int32( + PropertyState_DEFAULT_VALUE ) ) ); + + // Set attributes + xNameReplace->replaceByName( + "Attributes", + Any( sal_Int32( Attributes ) ) ); + + // Insert new item. + xContainer->insertByName( Name, Any( xNameReplace ) ); + + // Commit changes. + xBatch->commitChanges(); + + // Property set info is invalid. + if ( m_pInfo.is() ) + m_pInfo->reset(); + + // Notify propertyset info change listeners. + if ( m_pPropSetChangeListeners && + m_pPropSetChangeListeners->getLength() ) + { + PropertySetInfoChangeEvent evt( + static_cast< OWeakObject * >( this ), + Name, + -1, + PropertySetInfoChange::PROPERTY_INSERTED ); + notifyPropertySetInfoChange( evt ); + } + + // Success. + return; + } + } + catch (const IllegalArgumentException&) + { + // insertByName + + OSL_FAIL( "PersistentPropertySet::addProperty - " + "caught IllegalArgumentException!" ); + return; + } + catch (const ElementExistException&) + { + // insertByName + + OSL_FAIL( "PersistentPropertySet::addProperty - " + "caught ElementExistException!" ); + return; + } + catch (const WrappedTargetException&) + { + // replaceByName, insertByName, commitChanges + + OSL_FAIL( "PersistentPropertySet::addProperty - " + "caught WrappedTargetException!" ); + return; + } + catch (const RuntimeException&) + { + throw; + } + catch (const Exception&) + { + // createInstance + + OSL_FAIL( "PersistentPropertySet::addProperty - " + "caught Exception!" ); + return; + } + } + + OSL_FAIL( "PersistentPropertySet::addProperty - Error!" ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::removeProperty( const OUString& Name ) +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + OUString aFullValuesName = getFullKey(); + OUString aFullPropName = aFullValuesName + "/"; + aFullPropName += makeHierarchalNameSegment( Name ); + + // Property in set? + if ( !xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) ) + throw UnknownPropertyException(aFullPropName); + + // Property removable? + try + { + OUString aFullAttrName = aFullPropName + "/Attributes"; + + sal_Int32 nAttribs = 0; + if ( xRootHierNameAccess->getByHierarchicalName( aFullAttrName ) + >>= nAttribs ) + { + if ( !( nAttribs & PropertyAttribute::REMOVABLE ) ) + { + // Not removable! + throw NotRemoveableException(); + } + } + else + { + OSL_FAIL( "PersistentPropertySet::removeProperty - " + "No attributes!" ); + return; + } + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PersistentPropertySet::removeProperty - " + "caught NoSuchElementException!" ); + } + + // Remove property... + + Reference< XNameContainer > xContainer( + m_pCreator->getConfigWriteAccess( aFullValuesName ), + UNO_QUERY ); + Reference< XChangesBatch > xBatch( + m_pCreator->getConfigWriteAccess( OUString() ), + UNO_QUERY ); + + OSL_ENSURE( xBatch.is(), + "PersistentPropertySet::removeProperty - No batch!" ); + + OSL_ENSURE( xContainer.is(), + "PersistentPropertySet::removeProperty - No container!" ); + + if ( xBatch.is() && xContainer.is() ) + { + try + { + sal_Int32 nHandle = -1; + + if ( m_pPropSetChangeListeners && + m_pPropSetChangeListeners->getLength() ) + { + // Obtain property handle ( needed for propertysetinfo + // change event )... + + try + { + OUString aFullHandleName = aFullPropName + "/Handle"; + + if ( ! ( xRootHierNameAccess->getByHierarchicalName( + aFullHandleName ) >>= nHandle ) ) + nHandle = -1; + + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PersistentPropertySet::removeProperty - " + "caught NoSuchElementException!" ); + nHandle = -1; + } + } + + xContainer->removeByName( Name ); + xBatch->commitChanges(); + + // Property set info is invalid. + if ( m_pInfo.is() ) + m_pInfo->reset(); + + // Notify propertyset info change listeners. + if ( m_pPropSetChangeListeners && + m_pPropSetChangeListeners->getLength() ) + { + PropertySetInfoChangeEvent evt( + static_cast< OWeakObject * >( this ), + Name, + nHandle, + PropertySetInfoChange::PROPERTY_REMOVED ); + notifyPropertySetInfoChange( evt ); + } + + // Success. + return; + } + catch (const NoSuchElementException&) + { + // removeByName + + OSL_FAIL( "PersistentPropertySet::removeProperty - " + "caught NoSuchElementException!" ); + return; + } + catch (const WrappedTargetException&) + { + // commitChanges + + OSL_FAIL( "PersistentPropertySet::removeProperty - " + "caught WrappedTargetException!" ); + return; + } + } + } + + OSL_FAIL( "PersistentPropertySet::removeProperty - Error!" ); +} + + +// XPropertySetInfoChangeNotifier methods. + + +// virtual +void SAL_CALL PersistentPropertySet::addPropertySetInfoChangeListener( + const Reference< XPropertySetInfoChangeListener >& Listener ) +{ + if ( !m_pPropSetChangeListeners ) + m_pPropSetChangeListeners.reset( + new OInterfaceContainerHelper3<XPropertySetInfoChangeListener>( m_aMutex ) ); + + m_pPropSetChangeListeners->addInterface( Listener ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::removePropertySetInfoChangeListener( + const Reference< XPropertySetInfoChangeListener >& Listener ) +{ + if ( m_pPropSetChangeListeners ) + m_pPropSetChangeListeners->removeInterface( Listener ); +} + + +// XPropertyAccess methods. + + +// virtual +Sequence< PropertyValue > SAL_CALL PersistentPropertySet::getPropertyValues() +{ + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + try + { + Reference< XNameAccess > xNameAccess; + xRootHierNameAccess->getByHierarchicalName(getFullKey()) + >>= xNameAccess; + if ( xNameAccess.is() ) + { + // Obtain property names. + + Sequence< OUString > aElems = xNameAccess->getElementNames(); + + sal_Int32 nCount = aElems.getLength(); + if ( nCount ) + { + Reference< XHierarchicalNameAccess > xHierNameAccess( + xNameAccess, UNO_QUERY ); + + OSL_ENSURE( xHierNameAccess.is(), + "PersistentPropertySet::getPropertyValues - " + "No hierarchical name access!" ); + + if ( xHierNameAccess.is() ) + { + Sequence< PropertyValue > aValues( nCount ); + auto pValues = aValues.getArray(); + + static const OUStringLiteral aHandleName(u"/Handle"); + static const OUStringLiteral aValueName(u"/Value"); + static const OUStringLiteral aStateName(u"/State"); + + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + PropertyValue& rValue = pValues[ n ]; + OUString rName = aElems[ n ]; + OUString aXMLName + = makeHierarchalNameSegment( rName ); + + // Set property name. + + rValue.Name = rName; + + try + { + // Obtain and set property handle + OUString aHierName = aXMLName + aHandleName; + Any aKeyValue + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + if ( !( aKeyValue >>= rValue.Handle ) ) + OSL_FAIL( "PersistentPropertySet::getPropertyValues - " + "Error getting property handle!" ); + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PersistentPropertySet::getPropertyValues - " + "NoSuchElementException!" ); + } + + try + { + // Obtain and set property value + OUString aHierName = aXMLName + aValueName; + rValue.Value + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + // Note: The value may be void if addProperty + // was called with a default value + // of type void. + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PersistentPropertySet::getPropertyValues - " + "NoSuchElementException!" ); + } + + try + { + // Obtain and set property state + OUString aHierName = aXMLName +aStateName; + Any aKeyValue + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + sal_Int32 nState = 0; + if ( !( aKeyValue >>= nState ) ) + OSL_FAIL( "PersistentPropertySet::getPropertyValues - " + "Error getting property state!" ); + else + rValue.State = PropertyState( nState ); + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PersistentPropertySet::getPropertyValues - " + "NoSuchElementException!" ); + } + } + + return aValues; + } + } + } + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + } + } + + return Sequence< PropertyValue >( 0 ); +} + + +// virtual +void SAL_CALL PersistentPropertySet::setPropertyValues( + const Sequence< PropertyValue >& aProps ) +{ + if ( !aProps.hasElements() ) + return; + + osl::ClearableGuard< osl::Mutex > aCGuard( m_aMutex ); + + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pCreator->getRootConfigReadAccess(), UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + std::vector< PropertyChangeEvent > aEvents; + + OUString aFullPropNamePrefix( getFullKey() + "/" ); + + // Iterate over given property value sequence. + for ( const PropertyValue& rNewValue : aProps ) + { + const OUString& rName = rNewValue.Name; + + OUString aFullPropName = aFullPropNamePrefix; + aFullPropName += makeHierarchalNameSegment( rName ); + + // Does property exist? + if ( xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) ) + { + Reference< XNameReplace > xNameReplace( + m_pCreator->getConfigWriteAccess( + aFullPropName ), UNO_QUERY ); + Reference< XChangesBatch > xBatch( + m_pCreator->getConfigWriteAccess( + OUString() ), UNO_QUERY ); + + if ( xNameReplace.is() && xBatch.is() ) + { + try + { + // Write handle + xNameReplace->replaceByName( + "Handle", + Any( rNewValue.Handle ) ); + + // Save old value + OUString aValueName = aFullPropName +"/Value"; + Any aOldValue + = xRootHierNameAccess->getByHierarchicalName( + aValueName ); + // Write value + xNameReplace->replaceByName( + "Value", + rNewValue.Value ); + + // Write state ( Now it is a directly set value ) + xNameReplace->replaceByName( + "State", + Any( + sal_Int32( + PropertyState_DIRECT_VALUE ) ) ); + + // Commit changes. + xBatch->commitChanges(); + + if ( m_pPropertyChangeListeners ) + { + PropertyChangeEvent aEvt; + aEvt.Source = static_cast<OWeakObject*>(this); + aEvt.PropertyName = rNewValue.Name; + aEvt.PropertyHandle = rNewValue.Handle; + aEvt.Further = false; + aEvt.OldValue = aOldValue; + aEvt.NewValue = rNewValue.Value; + + aEvents.push_back( aEvt ); + } + } + catch (const IllegalArgumentException&) + { + // replaceByName + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName, replaceByName + } + catch (const WrappedTargetException&) + { + // replaceByName, commitChanges + } + } + } + } + + // Callback follows! + aCGuard.clear(); + + if ( m_pPropertyChangeListeners ) + { + // Notify property changes. + for (auto const& event : aEvents) + { + notifyPropertyChangeEvent( event ); + } + } + + return; + } + + OSL_FAIL( "PersistentPropertySet::setPropertyValues - Nothing set!" ); +} + + +// Non-interface methods + + +void PersistentPropertySet::notifyPropertyChangeEvent( + const PropertyChangeEvent& rEvent ) const +{ + // Get "normal" listeners for the property. + OInterfaceContainerHelper3<XPropertyChangeListener>* pContainer = + m_pPropertyChangeListeners->getContainer( rEvent.PropertyName ); + if ( pContainer && pContainer->getLength() ) + { + pContainer->notifyEach( &XPropertyChangeListener::propertyChange, rEvent ); + } + + // Get "normal" listeners for all properties. + OInterfaceContainerHelper3<XPropertyChangeListener>* pNoNameContainer = + m_pPropertyChangeListeners->getContainer( OUString() ); + if ( pNoNameContainer && pNoNameContainer->getLength() ) + { + pNoNameContainer->notifyEach( &XPropertyChangeListener::propertyChange, rEvent ); + } +} + + +void PersistentPropertySet::notifyPropertySetInfoChange( + const PropertySetInfoChangeEvent& evt ) const +{ + if ( !m_pPropSetChangeListeners ) + return; + + // Notify event listeners. + m_pPropSetChangeListeners->notifyEach( &XPropertySetInfoChangeListener::propertySetInfoChange, evt ); +} + + +const OUString& PersistentPropertySet::getFullKey() +{ + if ( m_aFullKey.isEmpty() ) + { + osl::Guard< osl::Mutex > aGuard( m_aMutex ); + if ( m_aFullKey.isEmpty() ) + { + m_aFullKey = makeHierarchalNameSegment( m_aKey ); + m_aFullKey += "/Values"; + } + } + + return m_aFullKey; +} + + +PropertySetRegistry& PersistentPropertySet::getPropertySetRegistry() +{ + return *m_pCreator; +} + + +// PropertySetInfo_Impl Implementation. + + +PropertySetInfo_Impl::PropertySetInfo_Impl( + PersistentPropertySet* pOwner ) +: m_pOwner( pOwner ) +{ +} + + +// XPropertySetInfo methods. + + +// virtual +Sequence< Property > SAL_CALL PropertySetInfo_Impl::getProperties() +{ + if ( !m_xProps ) + { + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(), + UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + try + { + Reference< XNameAccess > xNameAccess; + xRootHierNameAccess->getByHierarchicalName( + m_pOwner->getFullKey() ) + >>= xNameAccess; + if ( xNameAccess.is() ) + { + // Obtain property names. + + Sequence< OUString > aElems + = xNameAccess->getElementNames(); + + sal_uInt32 nCount = aElems.getLength(); + Sequence< Property > aPropSeq( nCount ); + + if ( nCount ) + { + Reference< XHierarchicalNameAccess > xHierNameAccess( + xNameAccess, UNO_QUERY ); + + OSL_ENSURE( xHierNameAccess.is(), + "PropertySetInfo_Impl::getProperties - " + "No hierarchical name access!" ); + + if ( xHierNameAccess.is() ) + { + static const OUStringLiteral aHandleName(u"/Handle"); + static const OUStringLiteral aValueName(u"/Value"); + static const OUStringLiteral aAttrName(u"/Attributes"); + + Property* pProps = aPropSeq.getArray(); + + for ( sal_uInt32 n = 0; n < nCount; ++n ) + { + Property& rProp = pProps[ n ]; + OUString rName = aElems[ n ]; + OUString aXMLName + = makeHierarchalNameSegment( rName ); + + // Set property name. + + rProp.Name = rName; + + try + { + // Obtain and set property handle + OUString aHierName = aXMLName + aHandleName; + Any aKeyValue + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + if ( !( aKeyValue >>= rProp.Handle ) ) + OSL_FAIL( "PropertySetInfo_Impl::getProperties - " + "Error getting property handle!" ); + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PropertySetInfo_Impl::getProperties - " + "NoSuchElementException!" ); + } + + try + { + // Obtain and set property type + OUString aHierName = aXMLName + aValueName; + Any aKeyValue + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + // Note: The type may be void if addProperty + // was called with a default value + // of type void. + + rProp.Type = aKeyValue.getValueType(); + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PropertySetInfo_Impl::getProperties - " + "NoSuchElementException!" ); + } + + try + { + // Obtain and set property attributes + OUString aHierName = aXMLName + aAttrName; + Any aKeyValue + = xHierNameAccess->getByHierarchicalName( + aHierName ); + + sal_Int32 nAttribs = 0; + if ( aKeyValue >>= nAttribs ) + rProp.Attributes + = sal_Int16( nAttribs ); + else + OSL_FAIL( "PropertySetInfo_Impl::getProperties - " + "Error getting property attributes!" ); + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PropertySetInfo_Impl::getProperties - " + "NoSuchElementException!" ); + } + } + } + } + + // Success. + m_xProps = std::move(aPropSeq); + return *m_xProps; + } + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + } + } + + OSL_FAIL( "PropertySetInfo_Impl::getProperties - Error!" ); + m_xProps.emplace(); + } + + return *m_xProps; +} + + +// virtual +Property SAL_CALL PropertySetInfo_Impl::getPropertyByName( + const OUString& aName ) +{ + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(), + UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + OUString aFullPropName( m_pOwner->getFullKey() + "/" ); + aFullPropName += makeHierarchalNameSegment( aName ); + + // Does property exist? + if ( !xRootHierNameAccess->hasByHierarchicalName( aFullPropName ) ) + throw UnknownPropertyException(aFullPropName); + + try + { + Property aProp; + + // Obtain handle. + OUString aKey = aFullPropName + "/Handle"; + + if ( !( xRootHierNameAccess->getByHierarchicalName( aKey ) + >>= aProp.Handle ) ) + { + OSL_FAIL( "PropertySetInfo_Impl::getPropertyByName - " + "No handle!" ); + return Property(); + } + + // Obtain Value and extract type. + aKey = aFullPropName + "/Value"; + + Any aValue = xRootHierNameAccess->getByHierarchicalName( aKey ); + if ( !aValue.hasValue() ) + { + OSL_FAIL( "PropertySetInfo_Impl::getPropertyByName - " + "No Value!" ); + return Property(); + } + + aProp.Type = aValue.getValueType(); + + // Obtain Attributes. + aKey = aFullPropName + "/Attributes"; + + sal_Int32 nAttribs = 0; + if ( xRootHierNameAccess->getByHierarchicalName( aKey ) + >>= nAttribs ) + aProp.Attributes = sal_Int16( nAttribs ); + else + { + OSL_FAIL( "PropertySetInfo_Impl::getPropertyByName - " + "No attributes!" ); + return Property(); + } + + // set name. + aProp.Name = aName; + + // Success. + return aProp; + } + catch (const NoSuchElementException&) + { + // getByHierarchicalName + + OSL_FAIL( "PropertySetInfo_Impl::getPropertyByName - " + "caught NoSuchElementException!" ); + } + + } + + OSL_FAIL( "PropertySetInfo_Impl::getPropertyByName - Error!" ); + return Property(); +} + + +// virtual +sal_Bool SAL_CALL PropertySetInfo_Impl::hasPropertyByName( + const OUString& Name ) +{ + Reference< XHierarchicalNameAccess > xRootHierNameAccess( + m_pOwner->getPropertySetRegistry().getRootConfigReadAccess(), + UNO_QUERY ); + if ( xRootHierNameAccess.is() ) + { + OUString aFullPropName( m_pOwner->getFullKey() + "/" ); + aFullPropName += makeHierarchalNameSegment( Name ); + + return xRootHierNameAccess->hasByHierarchicalName( aFullPropName ); + } + + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |