diff options
Diffstat (limited to 'ucbhelper/source/provider')
20 files changed, 6367 insertions, 0 deletions
diff --git a/ucbhelper/source/provider/authenticationfallback.cxx b/ucbhelper/source/provider/authenticationfallback.cxx new file mode 100644 index 000000000..04491520b --- /dev/null +++ b/ucbhelper/source/provider/authenticationfallback.cxx @@ -0,0 +1,31 @@ +/* -*- 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/. + */ + +#include <ucbhelper/authenticationfallback.hxx> +#include <com/sun/star/ucb/AuthenticationFallbackRequest.hpp> + +using namespace com::sun::star; +using namespace ucbhelper; + +AuthenticationFallbackRequest::AuthenticationFallbackRequest( + const OUString & rInstructions, + const OUString & rURL ) +{ + + ucb::AuthenticationFallbackRequest aRequest; + aRequest.instructions = rInstructions; + aRequest.url = rURL; + + setRequest( uno::Any( aRequest ) ); + m_xAuthFallback = new InteractionAuthFallback( this ); + + setContinuations({ new InteractionAbort(this), m_xAuthFallback }); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/cancelcommandexecution.cxx b/ucbhelper/source/provider/cancelcommandexecution.cxx new file mode 100644 index 000000000..90c0168c6 --- /dev/null +++ b/ucbhelper/source/provider/cancelcommandexecution.cxx @@ -0,0 +1,125 @@ +/* -*- 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 <osl/diagnose.h> +#include <rtl/ref.hxx> +#include <cppuhelper/exc_hlp.hxx> +#include <com/sun/star/ucb/CommandFailedException.hpp> +#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> +#include <com/sun/star/ucb/XCommandEnvironment.hpp> +#include <com/sun/star/ucb/XCommandProcessor.hpp> +#include <ucbhelper/interactionrequest.hxx> +#include <ucbhelper/cancelcommandexecution.hxx> +#include "simpleioerrorrequest.hxx" + +using namespace com::sun::star; + +namespace ucbhelper +{ + + +void cancelCommandExecution( const uno::Any & rException, + const uno::Reference< + ucb::XCommandEnvironment > & xEnv ) +{ + if ( xEnv.is() ) + { + uno::Reference< + task::XInteractionHandler > xIH = xEnv->getInteractionHandler(); + if ( xIH.is() ) + { + rtl::Reference< ucbhelper::InteractionRequest > xRequest + = new ucbhelper::InteractionRequest( rException ); + + xRequest->setContinuations({ new ucbhelper::InteractionAbort(xRequest.get()) }); + + xIH->handle( xRequest ); + + rtl::Reference< ucbhelper::InteractionContinuation > xSelection + = xRequest->getSelection(); + + if ( xSelection.is() ) + throw ucb::CommandFailedException( + OUString(), + uno::Reference< uno::XInterface >(), + rException ); + } + } + + cppu::throwException( rException ); + OSL_FAIL( "Return from cppu::throwException call!!!" ); + throw uno::RuntimeException(); +} + + +void cancelCommandExecution( const ucb::IOErrorCode eError, + const uno::Sequence< uno::Any > & rArgs, + const uno::Reference< + ucb::XCommandEnvironment > & xEnv, + const OUString & rMessage, + const uno::Reference< + ucb::XCommandProcessor > & xContext ) +{ + if ( !xEnv ) + { + // Fast path + + ucb::InteractiveAugmentedIOException aRequest; + aRequest.Message = rMessage; + aRequest.Context = xContext; + aRequest.Classification = task::InteractionClassification_ERROR; + aRequest.Code = eError; + aRequest.Arguments = rArgs; + cppu::throwException( uno::Any( aRequest ) ); + } + else + { + rtl::Reference< ucbhelper::SimpleIOErrorRequest > xRequest + = new ucbhelper::SimpleIOErrorRequest( + eError, rArgs, rMessage, xContext ); + uno::Reference< + task::XInteractionHandler > xIH = xEnv->getInteractionHandler(); + if ( xIH.is() ) + { + xIH->handle( xRequest ); + + rtl::Reference< ucbhelper::InteractionContinuation > xSelection + = xRequest->getSelection(); + + if ( xSelection.is() ) + throw ucb::CommandFailedException( OUString(), + xContext, + xRequest->getRequest() ); + } + cppu::throwException( xRequest->getRequest() ); + } + + OSL_FAIL( "Return from cppu::throwException call!!!" ); + throw uno::RuntimeException(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/contenthelper.cxx b/ucbhelper/source/provider/contenthelper.cxx new file mode 100644 index 000000000..75d0a8479 --- /dev/null +++ b/ucbhelper/source/provider/contenthelper.cxx @@ -0,0 +1,862 @@ +/* -*- 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 . + */ + +#include <sal/config.h> + +#include <com/sun/star/lang/NoSupportException.hpp> +#include <com/sun/star/ucb/ContentAction.hpp> +#include <com/sun/star/ucb/IllegalIdentifierException.hpp> +#include <com/sun/star/ucb/XPersistentPropertySet.hpp> +#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 <comphelper/interfacecontainer3.hxx> +#include <cppuhelper/interfacecontainer.hxx> +#include <cppuhelper/supportsservice.hxx> +#include <cppuhelper/queryinterface.hxx> +#include <ucbhelper/contenthelper.hxx> +#include <ucbhelper/contentidentifier.hxx> +#include "contentinfo.hxx" +#include <ucbhelper/providerhelper.hxx> +#include <ucbhelper/macros.hxx> + +#include <osl/diagnose.h> +#include <osl/mutex.hxx> +#include <rtl/ref.hxx> + +#include <unordered_map> + +using namespace com::sun::star; + +namespace ucbhelper_impl +{ + +namespace { + +class PropertyEventSequence +{ + uno::Sequence< beans::PropertyChangeEvent > m_aSeq; + sal_uInt32 m_nPos; + +public: + explicit PropertyEventSequence( sal_uInt32 nSize ) + : m_aSeq( nSize ), m_nPos( 0 ) {}; + + void append( const beans::PropertyChangeEvent& rEvt ) + { m_aSeq.getArray()[ m_nPos ] = rEvt; ++m_nPos; } + + const uno::Sequence< beans::PropertyChangeEvent >& getEvents() + { m_aSeq.realloc( m_nPos ); return m_aSeq; } +}; + +} + +typedef void* XPropertiesChangeListenerPtr; // -> Compiler problems! + +namespace { + +struct equalPtr +{ + bool operator()( const XPropertiesChangeListenerPtr& rp1, + const XPropertiesChangeListenerPtr& rp2 ) const + { + return ( rp1 == rp2 ); + } +}; + +struct hashPtr +{ + size_t operator()( const XPropertiesChangeListenerPtr& rp ) const + { + return reinterpret_cast<size_t>(rp); + } +}; + +} + +typedef std::unordered_map +< + XPropertiesChangeListenerPtr, + PropertyEventSequence, + hashPtr, + equalPtr +> +PropertiesEventListenerMap; + +typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString> + PropertyChangeListeners; + +struct ContentImplHelper_Impl +{ + rtl::Reference< ::ucbhelper::PropertySetInfo > m_xPropSetInfo; + rtl::Reference< ::ucbhelper::CommandProcessorInfo > m_xCommandsInfo; + std::unique_ptr<cppu::OInterfaceContainerHelper> m_pDisposeEventListeners; + std::unique_ptr<comphelper::OInterfaceContainerHelper3<css::ucb::XContentEventListener>> + m_pContentEventListeners; + std::unique_ptr<comphelper::OInterfaceContainerHelper3<beans::XPropertySetInfoChangeListener>> + m_pPropSetChangeListeners; + std::unique_ptr<cppu::OInterfaceContainerHelper> m_pCommandChangeListeners; + std::unique_ptr<PropertyChangeListeners> m_pPropertyChangeListeners; +}; + +} // namespace ucbhelper_impl + +using namespace ucbhelper_impl; + +namespace ucbhelper { + +ContentImplHelper::ContentImplHelper( + const uno::Reference< uno::XComponentContext >& rxContext, + const rtl::Reference< ContentProviderImplHelper >& rxProvider, + const uno::Reference< + css::ucb::XContentIdentifier >& Identifier ) +: m_pImpl( new ContentImplHelper_Impl ), + m_xContext( rxContext ), + m_xIdentifier( Identifier ), + m_xProvider( rxProvider ), + m_nCommandId( 0 ) +{ +} + +// virtual +ContentImplHelper::~ContentImplHelper() +{ +} + +void SAL_CALL ContentImplHelper::release() + noexcept +{ + // #144882# - Call to OWeakObject::release may destroy m_xProvider. + // Prevent this. + rtl::Reference< ContentProviderImplHelper > xKeepProviderAlive( + m_xProvider ); + + osl::MutexGuard aGuard( m_xProvider->m_aMutex ); + OWeakObject::release(); +} + +uno::Any SAL_CALL ContentImplHelper::queryInterface( const uno::Type & rType ) +{ + css::uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >(this), + static_cast< lang::XServiceInfo * >(this), + static_cast< lang::XComponent * >(this), + static_cast< css::ucb::XContent * >(this), + static_cast< css::ucb::XCommandProcessor * >(this), + static_cast< beans::XPropertiesChangeNotifier * >(this), + static_cast< css::ucb::XCommandInfoChangeNotifier * >(this), + static_cast< beans::XPropertyContainer * >(this), + static_cast< beans::XPropertySetInfoChangeNotifier * >(this), + static_cast< container::XChild * >(this)); + return aRet.hasValue() ? aRet : cppu::OWeakObject::queryInterface( rType ); +} + +XTYPEPROVIDER_IMPL_10( ContentImplHelper, + lang::XTypeProvider, + lang::XServiceInfo, + lang::XComponent, + css::ucb::XContent, + css::ucb::XCommandProcessor, + beans::XPropertiesChangeNotifier, + css::ucb::XCommandInfoChangeNotifier, + beans::XPropertyContainer, + beans::XPropertySetInfoChangeNotifier, + container::XChild ); + +// virtual +sal_Bool SAL_CALL ContentImplHelper::supportsService( + const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +// virtual +void SAL_CALL ContentImplHelper::dispose() +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pImpl->m_pDisposeEventListeners && + m_pImpl->m_pDisposeEventListeners->getLength() ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< lang::XComponent * >( this ); + m_pImpl->m_pDisposeEventListeners->disposeAndClear( aEvt ); + } + + if ( m_pImpl->m_pContentEventListeners && + m_pImpl->m_pContentEventListeners->getLength() ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< css::ucb::XContent * >( this ); + m_pImpl->m_pContentEventListeners->disposeAndClear( aEvt ); + } + + if ( m_pImpl->m_pPropSetChangeListeners && + m_pImpl->m_pPropSetChangeListeners->getLength() ) + { + lang::EventObject aEvt; + aEvt.Source + = static_cast< beans::XPropertySetInfoChangeNotifier * >( this ); + m_pImpl->m_pPropSetChangeListeners->disposeAndClear( aEvt ); + } + + if ( m_pImpl->m_pCommandChangeListeners && + m_pImpl->m_pCommandChangeListeners->getLength() ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< css::ucb::XCommandInfoChangeNotifier * >( this ); + m_pImpl->m_pCommandChangeListeners->disposeAndClear( aEvt ); + } + + if ( m_pImpl->m_pPropertyChangeListeners ) + { + lang::EventObject aEvt; + aEvt.Source + = static_cast< beans::XPropertiesChangeNotifier * >( this ); + m_pImpl->m_pPropertyChangeListeners->disposeAndClear( aEvt ); + } +} + +// virtual +void SAL_CALL ContentImplHelper::addEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pDisposeEventListeners ) + m_pImpl->m_pDisposeEventListeners.reset( + new cppu::OInterfaceContainerHelper( m_aMutex )); + + m_pImpl->m_pDisposeEventListeners->addInterface( Listener ); +} + +// virtual +void SAL_CALL ContentImplHelper::removeEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pImpl->m_pDisposeEventListeners ) + m_pImpl->m_pDisposeEventListeners->removeInterface( Listener ); +} + +// virtual +uno::Reference< css::ucb::XContentIdentifier > SAL_CALL +ContentImplHelper::getIdentifier() +{ + return m_xIdentifier; +} + +// virtual +void SAL_CALL ContentImplHelper::addContentEventListener( + const uno::Reference< css::ucb::XContentEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pContentEventListeners ) + m_pImpl->m_pContentEventListeners.reset( + new comphelper::OInterfaceContainerHelper3<css::ucb::XContentEventListener>( m_aMutex )); + + m_pImpl->m_pContentEventListeners->addInterface( Listener ); +} + +// virtual +void SAL_CALL ContentImplHelper::removeContentEventListener( + const uno::Reference< css::ucb::XContentEventListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pImpl->m_pContentEventListeners ) + m_pImpl->m_pContentEventListeners->removeInterface( Listener ); +} + +// virtual +sal_Int32 SAL_CALL ContentImplHelper::createCommandIdentifier() +{ + osl::MutexGuard aGuard( m_aMutex ); + + // Just increase counter on every call to generate an identifier. + return ++m_nCommandId; +} + +// virtual +void SAL_CALL ContentImplHelper::addPropertiesChangeListener( + const uno::Sequence< OUString >& PropertyNames, + const uno::Reference< beans::XPropertiesChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pPropertyChangeListeners ) + m_pImpl->m_pPropertyChangeListeners.reset( + new PropertyChangeListeners( m_aMutex )); + + if ( !PropertyNames.hasElements() ) + { + // Note: An empty sequence means a listener for "all" properties. + m_pImpl->m_pPropertyChangeListeners->addInterface( + OUString(), Listener ); + } + else + { + for ( const OUString& rName : PropertyNames ) + { + if ( !rName.isEmpty() ) + m_pImpl->m_pPropertyChangeListeners->addInterface( + rName, Listener ); + } + } +} + +// virtual +void SAL_CALL ContentImplHelper::removePropertiesChangeListener( + const uno::Sequence< OUString >& PropertyNames, + const uno::Reference< beans::XPropertiesChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pPropertyChangeListeners ) + return; + + if ( !PropertyNames.hasElements() ) + { + // Note: An empty sequence means a listener for "all" properties. + m_pImpl->m_pPropertyChangeListeners->removeInterface( + OUString(), Listener ); + } + else + { + for ( const OUString& rName : PropertyNames ) + { + if ( !rName.isEmpty() ) + m_pImpl->m_pPropertyChangeListeners->removeInterface( + rName, Listener ); + } + } +} + +// virtual +void SAL_CALL ContentImplHelper::addCommandInfoChangeListener( + const uno::Reference< css::ucb::XCommandInfoChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pCommandChangeListeners ) + m_pImpl->m_pCommandChangeListeners.reset( + new cppu::OInterfaceContainerHelper( m_aMutex )); + + m_pImpl->m_pCommandChangeListeners->addInterface( Listener ); +} + +// virtual +void SAL_CALL ContentImplHelper::removeCommandInfoChangeListener( + const uno::Reference< css::ucb::XCommandInfoChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pImpl->m_pCommandChangeListeners ) + m_pImpl->m_pCommandChangeListeners->removeInterface( Listener ); +} + +// virtual +void SAL_CALL ContentImplHelper::addProperty( + const OUString& Name, + sal_Int16 Attributes, + const uno::Any& DefaultValue ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + // Make sure a property with the requested name does not already + // exist in dynamic and static(!) properties. + + // @@@ Need real command environment here, but where to get it from? + // XPropertyContainer interface should be replaced by + // XCommandProcessor commands! + uno::Reference< css::ucb::XCommandEnvironment > xEnv; + + if ( getPropertySetInfo( xEnv )->hasPropertyByName( Name ) ) + { + // Property does already exist. + throw beans::PropertyExistException(); + } + + // Add a new dynamic property. + // Open/create persistent property set. + uno::Reference< css::ucb::XPersistentPropertySet > xSet( + getAdditionalPropertySet( true ) ); + + OSL_ENSURE( xSet.is(), + "ContentImplHelper::addProperty - No property set!" ); + + if ( !xSet.is() ) + return; + + uno::Reference< beans::XPropertyContainer > xContainer( + xSet, uno::UNO_QUERY ); + + OSL_ENSURE( + xContainer.is(), + "ContentImplHelper::addProperty - No property container!" ); + + if ( !xContainer.is() ) + return; + + // Property is always removable. + Attributes |= beans::PropertyAttribute::REMOVABLE; + + try + { + xContainer->addProperty( Name, Attributes, DefaultValue ); + } + catch ( beans::PropertyExistException const & ) + { + OSL_FAIL( "ContentImplHelper::addProperty - Exists!" ); + throw; + } + catch ( beans::IllegalTypeException const & ) + { + OSL_FAIL( "ContentImplHelper::addProperty - Wrong Type!" ); + throw; + } + catch ( lang::IllegalArgumentException const & ) + { + OSL_FAIL( "ContentImplHelper::addProperty - Illegal Arg!" ); + throw; + } + + // Success! + + if ( m_pImpl->m_xPropSetInfo.is() ) + { + // Info cached in propertyset info is invalid now! + m_pImpl->m_xPropSetInfo->reset(); + } + + // Notify propertyset info change listeners. + if ( m_pImpl->m_pPropSetChangeListeners && + m_pImpl->m_pPropSetChangeListeners->getLength() ) + { + beans::PropertySetInfoChangeEvent evt( + static_cast< cppu::OWeakObject * >( this ), + Name, + -1, // No handle available + beans::PropertySetInfoChange::PROPERTY_INSERTED ); + notifyPropertySetInfoChange( evt ); + } +} + +// virtual +void SAL_CALL ContentImplHelper::removeProperty( const OUString& Name ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + try + { + // @@@ Need real command environment here, but where to get it from? + // XPropertyContainer interface should be replaced by + // XCommandProcessor commands! + uno::Reference< css::ucb::XCommandEnvironment > xEnv; + + beans::Property aProp + = getPropertySetInfo( xEnv )->getPropertyByName( Name ); + + if ( !( aProp.Attributes & beans::PropertyAttribute::REMOVABLE ) ) + { + // Not removable! + throw beans::NotRemoveableException(); + } + } + catch ( beans::UnknownPropertyException const & ) + { + OSL_FAIL( "ContentImplHelper::removeProperty - Unknown!" ); + throw; + } + + // Try to remove property from dynamic property set. + // Open persistent property set, if exists. + uno::Reference< css::ucb::XPersistentPropertySet > xSet( + getAdditionalPropertySet( false ) ); + if ( !xSet.is() ) + return; + + uno::Reference< beans::XPropertyContainer > xContainer( + xSet, uno::UNO_QUERY ); + + OSL_ENSURE( + xContainer.is(), + "ContentImplHelper::removeProperty - No property container!" ); + + if ( !xContainer.is() ) + return; + + try + { + xContainer->removeProperty( Name ); + } + catch ( beans::UnknownPropertyException const & ) + { + OSL_FAIL( "ContentImplHelper::removeProperty - Unknown!" ); + throw; + } + catch ( beans::NotRemoveableException const & ) + { + OSL_FAIL( + "ContentImplHelper::removeProperty - Unremovable!" ); + throw; + } + + xContainer = nullptr; + + // Success! + + if ( !xSet->getPropertySetInfo()->getProperties().hasElements() ) + { + // Remove empty propertyset from registry. + uno::Reference< css::ucb::XPropertySetRegistry > + xReg = xSet->getRegistry(); + if ( xReg.is() ) + { + OUString aKey( xSet->getKey() ); + xSet = nullptr; + xReg->removePropertySet( aKey ); + } + } + + if ( m_pImpl->m_xPropSetInfo.is() ) + { + // Info cached in propertyset info is invalid now! + m_pImpl->m_xPropSetInfo->reset(); + } + + // Notify propertyset info change listeners. + if ( m_pImpl->m_pPropSetChangeListeners && + m_pImpl->m_pPropSetChangeListeners->getLength() ) + { + beans::PropertySetInfoChangeEvent evt( + static_cast< cppu::OWeakObject * >( this ), + Name, + -1, // No handle available + beans::PropertySetInfoChange::PROPERTY_REMOVED ); + notifyPropertySetInfoChange( evt ); + } +} + +// virtual +void SAL_CALL ContentImplHelper::addPropertySetInfoChangeListener( + const uno::Reference< beans::XPropertySetInfoChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_pPropSetChangeListeners ) + m_pImpl->m_pPropSetChangeListeners.reset( + new comphelper::OInterfaceContainerHelper3<beans::XPropertySetInfoChangeListener>( m_aMutex )); + + m_pImpl->m_pPropSetChangeListeners->addInterface( Listener ); +} + +// virtual +void SAL_CALL ContentImplHelper::removePropertySetInfoChangeListener( + const uno::Reference< beans::XPropertySetInfoChangeListener >& Listener ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pImpl->m_pPropSetChangeListeners ) + m_pImpl->m_pPropSetChangeListeners->removeInterface( Listener ); +} + +// virtual +uno::Reference< uno::XInterface > SAL_CALL ContentImplHelper::getParent() +{ + uno::Reference< uno::XInterface > xParent; + OUString aURL = getParentURL(); + + if ( !aURL.isEmpty() ) + { + uno::Reference< css::ucb::XContentIdentifier > xId( + new ContentIdentifier( aURL ) ); + try + { + xParent.set( m_xProvider->queryContent( xId ) ); + } + catch ( css::ucb::IllegalIdentifierException const & ) + { + } + } + + return xParent; +} + +// virtual +void SAL_CALL ContentImplHelper::setParent( + const uno::Reference< uno::XInterface >& ) +{ + throw lang::NoSupportException(); +} + +uno::Reference< css::ucb::XPersistentPropertySet > +ContentImplHelper::getAdditionalPropertySet( bool bCreate ) +{ + // Get propertyset from provider. + return m_xProvider->getAdditionalPropertySet( + m_xIdentifier->getContentIdentifier(), bCreate ); +} + +bool ContentImplHelper::renameAdditionalPropertySet( + const OUString& rOldKey, + const OUString& rNewKey ) +{ + return m_xProvider->renameAdditionalPropertySet( + rOldKey, rNewKey, true/*bRecursive*/ ); +} + +bool ContentImplHelper::copyAdditionalPropertySet( + const OUString& rSourceKey, + const OUString& rTargetKey ) +{ + return m_xProvider->copyAdditionalPropertySet( + rSourceKey, rTargetKey, true/*bRecursive*/ ); +} + +bool ContentImplHelper::removeAdditionalPropertySet() +{ + return m_xProvider->removeAdditionalPropertySet( + m_xIdentifier->getContentIdentifier(), true/*bRecursive*/ ); +} + +void ContentImplHelper::notifyPropertiesChange( + const uno::Sequence< beans::PropertyChangeEvent >& evt ) const +{ + if ( !m_pImpl->m_pPropertyChangeListeners ) + return; + + sal_Int32 nCount = evt.getLength(); + if ( !nCount ) + return; + + // First, notify listeners interested in changes of every property. + cppu::OInterfaceContainerHelper* pAllPropsContainer + = m_pImpl->m_pPropertyChangeListeners->getContainer( + OUString() ); + if ( pAllPropsContainer ) + { + cppu::OInterfaceIteratorHelper aIter( *pAllPropsContainer ); + while ( aIter.hasMoreElements() ) + { + // Propagate event. + static_cast< beans::XPropertiesChangeListener* >( + aIter.next())->propertiesChange( evt ); + } + } + + PropertiesEventListenerMap aListeners; + + for ( const beans::PropertyChangeEvent& rEvent : evt ) + { + const OUString& rName = rEvent.PropertyName; + + cppu::OInterfaceContainerHelper* pPropsContainer + = m_pImpl->m_pPropertyChangeListeners->getContainer( rName ); + if ( pPropsContainer ) + { + cppu::OInterfaceIteratorHelper aIter( *pPropsContainer ); + while ( aIter.hasMoreElements() ) + { + PropertyEventSequence* p = nullptr; + + beans::XPropertiesChangeListener* pListener = + static_cast< beans::XPropertiesChangeListener * >( + aIter.next() ); + PropertiesEventListenerMap::iterator it = + aListeners.find( pListener ); + if ( it == aListeners.end() ) + { + // Not in map - create and insert new entry. + p = &aListeners.emplace( pListener, PropertyEventSequence(nCount)).first->second; + } + else + p = &it->second; + + if ( p ) + p->append( rEvent ); + } + } + } + + // Notify listeners. + PropertiesEventListenerMap::iterator it = aListeners.begin(); + while ( !aListeners.empty() ) + { + beans::XPropertiesChangeListener* pListener = + static_cast< beans::XPropertiesChangeListener * >( (*it).first ); + PropertyEventSequence pSeq = std::move(it->second); + + // Remove current element. + aListeners.erase( it ); + + // Propagate event. + pListener->propertiesChange( pSeq.getEvents() ); + + it = aListeners.begin(); + } +} + +void ContentImplHelper::notifyPropertySetInfoChange( + const beans::PropertySetInfoChangeEvent& evt ) const +{ + if ( !m_pImpl->m_pPropSetChangeListeners ) + return; + + // Notify event listeners. + m_pImpl->m_pPropSetChangeListeners->notifyEach( &beans::XPropertySetInfoChangeListener::propertySetInfoChange, evt ); +} + +void ContentImplHelper::notifyContentEvent( + const css::ucb::ContentEvent& evt ) const +{ + if ( !m_pImpl->m_pContentEventListeners ) + return; + + // Notify event listeners. + m_pImpl->m_pContentEventListeners->notifyEach( &css::ucb::XContentEventListener::contentEvent, evt); +} + +void ContentImplHelper::inserted() +{ + // Content is not yet registered at provider. + m_xProvider->registerNewContent( this ); + + // If the parent content is currently not instantiated, there can be + // no listeners interested in changes ;-) + + rtl::Reference< ContentImplHelper > xParent + = m_xProvider->queryExistingContent( getParentURL() ); + + if ( xParent.is() ) + { + css::ucb::ContentEvent aEvt( + static_cast< cppu::OWeakObject * >( xParent.get() ), // Source + css::ucb::ContentAction::INSERTED, // Action + this, // Content + xParent->getIdentifier() ); // Id + xParent->notifyContentEvent( aEvt ); + } +} + +void ContentImplHelper::deleted() +{ + uno::Reference< css::ucb::XContent > xThis = this; + + rtl::Reference< ContentImplHelper > xParent + = m_xProvider->queryExistingContent( getParentURL() ); + + if ( xParent.is() ) + { + // Let parent notify "REMOVED" event. + css::ucb::ContentEvent aEvt( + static_cast< cppu::OWeakObject * >( xParent.get() ), + css::ucb::ContentAction::REMOVED, + this, + xParent->getIdentifier() ); + xParent->notifyContentEvent( aEvt ); + } + + // Notify "DELETED" event. + css::ucb::ContentEvent aEvt1( + static_cast< cppu::OWeakObject * >( this ), + css::ucb::ContentAction::DELETED, + this, + getIdentifier() ); + notifyContentEvent( aEvt1 ); + + m_xProvider->removeContent( this ); +} + +bool ContentImplHelper::exchange( + const uno::Reference< css::ucb::XContentIdentifier >& rNewId ) +{ + uno::Reference< css::ucb::XContent > xThis = this; + + osl::ClearableMutexGuard aGuard( m_aMutex ); + + rtl::Reference< ContentImplHelper > xContent + = m_xProvider->queryExistingContent( rNewId ); + if ( xContent.is() ) + { + // @@@ + // Big trouble. Another object with the new identity exists. + // How shall I mutate to / merge with the other object? + return false; + } + + uno::Reference< css::ucb::XContentIdentifier > xOldId + = getIdentifier(); + + // Re-insert at provider. + m_xProvider->removeContent( this ); + m_xIdentifier = rNewId; + m_xProvider->registerNewContent( this ); + + aGuard.clear(); + + // Notify "EXCHANGED" event. + css::ucb::ContentEvent aEvt( + static_cast< cppu::OWeakObject * >( this ), + css::ucb::ContentAction::EXCHANGED, + this, + xOldId ); + notifyContentEvent( aEvt ); + return true; +} + +uno::Reference< css::ucb::XCommandInfo > +ContentImplHelper::getCommandInfo( + const uno::Reference< css::ucb::XCommandEnvironment > & xEnv, + bool bCache ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_xCommandsInfo.is() ) + m_pImpl->m_xCommandsInfo + = new CommandProcessorInfo( xEnv, this ); + else if ( !bCache ) + m_pImpl->m_xCommandsInfo->reset(); + + return m_pImpl->m_xCommandsInfo; +} + +uno::Reference< beans::XPropertySetInfo > +ContentImplHelper::getPropertySetInfo( + const uno::Reference< css::ucb::XCommandEnvironment > & xEnv, + bool bCache ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_xPropSetInfo.is() ) + m_pImpl->m_xPropSetInfo + = new PropertySetInfo( xEnv, this ); + else if ( !bCache ) + m_pImpl->m_xPropSetInfo->reset(); + + return m_pImpl->m_xPropSetInfo; +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/contentidentifier.cxx b/ucbhelper/source/provider/contentidentifier.cxx new file mode 100644 index 000000000..d4c13b2c0 --- /dev/null +++ b/ucbhelper/source/provider/contentidentifier.cxx @@ -0,0 +1,101 @@ +/* -*- 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 <ucbhelper/contentidentifier.hxx> + +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::ucb; + + +namespace ucbhelper +{ + + +// struct ContentIdentifier_Impl. + + +struct ContentIdentifier_Impl +{ + OUString m_aContentId; + OUString m_aProviderScheme; + + explicit ContentIdentifier_Impl( const OUString& rURL ); +}; + + +// ContentIdentifier_Impl Implementation. + + +ContentIdentifier_Impl::ContentIdentifier_Impl(const OUString& rURL ) +{ + // Normalize URL scheme ( it's case insensitive ). + + // The content provider scheme is the part before the first ':' + // within the content id. + sal_Int32 nPos = rURL.indexOf( ':' ); + if ( nPos != -1 ) + { + OUString aScheme( rURL.copy( 0, nPos ) ); + m_aProviderScheme = aScheme.toAsciiLowerCase(); + m_aContentId = rURL.replaceAt( 0, nPos, aScheme ); + } +} + + +// ContentIdentifier Implementation. + + +ContentIdentifier::ContentIdentifier( const OUString& rURL ) + : m_pImpl( new ContentIdentifier_Impl( rURL ) ) +{ +} + + +// virtual +ContentIdentifier::~ContentIdentifier() +{ +} + + +// XContentIdentifier methods. + + +// virtual +OUString SAL_CALL ContentIdentifier::getContentIdentifier() +{ + return m_pImpl->m_aContentId; +} + + +// virtual +OUString SAL_CALL ContentIdentifier::getContentProviderScheme() +{ + return m_pImpl->m_aProviderScheme; +} + +} /* namespace ucbhelper */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/contentinfo.cxx b/ucbhelper/source/provider/contentinfo.cxx new file mode 100644 index 000000000..b5ca80b79 --- /dev/null +++ b/ucbhelper/source/provider/contentinfo.cxx @@ -0,0 +1,322 @@ +/* -*- 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 <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/ucb/UnsupportedCommandException.hpp> +#include <com/sun/star/ucb/XPersistentPropertySet.hpp> +#include <com/sun/star/ucb/XCommandInfo.hpp> + +#include <ucbhelper/contenthelper.hxx> +#include "contentinfo.hxx" + +using namespace com::sun::star; + + +// PropertySetInfo Implementation. + + +namespace ucbhelper { + +PropertySetInfo::PropertySetInfo( + const uno::Reference< css::ucb::XCommandEnvironment >& rxEnv, + ContentImplHelper* pContent ) +: m_xEnv( rxEnv ), + m_pContent( pContent ) +{ +} + + +// virtual +PropertySetInfo::~PropertySetInfo() +{ +} + + +// XPropertySetInfo methods. + + +// virtual +uno::Sequence< beans::Property > SAL_CALL PropertySetInfo::getProperties() +{ + std::unique_lock aGuard( m_aMutex ); + return getPropertiesImpl(); +} + +const uno::Sequence< beans::Property > & PropertySetInfo::getPropertiesImpl() +{ + if ( m_xProps ) + return *m_xProps; + + // Get info for core ( native) properties. + + try + { + m_xProps = m_pContent->getProperties( m_xEnv ); + } + catch ( uno::RuntimeException const & ) + { + throw; + } + catch ( uno::Exception const & ) + { + m_xProps.emplace(); + } + + // Get info for additional properties. + + uno::Reference< css::ucb::XPersistentPropertySet > + xSet ( m_pContent->getAdditionalPropertySet( false ) ); + + if ( xSet.is() ) + { + // Get property set info. + uno::Reference< beans::XPropertySetInfo > xInfo( + xSet->getPropertySetInfo() ); + if ( xInfo.is() ) + { + const uno::Sequence< beans::Property >& rAddProps + = xInfo->getProperties(); + sal_Int32 nAddProps = rAddProps.getLength(); + if ( nAddProps > 0 ) + { + sal_Int32 nPos = m_xProps->getLength(); + m_xProps->realloc( nPos + nAddProps ); + + std::copy(rAddProps.begin(), rAddProps.end(), + std::next(m_xProps->getArray(), nPos)); + } + } + } + return *m_xProps; +} + + +// virtual +beans::Property SAL_CALL PropertySetInfo::getPropertyByName( + const OUString& aName ) +{ + beans::Property aProp; + if ( queryProperty( aName, aProp ) ) + return aProp; + + throw beans::UnknownPropertyException(aName); +} + + +// virtual +sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName( + const OUString& Name ) +{ + beans::Property aProp; + return queryProperty( Name, aProp ); +} + + +// Non-Interface methods. + + +void PropertySetInfo::reset() +{ + std::unique_lock aGuard( m_aMutex ); + m_xProps.reset(); +} + + +bool PropertySetInfo::queryProperty( + std::u16string_view rName, beans::Property& rProp ) +{ + std::unique_lock aGuard( m_aMutex ); + + getPropertiesImpl(); + + const beans::Property* pProps = m_xProps->getConstArray(); + sal_Int32 nCount = m_xProps->getLength(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + const beans::Property& rCurrProp = pProps[ n ]; + if ( rCurrProp.Name == rName ) + { + rProp = rCurrProp; + return true; + } + } + + return false; +} + + +// CommandProcessorInfo Implementation. + + +CommandProcessorInfo::CommandProcessorInfo( + const uno::Reference< css::ucb::XCommandEnvironment >& rxEnv, + ContentImplHelper* pContent ) +: m_xEnv( rxEnv ), + m_pContent( pContent ) +{ +} + + +// virtual +CommandProcessorInfo::~CommandProcessorInfo() +{ +} + + +// XCommandInfo methods. + + +// virtual +uno::Sequence< css::ucb::CommandInfo > SAL_CALL CommandProcessorInfo::getCommands() +{ + std::unique_lock aGuard( m_aMutex ); + return getCommandsImpl(); +} + +const uno::Sequence< css::ucb::CommandInfo > & CommandProcessorInfo::getCommandsImpl() +{ + if ( m_xCommands ) + return *m_xCommands; + + // Get info for commands. + + try + { + m_xCommands = m_pContent->getCommands( m_xEnv ); + } + catch ( uno::RuntimeException const & ) + { + throw; + } + catch ( uno::Exception const & ) + { + m_xCommands.emplace(); + } + return *m_xCommands; +} + + +// virtual +css::ucb::CommandInfo SAL_CALL +CommandProcessorInfo::getCommandInfoByName( + const OUString& Name ) +{ + css::ucb::CommandInfo aInfo; + if ( queryCommand( Name, aInfo ) ) + return aInfo; + + throw css::ucb::UnsupportedCommandException(); +} + + +// virtual +css::ucb::CommandInfo SAL_CALL +CommandProcessorInfo::getCommandInfoByHandle( sal_Int32 Handle ) +{ + css::ucb::CommandInfo aInfo; + if ( queryCommand( Handle, aInfo ) ) + return aInfo; + + throw css::ucb::UnsupportedCommandException(); +} + + +// virtual +sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByName( + const OUString& Name ) +{ + css::ucb::CommandInfo aInfo; + return queryCommand( Name, aInfo ); +} + + +// virtual +sal_Bool SAL_CALL CommandProcessorInfo::hasCommandByHandle( sal_Int32 Handle ) +{ + css::ucb::CommandInfo aInfo; + return queryCommand( Handle, aInfo ); +} + + +// Non-Interface methods. + + +void CommandProcessorInfo::reset() +{ + std::unique_lock aGuard( m_aMutex ); + m_xCommands.reset(); +} + + +bool CommandProcessorInfo::queryCommand( + std::u16string_view rName, + css::ucb::CommandInfo& rCommand ) +{ + std::unique_lock aGuard( m_aMutex ); + + getCommandsImpl(); + + const css::ucb::CommandInfo* pCommands + = m_xCommands->getConstArray(); + sal_Int32 nCount = m_xCommands->getLength(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + const css::ucb::CommandInfo& rCurrCommand = pCommands[ n ]; + if ( rCurrCommand.Name == rName ) + { + rCommand = rCurrCommand; + return true; + } + } + + return false; +} + + +bool CommandProcessorInfo::queryCommand( + sal_Int32 nHandle, + css::ucb::CommandInfo& rCommand ) +{ + std::unique_lock aGuard( m_aMutex ); + + getCommandsImpl(); + + const css::ucb::CommandInfo* pCommands = m_xCommands->getConstArray(); + sal_Int32 nCount = m_xCommands->getLength(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + const css::ucb::CommandInfo& rCurrCommand = pCommands[ n ]; + if ( rCurrCommand.Handle == nHandle ) + { + rCommand = rCurrCommand; + return true; + } + } + + return false; +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/contentinfo.hxx b/ucbhelper/source/provider/contentinfo.hxx new file mode 100644 index 000000000..922384832 --- /dev/null +++ b/ucbhelper/source/provider/contentinfo.hxx @@ -0,0 +1,119 @@ +/* -*- 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 . + */ + +#ifndef UCBHELPER_SOURCE_PROVIDER_CONTENTINFO_HXX +#define UCBHELPER_SOURCE_PROVIDER_CONTENTINFO_HXX + +#include <optional> +#include <com/sun/star/ucb/XCommandInfo.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <cppuhelper/implbase.hxx> + +#include <mutex> + +namespace com::sun::star::ucb { class XCommandEnvironment; } + +namespace ucbhelper { + + + + +class ContentImplHelper; + +/** + * This class provides a propertyset info ( the complete implementation of + * the interface XPropertySetInfo ) for an object derived from class + * ucb::ContentImplHelper. The implementation takes care about Additional + * Core Properties that may have been added to the content. + */ +class PropertySetInfo : + public cppu::WeakImplHelper<css::beans::XPropertySetInfo> +{ + css::uno::Reference< css::ucb::XCommandEnvironment > + m_xEnv; + std::optional<css::uno::Sequence< css::beans::Property >> + m_xProps; + std::mutex m_aMutex; + ContentImplHelper* m_pContent; + +private: + bool queryProperty( std::u16string_view rName, + css::beans::Property& rProp ); + const css::uno::Sequence< css::beans::Property > & getPropertiesImpl(); + +public: + PropertySetInfo( const css::uno::Reference< css::ucb::XCommandEnvironment >& rxEnv, + ContentImplHelper* pContent ); + virtual ~PropertySetInfo() override; + + // XPropertySetInfo + virtual css::uno::Sequence< css::beans::Property > SAL_CALL getProperties() override; + virtual css::beans::Property SAL_CALL getPropertyByName( const OUString& aName ) override; + virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override; + + // Non-Interface methods. + void reset(); +}; + + + + +/** + * This class provides a command info ( the complete implementation of + * the interface XCommandInfo ) for an object derived from class + * ucb::ContentImplHelper. + */ +class CommandProcessorInfo : + public cppu::WeakImplHelper<css::ucb::XCommandInfo> +{ + css::uno::Reference< css::ucb::XCommandEnvironment > + m_xEnv; + std::optional<css::uno::Sequence< css::ucb::CommandInfo >> + m_xCommands; + std::mutex m_aMutex; + ContentImplHelper* m_pContent; + +private: + bool queryCommand( std::u16string_view rName, + css::ucb::CommandInfo& rCommand ); + bool queryCommand( sal_Int32 nHandle, + css::ucb::CommandInfo& rCommand ); + const css::uno::Sequence< css::ucb::CommandInfo > & getCommandsImpl(); + +public: + CommandProcessorInfo( const css::uno::Reference< css::ucb::XCommandEnvironment >& rxEnv, + ContentImplHelper* pContent ); + virtual ~CommandProcessorInfo() override; + + // XCommandInfo + virtual css::uno::Sequence< css::ucb::CommandInfo > SAL_CALL getCommands() override; + virtual css::ucb::CommandInfo SAL_CALL getCommandInfoByName( const OUString& Name ) override; + virtual css::ucb::CommandInfo SAL_CALL getCommandInfoByHandle( sal_Int32 Handle ) override; + virtual sal_Bool SAL_CALL hasCommandByName( const OUString& Name ) override; + virtual sal_Bool SAL_CALL hasCommandByHandle( sal_Int32 Handle ) override; + + // Non-Interface methods. + void reset(); +}; + +} // namespace ucbhelper + +#endif /* ! UCBHELPER_SOURCE_PROVIDER_CONTENTINFO_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/fd_inputstream.cxx b/ucbhelper/source/provider/fd_inputstream.cxx new file mode 100644 index 000000000..795c2dcae --- /dev/null +++ b/ucbhelper/source/provider/fd_inputstream.cxx @@ -0,0 +1,146 @@ +/* -*- 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 . + */ + +#include <ucbhelper/fd_inputstream.hxx> + +#include <com/sun/star/io/IOException.hpp> +#include <osl/diagnose.h> +#include <sal/log.hxx> +#include <algorithm> + +using namespace com::sun::star::uno; +using namespace com::sun::star::lang; +using namespace com::sun::star::io; + +namespace ucbhelper +{ + FdInputStream::FdInputStream( oslFileHandle tmpfl ) + : m_tmpfl(tmpfl) + , m_nLength( 0 ) + { + if ( !m_tmpfl ) + osl_createTempFile( nullptr, &m_tmpfl, nullptr ); + OSL_ENSURE( m_tmpfl, "input stream without tempfile!" ); + + if ( osl_setFilePos( m_tmpfl, osl_Pos_End, 0 ) == osl_File_E_None ) + { + sal_uInt64 nFileSize = 0; + if ( osl_getFilePos( m_tmpfl, &nFileSize ) == osl_File_E_None ) + m_nLength = nFileSize; + oslFileError rc = osl_setFilePos( m_tmpfl, osl_Pos_Absolut, 0 ); + SAL_WARN_IF(rc != osl_File_E_None, "ucbhelper", "osl_setFilePos failed"); + } + } + + FdInputStream::~FdInputStream() + { + if ( nullptr != m_tmpfl) + osl_closeFile(m_tmpfl); + } + + sal_Int32 SAL_CALL FdInputStream::readBytes(Sequence< sal_Int8 >& aData, + sal_Int32 nBytesToRead) + { + osl::MutexGuard aGuard(m_aMutex); + + sal_uInt64 nBeforePos( 0 ); + sal_uInt64 nBytesRequested( nBytesToRead ); + sal_uInt64 nBytesRead( 0 ); + + osl_getFilePos( m_tmpfl, &nBeforePos ); + + if ( 0 == ( nBytesRequested = std::min< sal_uInt64 >( m_nLength - nBeforePos, nBytesRequested ) ) ) + return 0; + + if ( 0 <= nBytesToRead && aData.getLength() < nBytesToRead ) + aData.realloc( nBytesToRead ); + + if ( osl_readFile( m_tmpfl, aData.getArray(), nBytesRequested, &nBytesRead ) != osl_File_E_None ) + throw IOException(); + + return sal_Int32( nBytesRead ); + } + + + sal_Int32 SAL_CALL FdInputStream::readSomeBytes( Sequence< sal_Int8 >& aData, + sal_Int32 nMaxBytesToRead ) + { + return readBytes(aData,nMaxBytesToRead); + } + + + void SAL_CALL FdInputStream::skipBytes(sal_Int32 nBytesToSkip) + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_tmpfl) + throw IOException(); + + oslFileError rc = osl_setFilePos( m_tmpfl, osl_Pos_Current, nBytesToSkip ); + SAL_WARN_IF(rc != osl_File_E_None, "ucbhelper", "osl_setFilePos failed"); + } + + + sal_Int32 SAL_CALL FdInputStream::available() + { + return std::min<sal_Int64>(SAL_MAX_INT32, m_nLength - getPosition()); + } + + + void SAL_CALL FdInputStream::closeInput() + { + osl::MutexGuard aGuard(m_aMutex); + if(m_tmpfl) + { + osl_closeFile(m_tmpfl); + m_tmpfl = nullptr; + } + } + + + void SAL_CALL FdInputStream::seek(sal_Int64 location) + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_tmpfl) + throw IOException(); + + oslFileError rc = osl_setFilePos( m_tmpfl, osl_Pos_Absolut, location ); + SAL_WARN_IF(rc != osl_File_E_None, "ucbhelper", "osl_setFilePos failed"); + } + + + sal_Int64 SAL_CALL + FdInputStream::getPosition() + { + osl::MutexGuard aGuard(m_aMutex); + if(!m_tmpfl) + throw IOException(); + + sal_uInt64 nFilePos = 0; + osl_getFilePos( m_tmpfl, &nFilePos ); + return nFilePos; + } + + + sal_Int64 SAL_CALL FdInputStream::getLength() + { + return m_nLength; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/interactionrequest.cxx b/ucbhelper/source/provider/interactionrequest.cxx new file mode 100644 index 000000000..95ed41994 --- /dev/null +++ b/ucbhelper/source/provider/interactionrequest.cxx @@ -0,0 +1,631 @@ +/* -*- 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 <ucbhelper/interactionrequest.hxx> + +#include <rtl/ref.hxx> +#include <osl/diagnose.h> +#include <cppuhelper/typeprovider.hxx> +#include <cppuhelper/queryinterface.hxx> + +using namespace com::sun::star; +using namespace ucbhelper; + + +// InteractionRequest Implementation. + + +namespace ucbhelper +{ + +struct InteractionRequest_Impl +{ + rtl::Reference< InteractionContinuation > m_xSelection; + css::uno::Any m_aRequest; + css::uno::Sequence< + css::uno::Reference< + css::task::XInteractionContinuation > > m_aContinuations; + + InteractionRequest_Impl() {} + explicit InteractionRequest_Impl( const uno::Any & rRequest ) + : m_aRequest( rRequest ) {} +}; + +} + + +InteractionRequest::InteractionRequest() +: m_pImpl( new InteractionRequest_Impl ) +{ +} + + +InteractionRequest::InteractionRequest( const uno::Any & rRequest ) +: m_pImpl( new InteractionRequest_Impl( rRequest ) ) +{ +} + + +// virtual +InteractionRequest::~InteractionRequest() +{ +} + + +void InteractionRequest::setRequest( const uno::Any & rRequest ) +{ + m_pImpl->m_aRequest = rRequest; +} + + +void InteractionRequest::setContinuations( + const uno::Sequence< uno::Reference< + task::XInteractionContinuation > > & rContinuations ) +{ + m_pImpl->m_aContinuations = rContinuations; +} + + +rtl::Reference< InteractionContinuation > const & +InteractionRequest::getSelection() const +{ + return m_pImpl->m_xSelection; +} + + +void InteractionRequest::setSelection( + const rtl::Reference< InteractionContinuation > & rxSelection ) +{ + m_pImpl->m_xSelection = rxSelection; +} + + +// XInterface methods. + + +// XInteractionRequest methods. + + +// virtual +uno::Any SAL_CALL InteractionRequest::getRequest() +{ + return m_pImpl->m_aRequest; +} + + +// virtual +uno::Sequence< uno::Reference< task::XInteractionContinuation > > SAL_CALL +InteractionRequest::getContinuations() +{ + return m_pImpl->m_aContinuations; +} + + +// InteractionContinuation Implementation. + + +InteractionContinuation::InteractionContinuation( + InteractionRequest * pRequest ) +: m_pRequest( pRequest ) +{ +} + + +// virtual +InteractionContinuation::~InteractionContinuation() +{ +} + + +void InteractionContinuation::recordSelection() +{ + m_pRequest->setSelection( this ); +} + + +// InteractionAbort Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionAbort::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< task::XInteractionAbort * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL InteractionAbort::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionAbort::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<task::XInteractionAbort>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionAbort::select() +{ + recordSelection(); +} + + +// InteractionRetry Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionRetry::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< task::XInteractionRetry * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL InteractionRetry::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionRetry::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<task::XInteractionRetry>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionRetry::select() +{ + recordSelection(); +} + + +// InteractionApprove Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionApprove::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< task::XInteractionApprove * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL InteractionApprove::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionApprove::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<task::XInteractionApprove>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionApprove::select() +{ + recordSelection(); +} + + +// InteractionDisapprove Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionDisapprove::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< task::XInteractionDisapprove * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL InteractionDisapprove::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionDisapprove::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<task::XInteractionDisapprove>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionDisapprove::select() +{ + recordSelection(); +} + + +// InteractionSupplyAuthentication Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionSupplyAuthentication::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< ucb::XInteractionSupplyAuthentication * >( this ), + static_cast< ucb::XInteractionSupplyAuthentication2 * >( this )); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL +InteractionSupplyAuthentication::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionSupplyAuthentication::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<ucb::XInteractionSupplyAuthentication2>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionSupplyAuthentication::select() +{ + recordSelection(); +} + + +// XInteractionSupplyAuthentication methods. + + +// virtual +sal_Bool SAL_CALL +InteractionSupplyAuthentication::canSetRealm() +{ + return m_bCanSetRealm; +} + + +// virtual +void SAL_CALL +InteractionSupplyAuthentication::setRealm( const OUString& Realm ) +{ + OSL_ENSURE( m_bCanSetPassword, + "InteractionSupplyAuthentication::setRealm - Not supported!" ); + + if ( m_bCanSetRealm ) + m_aRealm = Realm; +} + + +// virtual +sal_Bool SAL_CALL +InteractionSupplyAuthentication::canSetUserName() +{ + return m_bCanSetUserName; +} + + +// virtual +void SAL_CALL +InteractionSupplyAuthentication::setUserName( const OUString& UserName ) +{ + OSL_ENSURE( m_bCanSetUserName, + "InteractionSupplyAuthentication::setUserName - Not supported!" ); + + if ( m_bCanSetUserName ) + m_aUserName = UserName; +} + + +// virtual +sal_Bool SAL_CALL +InteractionSupplyAuthentication::canSetPassword() +{ + return m_bCanSetPassword; +} + + +// virtual +void SAL_CALL +InteractionSupplyAuthentication::setPassword( const OUString& Password ) +{ + OSL_ENSURE( m_bCanSetPassword, + "InteractionSupplyAuthentication::setPassword - Not supported!" ); + + if ( m_bCanSetPassword ) + m_aPassword = Password; +} + + +// virtual +uno::Sequence< ucb::RememberAuthentication > SAL_CALL +InteractionSupplyAuthentication::getRememberPasswordModes( + ucb::RememberAuthentication& Default ) +{ + Default = m_eDefaultRememberPasswordMode; + return m_aRememberPasswordModes; +} + + +// virtual +void SAL_CALL +InteractionSupplyAuthentication::setRememberPassword( + ucb::RememberAuthentication Remember ) +{ + m_eRememberPasswordMode = Remember; +} + + +// virtual +sal_Bool SAL_CALL +InteractionSupplyAuthentication::canSetAccount() +{ + return m_bCanSetAccount; +} + + +// virtual +void SAL_CALL +InteractionSupplyAuthentication::setAccount( const OUString& /*Account*/ ) +{ + OSL_ENSURE( m_bCanSetAccount, + "InteractionSupplyAuthentication::setAccount - Not supported!" ); +} + + +// virtual +uno::Sequence< ucb::RememberAuthentication > SAL_CALL +InteractionSupplyAuthentication::getRememberAccountModes( + ucb::RememberAuthentication& Default ) +{ + Default = m_eDefaultRememberAccountMode; + return m_aRememberAccountModes; +} + + +// virtual +void SAL_CALL InteractionSupplyAuthentication::setRememberAccount( + ucb::RememberAuthentication ) +{ +} + + +// XInteractionSupplyAuthentication2 methods. + + +// virtual +sal_Bool SAL_CALL +InteractionSupplyAuthentication::canUseSystemCredentials( + sal_Bool& Default ) +{ + Default = false; + return m_bCanUseSystemCredentials; +} + + +// virtual +void SAL_CALL InteractionSupplyAuthentication::setUseSystemCredentials( + sal_Bool UseSystemCredentials ) +{ + if ( m_bCanUseSystemCredentials ) + m_bUseSystemCredentials = UseSystemCredentials; +} + + +// InteractionReplaceExistingData Implementation. + + +// XInterface methods. + + +// virtual +uno::Any SAL_CALL +InteractionReplaceExistingData::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< ucb::XInteractionReplaceExistingData * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + + +// XTypeProvider methods. + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL +InteractionReplaceExistingData::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + + +// virtual +uno::Sequence< uno::Type > SAL_CALL InteractionReplaceExistingData::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<ucb::XInteractionReplaceExistingData>::get() ); + + return s_aCollection.getTypes(); +} + + +// XInteractionContinuation methods. + + +// virtual +void SAL_CALL InteractionReplaceExistingData::select() +{ + recordSelection(); +} + +// InteractionAuthFallback Implementation + +// XInterface methods. + +// virtual +uno::Any SAL_CALL +InteractionAuthFallback::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< task::XInteractionContinuation * >( this ), + static_cast< ucb::XInteractionAuthFallback * >( this )); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + +// XInteractionContinuation methods. + +// virtual +void SAL_CALL InteractionAuthFallback::select() +{ + recordSelection(); +} + +// XInteractionAuthFallback methods + +// virtual +void SAL_CALL InteractionAuthFallback::setCode( const OUString& code ) +{ + m_aCode = code; +} + +const OUString& InteractionAuthFallback::getCode() const +{ + return m_aCode; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/propertyvalueset.cxx b/ucbhelper/source/provider/propertyvalueset.cxx new file mode 100644 index 000000000..a6a7312c2 --- /dev/null +++ b/ucbhelper/source/provider/propertyvalueset.cxx @@ -0,0 +1,687 @@ +/* -*- 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 <vector> +#include <com/sun/star/beans/Property.hpp> +#include <com/sun/star/beans/XPropertyAccess.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/script/CannotConvertException.hpp> +#include <com/sun/star/script/Converter.hpp> + +#include <osl/diagnose.h> +#include <ucbhelper/propertyvalueset.hxx> +#include <o3tl/safeint.hxx> +#include <o3tl/typed_flags_set.hxx> + +using namespace com::sun::star::beans; +using namespace com::sun::star::container; +using namespace com::sun::star::io; +using namespace com::sun::star::lang; +using namespace com::sun::star::script; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::uno; +using namespace com::sun::star::util; + +enum class PropsSet { + NONE = 0x00000000, + String = 0x00000001, + Boolean = 0x00000002, + Byte = 0x00000004, + Short = 0x00000008, + Int = 0x00000010, + Long = 0x00000020, + Float = 0x00000040, + Double = 0x00000080, + Bytes = 0x00000100, + Date = 0x00000200, + Time = 0x00000400, + Timestamp = 0x00000800, + BinaryStream = 0x00001000, + CharacterStream = 0x00002000, + Ref = 0x00004000, + Blob = 0x00008000, + Clob = 0x00010000, + Array = 0x00020000, + Object = 0x00040000 +}; +namespace o3tl { + template<> struct typed_flags<PropsSet> : is_typed_flags<PropsSet, 0x0007ffff> {}; +} + +namespace ucbhelper_impl +{ + + +struct PropertyValue +{ + OUString sPropertyName; + + PropsSet nPropsSet; + PropsSet nOrigValue; + + OUString aString; // getString + bool bBoolean; // getBoolean + sal_Int8 nByte; // getByte + sal_Int16 nShort; // getShort + sal_Int32 nInt; // getInt + sal_Int64 nLong; // getLong + float nFloat; // getFloat + double nDouble; // getDouble + + Sequence< sal_Int8 > aBytes; // getBytes + Date aDate; // getDate + Time aTime; // getTime + DateTime aTimestamp; // getTimestamp + Reference< XInputStream > xBinaryStream; // getBinaryStream + Reference< XInputStream > xCharacterStream; // getCharacterStream + Reference< XRef > xRef; // getRef + Reference< XBlob > xBlob; // getBlob + Reference< XClob > xClob; // getClob + Reference< XArray > xArray; // getArray + Any aObject; // getObject + + PropertyValue() + : nPropsSet( PropsSet::NONE ), nOrigValue( PropsSet::NONE ), + bBoolean(false), + nByte(0), + nShort(0), + nInt(0), + nLong(0), + nFloat(0.0), + nDouble(0.0) + {} +}; +} // namespace ucbhelper_impl + +using namespace ucbhelper_impl; + +namespace ucbhelper +{ + +class PropertyValues : public std::vector< ucbhelper_impl::PropertyValue > {}; + +} // namespace ucbhelper + + +namespace ucbhelper { + + +// PropertyValueSet Implementation. + + +PropertyValueSet::PropertyValueSet( + const Reference< XComponentContext >& rxContext ) +: m_xContext( rxContext ), + m_pValues( new PropertyValues ), + m_bWasNull( false ), + m_bTriedToGetTypeConverter( false ) + +{ +} + + +// virtual +PropertyValueSet::~PropertyValueSet() +{ +} + + +// XRow methods. + + +template <class T, T ucbhelper_impl::PropertyValue::*_member_name_> +T PropertyValueSet::getValue(PropsSet nTypeName, sal_Int32 columnIndex) +{ + std::unique_lock aGuard( m_aMutex ); + + T aValue {}; /* default ctor */ + + m_bWasNull = true; + + if ( ( columnIndex < 1 ) || ( o3tl::make_unsigned(columnIndex) > m_pValues->size() ) ) + { + OSL_FAIL( "PropertyValueSet - index out of range!" ); + return aValue; + } + ucbhelper_impl::PropertyValue& rValue = (*m_pValues)[ columnIndex - 1 ]; + + if ( rValue.nOrigValue == PropsSet::NONE ) + return aValue; + + if ( rValue.nPropsSet & nTypeName ) + { + /* Values is present natively... */ + aValue = rValue.*_member_name_; + m_bWasNull = false; + return aValue; + } + + if ( !(rValue.nPropsSet & PropsSet::Object) ) + { + /* Value is not (yet) available as Any. Create it. */ + getObject( columnIndex, Reference< XNameAccess >() ); + } + + if ( rValue.nPropsSet & PropsSet::Object ) + { + /* Value is available as Any. */ + + if ( rValue.aObject.hasValue() ) + { + /* Try to convert into native value. */ + if ( rValue.aObject >>= aValue ) + { + rValue.*_member_name_ = aValue; + rValue.nPropsSet |= nTypeName; + m_bWasNull = false; + } + else + { + /* Last chance. Try type converter service... */ + + Reference< XTypeConverter > xConverter = getTypeConverter(); + if ( xConverter.is() ) + { + try + { + Any aConvAny = xConverter->convertTo( + rValue.aObject, + cppu::UnoType<T>::get() ); + + if ( aConvAny >>= aValue ) + { + rValue.*_member_name_ = aValue; + rValue.nPropsSet |= nTypeName; + m_bWasNull = false; + } + } + catch (const IllegalArgumentException&) + { + } + catch (const CannotConvertException&) + { + } + } + } + } + } + + return aValue; +} + + +// virtual +sal_Bool SAL_CALL PropertyValueSet::wasNull() +{ + // This method can not be implemented correctly!!! Imagine different + // threads doing a getXYZ - wasNull calling sequence on the same + // implementation object... + return m_bWasNull; +} + + +// virtual +OUString SAL_CALL PropertyValueSet::getString( sal_Int32 columnIndex ) +{ + return getValue<OUString, &ucbhelper_impl::PropertyValue::aString>(PropsSet::String, columnIndex); +} + + +// virtual +sal_Bool SAL_CALL PropertyValueSet::getBoolean( sal_Int32 columnIndex ) +{ + return getValue<bool, &ucbhelper_impl::PropertyValue::bBoolean>(PropsSet::Boolean, columnIndex); +} + + +// virtual +sal_Int8 SAL_CALL PropertyValueSet::getByte( sal_Int32 columnIndex ) +{ + return getValue<sal_Int8, &ucbhelper_impl::PropertyValue::nByte>(PropsSet::Byte, columnIndex); +} + + +// virtual +sal_Int16 SAL_CALL PropertyValueSet::getShort( sal_Int32 columnIndex ) +{ + return getValue<sal_Int16, &ucbhelper_impl::PropertyValue::nShort>(PropsSet::Short, columnIndex); +} + + +// virtual +sal_Int32 SAL_CALL PropertyValueSet::getInt( sal_Int32 columnIndex ) +{ + return getValue<sal_Int32, &ucbhelper_impl::PropertyValue::nInt>(PropsSet::Int, columnIndex); +} + + +// virtual +sal_Int64 SAL_CALL PropertyValueSet::getLong( sal_Int32 columnIndex ) +{ + return getValue<sal_Int64, &ucbhelper_impl::PropertyValue::nLong>(PropsSet::Long, columnIndex); +} + + +// virtual +float SAL_CALL PropertyValueSet::getFloat( sal_Int32 columnIndex ) +{ + return getValue<float, &ucbhelper_impl::PropertyValue::nFloat>(PropsSet::Float, columnIndex); +} + + +// virtual +double SAL_CALL PropertyValueSet::getDouble( sal_Int32 columnIndex ) +{ + return getValue<double, &ucbhelper_impl::PropertyValue::nDouble>(PropsSet::Double, columnIndex); +} + + +// virtual +Sequence< sal_Int8 > SAL_CALL +PropertyValueSet::getBytes( sal_Int32 columnIndex ) +{ + return getValue<Sequence< sal_Int8 >, &ucbhelper_impl::PropertyValue::aBytes>(PropsSet::Bytes, columnIndex); +} + + +// virtual +Date SAL_CALL PropertyValueSet::getDate( sal_Int32 columnIndex ) +{ + return getValue<Date, &ucbhelper_impl::PropertyValue::aDate>(PropsSet::Date, columnIndex); +} + + +// virtual +Time SAL_CALL PropertyValueSet::getTime( sal_Int32 columnIndex ) +{ + return getValue<Time, &ucbhelper_impl::PropertyValue::aTime>(PropsSet::Time, columnIndex); +} + + +// virtual +DateTime SAL_CALL PropertyValueSet::getTimestamp( sal_Int32 columnIndex ) +{ + return getValue<DateTime, &ucbhelper_impl::PropertyValue::aTimestamp>(PropsSet::Timestamp, columnIndex); +} + + +// virtual +Reference< XInputStream > SAL_CALL +PropertyValueSet::getBinaryStream( sal_Int32 columnIndex ) +{ + return getValue<Reference< XInputStream >, &ucbhelper_impl::PropertyValue::xBinaryStream>(PropsSet::BinaryStream, columnIndex); +} + + +// virtual +Reference< XInputStream > SAL_CALL +PropertyValueSet::getCharacterStream( sal_Int32 columnIndex ) +{ + return getValue<Reference< XInputStream >, &ucbhelper_impl::PropertyValue::xCharacterStream>(PropsSet::CharacterStream, columnIndex); +} + + +// virtual +Any SAL_CALL PropertyValueSet::getObject( + sal_Int32 columnIndex, + const Reference< XNameAccess >& ) +{ + std::unique_lock aGuard( m_aMutex ); + + Any aValue; + + m_bWasNull = true; + + if ( ( columnIndex < 1 ) + || ( o3tl::make_unsigned(columnIndex) > m_pValues->size() ) ) + { + OSL_FAIL( "PropertyValueSet - index out of range!" ); + } + else + { + ucbhelper_impl::PropertyValue& rValue + = (*m_pValues)[ columnIndex - 1 ]; + + if ( rValue.nPropsSet & PropsSet::Object ) + { + // Values is present natively... + aValue = rValue.aObject; + m_bWasNull = false; + } + else + { + // Make Any from original value. + + switch ( rValue.nOrigValue ) + { + case PropsSet::NONE: + break; + + case PropsSet::String: + aValue <<= rValue.aString; + break; + + case PropsSet::Boolean: + aValue <<= rValue.bBoolean; + break; + + case PropsSet::Byte: + aValue <<= rValue.nByte; + break; + + case PropsSet::Short: + aValue <<= rValue.nShort; + break; + + case PropsSet::Int: + aValue <<= rValue.nInt; + break; + + case PropsSet::Long: + aValue <<= rValue.nLong; + break; + + case PropsSet::Float: + aValue <<= rValue.nFloat; + break; + + case PropsSet::Double: + aValue <<= rValue.nDouble; + break; + + case PropsSet::Bytes: + aValue <<= rValue.aBytes; + break; + + case PropsSet::Date: + aValue <<= rValue.aDate; + break; + + case PropsSet::Time: + aValue <<= rValue.aTime; + break; + + case PropsSet::Timestamp: + aValue <<= rValue.aTimestamp; + break; + + case PropsSet::BinaryStream: + aValue <<= rValue.xBinaryStream; + break; + + case PropsSet::CharacterStream: + aValue <<= rValue.xCharacterStream; + break; + + case PropsSet::Ref: + aValue <<= rValue.xRef; + break; + + case PropsSet::Blob: + aValue <<= rValue.xBlob; + break; + + case PropsSet::Clob: + aValue <<= rValue.xClob; + break; + + case PropsSet::Array: + aValue <<= rValue.xArray; + break; + + case PropsSet::Object: + // Fall-through is intended! + default: + OSL_FAIL( "PropertyValueSet::getObject - " + "Wrong original type" ); + break; + } + + if ( aValue.hasValue() ) + { + rValue.aObject = aValue; + rValue.nPropsSet |= PropsSet::Object; + m_bWasNull = false; + } + } + } + + return aValue; +} + + +// virtual +Reference< XRef > SAL_CALL PropertyValueSet::getRef( sal_Int32 columnIndex ) +{ + return getValue<Reference< XRef >, &ucbhelper_impl::PropertyValue::xRef>(PropsSet::Ref, columnIndex); +} + + +// virtual +Reference< XBlob > SAL_CALL PropertyValueSet::getBlob( sal_Int32 columnIndex ) +{ + return getValue<Reference< XBlob >, &ucbhelper_impl::PropertyValue::xBlob>(PropsSet::Blob, columnIndex); +} + + +// virtual +Reference< XClob > SAL_CALL PropertyValueSet::getClob( sal_Int32 columnIndex ) +{ + return getValue<Reference< XClob >, &ucbhelper_impl::PropertyValue::xClob>(PropsSet::Clob, columnIndex); +} + + +// virtual +Reference< XArray > SAL_CALL PropertyValueSet::getArray( sal_Int32 columnIndex ) +{ + return getValue<Reference< XArray >, &ucbhelper_impl::PropertyValue::xArray>(PropsSet::Array, columnIndex); +} + + +// XColumnLocate methods. + + +// virtual +sal_Int32 SAL_CALL PropertyValueSet::findColumn( const OUString& columnName ) +{ + std::unique_lock aGuard( m_aMutex ); + + if ( !columnName.isEmpty() ) + { + sal_Int32 nCount = m_pValues->size(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + if ( (*m_pValues)[ n ].sPropertyName == columnName ) + return n + 1; // Index is 1-based. + } + } + return 0; +} + + +// Non-interface methods. + + +const Reference< XTypeConverter >& PropertyValueSet::getTypeConverter() +{ + std::unique_lock aGuard( m_aMutex ); + + if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() ) + { + m_bTriedToGetTypeConverter = true; + m_xTypeConverter = Converter::create(m_xContext); + + OSL_ENSURE( m_xTypeConverter.is(), + "PropertyValueSet::getTypeConverter() - " + "Service 'com.sun.star.script.Converter' n/a!" ); + } + return m_xTypeConverter; +} + + +template <class T, T ucbhelper_impl::PropertyValue::*_member_name_> +void PropertyValueSet::appendValue(const OUString& rPropName, PropsSet nTypeName, const T& rValue) +{ + std::unique_lock aGuard( m_aMutex ); + + ucbhelper_impl::PropertyValue aNewValue; + aNewValue.sPropertyName = rPropName; + aNewValue.nPropsSet = nTypeName; + aNewValue.nOrigValue = nTypeName; + aNewValue.*_member_name_ = rValue; + + m_pValues->push_back( aNewValue ); +} + + +void PropertyValueSet::appendString( const OUString& rPropName, + const OUString& rValue ) +{ + appendValue<OUString, &ucbhelper_impl::PropertyValue::aString>(rPropName, PropsSet::String, rValue); +} + + +void PropertyValueSet::appendBoolean( const OUString& rPropName, + bool bValue ) +{ + appendValue<bool, &ucbhelper_impl::PropertyValue::bBoolean>(rPropName, PropsSet::Boolean, bValue); +} + + +void PropertyValueSet::appendLong( const OUString& rPropName, + sal_Int64 nValue ) +{ + appendValue<sal_Int64, &ucbhelper_impl::PropertyValue::nLong>(rPropName, PropsSet::Long, nValue); +} + + +void PropertyValueSet::appendTimestamp( const OUString& rPropName, + const DateTime& rValue ) +{ + appendValue<DateTime, &ucbhelper_impl::PropertyValue::aTimestamp>(rPropName, PropsSet::Timestamp, rValue); +} + + +void PropertyValueSet::appendObject( const OUString& rPropName, + const Any& rValue ) +{ + appendValue<Any, &ucbhelper_impl::PropertyValue::aObject>(rPropName, PropsSet::Object, rValue); +} + + +void PropertyValueSet::appendVoid( const OUString& rPropName ) +{ + appendValue<Any, &ucbhelper_impl::PropertyValue::aObject>(rPropName, PropsSet::NONE, Any()); +} + + +void PropertyValueSet::appendPropertySet( + const Reference< XPropertySet >& rxSet ) +{ + if ( !rxSet.is() ) + return; + + Reference< XPropertySetInfo > xInfo = rxSet->getPropertySetInfo(); + if ( !xInfo.is() ) + return; + + const Sequence< Property > aProps = xInfo->getProperties(); + + Reference< XPropertyAccess > xPropertyAccess( rxSet, UNO_QUERY ); + if ( xPropertyAccess.is() ) + { + // Efficient: Get all prop values with one ( remote) call. + + const Sequence< css::beans::PropertyValue > aPropValues + = xPropertyAccess->getPropertyValues(); + + for ( const css::beans::PropertyValue& rPropValue : aPropValues ) + { + // Find info for current property value. + auto pProp = std::find_if(aProps.begin(), aProps.end(), + [&rPropValue](const Property& rProp) { return rProp.Name == rPropValue.Name; }); + if (pProp != aProps.end()) + { + // Found! + appendObject( *pProp, rPropValue.Value ); + } + } + } + else + { + // Get every single prop value with one ( remote) call. + + for ( const Property& rProp : aProps ) + { + try + { + Any aValue = rxSet->getPropertyValue( rProp.Name ); + + if ( aValue.hasValue() ) + appendObject( rProp, aValue ); + } + catch (const UnknownPropertyException&) + { + } + catch (const WrappedTargetException&) + { + } + } + } +} + + +bool PropertyValueSet::appendPropertySetValue( + const Reference< XPropertySet >& rxSet, + const Property& rProperty ) +{ + if ( rxSet.is() ) + { + try + { + Any aValue = rxSet->getPropertyValue( rProperty.Name ); + if ( aValue.hasValue() ) + { + appendObject( rProperty, aValue ); + return true; + } + } + catch (const UnknownPropertyException&) + { + } + catch (const WrappedTargetException&) + { + } + } + + // Error. + return false; +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/providerhelper.cxx b/ucbhelper/source/provider/providerhelper.cxx new file mode 100644 index 000000000..c0bbc8616 --- /dev/null +++ b/ucbhelper/source/provider/providerhelper.cxx @@ -0,0 +1,496 @@ +/* -*- 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 . + */ + +#include <sal/config.h> + +#include <com/sun/star/beans/IllegalTypeException.hpp> +#include <com/sun/star/beans/PropertyExistException.hpp> +#include <com/sun/star/beans/XPropertyAccess.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/container/XNamed.hpp> +#include <com/sun/star/ucb/Store.hpp> +#include <com/sun/star/ucb/XPropertySetRegistry.hpp> +#include <com/sun/star/ucb/XPropertySetRegistryFactory.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <ucbhelper/contenthelper.hxx> +#include <ucbhelper/providerhelper.hxx> + +#include <osl/diagnose.h> +#include <osl/mutex.hxx> +#include <cppuhelper/weakref.hxx> + +#include <unordered_map> + +using namespace com::sun::star; + +namespace ucbhelper_impl +{ + +typedef std::unordered_map +< + OUString, + uno::WeakReference< ucb::XContent > +> +Contents; + +struct ContentProviderImplHelper_Impl +{ + uno::Reference< css::ucb::XPropertySetRegistry > m_xPropertySetRegistry; + Contents m_aContents; +}; + +} // namespace ucbhelper_impl + +namespace ucbhelper { + +ContentProviderImplHelper::ContentProviderImplHelper( + const uno::Reference< uno::XComponentContext >& rxContext ) +: m_pImpl( new ucbhelper_impl::ContentProviderImplHelper_Impl ), + m_xContext( rxContext ) +{ +} + +// virtual +ContentProviderImplHelper::~ContentProviderImplHelper() +{ +} + +// virtual +sal_Bool SAL_CALL ContentProviderImplHelper::supportsService( + const OUString& ServiceName ) +{ + return cppu::supportsService(this, ServiceName); +} + +// virtual +sal_Int32 SAL_CALL ContentProviderImplHelper::compareContentIds( + const uno::Reference< css::ucb::XContentIdentifier >& Id1, + const uno::Reference< css::ucb::XContentIdentifier >& Id2 ) +{ + // Simply do a string compare. + + OUString aURL1( Id1->getContentIdentifier() ); + OUString aURL2( Id2->getContentIdentifier() ); + + return aURL1.compareTo( aURL2 ); +} + +void ContentProviderImplHelper::cleanupRegisteredContents() +{ + osl::MutexGuard aGuard( m_aMutex ); + + ucbhelper_impl::Contents::iterator it + = m_pImpl->m_aContents.begin(); + while( it != m_pImpl->m_aContents.end() ) + { + uno::Reference< ucb::XContent > xContent( (*it).second ); + if ( !xContent.is() ) + { + ucbhelper_impl::Contents::iterator tmp = it; + ++it; + m_pImpl->m_aContents.erase( tmp ); + } + else + { + ++it; + } + } +} + +void ContentProviderImplHelper::removeContent( ContentImplHelper* pContent ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + cleanupRegisteredContents(); + + const OUString aURL( + pContent->getIdentifier()->getContentIdentifier() ); + + ucbhelper_impl::Contents::iterator it = m_pImpl->m_aContents.find( aURL ); + + if ( it != m_pImpl->m_aContents.end() ) + m_pImpl->m_aContents.erase( it ); +} + +rtl::Reference< ContentImplHelper > +ContentProviderImplHelper::queryExistingContent( + const uno::Reference< css::ucb::XContentIdentifier >& Identifier ) +{ + return queryExistingContent( Identifier->getContentIdentifier() ); +} + +rtl::Reference< ContentImplHelper > +ContentProviderImplHelper::queryExistingContent( const OUString& rURL ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + cleanupRegisteredContents(); + + // Check, if a content with given id already exists... + + ucbhelper_impl::Contents::const_iterator it + = m_pImpl->m_aContents.find( rURL ); + if ( it != m_pImpl->m_aContents.end() ) + { + uno::Reference< ucb::XContent > xContent( (*it).second ); + if ( xContent.is() ) + { + return rtl::Reference< ContentImplHelper >( + static_cast< ContentImplHelper * >( xContent.get() ) ); + } + } + return rtl::Reference< ContentImplHelper >(); +} + +void ContentProviderImplHelper::queryExistingContents( + ContentRefList& rContents ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + cleanupRegisteredContents(); + + for ( const auto& rContent : m_pImpl->m_aContents ) + { + uno::Reference< ucb::XContent > xContent( rContent.second ); + if ( xContent.is() ) + { + rContents.emplace_back( + static_cast< ContentImplHelper * >( xContent.get() ) ); + } + } +} + +void ContentProviderImplHelper::registerNewContent( + const uno::Reference< ucb::XContent > & xContent ) +{ + if ( !xContent.is() ) + return; + + osl::MutexGuard aGuard( m_aMutex ); + + cleanupRegisteredContents(); + + const OUString aURL( + xContent->getIdentifier()->getContentIdentifier() ); + ucbhelper_impl::Contents::const_iterator it + = m_pImpl->m_aContents.find( aURL ); + if ( it == m_pImpl->m_aContents.end() ) + m_pImpl->m_aContents[ aURL ] = xContent; +} + +uno::Reference< css::ucb::XPropertySetRegistry > +ContentProviderImplHelper::getAdditionalPropertySetRegistry() +{ + // Get propertyset registry. + + osl::MutexGuard aGuard( m_aMutex ); + + if ( !m_pImpl->m_xPropertySetRegistry.is() ) + { + uno::Reference< css::ucb::XPropertySetRegistryFactory > + xRegFac = css::ucb::Store::create( m_xContext ); + + // Open/create a registry. + m_pImpl->m_xPropertySetRegistry + = xRegFac->createPropertySetRegistry( OUString() ); + + OSL_ENSURE( m_pImpl->m_xPropertySetRegistry.is(), + "ContentProviderImplHelper::getAdditionalPropertySet - " + "Error opening registry!" ); + } + + return m_pImpl->m_xPropertySetRegistry; +} + +uno::Reference< css::ucb::XPersistentPropertySet > +ContentProviderImplHelper::getAdditionalPropertySet( + const OUString& rKey, bool bCreate ) +{ + // Get propertyset registry. + getAdditionalPropertySetRegistry(); + + if ( m_pImpl->m_xPropertySetRegistry.is() ) + { + // Open/create persistent property set. + return m_pImpl->m_xPropertySetRegistry->openPropertySet( + rKey, bCreate ); + } + + return uno::Reference< css::ucb::XPersistentPropertySet >(); +} + +bool ContentProviderImplHelper::renameAdditionalPropertySet( + const OUString& rOldKey, + const OUString& rNewKey, + bool bRecursive ) +{ + if ( rOldKey == rNewKey ) + return true; + + osl::MutexGuard aGuard( m_aMutex ); + + if ( bRecursive ) + { + // Get propertyset registry. + getAdditionalPropertySetRegistry(); + + if ( !m_pImpl->m_xPropertySetRegistry.is() ) + return false; + + uno::Reference< container::XNameAccess > xNameAccess( + m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY ); + if ( !xNameAccess.is() ) + return false; + + const uno::Sequence< OUString > aKeys + = xNameAccess->getElementNames(); + if ( aKeys.hasElements() ) + { + OUString aOldKeyWithSlash = rOldKey; + OUString aOldKeyWithoutSlash; + if ( !aOldKeyWithSlash.endsWith("/") ) + { + aOldKeyWithSlash += "/"; + aOldKeyWithoutSlash = rOldKey; + } + else if ( !rOldKey.isEmpty() ) + aOldKeyWithoutSlash + = rOldKey.copy( 0, rOldKey.getLength() - 1 ); + + for ( const OUString& rKey : aKeys ) + { + if ( rKey.startsWith( aOldKeyWithSlash ) + || rKey == aOldKeyWithoutSlash ) + { + OUString aNewKey + = rKey.replaceAt( + 0, rOldKey.getLength(), rNewKey ); + if ( !renameAdditionalPropertySet( + rKey, aNewKey, false ) ) + return false; + } + } + } + } + else + { + // Get old property set, if exists. + uno::Reference< css::ucb::XPersistentPropertySet > xOldSet + = getAdditionalPropertySet( rOldKey, false ); + if ( xOldSet.is() ) + { + // Rename property set. + uno::Reference< container::XNamed > xNamed( + xOldSet, uno::UNO_QUERY ); + if ( !xNamed.is() ) + return false; + + // ??? throws no exceptions and has no return value ??? + xNamed->setName( rNewKey ); + } + } + return true; +} + +bool ContentProviderImplHelper::copyAdditionalPropertySet( + const OUString& rSourceKey, + const OUString& rTargetKey, + bool bRecursive ) +{ + if ( rSourceKey == rTargetKey ) + return true; + + osl::MutexGuard aGuard( m_aMutex ); + + if ( bRecursive ) + { + // Get propertyset registry. + getAdditionalPropertySetRegistry(); + + if ( !m_pImpl->m_xPropertySetRegistry.is() ) + return false; + + uno::Reference< container::XNameAccess > xNameAccess( + m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY ); + if ( !xNameAccess.is() ) + return false; + + const uno::Sequence< OUString > aKeys + = xNameAccess->getElementNames(); + if ( aKeys.hasElements() ) + { + OUString aSrcKeyWithSlash = rSourceKey; + OUString aSrcKeyWithoutSlash; + if ( !aSrcKeyWithSlash.endsWith("/") ) + { + aSrcKeyWithSlash += "/"; + aSrcKeyWithoutSlash = rSourceKey; + } + else if ( !rSourceKey.isEmpty() ) + aSrcKeyWithoutSlash = rSourceKey.copy( + 0, rSourceKey.getLength() - 1 ); + + for ( const OUString& rKey : aKeys ) + { + if ( rKey.startsWith(aSrcKeyWithSlash ) + || rKey == aSrcKeyWithoutSlash ) + { + OUString aNewKey + = rKey.replaceAt( + 0, rSourceKey.getLength(), rTargetKey ); + if ( !copyAdditionalPropertySet( + rKey, aNewKey, false ) ) + return false; + } + } + } + } + else + { + // Get old property set, if exists. + uno::Reference< css::ucb::XPersistentPropertySet > + xOldPropSet = getAdditionalPropertySet( rSourceKey, false ); + if ( !xOldPropSet.is() ) + return false; + + uno::Reference< beans::XPropertySetInfo > xPropSetInfo + = xOldPropSet->getPropertySetInfo(); + if ( !xPropSetInfo.is() ) + return false; + + uno::Reference< beans::XPropertyAccess > xOldPropAccess( + xOldPropSet, uno::UNO_QUERY ); + if ( !xOldPropAccess.is() ) + return false; + + // Obtain all values from old set. + const uno::Sequence< beans::PropertyValue > aValues + = xOldPropAccess->getPropertyValues(); + + const uno::Sequence< beans::Property > aProps + = xPropSetInfo->getProperties(); + + if ( aValues.hasElements() ) + { + // Fail, if property set with new key already exists. + uno::Reference< css::ucb::XPersistentPropertySet > + xNewPropSet + = getAdditionalPropertySet( rTargetKey, false ); + if ( xNewPropSet.is() ) + return false; + + // Create new, empty set. + xNewPropSet = getAdditionalPropertySet( rTargetKey, true ); + if ( !xNewPropSet.is() ) + return false; + + uno::Reference< beans::XPropertyContainer > xNewPropContainer( + xNewPropSet, uno::UNO_QUERY ); + if ( !xNewPropContainer.is() ) + return false; + + for ( const beans::PropertyValue& rValue : aValues ) + { + sal_Int16 nAttribs = 0; + auto pProp = std::find_if(aProps.begin(), aProps.end(), + [&rValue](const beans::Property& rProp) { return rProp.Name == rValue.Name; }); + if (pProp != aProps.end()) + nAttribs = pProp->Attributes; + + try + { + xNewPropContainer->addProperty( + rValue.Name, nAttribs, rValue.Value ); + } + catch ( beans::PropertyExistException & ) + { + } + catch ( beans::IllegalTypeException & ) + { + } + catch ( lang::IllegalArgumentException & ) + { + } + } + } + } + return true; +} + +bool ContentProviderImplHelper::removeAdditionalPropertySet( + const OUString& rKey, bool bRecursive ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( bRecursive ) + { + // Get propertyset registry. + getAdditionalPropertySetRegistry(); + + if ( !m_pImpl->m_xPropertySetRegistry.is() ) + return false; + + uno::Reference< container::XNameAccess > xNameAccess( + m_pImpl->m_xPropertySetRegistry, uno::UNO_QUERY ); + if ( !xNameAccess.is() ) + return false; + + const uno::Sequence< OUString > aKeys + = xNameAccess->getElementNames(); + if ( aKeys.hasElements() ) + { + OUString aKeyWithSlash = rKey; + OUString aKeyWithoutSlash; + if ( !aKeyWithSlash.endsWith("/") ) + { + aKeyWithSlash += "/"; + aKeyWithoutSlash = rKey; + } + else if ( !rKey.isEmpty() ) + aKeyWithoutSlash + = rKey.copy( 0, rKey.getLength() - 1 ); + + for ( const OUString& rCurrKey : aKeys ) + { + if ( rCurrKey.startsWith(aKeyWithSlash ) + || rCurrKey == aKeyWithoutSlash ) + { + if ( !removeAdditionalPropertySet( + rCurrKey, false ) ) + return false; + } + } + } + } + else + { + // Get propertyset registry. + getAdditionalPropertySetRegistry(); + + if ( !m_pImpl->m_xPropertySetRegistry.is() ) + return false; + + m_pImpl->m_xPropertySetRegistry->removePropertySet( rKey ); + } + return true; +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/registerucb.cxx b/ucbhelper/source/provider/registerucb.cxx new file mode 100644 index 000000000..842fc0083 --- /dev/null +++ b/ucbhelper/source/provider/registerucb.cxx @@ -0,0 +1,143 @@ +/* -*- 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 . + */ + +#include <ucbhelper/registerucb.hxx> +#include <com/sun/star/lang/IllegalArgumentException.hpp> +#include <com/sun/star/ucb/DuplicateProviderException.hpp> +#include <com/sun/star/ucb/XContentProviderManager.hpp> +#include <com/sun/star/ucb/XParameterizedContentProvider.hpp> +#include <com/sun/star/ucb/ContentProviderProxyFactory.hpp> +#include <com/sun/star/ucb/XContentProviderFactory.hpp> +#include <com/sun/star/uno/XComponentContext.hpp> +#include <com/sun/star/uno/RuntimeException.hpp> + +#include <osl/diagnose.h> + +using namespace com::sun::star; + +namespace ucbhelper { + + +// registerAtUcb + + +bool +registerAtUcb( + uno::Reference< ucb::XContentProviderManager > const & rManager, + uno::Reference< uno::XComponentContext > const & rxContext, + OUString const & rName, + OUString const & rArguments, + OUString const & rTemplate) +{ + OSL_ENSURE(rxContext.is(), + "ucb::registerAtUcb(): No service factory"); + + bool bNoProxy = rArguments.startsWith("{noproxy}"); + OUString + aProviderArguments(bNoProxy ? + rArguments. + copy(RTL_CONSTASCII_LENGTH("{noproxy}")) : + rArguments); + + uno::Reference< ucb::XContentProvider > xProvider; + + if (!rName.isEmpty()) + { + // First, try to instantiate proxy for provider: + if (!bNoProxy) + { + uno::Reference< ucb::XContentProviderFactory > xProxyFactory; + try + { + xProxyFactory = ucb::ContentProviderProxyFactory::create( rxContext ); + } + catch (uno::Exception const &) {} + OSL_ENSURE(xProxyFactory.is(), "No ContentProviderProxyFactory"); + if (xProxyFactory.is()) + xProvider = xProxyFactory->createContentProvider(rName); + } + + // Then, try to instantiate provider directly: + if (!xProvider.is()) + try + { + xProvider.set( + rxContext->getServiceManager()->createInstanceWithContext(rName, rxContext), + uno::UNO_QUERY); + } + catch (uno::RuntimeException const &) { throw; } + catch (uno::Exception const &) {} + } + + uno::Reference< ucb::XParameterizedContentProvider > + xParameterized(xProvider, uno::UNO_QUERY); + if (xParameterized.is()) + { + uno::Reference< ucb::XContentProvider > xInstance; + try + { + xInstance = xParameterized->registerInstance(rTemplate, + aProviderArguments, + true); + //@@@ if this call replaces an old instance, the commit-or- + // rollback code below will not work + } + catch (lang::IllegalArgumentException const &) {} + + if (xInstance.is()) + xProvider = xInstance; + } + + bool bSuccess = false; + if (rManager.is() && (rName.isEmpty() || xProvider.is())) + { + try + { + rManager->registerContentProvider(xProvider, rTemplate, true); + bSuccess = true; + } + catch (ucb::DuplicateProviderException const &) + { + if (xParameterized.is()) + try + { + xParameterized->deregisterInstance(rTemplate, + aProviderArguments); + } + catch (lang::IllegalArgumentException const &) {} + } + catch (...) + { + if (xParameterized.is()) + try + { + xParameterized->deregisterInstance(rTemplate, + aProviderArguments); + } + catch (lang::IllegalArgumentException const &) {} + catch (uno::RuntimeException const &) {} + throw; + } + } + return bSuccess; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/resultset.cxx b/ucbhelper/source/provider/resultset.cxx new file mode 100644 index 000000000..eff10d5d2 --- /dev/null +++ b/ucbhelper/source/provider/resultset.cxx @@ -0,0 +1,1495 @@ +/* -*- 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 <memory> +#include <mutex> +#include <comphelper/interfacecontainer4.hxx> +#include <comphelper/multiinterfacecontainer4.hxx> +#include <cppuhelper/queryinterface.hxx> +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/sdbc/SQLException.hpp> +#include <ucbhelper/resultset.hxx> +#include <ucbhelper/resultsetmetadata.hxx> +#include <ucbhelper/macros.hxx> +#include <osl/diagnose.h> + +using namespace com::sun::star; + + +namespace ucbhelper_impl +{ + +namespace { + +struct PropertyInfo +{ + const char* pName; + sal_Int32 nHandle; + sal_Int16 nAttributes; + const uno::Type& (*pGetCppuType)(); +}; + +} + +static const uno::Type& sal_Int32_getCppuType() +{ + return cppu::UnoType<sal_Int32>::get(); +} + +static const uno::Type& sal_Bool_getCppuType() +{ + return cppu::UnoType<bool>::get(); +} + +const PropertyInfo aPropertyTable[] = +{ + { "IsRowCountFinal", + 1000, + beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, + &sal_Bool_getCppuType + }, + { "RowCount", + 1001, + beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY, + &sal_Int32_getCppuType + }, + { nullptr, + 0, + 0, + nullptr + } +}; + +#define RESULTSET_PROPERTY_COUNT 2 + + + +namespace { + +class PropertySetInfo : + public cppu::OWeakObject, + public lang::XTypeProvider, + public beans::XPropertySetInfo +{ + uno::Sequence< beans::Property > m_aProps; + +private: + bool queryProperty( + std::u16string_view aName, beans::Property& rProp ) const; + +public: + PropertySetInfo( + const PropertyInfo* pProps, + sal_Int32 nProps ); + + // XInterface + virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType ) override; + virtual void SAL_CALL acquire() + noexcept override; + virtual void SAL_CALL release() + noexcept override; + + // XTypeProvider + virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() override; + virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes() override; + + // XPropertySetInfo + virtual uno::Sequence< beans::Property > SAL_CALL getProperties() override; + virtual beans::Property SAL_CALL getPropertyByName( + const OUString& aName ) override; + virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override; +}; + +} + +typedef comphelper::OMultiTypeInterfaceContainerHelperVar4<OUString, css::beans::XPropertyChangeListener> + PropertyChangeListeners; + +} // namespace ucbhelper_impl + +using namespace ucbhelper_impl; + +namespace ucbhelper +{ + + +// struct ResultSet_Impl. + + +struct ResultSet_Impl +{ + uno::Reference< uno::XComponentContext > m_xContext; + uno::Reference< css::ucb::XCommandEnvironment > m_xEnv; + uno::Reference< beans::XPropertySetInfo > m_xPropSetInfo; + uno::Reference< sdbc::XResultSetMetaData > m_xMetaData; + uno::Sequence< beans::Property > m_aProperties; + rtl::Reference< ResultSetDataSupplier > m_xDataSupplier; + std::mutex m_aMutex; + comphelper::OInterfaceContainerHelper4<lang::XEventListener> m_aDisposeEventListeners; + std::unique_ptr<PropertyChangeListeners> m_pPropertyChangeListeners; + sal_Int32 m_nPos; + bool m_bWasNull; + bool m_bAfterLast; + + inline ResultSet_Impl( + const uno::Reference< uno::XComponentContext >& rxContext, + const uno::Sequence< beans::Property >& rProperties, + const rtl::Reference< ResultSetDataSupplier >& rDataSupplier, + const uno::Reference< css::ucb::XCommandEnvironment >& rxEnv ); +}; + +inline ResultSet_Impl::ResultSet_Impl( + const uno::Reference< uno::XComponentContext >& rxContext, + const uno::Sequence< beans::Property >& rProperties, + const rtl::Reference< ResultSetDataSupplier >& rDataSupplier, + const uno::Reference< css::ucb::XCommandEnvironment >& rxEnv ) +: m_xContext( rxContext ), + m_xEnv( rxEnv ), + m_aProperties( rProperties ), + m_xDataSupplier( rDataSupplier ), + m_nPos( 0 ), // Position is one-based. Zero means: before first element. + m_bWasNull( false ), + m_bAfterLast( false ) +{ +} + + +// ResultSet Implementation. + + +ResultSet::ResultSet( + const uno::Reference< uno::XComponentContext >& rxContext, + const uno::Sequence< beans::Property >& rProperties, + const rtl::Reference< ResultSetDataSupplier >& rDataSupplier ) +: m_pImpl( new ResultSet_Impl( + rxContext, + rProperties, + rDataSupplier, + uno::Reference< css::ucb::XCommandEnvironment >() ) ) +{ + rDataSupplier->m_pResultSet = this; +} + + +ResultSet::ResultSet( + const uno::Reference< uno::XComponentContext >& rxContext, + const uno::Sequence< beans::Property >& rProperties, + const rtl::Reference< ResultSetDataSupplier >& rDataSupplier, + const uno::Reference< css::ucb::XCommandEnvironment >& rxEnv ) +: m_pImpl( new ResultSet_Impl( rxContext, rProperties, rDataSupplier, rxEnv ) ) +{ + rDataSupplier->m_pResultSet = this; +} + + +// virtual +ResultSet::~ResultSet() +{ +} + + +// XServiceInfo methods. + +OUString SAL_CALL ResultSet::getImplementationName() +{ + return "ResultSet"; +} + +sal_Bool SAL_CALL ResultSet::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL ResultSet::getSupportedServiceNames() +{ + return { RESULTSET_SERVICE_NAME }; +} + + +// XComponent methods. + + +// virtual +void SAL_CALL ResultSet::dispose() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( m_pImpl->m_aDisposeEventListeners.getLength(aGuard) ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< lang::XComponent * >( this ); + m_pImpl->m_aDisposeEventListeners.disposeAndClear( aGuard, aEvt ); + } + + if ( m_pImpl->m_pPropertyChangeListeners ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< beans::XPropertySet * >( this ); + m_pImpl->m_pPropertyChangeListeners->disposeAndClear( aGuard, aEvt ); + } + + m_pImpl->m_xDataSupplier->close(); +} + + +// virtual +void SAL_CALL ResultSet::addEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + m_pImpl->m_aDisposeEventListeners.addInterface( aGuard, Listener ); +} + + +// virtual +void SAL_CALL ResultSet::removeEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + m_pImpl->m_aDisposeEventListeners.removeInterface( aGuard, Listener ); +} + + +// XResultSetMetaDataSupplier methods. + + +// virtual +uno::Reference< sdbc::XResultSetMetaData > SAL_CALL ResultSet::getMetaData() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !m_pImpl->m_xMetaData.is() ) + m_pImpl->m_xMetaData = new ResultSetMetaData( m_pImpl->m_xContext, + m_pImpl->m_aProperties ); + + return m_pImpl->m_xMetaData; +} + + +// XResultSet methods. + + +// virtual +sal_Bool SAL_CALL ResultSet::next() +{ + // Note: Cursor is initially positioned before the first row. + // First call to 'next()' moves it to first row. + + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + // getResult works zero-based! + if ( !m_pImpl->m_xDataSupplier->getResult( m_pImpl->m_nPos ) ) + { + m_pImpl->m_bAfterLast = true; + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + m_pImpl->m_nPos++; + m_pImpl->m_xDataSupplier->validate(); + return true; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::isBeforeFirst() +{ + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + // getResult works zero-based! + if ( !m_pImpl->m_xDataSupplier->getResult( 0 ) ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + m_pImpl->m_xDataSupplier->validate(); + return ( m_pImpl->m_nPos == 0 ); +} + + +// virtual +sal_Bool SAL_CALL ResultSet::isAfterLast() +{ + m_pImpl->m_xDataSupplier->validate(); + return m_pImpl->m_bAfterLast; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::isFirst() +{ + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + m_pImpl->m_xDataSupplier->validate(); + return ( m_pImpl->m_nPos == 1 ); +} + + +// virtual +sal_Bool SAL_CALL ResultSet::isLast() +{ + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + if ( !nCount ) + { + m_pImpl->m_xDataSupplier->validate(); + return false; + } + + m_pImpl->m_xDataSupplier->validate(); + return ( m_pImpl->m_nPos == nCount ); +} + + +// virtual +void SAL_CALL ResultSet::beforeFirst() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = 0; + m_pImpl->m_xDataSupplier->validate(); +} + + +// virtual +void SAL_CALL ResultSet::afterLast() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = true; + m_pImpl->m_xDataSupplier->validate(); +} + + +// virtual +sal_Bool SAL_CALL ResultSet::first() +{ + // getResult works zero-based! + if ( m_pImpl->m_xDataSupplier->getResult( 0 ) ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = 1; + m_pImpl->m_xDataSupplier->validate(); + return true; + } + + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::last() +{ + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + if ( nCount ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = nCount; + m_pImpl->m_xDataSupplier->validate(); + return true; + } + + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +sal_Int32 SAL_CALL ResultSet::getRow() +{ + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_xDataSupplier->validate(); + return 0; + } + + m_pImpl->m_xDataSupplier->validate(); + return m_pImpl->m_nPos; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::absolute( sal_Int32 row ) +{ +/* + If the row number is positive, the cursor moves to the given row number + with respect to the beginning of the result set. The first row is row 1, + the second is row 2, and so on. + + If the given row number is negative, the cursor moves to an absolute row + position with respect to the end of the result set. For example, calling + absolute( -1 ) positions the cursor on the last row, absolute( -2 ) + indicates the next-to-last row, and so on. + + An attempt to position the cursor beyond the first/last row in the result + set leaves the cursor before/after the first/last row, respectively. + + Calling absolute( 1 ) is the same as calling first(). + + Calling absolute( -1 ) is the same as calling last(). +*/ + if ( row < 0 ) + { + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + + if ( ( row * -1 ) > nCount ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = 0; + m_pImpl->m_xDataSupplier->validate(); + return false; + } + else // |row| <= nCount + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = ( nCount + row + 1 ); + m_pImpl->m_xDataSupplier->validate(); + return true; + } + } + else if ( row == 0 ) + { + // @throws SQLException + // ... if row is 0 ... + throw sdbc::SQLException(); + } + else // row > 0 + { + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + + if ( row <= nCount ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = row; + m_pImpl->m_xDataSupplier->validate(); + return true; + } + else // row > nCount + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = true; + m_pImpl->m_xDataSupplier->validate(); + return false; + } + } + + // unreachable... +} + + +// virtual +sal_Bool SAL_CALL ResultSet::relative( sal_Int32 rows ) +{ +/* + Attempting to move beyond the first/last row in the result set + positions the cursor before/after the first/last row. + + Calling relative( 0 ) is valid, but does not change the cursor position. + + Calling relative( 1 ) is different from calling next() because it makes + sense to call next() when there is no current row, for example, when + the cursor is positioned before the first row or after the last row of + the result set. +*/ + if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) ) + { + // "No current row". + throw sdbc::SQLException(); + } + + if ( rows < 0 ) + { + if ( ( m_pImpl->m_nPos + rows ) > 0 ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows ); + m_pImpl->m_xDataSupplier->validate(); + return true; + } + else + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = 0; + m_pImpl->m_xDataSupplier->validate(); + return false; + } + } + else if ( rows == 0 ) + { + // nop. + m_pImpl->m_xDataSupplier->validate(); + return true; + } + else // rows > 0 + { + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + if ( ( m_pImpl->m_nPos + rows ) <= nCount ) + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = false; + m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows ); + m_pImpl->m_xDataSupplier->validate(); + return true; + } + else + { + std::unique_lock aGuard( m_pImpl->m_aMutex ); + m_pImpl->m_bAfterLast = true; + m_pImpl->m_xDataSupplier->validate(); + return false; + } + } + + // unreachable... +} + + +// virtual +sal_Bool SAL_CALL ResultSet::previous() +{ +/* + previous() is not the same as relative( -1 ) because it makes sense + to call previous() when there is no current row. +*/ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( m_pImpl->m_bAfterLast ) + { + m_pImpl->m_bAfterLast = false; + sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount(); + m_pImpl->m_nPos = nCount; + } + else if ( m_pImpl->m_nPos ) + m_pImpl->m_nPos--; + + if ( m_pImpl->m_nPos ) + { + m_pImpl->m_xDataSupplier->validate(); + return true; + } + + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +void SAL_CALL ResultSet::refreshRow() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) ) + return; + + m_pImpl->m_xDataSupplier->releasePropertyValues( m_pImpl->m_nPos ); + m_pImpl->m_xDataSupplier->validate(); +} + + +// virtual +sal_Bool SAL_CALL ResultSet::rowUpdated() +{ + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::rowInserted() +{ + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSet::rowDeleted() +{ + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +uno::Reference< uno::XInterface > SAL_CALL ResultSet::getStatement() +{ +/* + returns the Statement that produced this ResultSet object. If the + result set was generated some other way, ... this method returns null. +*/ + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< uno::XInterface >(); +} + + +// XRow methods. + + +// virtual +sal_Bool SAL_CALL ResultSet::wasNull() +{ + // This method can not be implemented correctly!!! Imagine different + // threads doing a getXYZ - wasNull calling sequence on the same + // implementation object... + + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_xDataSupplier->validate(); + return xValues->wasNull(); + } + } + + m_pImpl->m_xDataSupplier->validate(); + return m_pImpl->m_bWasNull; +} + + +// virtual +OUString SAL_CALL ResultSet::getString( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getString( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return OUString(); +} + + +// virtual +sal_Bool SAL_CALL ResultSet::getBoolean( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getBoolean( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return false; +} + + +// virtual +sal_Int8 SAL_CALL ResultSet::getByte( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getByte( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +sal_Int16 SAL_CALL ResultSet::getShort( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getShort( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +sal_Int32 SAL_CALL ResultSet::getInt( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getInt( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +sal_Int64 SAL_CALL ResultSet::getLong( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getLong( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +float SAL_CALL ResultSet::getFloat( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getFloat( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +double SAL_CALL ResultSet::getDouble( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getDouble( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return 0; +} + + +// virtual +uno::Sequence< sal_Int8 > SAL_CALL +ResultSet::getBytes( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getBytes( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Sequence< sal_Int8 >(); +} + + +// virtual +util::Date SAL_CALL ResultSet::getDate( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getDate( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return util::Date(); +} + + +// virtual +util::Time SAL_CALL ResultSet::getTime( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getTime( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return util::Time(); +} + + +// virtual +util::DateTime SAL_CALL +ResultSet::getTimestamp( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getTimestamp( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return util::DateTime(); +} + + +// virtual +uno::Reference< io::XInputStream > SAL_CALL +ResultSet::getBinaryStream( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getBinaryStream( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< io::XInputStream >(); +} + + +// virtual +uno::Reference< io::XInputStream > SAL_CALL +ResultSet::getCharacterStream( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getCharacterStream( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< io::XInputStream >(); +} + + +// virtual +uno::Any SAL_CALL ResultSet::getObject( + sal_Int32 columnIndex, + const uno::Reference< container::XNameAccess >& typeMap ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getObject( columnIndex, typeMap ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Any(); +} + + +// virtual +uno::Reference< sdbc::XRef > SAL_CALL +ResultSet::getRef( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getRef( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< sdbc::XRef >(); +} + + +// virtual +uno::Reference< sdbc::XBlob > SAL_CALL +ResultSet::getBlob( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getBlob( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< sdbc::XBlob >(); +} + + +// virtual +uno::Reference< sdbc::XClob > SAL_CALL +ResultSet::getClob( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getClob( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< sdbc::XClob >(); +} + + +// virtual +uno::Reference< sdbc::XArray > SAL_CALL +ResultSet::getArray( sal_Int32 columnIndex ) +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + { + uno::Reference< sdbc::XRow > xValues + = m_pImpl->m_xDataSupplier->queryPropertyValues( + m_pImpl->m_nPos - 1 ); + if ( xValues.is() ) + { + m_pImpl->m_bWasNull = false; + m_pImpl->m_xDataSupplier->validate(); + return xValues->getArray( columnIndex ); + } + } + + m_pImpl->m_bWasNull = true; + m_pImpl->m_xDataSupplier->validate(); + return uno::Reference< sdbc::XArray >(); +} + + +// XCloseable methods. + + +// virtual +void SAL_CALL ResultSet::close() +{ + m_pImpl->m_xDataSupplier->close(); + m_pImpl->m_xDataSupplier->validate(); +} + + +// XContentAccess methods. + + +// virtual +OUString SAL_CALL ResultSet::queryContentIdentifierString() +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + return m_pImpl->m_xDataSupplier->queryContentIdentifierString( + m_pImpl->m_nPos - 1 ); + + return OUString(); +} + + +// virtual +uno::Reference< css::ucb::XContentIdentifier > SAL_CALL +ResultSet::queryContentIdentifier() +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + return m_pImpl->m_xDataSupplier->queryContentIdentifier( + m_pImpl->m_nPos - 1 ); + + return uno::Reference< css::ucb::XContentIdentifier >(); +} + + +// virtual +uno::Reference< css::ucb::XContent > SAL_CALL +ResultSet::queryContent() +{ + if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast ) + return m_pImpl->m_xDataSupplier->queryContent( m_pImpl->m_nPos - 1 ); + + return uno::Reference< css::ucb::XContent >(); +} + + +// XPropertySet methods. + + +// virtual +uno::Reference< beans::XPropertySetInfo > SAL_CALL +ResultSet::getPropertySetInfo() +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !m_pImpl->m_xPropSetInfo.is() ) + m_pImpl->m_xPropSetInfo + = new PropertySetInfo( aPropertyTable, + RESULTSET_PROPERTY_COUNT ); + return m_pImpl->m_xPropSetInfo; +} + + +// virtual +void SAL_CALL ResultSet::setPropertyValue( const OUString& aPropertyName, + const uno::Any& ) +{ + if ( aPropertyName == "RowCount" ) + { + // property is read-only. + throw lang::IllegalArgumentException(); + } + else if ( aPropertyName == "IsRowCountFinal" ) + { + // property is read-only. + throw lang::IllegalArgumentException(); + } + else + { + throw beans::UnknownPropertyException(aPropertyName); + } +} + + +// virtual +uno::Any SAL_CALL ResultSet::getPropertyValue( + const OUString& PropertyName ) +{ + uno::Any aValue; + + if ( PropertyName == "RowCount" ) + { + aValue <<= m_pImpl->m_xDataSupplier->currentCount(); + } + else if ( PropertyName == "IsRowCountFinal" ) + { + aValue <<= m_pImpl->m_xDataSupplier->isCountFinal(); + } + else + { + throw beans::UnknownPropertyException(PropertyName); + } + + return aValue; +} + + +// virtual +void SAL_CALL ResultSet::addPropertyChangeListener( + const OUString& aPropertyName, + const uno::Reference< beans::XPropertyChangeListener >& xListener ) +{ + // Note: An empty property name means a listener for "all" properties. + + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !aPropertyName.isEmpty() && + aPropertyName != "RowCount" && + aPropertyName != "IsRowCountFinal" ) + throw beans::UnknownPropertyException(aPropertyName); + + if ( !m_pImpl->m_pPropertyChangeListeners ) + m_pImpl->m_pPropertyChangeListeners.reset( + new PropertyChangeListeners()); + + m_pImpl->m_pPropertyChangeListeners->addInterface(aGuard, + aPropertyName, xListener ); +} + + +// virtual +void SAL_CALL ResultSet::removePropertyChangeListener( + const OUString& aPropertyName, + const uno::Reference< beans::XPropertyChangeListener >& xListener ) +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !aPropertyName.isEmpty() && + aPropertyName != "RowCount" && + aPropertyName != "IsRowCountFinal" ) + throw beans::UnknownPropertyException(aPropertyName); + + if ( m_pImpl->m_pPropertyChangeListeners ) + m_pImpl->m_pPropertyChangeListeners->removeInterface(aGuard, + aPropertyName, xListener ); + +} + + +// virtual +void SAL_CALL ResultSet::addVetoableChangeListener( + const OUString&, + const uno::Reference< beans::XVetoableChangeListener >& ) +{ + // No constrained props, at the moment. +} + + +// virtual +void SAL_CALL ResultSet::removeVetoableChangeListener( + const OUString&, + const uno::Reference< beans::XVetoableChangeListener >& ) +{ + // No constrained props, at the moment. +} + + +// Non-interface methods. + + +void ResultSet::propertyChanged( const beans::PropertyChangeEvent& rEvt ) const +{ + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !m_pImpl->m_pPropertyChangeListeners ) + return; + + // Notify listeners interested especially in the changed property. + comphelper::OInterfaceContainerHelper4<beans::XPropertyChangeListener>* pPropsContainer + = m_pImpl->m_pPropertyChangeListeners->getContainer( + rEvt.PropertyName ); + if ( pPropsContainer ) + { + pPropsContainer->notifyEach(aGuard, &beans::XPropertyChangeListener::propertyChange, rEvt); + } + + // Notify listeners interested in all properties. + pPropsContainer + = m_pImpl->m_pPropertyChangeListeners->getContainer( OUString() ); + if ( pPropsContainer ) + { + comphelper::OInterfaceIteratorHelper4 aIter( aGuard, *pPropsContainer ); + while ( aIter.hasMoreElements() ) + { + aIter.next()->propertyChange( rEvt ); + } + } +} + + +void ResultSet::rowCountChanged( sal_uInt32 nOld, sal_uInt32 nNew ) +{ + OSL_ENSURE( nOld < nNew, "ResultSet::rowCountChanged - nOld >= nNew!" ); + + if ( !m_pImpl->m_pPropertyChangeListeners ) + return; + + propertyChanged( + beans::PropertyChangeEvent( + static_cast< cppu::OWeakObject * >( this ), + "RowCount", + false, + 1001, + uno::Any( nOld ), // old value + uno::Any( nNew ) ) ); // new value +} + + +void ResultSet::rowCountFinal() +{ + if ( !m_pImpl->m_pPropertyChangeListeners ) + return; + + propertyChanged( + beans::PropertyChangeEvent( + static_cast< cppu::OWeakObject * >( this ), + "IsRowCountFinal", + false, + 1000, + uno:: Any( false ), // old value + uno::Any( true ) ) ); // new value +} + + +const uno::Sequence< beans::Property >& ResultSet::getProperties() const +{ + return m_pImpl->m_aProperties; +} + + +const uno::Reference< css::ucb::XCommandEnvironment >& +ResultSet::getEnvironment() const +{ + return m_pImpl->m_xEnv; +} + +} // namespace ucbhelper + +namespace ucbhelper_impl { + + +// PropertySetInfo Implementation. + + +PropertySetInfo::PropertySetInfo( + const PropertyInfo* pProps, + sal_Int32 nProps ) + : m_aProps( nProps ) +{ + + if ( !nProps ) + return; + + const PropertyInfo* pEntry = pProps; + beans::Property* pProperties = m_aProps.getArray(); + + for ( sal_Int32 n = 0; n < nProps; ++n ) + { + beans::Property& rProp = pProperties[ n ]; + + rProp.Name = OUString::createFromAscii( pEntry->pName ); + rProp.Handle = pEntry->nHandle; + rProp.Type = pEntry->pGetCppuType(); + rProp.Attributes = pEntry->nAttributes; + + pEntry++; + } +} + + + +// XInterface methods. +void SAL_CALL PropertySetInfo::acquire() + noexcept +{ + OWeakObject::acquire(); +} + +void SAL_CALL PropertySetInfo::release() + noexcept +{ + OWeakObject::release(); +} + +css::uno::Any SAL_CALL PropertySetInfo::queryInterface( + const css::uno::Type & rType ) +{ + css::uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider* >(this), + static_cast< beans::XPropertySetInfo* >(this) + ); + return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ); +} + +// XTypeProvider methods. + + +XTYPEPROVIDER_IMPL_2( PropertySetInfo, + lang::XTypeProvider, + beans::XPropertySetInfo ); + + +// XPropertySetInfo methods. + + +// virtual +uno::Sequence< beans::Property > SAL_CALL PropertySetInfo::getProperties() +{ + return m_aProps; +} + + +// virtual +beans::Property SAL_CALL PropertySetInfo::getPropertyByName( + const OUString& aName ) +{ + beans::Property aProp; + if ( queryProperty( aName, aProp ) ) + return aProp; + + throw beans::UnknownPropertyException(aName); +} + + +// virtual +sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName( + const OUString& Name ) +{ + beans::Property aProp; + return queryProperty( Name, aProp ); +} + + +bool PropertySetInfo::queryProperty( + std::u16string_view aName, beans::Property& rProp ) const +{ + sal_Int32 nCount = m_aProps.getLength(); + const beans::Property* pProps = m_aProps.getConstArray(); + for ( sal_Int32 n = 0; n < nCount; ++n ) + { + const beans::Property& rCurr = pProps[ n ]; + if ( rCurr.Name == aName ) + { + rProp = rCurr; + return true; + } + } + + return false; +} + +} // namespace ucbhelper_impl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/resultsethelper.cxx b/ucbhelper/source/provider/resultsethelper.cxx new file mode 100644 index 000000000..60f8977d1 --- /dev/null +++ b/ucbhelper/source/provider/resultsethelper.cxx @@ -0,0 +1,254 @@ +/* -*- 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 + ************************************************************************** + + - This implementation is far away from completion. It has no interface + for changes notifications etc. + + *************************************************************************/ +#include <com/sun/star/ucb/ListActionType.hpp> +#include <com/sun/star/ucb/ListenerAlreadySetException.hpp> +#include <com/sun/star/ucb/ServiceNotFoundException.hpp> +#include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp> +#include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp> +#include <com/sun/star/ucb/XSourceInitialization.hpp> +#include <cppuhelper/supportsservice.hxx> +#include <ucbhelper/resultsethelper.hxx> + +#include <osl/diagnose.h> + +using namespace com::sun::star; + + +// ResultSetImplHelper Implementation. + + +namespace ucbhelper { + + +ResultSetImplHelper::ResultSetImplHelper( + const uno::Reference< uno::XComponentContext >& rxContext, + const css::ucb::OpenCommandArgument2& rCommand ) +: m_bStatic( false ), + m_bInitDone( false ), + m_aCommand( rCommand ), + m_xContext( rxContext ) +{ +} + + +// virtual +ResultSetImplHelper::~ResultSetImplHelper() +{ +} + + +// XServiceInfo methods. + +OUString SAL_CALL ResultSetImplHelper::getImplementationName() +{ + return "ResultSetImplHelper"; +} + +sal_Bool SAL_CALL ResultSetImplHelper::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL ResultSetImplHelper::getSupportedServiceNames() +{ + return { DYNAMICRESULTSET_SERVICE_NAME }; +} + +// XComponent methods. + + +// virtual +void SAL_CALL ResultSetImplHelper::dispose() +{ + std::unique_lock aGuard( m_aMutex ); + + if ( m_aDisposeEventListeners.getLength(aGuard) ) + { + lang::EventObject aEvt; + aEvt.Source = static_cast< lang::XComponent * >( this ); + m_aDisposeEventListeners.disposeAndClear( aGuard, aEvt ); + } +} + + +// virtual +void SAL_CALL ResultSetImplHelper::addEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + std::unique_lock aGuard( m_aMutex ); + + m_aDisposeEventListeners.addInterface( aGuard, Listener ); +} + + +// virtual +void SAL_CALL ResultSetImplHelper::removeEventListener( + const uno::Reference< lang::XEventListener >& Listener ) +{ + std::unique_lock aGuard( m_aMutex ); + + m_aDisposeEventListeners.removeInterface( aGuard, Listener ); +} + + +// XDynamicResultSet methods. + + +// virtual +uno::Reference< sdbc::XResultSet > SAL_CALL +ResultSetImplHelper::getStaticResultSet() +{ + std::unique_lock aGuard( m_aMutex ); + + if ( m_xListener.is() ) + throw css::ucb::ListenerAlreadySetException(); + + init( true ); + return m_xResultSet1; +} + + +// virtual +void SAL_CALL ResultSetImplHelper::setListener( + const uno::Reference< css::ucb::XDynamicResultSetListener >& Listener ) +{ + std::unique_lock aGuard( m_aMutex ); + + if ( m_bStatic || m_xListener.is() ) + throw css::ucb::ListenerAlreadySetException(); + + m_xListener = Listener; + + + // Create "welcome event" and send it to listener. + + + // Note: We only have the implementation for a static result set at the + // moment (src590). The dynamic result sets passed to the listener + // are a fake. This implementation will never call "notify" at the + // listener to propagate any changes!!! + + init( false ); + + uno::Any aInfo; + aInfo <<= css::ucb::WelcomeDynamicResultSetStruct( + m_xResultSet1 /* "old" */, + m_xResultSet2 /* "new" */ ); + + uno::Sequence< css::ucb::ListAction > aActions { + css::ucb::ListAction( + 0, // Position; not used + 0, // Count; not used + css::ucb::ListActionType::WELCOME, + aInfo ) }; + aGuard.unlock(); + + Listener->notify( + css::ucb::ListEvent( + static_cast< cppu::OWeakObject * >( this ), aActions ) ); +} + + +// virtual +sal_Int16 SAL_CALL ResultSetImplHelper::getCapabilities() +{ + // ! css::ucb::ContentResultSetCapability::SORTED + return 0; +} + + +// virtual +void SAL_CALL ResultSetImplHelper::connectToCache( + const uno::Reference< css::ucb::XDynamicResultSet > & xCache ) +{ + if ( m_xListener.is() ) + throw css::ucb::ListenerAlreadySetException(); + + if ( m_bStatic ) + throw css::ucb::ListenerAlreadySetException(); + + uno::Reference< css::ucb::XSourceInitialization > xTarget( xCache, uno::UNO_QUERY ); + if ( xTarget.is() ) + { + uno::Reference< css::ucb::XCachedDynamicResultSetStubFactory > xStubFactory; + try + { + xStubFactory + = css::ucb::CachedDynamicResultSetStubFactory::create( + m_xContext ); + } + catch ( uno::Exception const & ) + { + } + + if ( xStubFactory.is() ) + { + xStubFactory->connectToCache( + this, xCache, m_aCommand.SortingInfo, nullptr ); + return; + } + } + throw css::ucb::ServiceNotFoundException(); +} + + +// Non-interface methods. + + +void ResultSetImplHelper::init( bool bStatic ) +{ + if ( m_bInitDone ) + return; + + if ( bStatic ) + { + // virtual... derived class fills m_xResultSet1 + initStatic(); + + OSL_ENSURE( m_xResultSet1.is(), + "ResultSetImplHelper::init - No 1st result set!" ); + m_bStatic = true; + } + else + { + // virtual... derived class fills m_xResultSet1 and m_xResultSet2 + initDynamic(); + + OSL_ENSURE( m_xResultSet1.is(), + "ResultSetImplHelper::init - No 1st result set!" ); + OSL_ENSURE( m_xResultSet2.is(), + "ResultSetImplHelper::init - No 2nd result set!" ); + m_bStatic = false; + } + m_bInitDone = true; +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/resultsetmetadata.cxx b/ucbhelper/source/provider/resultsetmetadata.cxx new file mode 100644 index 000000000..40f69053f --- /dev/null +++ b/ucbhelper/source/provider/resultsetmetadata.cxx @@ -0,0 +1,404 @@ +/* -*- 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 <osl/diagnose.h> +#include <com/sun/star/beans/Property.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/io/XInputStream.hpp> +#include <com/sun/star/sdbc/ColumnValue.hpp> +#include <com/sun/star/sdbc/DataType.hpp> +#include <com/sun/star/sdbc/XArray.hpp> +#include <com/sun/star/sdbc/XBlob.hpp> +#include <com/sun/star/sdbc/XClob.hpp> +#include <com/sun/star/sdbc/XRef.hpp> +#include <com/sun/star/util/Date.hpp> +#include <com/sun/star/util/Time.hpp> +#include <com/sun/star/util/DateTime.hpp> +#include <com/sun/star/ucb/PropertiesManager.hpp> +#include <ucbhelper/resultsetmetadata.hxx> +#include <mutex> + +using namespace com::sun::star::beans; +using namespace com::sun::star::io; +using namespace com::sun::star::lang; +using namespace com::sun::star::sdbc; +using namespace com::sun::star::ucb; +using namespace com::sun::star::uno; +using namespace com::sun::star::util; + + +namespace ucbhelper_impl { + +struct ResultSetMetaData_Impl +{ + std::mutex m_aMutex; + std::vector< ::ucbhelper::ResultSetColumnData > m_aColumnData; + bool m_bObtainedTypes; + + explicit ResultSetMetaData_Impl( sal_Int32 nSize ) + : m_aColumnData( nSize ), m_bObtainedTypes( false ) {} + + explicit ResultSetMetaData_Impl( + std::vector< ::ucbhelper::ResultSetColumnData >&& rColumnData ) + : m_aColumnData( std::move(rColumnData) ), m_bObtainedTypes( false ) {} +}; + +} + +using namespace ucbhelper_impl; + +namespace ucbhelper { + + +// ResultSetMetaData Implementation. + + +ResultSetMetaData::ResultSetMetaData( + const Reference< XComponentContext >& rxContext, + const Sequence< Property >& rProps ) +: m_pImpl( new ResultSetMetaData_Impl( rProps.getLength() ) ), + m_xContext( rxContext ), + m_aProps( rProps ) +{ +} + + +ResultSetMetaData::ResultSetMetaData( + const Reference< XComponentContext >& rxContext, + const Sequence< Property >& rProps, + std::vector< ResultSetColumnData >&& rColumnData ) +: m_pImpl( new ResultSetMetaData_Impl( std::move(rColumnData) ) ), + m_xContext( rxContext ), + m_aProps( rProps ) +{ + OSL_ENSURE( m_pImpl->m_aColumnData.size() == sal_uInt32( rProps.getLength() ), + "ResultSetMetaData ctor - different array sizes!" ); +} + + +// virtual +ResultSetMetaData::~ResultSetMetaData() +{ +} + + +// XResultSetMetaData methods. + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::getColumnCount() +{ + return m_aProps.getLength(); +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isAutoIncrement( sal_Int32 /*column*/ ) +{ + /* + Checks whether column is automatically numbered, which makes it + read-only. + */ + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isCaseSensitive( sal_Int32 column ) +{ + if ( ( column < 1 ) || ( column > m_aProps.getLength() ) ) + return false; + + return m_pImpl->m_aColumnData[ column - 1 ].isCaseSensitive; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isSearchable( sal_Int32 /*column*/ ) +{ + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isCurrency( sal_Int32 /*column*/ ) +{ + return false; +} + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::isNullable( sal_Int32 /*column*/ ) +{ + return ColumnValue::NULLABLE; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isSigned( sal_Int32 /*column*/ ) +{ + return false; +} + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::getColumnDisplaySize( sal_Int32 /*column*/ ) +{ + /* + Gets the normal maximum width in characters for column. + */ + return 16; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getColumnLabel( sal_Int32 column ) +{ + /* + Gets the suggested column title for column, to be used in print- + outs and displays. + */ + + if ( ( column < 1 ) || ( column > m_aProps.getLength() ) ) + return OUString(); + + return m_aProps.getConstArray()[ column - 1 ].Name; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getColumnName( sal_Int32 column ) +{ + /* + Gets the name of column. + */ + + if ( ( column < 1 ) || ( column > m_aProps.getLength() ) ) + return OUString(); + + return m_aProps.getConstArray()[ column - 1 ].Name; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getSchemaName( sal_Int32 /*column*/ ) +{ + /* + Gets the schema name for the table from which column of this + result set was derived. + Because this feature is not widely supported, the return value + for many DBMSs will be an empty string. + */ + return OUString(); +} + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::getPrecision( sal_Int32 /*column*/ ) +{ + return -1; +} + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::getScale( sal_Int32 /*column*/ ) +{ + return 0; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getTableName( sal_Int32 /*column*/ ) +{ + /* + Gets the name of the table from which column of this result set + was derived or "" if there is none (for example, for a join). + Because this feature is not widely supported, the return value + for many DBMSs will be an empty string. + */ + return OUString(); +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getCatalogName( sal_Int32 /*column*/ ) +{ + /* + Gets the catalog name for the table from which column of this + result set was derived. + Because this feature is not widely supported, the return value + for many DBMSs will be an empty string. + */ + return OUString(); +} + + +// virtual +sal_Int32 SAL_CALL ResultSetMetaData::getColumnType( sal_Int32 column ) +{ + /* + Gets the JDBC type for the value stored in column. ... The STRUCT + and DISTINCT type codes are always returned for structured and + distinct types, regardless of whether the value will be mapped + according to the standard mapping or be a custom mapping. + */ + + if ( ( column < 1 ) || ( column > m_aProps.getLength() ) ) + return DataType::SQLNULL; + + if ( m_aProps.getConstArray()[ column - 1 ].Type + == cppu::UnoType<void>::get() ) + { + // No type given. Try UCB's Properties Manager... + + std::unique_lock aGuard( m_pImpl->m_aMutex ); + + if ( !m_pImpl->m_bObtainedTypes ) + { + try + { + Reference< XPropertySetInfo > xInfo = PropertiesManager::create( m_xContext ); + // Less (remote) calls... + + const Sequence< Property > aProps = xInfo->getProperties(); + + for ( Property& rProp : asNonConstRange(m_aProps) ) + { + auto pProp = std::find_if(aProps.begin(), aProps.end(), + [&rProp](const Property& rProp1) { return rProp.Name == rProp1.Name; }); + if (pProp != aProps.end()) + { + // Found... + rProp.Type = pProp->Type; + } + } + } + catch ( RuntimeException& ) + { + throw; + } + catch ( Exception& ) + { + // createInstance + } + + m_pImpl->m_bObtainedTypes = true; + } + } + + const Type& rType = m_aProps.getConstArray()[ column - 1 ].Type; + sal_Int32 nType = DataType::OTHER; + + if ( rType == cppu::UnoType<OUString>::get() ) + nType = DataType::VARCHAR; // XRow::getString + else if ( rType == cppu::UnoType<bool>::get() ) + nType = DataType::BIT; // XRow::getBoolean + else if ( rType == cppu::UnoType<sal_Int32>::get() ) + nType = DataType::INTEGER; // XRow::getInt + else if ( rType == cppu::UnoType<sal_Int64>::get() ) + nType = DataType::BIGINT; // XRow::getLong + else if ( rType == cppu::UnoType<sal_Int16>::get() ) + nType = DataType::SMALLINT; // XRow::getShort + else if ( rType == cppu::UnoType<sal_Int8>::get() ) + nType = DataType::TINYINT; // XRow::getByte + else if ( rType == cppu::UnoType<float>::get() ) + nType = DataType::REAL; // XRow::getFloat + else if ( rType == cppu::UnoType<double>::get() ) + nType = DataType::DOUBLE; // XRow::getDouble + else if ( rType == cppu::UnoType<Sequence<sal_Int8>>::get() ) + nType = DataType::VARBINARY;// XRow::getBytes + else if ( rType == cppu::UnoType<Date>::get() ) + nType = DataType::DATE; // XRow::getDate + else if ( rType == cppu::UnoType<Time>::get() ) + nType = DataType::TIME; // XRow::getTime + else if ( rType == cppu::UnoType<DateTime>::get() ) + nType = DataType::TIMESTAMP;// XRow::getTimestamp + else if ( rType == cppu::UnoType<XInputStream>::get() ) + nType = DataType::LONGVARBINARY; // XRow::getBinaryStream +// nType = DataType::LONGVARCHAR; // XRow::getCharacterStream + else if ( rType == cppu::UnoType<XClob>::get() ) + nType = DataType::CLOB; // XRow::getClob + else if ( rType == cppu::UnoType<XBlob>::get() ) + nType = DataType::BLOB; // XRow::getBlob + else if ( rType == cppu::UnoType<XArray>::get() ) + nType = DataType::ARRAY;// XRow::getArray + else if ( rType == cppu::UnoType<XRef>::get() ) + nType = DataType::REF;// XRow::getRef + else + nType = DataType::OBJECT;// XRow::getObject + + return nType; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getColumnTypeName( sal_Int32 /*column*/ ) +{ + /* + Gets the type name used by this particular data source for the + values stored in column. If the type code for the type of value + stored in column is STRUCT, DISTINCT or JAVA_OBJECT, this method + returns a fully-qualified SQL type name. + */ + return OUString(); +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isReadOnly( sal_Int32 /*column*/ ) +{ + return true; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isWritable( sal_Int32 /*column*/ ) +{ + return false; +} + + +// virtual +sal_Bool SAL_CALL ResultSetMetaData::isDefinitelyWritable( sal_Int32 /*column*/ ) +{ + return false; +} + + +// virtual +OUString SAL_CALL ResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ ) +{ + /* + Returns the fully-qualified name of the service whose instances + are manufactured if XResultSet::getObject is called to retrieve + a value from the column. + */ + return OUString(); +} + +} // namespace ucbhelper + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simpleauthenticationrequest.cxx b/ucbhelper/source/provider/simpleauthenticationrequest.cxx new file mode 100644 index 000000000..972864d9a --- /dev/null +++ b/ucbhelper/source/provider/simpleauthenticationrequest.cxx @@ -0,0 +1,147 @@ +/* -*- 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 . + */ + +#include <com/sun/star/ucb/URLAuthenticationRequest.hpp> +#include <ucbhelper/simpleauthenticationrequest.hxx> + +using namespace com::sun::star; +using namespace ucbhelper; + + +SimpleAuthenticationRequest::SimpleAuthenticationRequest( + const OUString & rURL, + const OUString & rServerName, + const OUString & rRealm, + const OUString & rUserName, + const OUString & rPassword, + bool bAllowUseSystemCredentials, + bool bAllowSessionStoring ) +{ + + // Fill request... + ucb::URLAuthenticationRequest aRequest; +// aRequest.Message = // OUString +// aRequest.Context = // XInterface + aRequest.Classification = task::InteractionClassification_ERROR; + aRequest.ServerName = rServerName; +// aRequest.Diagnostic = // OUString + aRequest.HasRealm = !rRealm.isEmpty(); + if ( aRequest.HasRealm ) + aRequest.Realm = rRealm; + aRequest.HasUserName = true; + aRequest.UserName = rUserName; + aRequest.HasPassword = true; + aRequest.Password = rPassword; + aRequest.HasAccount = false; + aRequest.URL = rURL; + + initialize(aRequest, + false, + true, + true, + aRequest.HasAccount, + bAllowUseSystemCredentials, + bAllowSessionStoring ); +} + + +SimpleAuthenticationRequest::SimpleAuthenticationRequest( + const OUString & rURL, + const OUString & rServerName, + EntityType eRealmType, + const OUString & rRealm, + EntityType eUserNameType, + const OUString & rUserName, + EntityType ePasswordType, + const OUString & rPassword) +{ + // Fill request... + ucb::URLAuthenticationRequest aRequest; +// aRequest.Message = // OUString +// aRequest.Context = // XInterface + aRequest.Classification = task::InteractionClassification_ERROR; + aRequest.ServerName = rServerName; +// aRequest.Diagnostic = // OUString + aRequest.HasRealm = eRealmType != ENTITY_NA; + if ( aRequest.HasRealm ) + aRequest.Realm = rRealm; + aRequest.HasUserName = eUserNameType != ENTITY_NA; + if ( aRequest.HasUserName ) + aRequest.UserName = rUserName; + aRequest.HasPassword = ePasswordType != ENTITY_NA; + if ( aRequest.HasPassword ) + aRequest.Password = rPassword; + aRequest.HasAccount = false; + aRequest.URL = rURL; + + initialize(aRequest, + eRealmType == ENTITY_MODIFY, + eUserNameType == ENTITY_MODIFY, + ePasswordType == ENTITY_MODIFY, + false, + false, + true ); +} + + +void SimpleAuthenticationRequest::initialize( + const ucb::URLAuthenticationRequest & rRequest, + bool bCanSetRealm, + bool bCanSetUserName, + bool bCanSetPassword, + bool bCanSetAccount, + bool bAllowUseSystemCredentials, + bool bAllowSessionStoring ) +{ + setRequest( uno::Any( rRequest ) ); + + // Fill continuations... + unsigned int nSize = 2; + + if( bAllowSessionStoring ) + nSize++; + + uno::Sequence< ucb::RememberAuthentication > aRememberModes( nSize ); + auto it = aRememberModes.getArray(); + *it++ = ucb::RememberAuthentication_NO; + + if( bAllowSessionStoring ) + *it++ = ucb::RememberAuthentication_SESSION; + + *it = ucb::RememberAuthentication_PERSISTENT; + + m_xAuthSupplier + = new InteractionSupplyAuthentication( + this, + bCanSetRealm, + bCanSetUserName, + bCanSetPassword, + bCanSetAccount, + aRememberModes, // rRememberPasswordModes + ucb::RememberAuthentication_SESSION, // eDefaultRememberPasswordMode + aRememberModes, // rRememberAccountModes + ucb::RememberAuthentication_SESSION, // eDefaultRememberAccountMode + bAllowUseSystemCredentials // bCanUseSystemCredentials, + ); + + setContinuations( + { new InteractionAbort(this), new InteractionRetry(this), m_xAuthSupplier }); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simplecertificatevalidationrequest.cxx b/ucbhelper/source/provider/simplecertificatevalidationrequest.cxx new file mode 100644 index 000000000..e1dba7a35 --- /dev/null +++ b/ucbhelper/source/provider/simplecertificatevalidationrequest.cxx @@ -0,0 +1,42 @@ +/* -*- 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 . + */ + +#include <com/sun/star/ucb/CertificateValidationRequest.hpp> +#include <ucbhelper/simplecertificatevalidationrequest.hxx> + +using namespace com::sun::star; +using namespace ucbhelper; + + +SimpleCertificateValidationRequest::SimpleCertificateValidationRequest( sal_Int32 lCertificateValidity, + const css::uno::Reference<css::security::XCertificate>& certificate, + const OUString & hostname) +{ + // Fill request... + ucb::CertificateValidationRequest aRequest; + aRequest.CertificateValidity = lCertificateValidity; + aRequest.Certificate = certificate; + aRequest.HostName = hostname; + + setRequest( uno::Any( aRequest ) ); + + setContinuations({ new InteractionAbort(this), new InteractionApprove(this) }); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simpleinteractionrequest.cxx b/ucbhelper/source/provider/simpleinteractionrequest.cxx new file mode 100644 index 000000000..d846be5d3 --- /dev/null +++ b/ucbhelper/source/provider/simpleinteractionrequest.cxx @@ -0,0 +1,92 @@ +/* -*- 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 . + */ + +#include <ucbhelper/simpleinteractionrequest.hxx> +#include <comphelper/sequence.hxx> + +#include <osl/diagnose.h> +#include <rtl/ref.hxx> + +using namespace com::sun::star; +using namespace ucbhelper; + + +SimpleInteractionRequest::SimpleInteractionRequest( + const uno::Any & rRequest, + const ContinuationFlags nContinuations ) +: InteractionRequest( rRequest ) +{ + // Set continuations. + OSL_ENSURE( nContinuations != ContinuationFlags::NONE, + "SimpleInteractionRequest - No continuation!" ); + + std::vector< uno::Reference< task::XInteractionContinuation > > aContinuations; + if ( nContinuations & ContinuationFlags::Abort ) + { + aContinuations.push_back( new InteractionAbort( this ) ); + } + if ( nContinuations & ContinuationFlags::Retry ) + { + aContinuations.push_back( new InteractionRetry( this ) ); + } + if ( nContinuations & ContinuationFlags::Approve ) + { + aContinuations.push_back( new InteractionApprove( this ) ); + } + if ( nContinuations & ContinuationFlags::Disapprove ) + { + aContinuations.push_back( new InteractionDisapprove( this ) ); + } + setContinuations( comphelper::containerToSequence(aContinuations) ); +} + + +ContinuationFlags SimpleInteractionRequest::getResponse() const +{ + rtl::Reference< InteractionContinuation > xSelection = getSelection(); + if ( xSelection.is() ) + { + InteractionContinuation * pSelection = xSelection.get(); + + uno::Reference< task::XInteractionAbort > xAbort( + pSelection, uno::UNO_QUERY ); + if ( xAbort.is() ) + return ContinuationFlags::Abort; + + uno::Reference< task::XInteractionRetry > xRetry( + pSelection, uno::UNO_QUERY ); + if ( xRetry.is() ) + return ContinuationFlags::Retry; + + uno::Reference< task::XInteractionApprove > xApprove( + pSelection, uno::UNO_QUERY ); + if ( xApprove.is() ) + return ContinuationFlags::Approve; + + uno::Reference< task::XInteractionDisapprove > xDisapprove( + pSelection, uno::UNO_QUERY ); + if ( xDisapprove.is() ) + return ContinuationFlags::Disapprove; + + OSL_FAIL( "SimpleInteractionRequest::getResponse - Unknown continuation!" ); + } + return ContinuationFlags::NONE; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simpleioerrorrequest.cxx b/ucbhelper/source/provider/simpleioerrorrequest.cxx new file mode 100644 index 000000000..df28f6352 --- /dev/null +++ b/ucbhelper/source/provider/simpleioerrorrequest.cxx @@ -0,0 +1,48 @@ +/* -*- 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 . + */ + +#include <com/sun/star/ucb/InteractiveAugmentedIOException.hpp> +#include <com/sun/star/ucb/XCommandProcessor.hpp> +#include "simpleioerrorrequest.hxx" + +using namespace com::sun::star; +using namespace ucbhelper; + + +SimpleIOErrorRequest::SimpleIOErrorRequest( + const ucb::IOErrorCode eError, + const uno::Sequence< uno::Any > & rArgs, + const OUString & rMessage, + const uno::Reference< ucb::XCommandProcessor > & xContext ) +{ + // Fill request... + ucb::InteractiveAugmentedIOException aRequest; + aRequest.Message = rMessage; + aRequest.Context = xContext; + aRequest.Classification = task::InteractionClassification_ERROR; + aRequest.Code = eError; + aRequest.Arguments = rArgs; + + setRequest( uno::Any( aRequest ) ); + + // Fill continuations... + setContinuations({ new InteractionAbort(this) }); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simpleioerrorrequest.hxx b/ucbhelper/source/provider/simpleioerrorrequest.hxx new file mode 100644 index 000000000..134f10a9a --- /dev/null +++ b/ucbhelper/source/provider/simpleioerrorrequest.hxx @@ -0,0 +1,65 @@ +/* -*- 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 . + */ + +#ifndef UCBHELPER_SOURCE_PROVIDER_SIMPLEIOERRORREQUEST_HXX +#define UCBHELPER_SOURCE_PROVIDER_SIMPLEIOERRORREQUEST_HXX + +#include <com/sun/star/ucb/IOErrorCode.hpp> +#include <ucbhelper/interactionrequest.hxx> + +namespace com::sun::star::ucb { class XCommandProcessor; } + +namespace ucbhelper { + +/** + * This class implements a simple IO error interaction request. Instances + * can be passed directly to XInteractionHandler::handle(...). Each + * instance contains an InteractiveIOException and one interaction + * continuation: "Abort". + * + * @see css::ucb::InteractiveIOException + * @see InteractionAbort + */ +class SimpleIOErrorRequest final : public ucbhelper::InteractionRequest +{ +public: + /** + * Constructor. + * + * @param xContext contains the command processor that executes the + * command related to the request. + * + * @param eError is the error code to pass along with the request. + * + * qparam rArgs are additional parameters according to the specification + * of the error code. Refer to com/sun/star/ucb/IOErrorCode.idl + * for details. + */ + SimpleIOErrorRequest( const css::ucb::IOErrorCode eError, + const css::uno::Sequence< css::uno::Any > & rArgs, + const OUString & rMessage, + const css::uno::Reference< css::ucb::XCommandProcessor > & xContext + ); +}; + +} // namespace ucbhelper + +#endif /* ! UCBHELPER_SOURCE_PROVIDER_SIMPLEIOERRORREQUEST_HXX */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucbhelper/source/provider/simplenameclashresolverequest.cxx b/ucbhelper/source/provider/simplenameclashresolverequest.cxx new file mode 100644 index 000000000..652bdcdbb --- /dev/null +++ b/ucbhelper/source/provider/simplenameclashresolverequest.cxx @@ -0,0 +1,157 @@ +/* -*- 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 . + */ + +#include <com/sun/star/ucb/NameClashResolveRequest.hpp> +#include <com/sun/star/ucb/XInteractionSupplyName.hpp> +#include <cppuhelper/typeprovider.hxx> +#include <cppuhelper/queryinterface.hxx> +#include <ucbhelper/simplenameclashresolverequest.hxx> + +using namespace com::sun::star; + +namespace ucbhelper { + +/** + * This class implements a standard interaction continuation, namely the + * interface XInteractionSupplyName. Instances of this class can be passed + * along with an interaction request to indicate the possibility to + * supply a new name. + */ +class InteractionSupplyName : public InteractionContinuation, + public css::lang::XTypeProvider, + public css::ucb::XInteractionSupplyName +{ + OUString m_aName; + +public: + explicit InteractionSupplyName( InteractionRequest * pRequest ) + : InteractionContinuation( pRequest ) {} + + // XInterface + virtual css::uno::Any SAL_CALL + queryInterface( const css::uno::Type & rType ) override; + virtual void SAL_CALL acquire() + noexcept override; + virtual void SAL_CALL release() + noexcept override; + + // XTypeProvider + virtual css::uno::Sequence< css::uno::Type > SAL_CALL + getTypes() override; + virtual css::uno::Sequence< sal_Int8 > SAL_CALL + getImplementationId() override; + + // XInteractionContinuation + virtual void SAL_CALL select() override; + + // XInteractionSupplyName + virtual void SAL_CALL setName( const OUString& Name ) override; + + // Non-interface methods. + + /** + * This method returns the name that was supplied by the interaction + * handler. + * + * @return the name. + */ + const OUString & getName() const { return m_aName; } +}; + +void SAL_CALL InteractionSupplyName::acquire() + noexcept +{ + OWeakObject::acquire(); +} + +void SAL_CALL InteractionSupplyName::release() + noexcept +{ + OWeakObject::release(); +} + +uno::Any SAL_CALL +InteractionSupplyName::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = cppu::queryInterface( rType, + static_cast< lang::XTypeProvider * >( this ), + static_cast< task::XInteractionContinuation * >( this ), + static_cast< ucb::XInteractionSupplyName * >( this ) ); + + return aRet.hasValue() + ? aRet : InteractionContinuation::queryInterface( rType ); +} + +uno::Sequence< sal_Int8 > SAL_CALL InteractionSupplyName::getImplementationId() +{ + return css::uno::Sequence<sal_Int8>(); +} + +uno::Sequence< uno::Type > SAL_CALL InteractionSupplyName::getTypes() +{ + static cppu::OTypeCollection s_aCollection( + cppu::UnoType<lang::XTypeProvider>::get(), + cppu::UnoType<ucb::XInteractionSupplyName>::get() ); + + return s_aCollection.getTypes(); +} + +void SAL_CALL InteractionSupplyName::select() +{ + recordSelection(); +} + +void SAL_CALL +InteractionSupplyName::setName( const OUString& Name ) +{ + m_aName = Name; +} + +SimpleNameClashResolveRequest::~SimpleNameClashResolveRequest() {} + +SimpleNameClashResolveRequest::SimpleNameClashResolveRequest( + const OUString & rTargetFolderURL, + const OUString & rClashingName ) +{ + // Fill request... + ucb::NameClashResolveRequest aRequest; +// aRequest.Message = // OUString +// aRequest.Context = // XInterface + aRequest.Classification = task::InteractionClassification_QUERY; + aRequest.TargetFolderURL = rTargetFolderURL; + aRequest.ClashingName = rClashingName; + aRequest.ProposedNewName = OUString(); + + setRequest( uno::Any( aRequest ) ); + + // Fill continuations... + m_xNameSupplier = new InteractionSupplyName( this ); + + setContinuations({ new InteractionAbort(this), m_xNameSupplier, + new InteractionReplaceExistingData(this) }); +} + +OUString const & SimpleNameClashResolveRequest::getNewName() const +{ + return m_xNameSupplier->getName(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |