From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- ucb/source/sorter/sortdynres.cxx | 516 +++++++++++ ucb/source/sorter/sortdynres.hxx | 164 ++++ ucb/source/sorter/sortresult.cxx | 1778 ++++++++++++++++++++++++++++++++++++ ucb/source/sorter/sortresult.hxx | 329 +++++++ ucb/source/sorter/srtrs1.component | 26 + 5 files changed, 2813 insertions(+) create mode 100644 ucb/source/sorter/sortdynres.cxx create mode 100644 ucb/source/sorter/sortdynres.hxx create mode 100644 ucb/source/sorter/sortresult.cxx create mode 100644 ucb/source/sorter/sortresult.hxx create mode 100644 ucb/source/sorter/srtrs1.component (limited to 'ucb/source/sorter') diff --git a/ucb/source/sorter/sortdynres.cxx b/ucb/source/sorter/sortdynres.cxx new file mode 100644 index 000000000..2f7039b55 --- /dev/null +++ b/ucb/source/sorter/sortdynres.cxx @@ -0,0 +1,516 @@ +/* -*- 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 "sortdynres.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace com::sun::star::beans; +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 comphelper; + + +// The mutex to synchronize access to containers. +static osl::Mutex& getContainerMutex() +{ + static osl::Mutex ourMutex; + + return ourMutex; +} + + +// SortedDynamicResultSet + +SortedDynamicResultSet::SortedDynamicResultSet( + const Reference < XDynamicResultSet > &xOriginal, + const Sequence < NumberedSortingInfo > &aOptions, + const Reference < XAnyCompareFactory > &xCompFac, + const Reference < XComponentContext > &rxContext ) +{ + mpDisposeEventListeners = nullptr; + mxOwnListener = new SortedDynamicResultSetListener( this ); + + mxOriginal = xOriginal; + maOptions = aOptions; + mxCompFac = xCompFac; + m_xContext = rxContext; + + mbGotWelcome = false; + mbUseOne = true; + mbStatic = false; +} + + +SortedDynamicResultSet::~SortedDynamicResultSet() +{ + mxOwnListener->impl_OwnerDies(); + mxOwnListener.clear(); + + mpDisposeEventListeners.reset(); + + mxOne.clear(); + mxTwo.clear(); + mxOriginal.clear(); +} + +// XServiceInfo methods. + +OUString SAL_CALL SortedDynamicResultSet::getImplementationName() +{ + return "com.sun.star.comp.ucb.SortedDynamicResultSet"; +} + +sal_Bool SAL_CALL SortedDynamicResultSet::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL SortedDynamicResultSet::getSupportedServiceNames() +{ + return { "com.sun.star.ucb.SortedDynamicResultSet" }; +} + +// XComponent methods. + +void SAL_CALL SortedDynamicResultSet::dispose() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpDisposeEventListeners && mpDisposeEventListeners->getLength() ) + { + EventObject aEvt; + aEvt.Source = static_cast< XComponent * >( this ); + mpDisposeEventListeners->disposeAndClear( aEvt ); + } + + mxOne.clear(); + mxTwo.clear(); + mxOriginal.clear(); + + mbUseOne = true; +} + +void SAL_CALL SortedDynamicResultSet::addEventListener( + const Reference< XEventListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpDisposeEventListeners ) + mpDisposeEventListeners.reset( + new OInterfaceContainerHelper3( getContainerMutex() ) ); + + mpDisposeEventListeners->addInterface( Listener ); +} + +void SAL_CALL SortedDynamicResultSet::removeEventListener( + const Reference< XEventListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpDisposeEventListeners ) + mpDisposeEventListeners->removeInterface( Listener ); +} + + +// XDynamicResultSet methods. + +Reference< XResultSet > SAL_CALL +SortedDynamicResultSet::getStaticResultSet() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mxListener.is() ) + throw ListenerAlreadySetException(); + + mbStatic = true; + + if ( mxOriginal.is() ) + { + mxOne = new SortedResultSet( mxOriginal->getStaticResultSet() ); + mxOne->Initialize( maOptions, mxCompFac ); + } + + return mxOne; +} + + +void SAL_CALL +SortedDynamicResultSet::setListener( const Reference< XDynamicResultSetListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mxListener.is() ) + throw ListenerAlreadySetException(); + + addEventListener( Listener ); + + mxListener = Listener; + + if ( mxOriginal.is() ) + mxOriginal->setListener( mxOwnListener ); +} + + +void SAL_CALL +SortedDynamicResultSet::connectToCache( const Reference< XDynamicResultSet > & xCache ) +{ + if( mxListener.is() ) + throw ListenerAlreadySetException(); + + if( mbStatic ) + throw ListenerAlreadySetException(); + + Reference< XSourceInitialization > xTarget( xCache, UNO_QUERY ); + if( xTarget.is() && m_xContext.is() ) + { + Reference< XCachedDynamicResultSetStubFactory > xStubFactory; + try + { + xStubFactory = CachedDynamicResultSetStubFactory::create( m_xContext ); + } + catch ( Exception const & ) + { + } + + if( xStubFactory.is() ) + { + xStubFactory->connectToCache( + this, xCache, Sequence< NumberedSortingInfo > (), nullptr ); + return; + } + } + throw ServiceNotFoundException(); +} + + +sal_Int16 SAL_CALL SortedDynamicResultSet::getCapabilities() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + sal_Int16 nCaps = 0; + + if ( mxOriginal.is() ) + nCaps = mxOriginal->getCapabilities(); + + nCaps |= ContentResultSetCapability::SORTED; + + return nCaps; +} + + +// XDynamicResultSetListener methods. + + +/** In the first notify-call the listener gets the two + XResultSets and has to hold them. The XResultSets + are implementations of the service ContentResultSet. + +

The notified new XResultSet will stay valid after returning + notification. The old one will become invalid after returning notification. + +

While in notify-call the listener is allowed to read old and new version, + except in the first call, where only the new Resultset is valid. + +

The Listener is allowed to blockade this call, until he really want to go + to the new version. The only situation, where the listener has to return the + update call at once is, while he disposes his broadcaster or while he is + removing himself as listener (otherwise you deadlock)!!! +*/ +void SortedDynamicResultSet::impl_notify( const ListEvent& Changes ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + bool bHasNew = false; + bool bHasModified = false; + + SortedResultSet *pCurSet = nullptr; + + // exchange mxNew and mxOld and immediately afterwards copy the tables + // from Old to New + if ( mbGotWelcome ) + { + if ( mbUseOne ) + { + mbUseOne = false; + mxTwo->CopyData( mxOne.get() ); + pCurSet = mxTwo.get(); + } + else + { + mbUseOne = true; + mxOne->CopyData( mxTwo.get() ); + pCurSet = mxOne.get(); + } + } + + if (!pCurSet) + return; + + Any aRet; + + try { + aRet = pCurSet->getPropertyValue("IsRowCountFinal"); + } + catch (const UnknownPropertyException&) {} + catch (const WrappedTargetException&) {} + + sal_Int32 nOldCount = pCurSet->GetCount(); + bool bWasFinal = false; + + aRet >>= bWasFinal; + + // handle the actions in the list + for ( const ListAction& aAction : Changes.Changes ) + { + switch ( aAction.ListActionType ) + { + case ListActionType::WELCOME: + { + WelcomeDynamicResultSetStruct aWelcome; + if ( aAction.ActionInfo >>= aWelcome ) + { + mxTwo = new SortedResultSet( aWelcome.Old ); + mxOne = new SortedResultSet( aWelcome.New ); + mxOne->Initialize( maOptions, mxCompFac ); + mbGotWelcome = true; + mbUseOne = true; + pCurSet = mxOne.get(); + + aWelcome.Old = mxTwo.get(); + aWelcome.New = mxOne.get(); + + ListAction aWelcomeAction; + aWelcomeAction.ActionInfo <<= aWelcome; + aWelcomeAction.Position = 0; + aWelcomeAction.Count = 0; + aWelcomeAction.ListActionType = ListActionType::WELCOME; + + maActions.Insert( aWelcomeAction ); + } + else + { + // throw RuntimeException(); + } + break; + } + case ListActionType::INSERTED: + { + pCurSet->InsertNew( aAction.Position, aAction.Count ); + bHasNew = true; + break; + } + case ListActionType::REMOVED: + { + pCurSet->Remove( aAction.Position, + aAction.Count, + &maActions ); + break; + } + case ListActionType::MOVED: + { + sal_Int32 nOffset = 0; + if ( aAction.ActionInfo >>= nOffset ) + { + pCurSet->Move( aAction.Position, + aAction.Count, + nOffset ); + } + break; + } + case ListActionType::PROPERTIES_CHANGED: + { + pCurSet->SetChanged( aAction.Position, aAction.Count ); + bHasModified = true; + break; + } + default: break; + } + } + + if ( bHasModified ) + pCurSet->ResortModified( &maActions ); + + if ( bHasNew ) + pCurSet->ResortNew( &maActions ); + + // send the new actions with a notify to the listeners + SendNotify(); + + // check for propertyChangeEvents + pCurSet->CheckProperties( nOldCount, bWasFinal ); +} + +// XEventListener + +void SortedDynamicResultSet::impl_disposing() +{ + mxListener.clear(); + mxOriginal.clear(); +} + +// private methods + +void SortedDynamicResultSet::SendNotify() +{ + sal_Int32 nCount = maActions.Count(); + + if ( nCount && mxListener.is() ) + { + Sequence< ListAction > aActionList( maActions.Count() ); + ListAction *pActionList = aActionList.getArray(); + + for ( sal_Int32 i=0; inotify( aNewEvent ); + } + + // clean up + maActions.Clear(); +} + +// SortedDynamicResultSetFactory + +SortedDynamicResultSetFactory::SortedDynamicResultSetFactory( + const Reference< XComponentContext > & rxContext ) +{ + m_xContext = rxContext; +} + + +SortedDynamicResultSetFactory::~SortedDynamicResultSetFactory() +{ +} + + +// XServiceInfo methods. + +OUString SAL_CALL SortedDynamicResultSetFactory::getImplementationName() +{ + return "com.sun.star.comp.ucb.SortedDynamicResultSetFactory"; +} + +sal_Bool SAL_CALL SortedDynamicResultSetFactory::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL SortedDynamicResultSetFactory::getSupportedServiceNames() +{ + return { "com.sun.star.ucb.SortedDynamicResultSetFactory" }; +} + + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface* +ucb_SortedDynamicResultSetFactory_get_implementation( + css::uno::XComponentContext* context, css::uno::Sequence const&) +{ + return cppu::acquire(new SortedDynamicResultSetFactory(context)); +} + +// SortedDynamicResultSetFactory methods. + +Reference< XDynamicResultSet > SAL_CALL +SortedDynamicResultSetFactory::createSortedDynamicResultSet( + const Reference< XDynamicResultSet > & Source, + const Sequence< NumberedSortingInfo > & Info, + const Reference< XAnyCompareFactory > & CompareFactory ) +{ + Reference< XDynamicResultSet > xRet = new SortedDynamicResultSet( Source, Info, CompareFactory, m_xContext ); + return xRet; +} + +// EventList + +void EventList::Clear() +{ + maData.clear(); +} + +void EventList::AddEvent( sal_IntPtr nType, sal_Int32 nPos ) +{ + ListAction aAction; + aAction.Position = nPos; + aAction.Count = 1; + aAction.ListActionType = nType; + + Insert( aAction ); +} + +// SortedDynamicResultSetListener + +SortedDynamicResultSetListener::SortedDynamicResultSetListener( + SortedDynamicResultSet *mOwner ) +{ + mpOwner = mOwner; +} + + +SortedDynamicResultSetListener::~SortedDynamicResultSetListener() +{ +} + +// XEventListener ( base of XDynamicResultSetListener ) + +void SAL_CALL +SortedDynamicResultSetListener::disposing( const EventObject& /*Source*/ ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpOwner ) + mpOwner->impl_disposing(); +} + + +// XDynamicResultSetListener + +void SAL_CALL +SortedDynamicResultSetListener::notify( const ListEvent& Changes ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpOwner ) + mpOwner->impl_notify( Changes ); +} + +// own methods: + +void +SortedDynamicResultSetListener::impl_OwnerDies() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + mpOwner = nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucb/source/sorter/sortdynres.hxx b/ucb/source/sorter/sortdynres.hxx new file mode 100644 index 000000000..1098f223a --- /dev/null +++ b/ucb/source/sorter/sortdynres.hxx @@ -0,0 +1,164 @@ +/* -*- 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 . + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "sortresult.hxx" + + + +class SortedDynamicResultSetListener; + +class SortedDynamicResultSet: public cppu::WeakImplHelper < + css::lang::XServiceInfo, + css::ucb::XDynamicResultSet > +{ + std::unique_ptr> mpDisposeEventListeners; + + css::uno::Reference < css::ucb::XDynamicResultSetListener > mxListener; + + css::uno::Reference < css::ucb::XDynamicResultSet > mxOriginal; + css::uno::Sequence < css::ucb::NumberedSortingInfo > maOptions; + css::uno::Reference < css::ucb::XAnyCompareFactory > mxCompFac; + css::uno::Reference < css::uno::XComponentContext > m_xContext; + + rtl::Reference mxOne; + rtl::Reference mxTwo; + rtl::Reference mxOwnListener; + + EventList maActions; + osl::Mutex maMutex; + bool mbGotWelcome:1; + bool mbUseOne:1; + bool mbStatic:1; + +private: + void SendNotify(); + +public: + SortedDynamicResultSet( const css::uno::Reference < css::ucb::XDynamicResultSet > &xOriginal, + const css::uno::Sequence < css::ucb::NumberedSortingInfo > &aOptions, + const css::uno::Reference < css::ucb::XAnyCompareFactory > &xCompFac, + const css::uno::Reference < css::uno::XComponentContext > &rxContext ); + + virtual ~SortedDynamicResultSet() override; + + + // XServiceInfo + + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // XComponent + + virtual void SAL_CALL dispose() override; + + virtual void SAL_CALL + addEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener ) override; + + virtual void SAL_CALL + removeEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener ) override; + + + // XDynamicResultSet + + virtual css::uno::Reference< css::sdbc::XResultSet > SAL_CALL getStaticResultSet() override; + + virtual void SAL_CALL + setListener( const css::uno::Reference< css::ucb::XDynamicResultSetListener >& Listener ) override; + + virtual void SAL_CALL + connectToCache( const css::uno::Reference< css::ucb::XDynamicResultSet > & xCache ) override; + + virtual sal_Int16 SAL_CALL + getCapabilities() override; + + + // own methods: + + /// @throws css::uno::RuntimeException + void impl_disposing(); + + /// @throws css::uno::RuntimeException + void impl_notify( const css::ucb::ListEvent& Changes ); +}; + +class SortedDynamicResultSetListener: public cppu::WeakImplHelper < + css::ucb::XDynamicResultSetListener > +{ + SortedDynamicResultSet *mpOwner; + osl::Mutex maMutex; + +public: + SortedDynamicResultSetListener( SortedDynamicResultSet *mOwner ); + virtual ~SortedDynamicResultSetListener() override; + + // XEventListener ( base of XDynamicResultSetListener ) + + virtual void SAL_CALL + disposing( const css::lang::EventObject& Source ) override; + + // XDynamicResultSetListener + + virtual void SAL_CALL notify( const css::ucb::ListEvent& Changes ) override; + + // own methods: + + void impl_OwnerDies(); +}; + + +class SortedDynamicResultSetFactory: public cppu::WeakImplHelper < + css::lang::XServiceInfo, + css::ucb::XSortedDynamicResultSetFactory > +{ + + css::uno::Reference< css::uno::XComponentContext > m_xContext; + +public: + SortedDynamicResultSetFactory( + const css::uno::Reference< css::uno::XComponentContext > & rxContext); + + virtual ~SortedDynamicResultSetFactory() override; + + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // XSortedDynamicResultSetFactory + virtual css::uno::Reference< css::ucb::XDynamicResultSet > SAL_CALL + createSortedDynamicResultSet( + const css::uno::Reference< css::ucb::XDynamicResultSet > & Source, + const css::uno::Sequence< css::ucb::NumberedSortingInfo > & Info, + const css::uno::Reference< css::ucb::XAnyCompareFactory > & CompareFactory ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucb/source/sorter/sortresult.cxx b/ucb/source/sorter/sortresult.cxx new file mode 100644 index 000000000..e5b7ce746 --- /dev/null +++ b/ucb/source/sorter/sortresult.cxx @@ -0,0 +1,1778 @@ +/* -*- 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 "sortresult.hxx" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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::sdbc; +using namespace com::sun::star::ucb; +using namespace com::sun::star::uno; +using namespace com::sun::star::util; +using namespace comphelper; +using namespace cppu; + + +// The mutex to synchronize access to containers. +static osl::Mutex& getContainerMutex() +{ + static osl::Mutex ourMutex; + + return ourMutex; +} + + +struct SortInfo +{ + bool mbUseOwnCompare; + bool mbAscending; + bool mbCaseSensitive; + sal_Int32 mnColumn; + sal_Int32 mnType; + SortInfo* mpNext; + Reference < XAnyCompare > mxCompareFunction; +}; + + +struct SortListData +{ + bool mbModified; + sal_IntPtr mnCurPos; + sal_IntPtr mnOldPos; + + explicit SortListData( sal_IntPtr nPos ); +}; + + + + +class SRSPropertySetInfo : public cppu::WeakImplHelper < + XPropertySetInfo > +{ + Property maProps[2]; + +private: + +public: + SRSPropertySetInfo(); + + // XPropertySetInfo + virtual Sequence< Property > SAL_CALL getProperties() override; + virtual Property SAL_CALL getPropertyByName( const OUString& aName ) override; + virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override; +}; + + +SortedResultSet::SortedResultSet( Reference< XResultSet > const & aResult ) +{ + mpDisposeEventListeners = nullptr; + mpPropChangeListeners = nullptr; + mpVetoChangeListeners = nullptr; + + mxOriginal = aResult; + mpSortInfo = nullptr; + mnLastSort = 0; + mnCurEntry = 0; + mnCount = 0; + mbIsCopy = false; +} + + +SortedResultSet::~SortedResultSet() +{ + mxOriginal.clear(); + mxOther.clear(); + + if ( !mbIsCopy ) + { + SortInfo *pInfo = mpSortInfo; + while ( pInfo ) + { + mpSortInfo = pInfo->mpNext; + delete pInfo; + pInfo = mpSortInfo; + } + } + + mpSortInfo = nullptr; + + mpPropSetInfo.clear(); +} + + +// XServiceInfo methods. + +OUString SAL_CALL SortedResultSet::getImplementationName() +{ + return "com.sun.star.comp.ucb.SortedResultSet"; +} + +sal_Bool SAL_CALL SortedResultSet::supportsService( const OUString& ServiceName ) +{ + return cppu::supportsService( this, ServiceName ); +} + +css::uno::Sequence< OUString > SAL_CALL SortedResultSet::getSupportedServiceNames() +{ + return { RESULTSET_SERVICE_NAME }; +} + + +// XComponent methods. + +void SAL_CALL SortedResultSet::dispose() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpDisposeEventListeners && mpDisposeEventListeners->getLength() ) + { + EventObject aEvt; + aEvt.Source = static_cast< XComponent * >( this ); + mpDisposeEventListeners->disposeAndClear( aEvt ); + } + + if ( mpPropChangeListeners ) + { + EventObject aEvt; + aEvt.Source = static_cast< XPropertySet * >( this ); + mpPropChangeListeners->disposeAndClear( aEvt ); + } + + if ( mpVetoChangeListeners ) + { + EventObject aEvt; + aEvt.Source = static_cast< XPropertySet * >( this ); + mpVetoChangeListeners->disposeAndClear( aEvt ); + } + + mxOriginal.clear(); + mxOther.clear(); +} + + +void SAL_CALL SortedResultSet::addEventListener( + const Reference< XEventListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpDisposeEventListeners ) + mpDisposeEventListeners = + new OInterfaceContainerHelper3( getContainerMutex() ); + + mpDisposeEventListeners->addInterface( Listener ); +} + + +void SAL_CALL SortedResultSet::removeEventListener( + const Reference< XEventListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpDisposeEventListeners ) + mpDisposeEventListeners->removeInterface( Listener ); +} + + +// XContentAccess methods. + + +OUString SAL_CALL +SortedResultSet::queryContentIdentifierString() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XContentAccess >::query(mxOriginal)->queryContentIdentifierString(); +} + + +Reference< XContentIdentifier > SAL_CALL +SortedResultSet::queryContentIdentifier() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XContentAccess >::query(mxOriginal)->queryContentIdentifier(); +} + + +Reference< XContent > SAL_CALL +SortedResultSet::queryContent() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XContentAccess >::query(mxOriginal)->queryContent(); +} + + +// XResultSet methods. + +sal_Bool SAL_CALL SortedResultSet::next() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + mnCurEntry++; + + if ( mnCurEntry > 0 ) + { + if ( mnCurEntry <= mnCount ) + { + sal_Int32 nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + else + { + mnCurEntry = mnCount + 1; + } + } + return false; +} + + +sal_Bool SAL_CALL SortedResultSet::isBeforeFirst() +{ + if ( mnCurEntry ) + return false; + else + return true; +} + + +sal_Bool SAL_CALL SortedResultSet::isAfterLast() +{ + if ( mnCurEntry > mnCount ) + return true; + else + return false; +} + + +sal_Bool SAL_CALL SortedResultSet::isFirst() +{ + if ( mnCurEntry == 1 ) + return true; + else + return false; +} + + +sal_Bool SAL_CALL SortedResultSet::isLast() +{ + if ( mnCurEntry == mnCount ) + return true; + else + return false; +} + + +void SAL_CALL SortedResultSet::beforeFirst() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + mnCurEntry = 0; + mxOriginal->beforeFirst(); +} + + +void SAL_CALL SortedResultSet::afterLast() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + mnCurEntry = mnCount+1; + mxOriginal->afterLast(); +} + + +sal_Bool SAL_CALL SortedResultSet::first() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mnCount ) + { + mnCurEntry = 1; + sal_Int32 nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + else + { + mnCurEntry = 0; + return false; + } +} + + +sal_Bool SAL_CALL SortedResultSet::last() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mnCount ) + { + mnCurEntry = mnCount; + sal_Int32 nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + else + { + mnCurEntry = 0; + return false; + } +} + + +sal_Int32 SAL_CALL SortedResultSet::getRow() +{ + return mnCurEntry; +} + + +/** + moves the cursor to the given row number in the result set. +

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 moveToPosition(-1) positions the + cursor on the last row, moveToPosition(-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. +

Note: Calling moveToPosition(1) is the same + as calling moveToFirst(). Calling + moveToPosition(-1) is the same as calling + moveToLast(). + @param row + is the number of rows to move. Could be negative. + @returns + if the cursor is on a row; otherwise + @throws SQLException + if a database access error occurs or if row is 0, or the result set + type is FORWARD_ONLY. + */ +sal_Bool SAL_CALL SortedResultSet::absolute( sal_Int32 row ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + sal_Int32 nIndex; + + if ( row > 0 ) + { + if ( row <= mnCount ) + { + mnCurEntry = row; + nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + else + { + mnCurEntry = mnCount + 1; + return false; + } + } + else if ( row == 0 ) + { + throw SQLException(); + } + else + { + if ( mnCount + row + 1 > 0 ) + { + mnCurEntry = mnCount + row + 1; + nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + else + { + mnCurEntry = 0; + return false; + } + } +} + + +/** + moves the cursor a relative number of rows, either positive or negative. +

+ Attempting to move beyond the first/last row in the result set positions + the cursor before/after the first/last row. Calling + moveRelative(0) is valid, but does not change the cursor + position. +

Note: Calling moveRelative(1) is different from calling + moveNext() because is makes sense to call + moveNext() 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. + @param rows + is the number of rows to move. Could be negative. + @returns + if the cursor is on a valid row; if it is off + the result set. + @throws SQLException + if a database access error occurs or if there is no + current row, or the result set type is FORWARD_ONLY. + */ +sal_Bool SAL_CALL SortedResultSet::relative( sal_Int32 rows ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + if ( rows == 0 ) + return true; + + sal_Int32 nTmp = mnCurEntry + rows; + + if ( nTmp <= 0 ) + { + mnCurEntry = 0; + return false; + } + else if ( nTmp > mnCount ) + { + mnCurEntry = mnCount + 1; + return false; + } + else + { + mnCurEntry = nTmp; + nTmp = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nTmp ); + } +} + + +/** + moves the cursor to the previous row in the result set. +

Note: previous() is not the same as + relative(-1) because it makes sense to call + previous() when there is no current row. + @returns if the cursor is on a valid row; if it is off + the result set. + @throws SQLException + if a database access error occurs or the result set type + is FORWARD_ONLY. + */ +sal_Bool SAL_CALL SortedResultSet::previous() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + mnCurEntry -= 1; + + if ( mnCurEntry > 0 ) + { + if ( mnCurEntry <= mnCount ) + { + sal_Int32 nIndex = maS2O[ mnCurEntry ]; + return mxOriginal->absolute( nIndex ); + } + } + else + mnCurEntry = 0; + + return false; +} + + +void SAL_CALL SortedResultSet::refreshRow() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + mxOriginal->refreshRow(); +} + + +sal_Bool SAL_CALL SortedResultSet::rowUpdated() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + return mxOriginal->rowUpdated(); +} + + +sal_Bool SAL_CALL SortedResultSet::rowInserted() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + return mxOriginal->rowInserted(); +} + + +sal_Bool SAL_CALL SortedResultSet::rowDeleted() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + return mxOriginal->rowDeleted(); +} + + +Reference< XInterface > SAL_CALL SortedResultSet::getStatement() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) ) + { + throw SQLException(); + } + + return mxOriginal->getStatement(); +} + + +// XRow methods. + + +sal_Bool SAL_CALL SortedResultSet::wasNull() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->wasNull(); +} + + +OUString SAL_CALL SortedResultSet::getString( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getString( columnIndex ); +} + + +sal_Bool SAL_CALL SortedResultSet::getBoolean( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getBoolean( columnIndex ); +} + + +sal_Int8 SAL_CALL SortedResultSet::getByte( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getByte( columnIndex ); +} + + +sal_Int16 SAL_CALL SortedResultSet::getShort( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getShort( columnIndex ); +} + + +sal_Int32 SAL_CALL SortedResultSet::getInt( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getInt( columnIndex ); +} + +sal_Int64 SAL_CALL SortedResultSet::getLong( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getLong( columnIndex ); +} + + +float SAL_CALL SortedResultSet::getFloat( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getFloat( columnIndex ); +} + + +double SAL_CALL SortedResultSet::getDouble( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getDouble( columnIndex ); +} + + +Sequence< sal_Int8 > SAL_CALL SortedResultSet::getBytes( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getBytes( columnIndex ); +} + + +Date SAL_CALL SortedResultSet::getDate( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getDate( columnIndex ); +} + + +Time SAL_CALL SortedResultSet::getTime( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getTime( columnIndex ); +} + + +DateTime SAL_CALL SortedResultSet::getTimestamp( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getTimestamp( columnIndex ); +} + + +Reference< XInputStream > SAL_CALL +SortedResultSet::getBinaryStream( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getBinaryStream( columnIndex ); +} + + +Reference< XInputStream > SAL_CALL +SortedResultSet::getCharacterStream( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getCharacterStream( columnIndex ); +} + + +Any SAL_CALL SortedResultSet::getObject( sal_Int32 columnIndex, + const Reference< XNameAccess >& typeMap ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getObject( columnIndex, + typeMap); +} + + +Reference< XRef > SAL_CALL SortedResultSet::getRef( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getRef( columnIndex ); +} + + +Reference< XBlob > SAL_CALL SortedResultSet::getBlob( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getBlob( columnIndex ); +} + + +Reference< XClob > SAL_CALL SortedResultSet::getClob( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getClob( columnIndex ); +} + + +Reference< XArray > SAL_CALL SortedResultSet::getArray( sal_Int32 columnIndex ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XRow >::query(mxOriginal)->getArray( columnIndex ); +} + + +// XCloseable methods. + + +void SAL_CALL SortedResultSet::close() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + Reference< XCloseable >::query(mxOriginal)->close(); +} + + +// XResultSetMetaDataSupplier methods. + + +Reference< XResultSetMetaData > SAL_CALL SortedResultSet::getMetaData() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + return Reference< XResultSetMetaDataSupplier >::query(mxOriginal)->getMetaData(); +} + + +// XPropertySet methods. + + +Reference< XPropertySetInfo > SAL_CALL +SortedResultSet::getPropertySetInfo() +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpPropSetInfo.is() ) + { + mpPropSetInfo = new SRSPropertySetInfo(); + } + + return mpPropSetInfo; +} + + +void SAL_CALL SortedResultSet::setPropertyValue( + const OUString& PropertyName, + const Any& ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( PropertyName == "RowCount" || PropertyName == "IsRowCountFinal" ) + throw IllegalArgumentException(); + else + throw UnknownPropertyException(PropertyName); +} + + +Any SAL_CALL SortedResultSet::getPropertyValue( const OUString& PropertyName ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + Any aRet; + + if ( PropertyName == "RowCount" ) + { + aRet <<= maS2O.Count(); + } + else if ( PropertyName == "IsRowCountFinal" ) + { + bool bOrgFinal = false; + Any aOrgRet; + + aRet <<= false; + + aOrgRet = Reference< XPropertySet >::query(mxOriginal)-> + getPropertyValue( PropertyName ); + aOrgRet >>= bOrgFinal; + + if ( bOrgFinal ) + { + aOrgRet = Reference< XPropertySet >::query(mxOriginal)-> + getPropertyValue("RowCount"); + sal_uInt32 nOrgCount = 0; + aOrgRet >>= nOrgCount; + if ( nOrgCount == maS2O.Count() ) + aRet <<= true; + } + } + else + throw UnknownPropertyException(PropertyName); + + return aRet; +} + + +void SAL_CALL SortedResultSet::addPropertyChangeListener( + const OUString& PropertyName, + const Reference< XPropertyChangeListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpPropChangeListeners ) + mpPropChangeListeners.reset( + new comphelper::OMultiTypeInterfaceContainerHelperVar3(getContainerMutex()) ); + + mpPropChangeListeners->addInterface( PropertyName, Listener ); +} + + +void SAL_CALL SortedResultSet::removePropertyChangeListener( + const OUString& PropertyName, + const Reference< XPropertyChangeListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpPropChangeListeners ) + mpPropChangeListeners->removeInterface( PropertyName, Listener ); +} + + +void SAL_CALL SortedResultSet::addVetoableChangeListener( + const OUString& PropertyName, + const Reference< XVetoableChangeListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpVetoChangeListeners ) + mpVetoChangeListeners.reset( + new comphelper::OMultiTypeInterfaceContainerHelperVar3(getContainerMutex()) ); + + mpVetoChangeListeners->addInterface( PropertyName, Listener ); +} + + +void SAL_CALL SortedResultSet::removeVetoableChangeListener( + const OUString& PropertyName, + const Reference< XVetoableChangeListener >& Listener ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( mpVetoChangeListeners ) + mpVetoChangeListeners->removeInterface( PropertyName, Listener ); +} + + +// private methods + +sal_Int32 SortedResultSet::CompareImpl( const Reference < XResultSet >& xResultOne, + const Reference < XResultSet >& xResultTwo, + sal_Int32 nIndexOne, sal_Int32 nIndexTwo, + SortInfo const * pSortInfo ) +{ + Reference < XRow > xRowOne( xResultOne, UNO_QUERY ); + Reference < XRow > xRowTwo( xResultTwo, UNO_QUERY ); + + sal_IntPtr nCompare = 0; + sal_Int32 nColumn = pSortInfo->mnColumn; + + switch ( pSortInfo->mnType ) + { + case DataType::BIT : + case DataType::TINYINT : + case DataType::SMALLINT : + case DataType::INTEGER : + { + sal_Int32 aOne = 0; + sal_Int32 aTwo = 0; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getInt( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getInt( nColumn ); + + if ( aOne < aTwo ) + nCompare = -1; + else if ( aOne == aTwo ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::BIGINT : + { + sal_Int64 aOne = 0; + sal_Int64 aTwo = 0; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getLong( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getLong( nColumn ); + + if ( aOne < aTwo ) + nCompare = -1; + else if ( aOne == aTwo ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::CHAR : + case DataType::VARCHAR : + case DataType::LONGVARCHAR : + { + OUString aOne, aTwo; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getString( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getString( nColumn ); + + if ( ! pSortInfo->mbCaseSensitive ) + { + aOne = aOne.toAsciiLowerCase(); + aTwo = aTwo.toAsciiLowerCase(); + } + + nCompare = aOne.compareTo( aTwo ); + break; + } + case DataType::DATE : + { + Date aOne, aTwo; + sal_Int32 nTmp; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getDate( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getDate( nColumn ); + + nTmp = static_cast(aTwo.Year) - static_cast(aOne.Year); + if ( !nTmp ) { + nTmp = static_cast(aTwo.Month) - static_cast(aOne.Month); + if ( !nTmp ) + nTmp = static_cast(aTwo.Day) - static_cast(aOne.Day); + } + + if ( nTmp < 0 ) + nCompare = -1; + else if ( nTmp == 0 ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::TIME : + { + Time aOne, aTwo; + sal_Int32 nTmp; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getTime( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getTime( nColumn ); + + nTmp = static_cast(aTwo.Hours) - static_cast(aOne.Hours); + if ( !nTmp ) + nTmp = static_cast(aTwo.Minutes) - static_cast(aOne.Minutes); + if ( !nTmp ) + nTmp = static_cast(aTwo.Seconds) - static_cast(aOne.Seconds); + if ( !nTmp ) + nTmp = static_cast(aTwo.NanoSeconds) + - static_cast(aOne.NanoSeconds); + + if ( nTmp < 0 ) + nCompare = -1; + else if ( nTmp == 0 ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::TIMESTAMP : + { + DateTime aOne, aTwo; + sal_Int32 nTmp; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getTimestamp( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getTimestamp( nColumn ); + + nTmp = static_cast(aTwo.Year) - static_cast(aOne.Year); + if ( !nTmp ) + nTmp = static_cast(aTwo.Month) - static_cast(aOne.Month); + if ( !nTmp ) + nTmp = static_cast(aTwo.Day) - static_cast(aOne.Day); + if ( !nTmp ) + nTmp = static_cast(aTwo.Hours) - static_cast(aOne.Hours); + if ( !nTmp ) + nTmp = static_cast(aTwo.Minutes) - static_cast(aOne.Minutes); + if ( !nTmp ) + nTmp = static_cast(aTwo.Seconds) - static_cast(aOne.Seconds); + if ( !nTmp ) + nTmp = static_cast(aTwo.NanoSeconds) + - static_cast(aOne.NanoSeconds); + + if ( nTmp < 0 ) + nCompare = -1; + else if ( nTmp == 0 ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::REAL : + { + float aOne = 0; + float aTwo = 0; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getFloat( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getFloat( nColumn ); + + if ( aOne < aTwo ) + nCompare = -1; + else if ( aOne == aTwo ) + nCompare = 0; + else + nCompare = 1; + + break; + } + case DataType::FLOAT : + case DataType::DOUBLE : + { + double aOne = 0; + double aTwo = 0; + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getDouble( nColumn ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getDouble( nColumn ); + + if ( aOne < aTwo ) + nCompare = -1; + else if ( aOne == aTwo ) + nCompare = 0; + else + nCompare = 1; + + break; + } + default: + { + OSL_FAIL( "DataType not supported for compare!" ); + } + } + + return nCompare; +} + + +sal_Int32 SortedResultSet::CompareImpl( const Reference < XResultSet >& xResultOne, + const Reference < XResultSet >& xResultTwo, + sal_Int32 nIndexOne, sal_Int32 nIndexTwo ) +{ + sal_IntPtr nCompare = 0; + SortInfo* pInfo = mpSortInfo; + + while ( !nCompare && pInfo ) + { + if ( pInfo->mbUseOwnCompare ) + { + nCompare = CompareImpl( xResultOne, xResultTwo, + nIndexOne, nIndexTwo, pInfo ); + } + else + { + Any aOne, aTwo; + + Reference < XRow > xRowOne = + Reference< XRow >::query( xResultOne ); + Reference < XRow > xRowTwo = + Reference< XRow >::query( xResultTwo ); + + if ( xResultOne->absolute( nIndexOne ) ) + aOne = xRowOne->getObject( pInfo->mnColumn, nullptr ); + if ( xResultTwo->absolute( nIndexTwo ) ) + aTwo = xRowTwo->getObject( pInfo->mnColumn, nullptr ); + + nCompare = pInfo->mxCompareFunction->compare( aOne, aTwo ); + } + + if ( ! pInfo->mbAscending ) + nCompare = - nCompare; + + pInfo = pInfo->mpNext; + } + + return nCompare; +} + + +sal_Int32 SortedResultSet::Compare( SortListData const *pOne, + SortListData const *pTwo ) +{ + sal_IntPtr nIndexOne; + sal_IntPtr nIndexTwo; + + Reference < XResultSet > xResultOne; + Reference < XResultSet > xResultTwo; + + if ( pOne->mbModified ) + { + xResultOne = mxOther; + nIndexOne = pOne->mnOldPos; + } + else + { + xResultOne = mxOriginal; + nIndexOne = pOne->mnCurPos; + } + + if ( pTwo->mbModified ) + { + xResultTwo = mxOther; + nIndexTwo = pTwo->mnOldPos; + } + else + { + xResultTwo = mxOriginal; + nIndexTwo = pTwo->mnCurPos; + } + + sal_IntPtr nCompare; + nCompare = CompareImpl( xResultOne, xResultTwo, + nIndexOne, nIndexTwo ); + return nCompare; +} + + +sal_Int32 SortedResultSet::FindPos( SortListData const *pEntry, + sal_IntPtr _nStart, sal_IntPtr _nEnd ) +{ + if ( _nStart > _nEnd ) + return _nStart + 1; + + sal_IntPtr nStart = _nStart; + sal_IntPtr nEnd = _nEnd; + sal_IntPtr nMid = 0, nCompare = 0; + + + while ( nStart <= nEnd ) + { + nMid = ( nEnd - nStart ) / 2 + nStart; + SortListData *pMid = maS2O.GetData( nMid ); + nCompare = Compare( pEntry, pMid ); + + if ( !nCompare ) + nCompare = (pEntry != pMid) ? ((pEntry < pMid) ? -1 : 1) : 0; + + if ( nCompare < 0 ) // pEntry < pMid + nEnd = nMid - 1; + else + nStart = nMid + 1; + } + + if ( nCompare < 0 ) // pEntry < pMid + return nMid; + else + return nMid+1; +} + + +void SortedResultSet::PropertyChanged( const PropertyChangeEvent& rEvt ) +{ + osl::Guard< osl::Mutex > aGuard( maMutex ); + + if ( !mpPropChangeListeners ) + return; + + // Notify listeners interested especially in the changed property. + OInterfaceContainerHelper3* pPropsContainer = + mpPropChangeListeners->getContainer( rEvt.PropertyName ); + if ( pPropsContainer ) + pPropsContainer->notifyEach( &XPropertyChangeListener::propertyChange, rEvt ); + + // Notify listeners interested in all properties. + pPropsContainer = mpPropChangeListeners->getContainer( OUString() ); + if ( pPropsContainer ) + pPropsContainer->notifyEach( &XPropertyChangeListener::propertyChange, rEvt ); +} + + +// public methods + + +void SortedResultSet::CopyData( SortedResultSet *pSource ) +{ + const SortedEntryList& rSrcS2O = pSource->maS2O; + + sal_IntPtr i, nCount; + + maS2O.Clear(); + m_O2S.clear(); + m_ModList.clear(); + + maS2O.Insert( nullptr, 0 ); + m_O2S.push_back(0); + + nCount = rSrcS2O.Count(); + + for ( i=1; i(new SortListData( rSrcS2O[ i ] )), i ); + m_O2S.push_back(pSource->m_O2S[i]); + } + + mnLastSort = maS2O.Count(); + mxOther = pSource->mxOriginal; + + if ( !mpSortInfo ) + { + mpSortInfo = pSource->mpSortInfo; + mbIsCopy = true; + } +} + + +void SortedResultSet::Initialize( + const Sequence < NumberedSortingInfo > &xSortInfo, + const Reference< XAnyCompareFactory > &xCompFactory ) +{ + BuildSortInfo( mxOriginal, xSortInfo, xCompFactory ); + // Insert dummy at pos 0 + maS2O.Insert( std::unique_ptr(new SortListData( 0 )), 0 ); + + sal_IntPtr nIndex = 1; + + // now fetch all the elements from the original result set, + // get there new position in the sorted result set and insert + // an entry in the sorted to original mapping list + try { + while ( mxOriginal->absolute( nIndex ) ) + { + std::unique_ptr pData(new SortListData( nIndex )); + sal_IntPtr nPos = FindPos( pData.get(), 1, nIndex-1 ); + + maS2O.Insert( std::move(pData), nPos ); + + nIndex++; + } + } + catch (const SQLException&) + { + TOOLS_WARN_EXCEPTION("ucb", ""); + } + + // when we have fetched all the elements, we can create the + // original to sorted mapping list from the s2o list + m_O2S.clear(); + m_O2S.push_back(0); + + // insert some dummy entries first and replace then + // the entries with the right ones + size_t i; + + for ( i=1; i aGuard( maMutex ); + + if ( !mpPropChangeListeners ) + return; + + try { + // check for propertyChangeEvents + if ( nOldCount != GetCount() ) + { + bool bIsFinal = false; + PropertyChangeEvent aEvt; + + aEvt.PropertyName = "RowCount"; + aEvt.Further = false; + aEvt.PropertyHandle = -1; + aEvt.OldValue <<= nOldCount; + aEvt.NewValue <<= GetCount(); + + PropertyChanged( aEvt ); + + OUString aName = "IsRowCountFinal"; + Any aRet = getPropertyValue( aName ); + if ( (aRet >>= bIsFinal) && bIsFinal != bWasFinal ) + { + aEvt.PropertyName = aName; + aEvt.Further = false; + aEvt.PropertyHandle = -1; + aEvt.OldValue <<= bWasFinal; + aEvt.NewValue <<= bIsFinal; + PropertyChanged( aEvt ); + } + } + } + catch (const UnknownPropertyException&) {} + catch (const WrappedTargetException&) {} +} + + +void SortedResultSet::InsertNew( sal_Int32 nPos, sal_Int32 nCount ) +{ + // for all entries in the msS20-list, which are >= nPos, increase by nCount + sal_IntPtr i, nEnd; + + nEnd = maS2O.Count(); + for ( i=1; i<=nEnd; i++ ) + { + SortListData *pData = maS2O.GetData( i ); + if ( pData->mnCurPos >= nPos ) + { + pData->mnCurPos += nCount; + } + } + + // and append the new entries at the end of the maS2O-list or insert at the + // position nPos in the maS2O-list + for ( i=0; i pData(new SortListData( nEnd )); + + maS2O.Insert( std::move(pData), nEnd ); // Insert( Value, Position ) + m_O2S.insert(m_O2S.begin() + nPos + i, nEnd); + } + + mnCount += nCount; +} + + +void SortedResultSet::Remove( sal_Int32 nPos, sal_Int32 nCount, EventList *pEvents ) +{ + sal_IntPtr nOldLastSort; + + // correct mnLastSort first + nOldLastSort = mnLastSort; + if ( nPos <= mnLastSort ) + { + if ( nPos + nCount - 1 <= mnLastSort ) + mnLastSort -= nCount; + else + mnLastSort = nPos - 1; + } + + // remove the entries from the lists and correct the positions + // in the original2sorted list + for ( sal_IntPtr i=0; i < nCount; i++ ) + { + sal_IntPtr nSortPos = m_O2S[nPos]; + m_O2S.erase(m_O2S.begin() + nPos); + + for (size_t j=1; j < m_O2S.size(); ++j) + { + sal_IntPtr nVal = m_O2S[j]; + if ( nVal > nSortPos ) + { + --nVal; + m_O2S[j] = nVal; + } + } + + std::unique_ptr pData = maS2O.Remove( nSortPos ); + if ( pData->mbModified ) + m_ModList.erase(std::find(m_ModList.begin(), m_ModList.end(), pData.get())); + + // generate remove Event, but not for new entries + if ( nSortPos <= nOldLastSort ) + pEvents->AddEvent( ListActionType::REMOVED, nSortPos ); + } + + // correct the positions in the sorted list + for ( sal_uInt32 i=1; i<= maS2O.Count(); i++ ) + { + SortListData *pData = maS2O.GetData( i ); + if ( pData->mnCurPos > nPos ) + pData->mnCurPos -= nCount; + } + + mnCount -= nCount; +} + + +void SortedResultSet::Move( sal_Int32 nPos, sal_Int32 nCount, sal_Int32 nOffset ) +{ + if ( !nOffset ) + return; + + sal_IntPtr i, nSortPos, nTo; + SortListData *pData; + + for ( i=0; imnCurPos += nOffset; + } + + if ( nOffset < 0 ) + { + for ( i=nPos+nOffset; imnCurPos += nCount; + } + } + else + { + sal_IntPtr nStart = nPos + nCount; + sal_IntPtr nEnd = nStart + nOffset; + for ( i=nStart; imnCurPos -= nCount; + } + } + + // remember the to be moved entries + std::unique_ptr pTmpArr(new sal_IntPtr[ nCount ]); + for ( i=0; inOffset; i-- ) + { + sal_IntPtr const nVal = m_O2S[nFrom + i]; + m_O2S[nTo + i] = nVal; + } + + } + else + { + sal_IntPtr nStart = nPos + nCount; + for ( i=0; i& aResult, + const Sequence < NumberedSortingInfo > &xSortInfo, + const Reference< XAnyCompareFactory > &xCompFactory ) +{ + Reference < XResultSetMetaDataSupplier > xMeta ( aResult, UNO_QUERY ); + + if ( ! xMeta.is() ) + { + OSL_FAIL( "No MetaData, No Sorting!" ); + return; + } + + Reference < XResultSetMetaData > xData = xMeta->getMetaData(); + const NumberedSortingInfo *pSortInfo = xSortInfo.getConstArray(); + + sal_Int32 nColumn; + OUString aPropName; + SortInfo *pInfo; + + for ( sal_Int32 i=xSortInfo.getLength(); i > 0; ) + { + --i; + nColumn = pSortInfo[ i ].ColumnIndex; + aPropName = xData->getColumnName( nColumn ); + pInfo = new SortInfo; + + if ( xCompFactory.is() ) + pInfo->mxCompareFunction = xCompFactory->createAnyCompareByName( + aPropName ); + + if ( pInfo->mxCompareFunction.is() ) + { + pInfo->mbUseOwnCompare = false; + pInfo->mnType = 0; + } + else + { + pInfo->mbUseOwnCompare = true; + pInfo->mnType = xData->getColumnType( nColumn ); + } + + pInfo->mnColumn = nColumn; + pInfo->mbAscending = pSortInfo[ i ].Ascending; + pInfo->mbCaseSensitive = xData->isCaseSensitive( nColumn ); + pInfo->mpNext = mpSortInfo; + mpSortInfo = pInfo; + } +} + + +void SortedResultSet::SetChanged( sal_Int32 nPos, sal_Int32 nCount ) +{ + for ( sal_IntPtr i=0; imbModified ) + { + pData->mbModified = true; + m_ModList.push_back(pData); + } + } + nPos += 1; + } +} + + +void SortedResultSet::ResortModified( EventList* pList ) +{ + sal_IntPtr nCompare, nCurPos, nNewPos; + sal_IntPtr nStart, nEnd, nOffset, nVal; + + try { + for (size_t i = 0; i < m_ModList.size(); ++i) + { + SortListData *const pData = m_ModList[i]; + nCompare = CompareImpl( mxOther, mxOriginal, + pData->mnOldPos, pData->mnCurPos ); + pData->mbModified = false; + if ( nCompare != 0 ) + { + nCurPos = m_O2S[pData->mnCurPos]; + if ( nCompare < 0 ) + { + nNewPos = FindPos( pData, 1, nCurPos-1 ); + nStart = nNewPos; + nEnd = nCurPos; + nOffset = 1; + } + else + { + nNewPos = FindPos( pData, nCurPos+1, mnLastSort ); + nStart = nCurPos; + nEnd = mnLastSort; + nOffset = -1; + } + + if ( nNewPos != nCurPos ) + { + // correct the lists! + maS2O.Move( static_cast(nCurPos), nNewPos ); + for (size_t j = 1; j < m_O2S.size(); ++j) + { + nVal = m_O2S[j]; + if ( ( nStart <= nVal ) && ( nVal <= nEnd ) ) + { + nVal += nOffset; + m_O2S[j] = nVal; + } + } + + m_O2S[pData->mnCurPos] = nNewPos; + + ListAction aAction; + aAction.Position = nCurPos; + aAction.Count = 1; + aAction.ListActionType = ListActionType::MOVED; + aAction.ActionInfo <<= nNewPos-nCurPos; + pList->Insert( aAction ); + } + pList->AddEvent( ListActionType::PROPERTIES_CHANGED, nNewPos ); + } + } + } + catch (const SQLException&) + { + TOOLS_WARN_EXCEPTION("ucb", ""); + } + + m_ModList.clear(); +} + + +void SortedResultSet::ResortNew( EventList* pList ) +{ + sal_IntPtr i, nNewPos, nVal; + + try { + for ( i = mnLastSort; i(maS2O.Count()); i++ ) + { + SortListData *const pData = m_ModList[i]; + nNewPos = FindPos( pData, 1, mnLastSort ); + if ( nNewPos != i ) + { + maS2O.Move( static_cast(i), nNewPos ); + for (size_t j=1; j< m_O2S.size(); ++j) + { + nVal = m_O2S[j]; + if ( nVal >= nNewPos ) + m_O2S[j] = nVal + 1; + } + m_O2S[pData->mnCurPos] = nNewPos; + } + mnLastSort++; + pList->AddEvent( ListActionType::INSERTED, nNewPos ); + } + } + catch (const SQLException&) + { + TOOLS_WARN_EXCEPTION("ucb", ""); + } +} + + +// SortListData + + +SortListData::SortListData( sal_IntPtr nPos ) + : mbModified(false) + , mnCurPos(nPos) + , mnOldPos(nPos) +{ +}; + +SortedEntryList::SortedEntryList() +{ +} + +SortedEntryList::~SortedEntryList() +{ +} + +void SortedEntryList::Clear() +{ + maData.clear(); +} + + +void SortedEntryList::Insert( std::unique_ptr pEntry, sal_Int32 nPos ) +{ + if ( nPos < static_cast(maData.size()) ) + maData.insert( maData.begin() + nPos, std::move(pEntry) ); + else + maData.push_back( std::move(pEntry) ); +} + +void SortedEntryList::Move( sal_Int32 nOldPos, sal_Int32 nNewPos ) +{ + auto p = std::move(maData[nOldPos]); + maData.erase( maData.begin() + nOldPos ); + maData.insert(maData.begin() + nNewPos, std::move(p)); +} + +std::unique_ptr SortedEntryList::Remove( sal_Int32 nPos ) +{ + std::unique_ptr pData; + + if ( nPos < static_cast(maData.size()) ) + { + pData = std::move(maData[ nPos ]); + maData.erase( maData.begin() + nPos ); + } + + return pData; +} + + +SortListData* SortedEntryList::GetData( sal_Int32 nPos ) +{ + SortListData *pData; + + if ( nPos < static_cast(maData.size()) ) + pData = maData[ nPos ].get(); + else + pData = nullptr; + + return pData; +} + + +sal_Int32 SortedEntryList::operator [] ( sal_Int32 nPos ) const +{ + SortListData *pData; + + if ( nPos < static_cast(maData.size()) ) + pData = maData[ nPos ].get(); + else + pData = nullptr; + + if ( pData ) + if ( ! pData->mbModified ) + return pData->mnCurPos; + else + { + OSL_FAIL( "SortedEntryList: Can't get value for modified entry!"); + return 0; + } + else + { + OSL_FAIL( "SortedEntryList: invalid pos!"); + return 0; + } +} + + +SRSPropertySetInfo::SRSPropertySetInfo() +{ + maProps[0].Name = "RowCount"; + maProps[0].Handle = -1; + maProps[0].Type = cppu::UnoType::get(); + maProps[0].Attributes = -1; + + maProps[1].Name = "IsRowCountFinal"; + maProps[1].Handle = -1; + maProps[1].Type = cppu::UnoType::get(); + maProps[1].Attributes = -1; +} + +// XPropertySetInfo methods. + +Sequence< Property > SAL_CALL +SRSPropertySetInfo::getProperties() +{ + return Sequence < Property > ( maProps, 2 ); +} + + +Property SAL_CALL +SRSPropertySetInfo::getPropertyByName( const OUString& Name ) +{ + if ( Name == "RowCount" ) + return maProps[0]; + else if ( Name == "IsRowCountFinal" ) + return maProps[1]; + else + throw UnknownPropertyException(Name); +} + + +sal_Bool SAL_CALL +SRSPropertySetInfo::hasPropertyByName( const OUString& Name ) +{ + if ( Name == "RowCount" ) + return true; + else if ( Name == "IsRowCountFinal" ) + return true; + else + return false; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucb/source/sorter/sortresult.hxx b/ucb/source/sorter/sortresult.hxx new file mode 100644 index 000000000..caf3d76e3 --- /dev/null +++ b/ucb/source/sorter/sortresult.hxx @@ -0,0 +1,329 @@ +/* -*- 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 . + */ + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +struct SortInfo; +struct SortListData; +class SRSPropertySetInfo; + + +class SortedEntryList +{ + std::deque < std::unique_ptr > maData; + +public: + SortedEntryList(); + ~SortedEntryList(); + + sal_uInt32 Count() const { return static_cast(maData.size()); } + + void Clear(); + void Insert( std::unique_ptr pEntry, sal_Int32 nPos ); + std::unique_ptr Remove( sal_Int32 nPos ); + SortListData* GetData( sal_Int32 nPos ); + void Move( sal_Int32 nOldPos, sal_Int32 nNewPos ); + + sal_Int32 operator [] ( sal_Int32 nPos ) const; +}; + + +class EventList +{ + std::deque maData; + +public: + EventList(){} + + sal_uInt32 Count() const { return static_cast(maData.size()); } + + void AddEvent( sal_IntPtr nType, sal_Int32 nPos ); + void Insert( const css::ucb::ListAction& rAction ) { maData.push_back( rAction ); } + void Clear(); + css::ucb::ListAction& GetAction( sal_Int32 nIndex ) { return maData[ nIndex ]; } +}; + + +inline constexpr OUStringLiteral RESULTSET_SERVICE_NAME = u"com.sun.star.ucb.SortedResultSet"; + + +class SortedResultSet: public cppu::WeakImplHelper < + css::lang::XServiceInfo, + css::lang::XComponent, + css::ucb::XContentAccess, + css::sdbc::XResultSet, + css::sdbc::XRow, + css::sdbc::XCloseable, + css::sdbc::XResultSetMetaDataSupplier, + css::beans::XPropertySet > +{ + comphelper::OInterfaceContainerHelper3 *mpDisposeEventListeners; + std::unique_ptr> mpPropChangeListeners; + std::unique_ptr> mpVetoChangeListeners; + + css::uno::Reference < css::sdbc::XResultSet > mxOriginal; + css::uno::Reference < css::sdbc::XResultSet > mxOther; + + rtl::Reference mpPropSetInfo; + SortInfo* mpSortInfo; + osl::Mutex maMutex; + SortedEntryList maS2O; // maps the sorted entries to the original ones + std::deque m_O2S; /// maps the original Entries to the sorted ones + std::deque m_ModList; /// keeps track of modified entries + sal_Int32 mnLastSort; // index of the last sorted entry; + sal_Int32 mnCurEntry; // index of the current entry + sal_Int32 mnCount; // total count of the elements + bool mbIsCopy; + + +private: + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + sal_Int32 FindPos( SortListData const *pEntry, sal_IntPtr nStart, sal_IntPtr nEnd ); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + sal_Int32 Compare( SortListData const *pOne, + SortListData const *pTwo ); + void BuildSortInfo( const css::uno::Reference< css::sdbc::XResultSet >& aResult, + const css::uno::Sequence < css::ucb::NumberedSortingInfo > &xSortInfo, + const css::uno::Reference< css::ucb::XAnyCompareFactory > &xCompFac ); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + static sal_Int32 CompareImpl( const css::uno::Reference < css::sdbc::XResultSet >& xResultOne, + const css::uno::Reference < css::sdbc::XResultSet >& xResultTwo, + sal_Int32 nIndexOne, sal_Int32 nIndexTwo, + SortInfo const * pSortInfo ); + /// @throws css::sdbc::SQLException + /// @throws css::uno::RuntimeException + sal_Int32 CompareImpl( const css::uno::Reference < css::sdbc::XResultSet >& xResultOne, + const css::uno::Reference < css::sdbc::XResultSet >& xResultTwo, + sal_Int32 nIndexOne, sal_Int32 nIndexTwo ); + void PropertyChanged( const css::beans::PropertyChangeEvent& rEvt ); + +public: + SortedResultSet( css::uno::Reference< css::sdbc::XResultSet > const & aResult ); + virtual ~SortedResultSet() override; + + sal_Int32 GetCount() const { return mnCount; } + + void CopyData( SortedResultSet* pSource ); + void Initialize( const css::uno::Sequence < css::ucb::NumberedSortingInfo > &xSortInfo, + const css::uno::Reference< css::ucb::XAnyCompareFactory > &xCompFac ); + void CheckProperties( sal_Int32 nOldCount, bool bWasFinal ); + + void InsertNew( sal_Int32 nPos, sal_Int32 nCount ); + void SetChanged( sal_Int32 nPos, sal_Int32 nCount ); + void Remove( sal_Int32 nPos, sal_Int32 nCount, EventList *pList ); + void Move( sal_Int32 nPos, sal_Int32 nCount, sal_Int32 nOffset ); + + void ResortModified( EventList* pList ); + void ResortNew( EventList* pList ); + + // XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override; + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + // XComponent + virtual void SAL_CALL + dispose() override; + + virtual void SAL_CALL + addEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener ) override; + + virtual void SAL_CALL + removeEventListener( const css::uno::Reference< css::lang::XEventListener >& Listener ) override; + + // XContentAccess + virtual OUString SAL_CALL + queryContentIdentifierString() override; + virtual css::uno::Reference< + css::ucb::XContentIdentifier > SAL_CALL + queryContentIdentifier() override; + virtual css::uno::Reference< + css::ucb::XContent > SAL_CALL + queryContent() override; + + // XResultSet + virtual sal_Bool SAL_CALL + next() override; + virtual sal_Bool SAL_CALL + isBeforeFirst() override; + virtual sal_Bool SAL_CALL + isAfterLast() override; + virtual sal_Bool SAL_CALL + isFirst() override; + virtual sal_Bool SAL_CALL + isLast() override; + virtual void SAL_CALL + beforeFirst() override; + virtual void SAL_CALL + afterLast() override; + virtual sal_Bool SAL_CALL + first() override; + virtual sal_Bool SAL_CALL + last() override; + virtual sal_Int32 SAL_CALL + getRow() override; + virtual sal_Bool SAL_CALL + absolute( sal_Int32 row ) override; + virtual sal_Bool SAL_CALL + relative( sal_Int32 rows ) override; + virtual sal_Bool SAL_CALL + previous() override; + virtual void SAL_CALL + refreshRow() override; + virtual sal_Bool SAL_CALL + rowUpdated() override; + virtual sal_Bool SAL_CALL + rowInserted() override; + virtual sal_Bool SAL_CALL + rowDeleted() override; + virtual css::uno::Reference< + css::uno::XInterface > SAL_CALL + getStatement() override; + + // XRow + virtual sal_Bool SAL_CALL + wasNull() override; + + virtual OUString SAL_CALL + getString( sal_Int32 columnIndex ) override; + + virtual sal_Bool SAL_CALL + getBoolean( sal_Int32 columnIndex ) override; + + virtual sal_Int8 SAL_CALL + getByte( sal_Int32 columnIndex ) override; + + virtual sal_Int16 SAL_CALL + getShort( sal_Int32 columnIndex ) override; + + virtual sal_Int32 SAL_CALL + getInt( sal_Int32 columnIndex ) override; + + virtual sal_Int64 SAL_CALL + getLong( sal_Int32 columnIndex ) override; + + virtual float SAL_CALL + getFloat( sal_Int32 columnIndex ) override; + + virtual double SAL_CALL + getDouble( sal_Int32 columnIndex ) override; + + virtual css::uno::Sequence< sal_Int8 > SAL_CALL + getBytes( sal_Int32 columnIndex ) override; + + virtual css::util::Date SAL_CALL + getDate( sal_Int32 columnIndex ) override; + + virtual css::util::Time SAL_CALL + getTime( sal_Int32 columnIndex ) override; + + virtual css::util::DateTime SAL_CALL + getTimestamp( sal_Int32 columnIndex ) override; + + virtual css::uno::Reference< + css::io::XInputStream > SAL_CALL + getBinaryStream( sal_Int32 columnIndex ) override; + + virtual css::uno::Reference< + css::io::XInputStream > SAL_CALL + getCharacterStream( sal_Int32 columnIndex ) override; + + virtual css::uno::Any SAL_CALL + getObject( sal_Int32 columnIndex, + const css::uno::Reference< + css::container::XNameAccess >& typeMap ) override; + virtual css::uno::Reference< + css::sdbc::XRef > SAL_CALL + getRef( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< + css::sdbc::XBlob > SAL_CALL + getBlob( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< + css::sdbc::XClob > SAL_CALL + getClob( sal_Int32 columnIndex ) override; + virtual css::uno::Reference< + css::sdbc::XArray > SAL_CALL + getArray( sal_Int32 columnIndex ) override; + + // XCloseable + virtual void SAL_CALL + close() override; + + // XResultSetMetaDataSupplier + virtual css::uno::Reference< css::sdbc::XResultSetMetaData > SAL_CALL + getMetaData() override; + + + // XPropertySet + virtual css::uno::Reference< + css::beans::XPropertySetInfo > SAL_CALL + getPropertySetInfo() override; + + virtual void SAL_CALL + setPropertyValue( const OUString& PropertyName, + const css::uno::Any& Value ) override; + + virtual css::uno::Any SAL_CALL + getPropertyValue( const OUString& PropertyName ) override; + + virtual void SAL_CALL + addPropertyChangeListener( const OUString& PropertyName, + const css::uno::Reference< + css::beans::XPropertyChangeListener >& Listener ) override; + + virtual void SAL_CALL + removePropertyChangeListener( const OUString& PropertyName, + const css::uno::Reference< + css::beans::XPropertyChangeListener >& Listener ) override; + + virtual void SAL_CALL + addVetoableChangeListener( const OUString& PropertyName, + const css::uno::Reference< + css::beans::XVetoableChangeListener >& Listener ) override; + + virtual void SAL_CALL + removeVetoableChangeListener( const OUString& PropertyName, + const css::uno::Reference< + css::beans::XVetoableChangeListener >& aListener ) override; +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/ucb/source/sorter/srtrs1.component b/ucb/source/sorter/srtrs1.component new file mode 100644 index 000000000..a96277d0b --- /dev/null +++ b/ucb/source/sorter/srtrs1.component @@ -0,0 +1,26 @@ + + + + + + + + -- cgit v1.2.3