diff options
Diffstat (limited to 'ucb/source/ucp/file/filrset.cxx')
-rw-r--r-- | ucb/source/ucp/file/filrset.cxx | 936 |
1 files changed, 936 insertions, 0 deletions
diff --git a/ucb/source/ucp/file/filrset.cxx b/ucb/source/ucp/file/filrset.cxx new file mode 100644 index 000000000000..5dcdd8445556 --- /dev/null +++ b/ucb/source/ucp/file/filrset.cxx @@ -0,0 +1,936 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_ucb.hxx" +#include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp> +#include "filid.hxx" +#include "shell.hxx" +#include "filprp.hxx" +#include "filrset.hxx" +#include <com/sun/star/ucb/OpenMode.hpp> +#include "prov.hxx" +#include <com/sun/star/uno/Reference.h> + +#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBBUTE_HPP_ +#include <com/sun/star/beans/PropertyAttribute.hpp> +#endif +#include <com/sun/star/ucb/ListActionType.hpp> +#include <com/sun/star/ucb/XSourceInitialization.hpp> +#include <com/sun/star/ucb/XCachedDynamicResultSetStubFactory.hpp> +#include <ucbhelper/resultsetmetadata.hxx> + +using namespace fileaccess; +using namespace com::sun::star; + +XResultSet_impl::XResultSet_impl( + shell* pMyShell, + const rtl::OUString& aUnqPath, + sal_Int32 OpenMode, + const uno::Sequence< beans::Property >& seq, + const uno::Sequence< ucb::NumberedSortingInfo >& seqSort ) + : m_pMyShell( pMyShell ), + m_xProvider( pMyShell->m_pProvider ), + m_nRow( -1 ), + m_nOpenMode( OpenMode ), + m_bRowCountFinal( false ), + m_aBaseDirectory( aUnqPath ), + m_aFolder( aUnqPath ), + m_sProperty( seq ), + m_sSortingInfo( seqSort ), + m_pDisposeEventListeners( 0 ), + m_pRowCountListeners( 0 ), + m_pIsFinalListeners( 0 ), + m_bStatic( false ), + m_nErrorCode( TASKHANDLER_NO_ERROR ), + m_nMinorErrorCode( TASKHANDLER_NO_ERROR ) +{ + osl::FileBase::RC err = m_aFolder.open(); + if( err != osl::FileBase::E_None ) + { + m_nIsOpen = false; + m_aFolder.close(); + + m_nErrorCode = TASKHANDLING_OPEN_FOR_DIRECTORYLISTING; + m_nMinorErrorCode = err; + } + else + m_nIsOpen = true; + + m_pMyShell->registerNotifier( m_aBaseDirectory,this ); +} + + +XResultSet_impl::~XResultSet_impl() +{ + m_pMyShell->deregisterNotifier( m_aBaseDirectory,this ); + + if( m_nIsOpen ) + m_aFolder.close(); + + delete m_pDisposeEventListeners; + delete m_pRowCountListeners; + delete m_pIsFinalListeners; +} + + + +sal_Int32 SAL_CALL XResultSet_impl::CtorSuccess() +{ + return m_nErrorCode; +} + + + +sal_Int32 SAL_CALL XResultSet_impl::getMinorError() +{ + return m_nMinorErrorCode; +} + + +void SAL_CALL +XResultSet_impl::acquire( + void ) + throw() +{ + OWeakObject::acquire(); +} + + +void SAL_CALL +XResultSet_impl::release( + void ) + throw() +{ + OWeakObject::release(); +} + + + +uno::Any SAL_CALL +XResultSet_impl::queryInterface( + const uno::Type& rType ) + throw( uno::RuntimeException ) +{ + uno::Any aRet = cppu::queryInterface( + rType, + SAL_STATIC_CAST( lang::XComponent*, this), + SAL_STATIC_CAST( lang::XTypeProvider*, this), + SAL_STATIC_CAST( lang::XEventListener*, this), + SAL_STATIC_CAST( sdbc::XRow*, this), + SAL_STATIC_CAST( sdbc::XResultSet*, this), + SAL_STATIC_CAST( sdbc::XCloseable*, this), + SAL_STATIC_CAST( sdbc::XResultSetMetaDataSupplier*, this), + SAL_STATIC_CAST( beans::XPropertySet*, this ), + SAL_STATIC_CAST( ucb::XContentAccess*, this), + SAL_STATIC_CAST( ucb::XDynamicResultSet*,this) ); + return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType ); +} + + +void SAL_CALL +XResultSet_impl::disposing( const lang::EventObject& ) + throw( uno::RuntimeException ) +{ + // To do, but what +} + + +XTYPEPROVIDER_IMPL_10( XResultSet_impl, + lang::XTypeProvider, + lang::XTypeProvider, + lang::XEventListener, + sdbc::XRow, + sdbc::XResultSet, + XDynamicResultSet, + sdbc::XCloseable, + sdbc::XResultSetMetaDataSupplier, + beans::XPropertySet, + ucb::XContentAccess ) + + +void SAL_CALL +XResultSet_impl::addEventListener( + const uno::Reference< lang::XEventListener >& Listener ) + throw( uno::RuntimeException ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( ! m_pDisposeEventListeners ) + m_pDisposeEventListeners = + new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); + + m_pDisposeEventListeners->addInterface( Listener ); +} + + +void SAL_CALL +XResultSet_impl::removeEventListener( + const uno::Reference< lang::XEventListener >& Listener ) + throw( uno::RuntimeException ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_pDisposeEventListeners ) + m_pDisposeEventListeners->removeInterface( Listener ); +} + + + +void SAL_CALL +XResultSet_impl::dispose() + throw( uno::RuntimeException ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + lang::EventObject aEvt; + aEvt.Source = static_cast< lang::XComponent * >( this ); + + if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() ) + { + m_pDisposeEventListeners->disposeAndClear( aEvt ); + } + if( m_pRowCountListeners && m_pRowCountListeners->getLength() ) + { + m_pRowCountListeners->disposeAndClear( aEvt ); + } + if( m_pIsFinalListeners && m_pIsFinalListeners->getLength() ) + { + m_pIsFinalListeners->disposeAndClear( aEvt ); + } +} + + + +void XResultSet_impl::rowCountChanged() +{ + sal_Int32 aOldValue,aNewValue; + uno::Sequence< uno::Reference< uno::XInterface > > seq; + { + osl::MutexGuard aGuard( m_aMutex ); + if( m_pRowCountListeners ) + seq = m_pRowCountListeners->getElements(); + aNewValue = m_aItems.size(); + aOldValue = aNewValue-1; + } + beans::PropertyChangeEvent aEv; + aEv.PropertyName = rtl::OUString::createFromAscii( "RowCount" ); + aEv.Further = false; + aEv.PropertyHandle = -1; + aEv.OldValue <<= aOldValue; + aEv.NewValue <<= aNewValue; + for( sal_Int32 i = 0; i < seq.getLength(); ++i ) + { + uno::Reference< beans::XPropertyChangeListener > listener( + seq[i], uno::UNO_QUERY ); + if( listener.is() ) + listener->propertyChange( aEv ); + } +} + + +void XResultSet_impl::isFinalChanged() +{ + uno::Sequence< uno::Reference< XInterface > > seq; + { + osl::MutexGuard aGuard( m_aMutex ); + if( m_pIsFinalListeners ) + seq = m_pIsFinalListeners->getElements(); + m_bRowCountFinal = true; + } + beans::PropertyChangeEvent aEv; + aEv.PropertyName = rtl::OUString::createFromAscii( "IsRowCountFinal" ); + aEv.Further = false; + aEv.PropertyHandle = -1; + sal_Bool fval = false; + sal_Bool tval = true; + aEv.OldValue <<= fval; + aEv.NewValue <<= tval; + for( sal_Int32 i = 0; i < seq.getLength(); ++i ) + { + uno::Reference< beans::XPropertyChangeListener > listener( + seq[i], uno::UNO_QUERY ); + if( listener.is() ) + listener->propertyChange( aEv ); + } +} + + +sal_Bool SAL_CALL +XResultSet_impl::OneMore( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + if( ! m_nIsOpen ) + return false; + + osl::FileBase::RC err; + sal_Bool IsRegular; + rtl::OUString aUnqPath; + osl::DirectoryItem m_aDirIte; + uno::Reference< sdbc::XRow > aRow; + + while( true ) + { + err = m_aFolder.getNextItem( m_aDirIte ); + + if( err == osl::FileBase::E_NOENT || err == osl::FileBase::E_INVAL ) + { + m_aFolder.close(); + isFinalChanged(); + return ( m_nIsOpen = false ); + } + else if( err == osl::FileBase::E_None ) + { + aRow = m_pMyShell->getv( + this, m_sProperty, m_aDirIte, aUnqPath, IsRegular ); + + if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && IsRegular ) + { + osl::MutexGuard aGuard( m_aMutex ); + m_aItems.push_back( aRow ); + m_aIdents.push_back( + uno::Reference< ucb::XContentIdentifier >() ); + m_aUnqPath.push_back( aUnqPath ); + rowCountChanged(); + return true; + + } + else if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && ! IsRegular ) + { + continue; + } + else if( m_nOpenMode == ucb::OpenMode::FOLDERS && ! IsRegular ) + { + osl::MutexGuard aGuard( m_aMutex ); + m_aItems.push_back( aRow ); + m_aIdents.push_back( + uno::Reference< ucb::XContentIdentifier >() ); + m_aUnqPath.push_back( aUnqPath ); + rowCountChanged(); + return true; + } + else if( m_nOpenMode == ucb::OpenMode::FOLDERS && IsRegular ) + { + continue; + } + else + { + osl::MutexGuard aGuard( m_aMutex ); + m_aItems.push_back( aRow ); + m_aIdents.push_back( + uno::Reference< ucb::XContentIdentifier >() ); + m_aUnqPath.push_back( aUnqPath ); + rowCountChanged(); + return true; + } + } + else // error fetching anything + { + throw sdbc::SQLException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), ::rtl::OUString(), 0, uno::Any() ); + } + } +} + + + + + +sal_Bool SAL_CALL +XResultSet_impl::next( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + sal_Bool test; + if( ++m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) ) test = true; + else + test = OneMore(); + return test; +} + + +sal_Bool SAL_CALL +XResultSet_impl::isBeforeFirst( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return m_nRow == -1; +} + + +sal_Bool SAL_CALL +XResultSet_impl::isAfterLast( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()); // Cannot happen, if m_aFolder.isOpen() +} + + +sal_Bool SAL_CALL +XResultSet_impl::isFirst( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return m_nRow == 0; +} + + +sal_Bool SAL_CALL +XResultSet_impl::isLast( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + if( m_nRow == sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1 ) + return ! OneMore(); + else + return false; +} + + +void SAL_CALL +XResultSet_impl::beforeFirst( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + m_nRow = -1; +} + + +void SAL_CALL +XResultSet_impl::afterLast( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size()); + while( OneMore() ) + ++m_nRow; +} + + +sal_Bool SAL_CALL +XResultSet_impl::first( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + m_nRow = -1; + return next(); +} + + +sal_Bool SAL_CALL +XResultSet_impl::last( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1; + while( OneMore() ) + ++m_nRow; + return true; +} + + +sal_Int32 SAL_CALL +XResultSet_impl::getRow( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + // Test, whether behind last row + if( -1 == m_nRow || m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()) ) + return 0; + else + return m_nRow+1; +} + + + +sal_Bool SAL_CALL XResultSet_impl::absolute( sal_Int32 row ) + throw( sdbc::SQLException, uno::RuntimeException) +{ + if( row >= 0 ) + { + m_nRow = row - 1; + if( row >= sal::static_int_cast<sal_Int32>(m_aItems.size()) ) + while( row-- && OneMore() ) + ; + } + else + { + last(); + m_nRow += ( row + 1 ); + if( m_nRow < -1 ) + m_nRow = -1; + } + + return 0<= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()); +} + + + + +sal_Bool SAL_CALL +XResultSet_impl::relative( + sal_Int32 row ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + if( isAfterLast() || isBeforeFirst() ) + throw sdbc::SQLException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >(), ::rtl::OUString(), 0, uno::Any() ); + if( row > 0 ) + while( row-- ) next(); + else if( row < 0 ) + while( row++ && m_nRow > - 1 ) previous(); + + return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()); +} + + + +sal_Bool SAL_CALL +XResultSet_impl::previous( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + if( m_nRow > sal::static_int_cast<sal_Int32>(m_aItems.size()) ) + m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size()); // Correct Handling of afterLast + if( 0 <= m_nRow ) -- m_nRow; + + return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()); +} + + +void SAL_CALL +XResultSet_impl::refreshRow( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + // get the row from the filesystem + return; +} + + +sal_Bool SAL_CALL +XResultSet_impl::rowUpdated( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return false; +} + +sal_Bool SAL_CALL +XResultSet_impl::rowInserted( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return false; +} + +sal_Bool SAL_CALL +XResultSet_impl::rowDeleted( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return false; +} + + +uno::Reference< uno::XInterface > SAL_CALL +XResultSet_impl::getStatement( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + return uno::Reference< uno::XInterface >(); +} + + +// XCloseable + +void SAL_CALL +XResultSet_impl::close( + void ) + throw( sdbc::SQLException, + uno::RuntimeException) +{ + if( m_nIsOpen ) + { + m_aFolder.close(); + isFinalChanged(); + osl::MutexGuard aGuard( m_aMutex ); + m_nIsOpen = false; + } +} + + + +rtl::OUString SAL_CALL +XResultSet_impl::queryContentIdentifierString( + void ) + throw( uno::RuntimeException ) +{ + uno::Reference< ucb::XContentIdentifier > xContentId + = queryContentIdentifier(); + + if( xContentId.is() ) + return xContentId->getContentIdentifier(); + else + return rtl::OUString(); +} + + +uno::Reference< ucb::XContentIdentifier > SAL_CALL +XResultSet_impl::queryContentIdentifier( + void ) + throw( uno::RuntimeException ) +{ + if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) ) + { + if( ! m_aIdents[m_nRow].is() ) + { + FileContentIdentifier* p + = new FileContentIdentifier( m_pMyShell, + m_aUnqPath[ m_nRow ] ); + m_aIdents[m_nRow] = uno::Reference< ucb::XContentIdentifier >(p); + } + return m_aIdents[m_nRow]; + } + return uno::Reference< ucb::XContentIdentifier >(); +} + + +uno::Reference< ucb::XContent > SAL_CALL +XResultSet_impl::queryContent( + void ) + throw( uno::RuntimeException ) +{ + if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) ) + return m_pMyShell->m_pProvider->queryContent( queryContentIdentifier() ); + else + return uno::Reference< ucb::XContent >(); +} + + +// XDynamicResultSet + + +// virtual +uno::Reference< sdbc::XResultSet > SAL_CALL +XResultSet_impl::getStaticResultSet() + throw( ucb::ListenerAlreadySetException, + uno::RuntimeException ) +{ + osl::MutexGuard aGuard( m_aMutex ); + + if ( m_xListener.is() ) + throw ucb::ListenerAlreadySetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); + + return uno::Reference< sdbc::XResultSet >( this ); +} + +//========================================================================= +// virtual +void SAL_CALL +XResultSet_impl::setListener( + const uno::Reference< ucb::XDynamicResultSetListener >& Listener ) + throw( ucb::ListenerAlreadySetException, + uno::RuntimeException ) +{ + osl::ClearableMutexGuard aGuard( m_aMutex ); + + if ( m_xListener.is() ) + throw ucb::ListenerAlreadySetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); + + 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!!! + + uno::Any aInfo; + aInfo <<= ucb::WelcomeDynamicResultSetStruct( this, /* "old" */ + this /* "new" */ ); + + uno::Sequence< ucb::ListAction > aActions( 1 ); + aActions.getArray()[ 0 ] = ucb::ListAction( 0, // Position; not used + 0, // Count; not used + ucb::ListActionType::WELCOME, + aInfo ); + aGuard.clear(); + + Listener->notify( + ucb::ListEvent( + static_cast< cppu::OWeakObject * >( this ), aActions ) ); +} + +//========================================================================= +// virtual +void SAL_CALL +XResultSet_impl::connectToCache( + const uno::Reference< ucb::XDynamicResultSet > & xCache ) + throw( ucb::ListenerAlreadySetException, + ucb::AlreadyInitializedException, + ucb::ServiceNotFoundException, + uno::RuntimeException ) +{ + uno::Reference< lang::XMultiServiceFactory > mxSMgr + = m_pMyShell->m_xMultiServiceFactory; + + if( m_xListener.is() ) + throw ucb::ListenerAlreadySetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); + if( m_bStatic ) + throw ucb::ListenerAlreadySetException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); + + uno::Reference< ucb::XSourceInitialization > xTarget( + xCache, uno::UNO_QUERY ); + if( xTarget.is() && mxSMgr.is() ) + { + uno::Reference< ucb::XCachedDynamicResultSetStubFactory > xStubFactory; + try + { + xStubFactory + = uno::Reference< ucb::XCachedDynamicResultSetStubFactory >( + mxSMgr->createInstance( + rtl::OUString::createFromAscii( + "com.sun.star.ucb.CachedDynamicResultSetStubFactory" ) ), + uno::UNO_QUERY ); + } + catch ( uno::Exception const & ) + { + } + + if( xStubFactory.is() ) + { + xStubFactory->connectToCache( + this, xCache,m_sSortingInfo, NULL ); + return; + } + } + throw ucb::ServiceNotFoundException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); +} + +//========================================================================= +// virtual +sal_Int16 SAL_CALL +XResultSet_impl::getCapabilities() + throw( uno::RuntimeException ) +{ + // Never set ucb::ContentResultSetCapability::SORTED + // - Underlying content cannot provide sorted data... + return 0; +} + +// XResultSetMetaDataSupplier +uno::Reference< sdbc::XResultSetMetaData > SAL_CALL +XResultSet_impl::getMetaData( + void ) + throw( sdbc::SQLException, + uno::RuntimeException ) +{ + for ( sal_Int32 n = 0; n < m_sProperty.getLength(); ++n ) + { + if ( m_sProperty.getConstArray()[ n ].Name.compareToAscii( "Title" ) + == 0 ) + { + // @@@ #82177# - Determine correct value! + sal_Bool bCaseSensitiveChildren = sal_False; + + std::vector< ::ucbhelper::ResultSetColumnData > + aColumnData( m_sProperty.getLength() ); + aColumnData[ n ].isCaseSensitive = bCaseSensitiveChildren; + + ::ucbhelper::ResultSetMetaData* p = + new ::ucbhelper::ResultSetMetaData( + m_pMyShell->m_xMultiServiceFactory, + m_sProperty, + aColumnData ); + return uno::Reference< sdbc::XResultSetMetaData >( p ); + } + } + + ::ucbhelper::ResultSetMetaData* p = + new ::ucbhelper::ResultSetMetaData( + m_pMyShell->m_xMultiServiceFactory, m_sProperty ); + return uno::Reference< sdbc::XResultSetMetaData >( p ); +} + + + +// XPropertySet +uno::Reference< beans::XPropertySetInfo > SAL_CALL +XResultSet_impl::getPropertySetInfo() + throw( uno::RuntimeException) +{ + + uno::Sequence< beans::Property > seq(2); + seq[0].Name = rtl::OUString::createFromAscii( "RowCount" ); + seq[0].Handle = -1; + seq[0].Type = getCppuType( static_cast< sal_Int32* >(0) ); + seq[0].Attributes = beans::PropertyAttribute::READONLY; + + seq[0].Name = rtl::OUString::createFromAscii( "IsRowCountFinal" ); + seq[0].Handle = -1; + seq[0].Type = getCppuType( static_cast< sal_Bool* >(0) ); + seq[0].Attributes = beans::PropertyAttribute::READONLY; + + XPropertySetInfo_impl* p = new XPropertySetInfo_impl( m_pMyShell, + seq ); + return uno::Reference< beans::XPropertySetInfo > ( p ); +} + + + +void SAL_CALL XResultSet_impl::setPropertyValue( + const rtl::OUString& aPropertyName, const uno::Any& ) + throw( beans::UnknownPropertyException, + beans::PropertyVetoException, + lang::IllegalArgumentException, + lang::WrappedTargetException, + uno::RuntimeException) +{ + if( aPropertyName == rtl::OUString::createFromAscii( "IsRowCountFinal" ) || + aPropertyName == rtl::OUString::createFromAscii( "RowCount" ) ) + return; + throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); +} + + +uno::Any SAL_CALL XResultSet_impl::getPropertyValue( + const rtl::OUString& PropertyName ) + throw( beans::UnknownPropertyException, + lang::WrappedTargetException, + uno::RuntimeException) +{ + if( PropertyName == rtl::OUString::createFromAscii( "IsRowCountFinal" ) ) + { + uno::Any aAny; + aAny <<= m_bRowCountFinal; + return aAny; + } + else if ( PropertyName == rtl::OUString::createFromAscii( "RowCount" ) ) + { + uno::Any aAny; + sal_Int32 count = sal::static_int_cast<sal_Int32>(m_aItems.size()); + aAny <<= count; + return aAny; + } + else + throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); +} + + +void SAL_CALL XResultSet_impl::addPropertyChangeListener( + const rtl::OUString& aPropertyName, + const uno::Reference< beans::XPropertyChangeListener >& xListener ) + throw( beans::UnknownPropertyException, + lang::WrappedTargetException, + uno::RuntimeException) +{ + if( aPropertyName == rtl::OUString::createFromAscii( "IsRowCountFinal" ) ) + { + osl::MutexGuard aGuard( m_aMutex ); + if ( ! m_pIsFinalListeners ) + m_pIsFinalListeners = + new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); + + m_pIsFinalListeners->addInterface( xListener ); + } + else if ( aPropertyName == rtl::OUString::createFromAscii( "RowCount" ) ) + { + osl::MutexGuard aGuard( m_aMutex ); + if ( ! m_pRowCountListeners ) + m_pRowCountListeners = + new cppu::OInterfaceContainerHelper( m_aEventListenerMutex ); + m_pRowCountListeners->addInterface( xListener ); + } + else + throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); +} + + +void SAL_CALL XResultSet_impl::removePropertyChangeListener( + const rtl::OUString& aPropertyName, + const uno::Reference< beans::XPropertyChangeListener >& aListener ) + throw( beans::UnknownPropertyException, + lang::WrappedTargetException, + uno::RuntimeException) +{ + if( aPropertyName == rtl::OUString::createFromAscii( "IsRowCountFinal" ) && + m_pIsFinalListeners ) + { + osl::MutexGuard aGuard( m_aMutex ); + m_pIsFinalListeners->removeInterface( aListener ); + } + else if ( aPropertyName == rtl::OUString::createFromAscii( "RowCount" ) && + m_pRowCountListeners ) + { + osl::MutexGuard aGuard( m_aMutex ); + + m_pRowCountListeners->removeInterface( aListener ); + } + else + throw beans::UnknownPropertyException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ), uno::Reference< uno::XInterface >() ); +} + +void SAL_CALL XResultSet_impl::addVetoableChangeListener( + const rtl::OUString&, + const uno::Reference< beans::XVetoableChangeListener >& ) + throw( beans::UnknownPropertyException, + lang::WrappedTargetException, + uno::RuntimeException) +{ +} + + +void SAL_CALL XResultSet_impl::removeVetoableChangeListener( + const rtl::OUString&, + const uno::Reference< beans::XVetoableChangeListener >& ) + throw( beans::UnknownPropertyException, + lang::WrappedTargetException, + uno::RuntimeException) +{ +} |