Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2099 insertions, 0 deletions

diff --git a/ucb/source/cacher/cachedcontentresultset.cxx b/ucb/source/cacher/cachedcontentresultset.cxx
new file mode 100644
index 000000000..c169a3734
--- /dev/null
+++ b/ucb/source/cacher/cachedcontentresultset.cxx
@@ -0,0 +1,2099 @@
+/* -*- 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 "cachedcontentresultset.hxx"
+#include <com/sun/star/sdbc/FetchDirection.hpp>
+#include <com/sun/star/sdbc/SQLException.hpp>
+#include <com/sun/star/ucb/FetchError.hpp>
+#include <com/sun/star/beans/PropertyAttribute.hpp>
+#include <com/sun/star/script/CannotConvertException.hpp>
+#include <com/sun/star/script/Converter.hpp>
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <rtl/ustring.hxx>
+#include <o3tl/any.hxx>
+#include <osl/diagnose.h>
+#include <cppuhelper/exc_hlp.hxx>
+#include <cppuhelper/queryinterface.hxx>
+#include <ucbhelper/macros.hxx>
+#include <optional>
+#include <string_view>
+
+using namespace com::sun::star::beans;
+using namespace com::sun::star::lang;
+using namespace com::sun::star::script;
+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 cppu;
+
+
+#define COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE 256
+#define COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION FetchDirection::FORWARD
+
+//if you change this function template please pay attention to
+//function getObject, where this is similar implemented
+
+template<typename T> T CachedContentResultSet::rowOriginGet(
+    T (SAL_CALL css::sdbc::XRow::* f)(sal_Int32), sal_Int32 columnIndex)
+{
+    impl_EnsureNotDisposed();
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    sal_Int32 nRow = m_nRow;
+    sal_Int32 nFetchSize = m_nFetchSize;
+    sal_Int32 nFetchDirection = m_nFetchDirection;
+    if( !m_aCache.hasRow( nRow ) )
+    {
+        bool isCleared = false;
+        if( !m_aCache.hasCausedException( nRow ) )
+        {
+            if( !m_xFetchProvider.is() )
+            {
+                OSL_FAIL( "broadcaster was disposed already" );
+                throw SQLException();
+            }
+            aGuard.clear();
+            isCleared = true;
+            if( impl_isForwardOnly() )
+                applyPositionToOrigin( nRow );
+
+            impl_fetchData( nRow, nFetchSize, nFetchDirection );
+        }
+        if (isCleared)
+        {
+            aGuard.reset();
+        }
+        if( !m_aCache.hasRow( nRow ) )
+        {
+            m_bLastReadWasFromCache = false;
+            aGuard.clear();
+            applyPositionToOrigin( nRow );
+            impl_init_xRowOrigin();
+            return (m_xRowOrigin.get()->*f)( columnIndex );
+        }
+    }
+    const Any& rValue = m_aCache.getAny( nRow, columnIndex );
+    T aRet = T();
+    m_bLastReadWasFromCache = true;
+    m_bLastCachedReadWasNull = !( rValue >>= aRet );
+    /* Last chance. Try type converter service... */
+    if ( m_bLastCachedReadWasNull && rValue.hasValue() )
+    {
+        Reference< XTypeConverter > xConverter = getTypeConverter();
+        if ( xConverter.is() )
+        {
+            try
+            {
+                Any aConvAny = xConverter->convertTo(
+                    rValue,
+                    cppu::UnoType<T>::get() );
+                m_bLastCachedReadWasNull = !( aConvAny >>= aRet );
+            }
+            catch (const IllegalArgumentException&)
+            {
+            }
+            catch (const CannotConvertException&)
+            {
+            }
+        }
+    }
+    return aRet;
+}
+
+
+// CCRS_Cache methods
+
+
+CachedContentResultSet::CCRS_Cache::CCRS_Cache(
+    const Reference< XContentIdentifierMapping > & xMapping )
+    : m_xContentIdentifierMapping( xMapping )
+{
+}
+
+CachedContentResultSet::CCRS_Cache::~CCRS_Cache()
+{
+}
+
+void CachedContentResultSet::CCRS_Cache
+    ::clear()
+{
+    m_pResult.reset();
+    m_pMappedReminder.reset();
+}
+
+void CachedContentResultSet::CCRS_Cache
+    ::loadData( const FetchResult& rResult )
+{
+    clear();
+    m_pResult = rResult;
+}
+
+bool CachedContentResultSet::CCRS_Cache
+    ::hasRow( sal_Int32 row ) const
+{
+    if( !m_pResult )
+        return false;
+    sal_Int32 nStart = m_pResult->StartIndex;
+    sal_Int32 nEnd = nStart;
+    if( m_pResult->Orientation )
+        nEnd += m_pResult->Rows.getLength() - 1;
+    else
+        nStart -= m_pResult->Rows.getLength() + 1;
+
+    return nStart <= row && row <= nEnd;
+}
+
+sal_Int32 CachedContentResultSet::CCRS_Cache
+    ::getMaxRow() const
+{
+    if( !m_pResult )
+        return 0;
+    sal_Int32 nEnd = m_pResult->StartIndex;
+    if( m_pResult->Orientation )
+        return nEnd + m_pResult->Rows.getLength() - 1;
+    else
+        return nEnd;
+}
+
+bool CachedContentResultSet::CCRS_Cache
+    ::hasKnownLast() const
+{
+    if( !m_pResult )
+        return false;
+
+    return ( m_pResult->FetchError & FetchError::ENDOFDATA )
+        && m_pResult->Orientation
+        && m_pResult->Rows.hasElements();
+}
+
+bool CachedContentResultSet::CCRS_Cache
+    ::hasCausedException( sal_Int32 nRow ) const
+{
+    if( !m_pResult )
+        return false;
+    if( !( m_pResult->FetchError & FetchError::EXCEPTION ) )
+        return false;
+
+    sal_Int32 nEnd = m_pResult->StartIndex;
+    if( m_pResult->Orientation )
+        nEnd += m_pResult->Rows.getLength();
+
+    return nRow == nEnd+1;
+}
+
+Any& CachedContentResultSet::CCRS_Cache
+    ::getRowAny( sal_Int32 nRow )
+{
+    if( !nRow )
+        throw SQLException();
+    if( !m_pResult )
+        throw SQLException();
+    if( !hasRow( nRow ) )
+        throw SQLException();
+
+    sal_Int32 nDiff = nRow - m_pResult->StartIndex;
+    if( nDiff < 0 )
+        nDiff *= -1;
+
+    return m_pResult->Rows.getArray()[nDiff];
+}
+
+void CachedContentResultSet::CCRS_Cache
+    ::remindMapped( sal_Int32 nRow )
+{
+    //remind that this row was mapped
+    if( !m_pResult )
+        return;
+    sal_Int32 nDiff = nRow - m_pResult->StartIndex;
+    if( nDiff < 0 )
+        nDiff *= -1;
+    Sequence< sal_Bool >& rMappedReminder = getMappedReminder();
+    if( nDiff < rMappedReminder.getLength() )
+    {
+        sal_Bool* pMappedReminder = rMappedReminder.getArray();
+        pMappedReminder[nDiff] = true;
+    }
+}
+
+bool CachedContentResultSet::CCRS_Cache
+    ::isRowMapped( sal_Int32 nRow )
+{
+    if( !m_pMappedReminder || !m_pResult )
+        return false;
+    sal_Int32 nDiff = nRow - m_pResult->StartIndex;
+    if( nDiff < 0 )
+        nDiff *= -1;
+    if( nDiff < m_pMappedReminder->getLength() )
+        return (*m_pMappedReminder)[nDiff];
+    return false;
+}
+
+Sequence< sal_Bool >& CachedContentResultSet::CCRS_Cache
+    ::getMappedReminder()
+{
+    if( !m_pMappedReminder )
+    {
+        sal_Int32 nCount = m_pResult->Rows.getLength();
+        m_pMappedReminder.emplace( nCount );
+        std::fill_n(m_pMappedReminder->getArray(), m_pMappedReminder->getLength(), false);
+    }
+    return *m_pMappedReminder;
+}
+
+const Any& CachedContentResultSet::CCRS_Cache
+    ::getAny( sal_Int32 nRow, sal_Int32 nColumnIndex )
+{
+    if( !nColumnIndex )
+        throw SQLException();
+    if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
+    {
+        Any& rRow = getRowAny( nRow );
+        Sequence< Any > aValue;
+        rRow >>= aValue;
+        if( m_xContentIdentifierMapping->mapRow( aValue ) )
+        {
+            rRow <<= aValue;
+            remindMapped( nRow );
+        }
+        else
+            m_xContentIdentifierMapping.clear();
+    }
+    auto & rowAny = getRowAny(nRow);
+    auto rRow = o3tl::doAccess<Sequence<Any>>(rowAny);
+
+    if( nColumnIndex > rRow->getLength() )
+        throw SQLException();
+    return (*rRow)[nColumnIndex-1];
+}
+
+OUString const & CachedContentResultSet::CCRS_Cache
+    ::getContentIdentifierString( sal_Int32 nRow )
+{
+    try
+    {
+        if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
+        {
+            Any& rRow = getRowAny( nRow );
+            OUString aValue;
+            rRow >>= aValue;
+            rRow <<= m_xContentIdentifierMapping->mapContentIdentifierString( aValue );
+            remindMapped( nRow );
+        }
+        return *o3tl::doAccess<OUString>(getRowAny(nRow));
+    }
+    catch(const SQLException& ex)
+    {
+        css::uno::Any anyEx = cppu::getCaughtException();
+        throw css::lang::WrappedTargetRuntimeException( ex.Message,
+                        css::uno::Reference< css::uno::XInterface >(),
+                        anyEx );
+    }
+}
+
+Reference< XContentIdentifier > CachedContentResultSet::CCRS_Cache
+    ::getContentIdentifier( sal_Int32 nRow )
+{
+    try
+    {
+        if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
+        {
+            Any& rRow = getRowAny( nRow );
+            Reference< XContentIdentifier > aValue;
+            rRow >>= aValue;
+            rRow <<= m_xContentIdentifierMapping->mapContentIdentifier( aValue );
+            remindMapped( nRow );
+        }
+        return *o3tl::doAccess<Reference<XContentIdentifier>>(getRowAny(nRow));
+    }
+    catch(const SQLException& ex)
+    {
+        css::uno::Any anyEx = cppu::getCaughtException();
+        throw css::lang::WrappedTargetRuntimeException( ex.Message,
+                        css::uno::Reference< css::uno::XInterface >(),
+                        anyEx );
+    }
+}
+
+Reference< XContent > CachedContentResultSet::CCRS_Cache
+    ::getContent( sal_Int32 nRow )
+{
+    try
+    {
+        if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
+        {
+            Any& rRow = getRowAny( nRow );
+            Reference< XContent > aValue;
+            rRow >>= aValue;
+            rRow <<= m_xContentIdentifierMapping->mapContent( aValue );
+            remindMapped( nRow );
+        }
+        return *o3tl::doAccess<Reference<XContent>>(getRowAny(nRow));
+    }
+    catch (const SQLException& ex)
+    {
+        css::uno::Any anyEx = cppu::getCaughtException();
+        throw css::lang::WrappedTargetRuntimeException( ex.Message,
+                        css::uno::Reference< css::uno::XInterface >(),
+                        anyEx );
+    }
+}
+
+
+
+
+class CCRS_PropertySetInfo :
+                public cppu::OWeakObject,
+                public css::lang::XTypeProvider,
+                public css::beans::XPropertySetInfo
+{
+    friend class CachedContentResultSet;
+
+    //my Properties
+    std::optional<Sequence< css::beans::Property >>
+                            m_xProperties;
+
+    sal_Int32               m_nFetchSizePropertyHandle;
+    sal_Int32               m_nFetchDirectionPropertyHandle;
+
+private:
+    sal_Int32
+    impl_getRemainedHandle() const;
+
+    bool
+    impl_queryProperty(
+            std::u16string_view rName
+            , css::beans::Property& rProp ) const;
+    sal_Int32
+    impl_getPos( std::u16string_view rName ) const;
+
+    static bool
+    impl_isMyPropertyName( std::u16string_view rName );
+
+public:
+    explicit CCRS_PropertySetInfo(   Reference<
+            XPropertySetInfo > const & xPropertySetInfoOrigin );
+
+    // 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 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;
+};
+
+//some helping variables ( names for my special properties )
+const char16_t g_sPropertyNameForCount[] = u"RowCount";
+const char16_t g_sPropertyNameForFinalCount[] = u"IsRowCountFinal";
+constexpr OUStringLiteral g_sPropertyNameForFetchSize(u"FetchSize");
+constexpr OUStringLiteral g_sPropertyNameForFetchDirection(u"FetchDirection");
+
+CCRS_PropertySetInfo::CCRS_PropertySetInfo(
+        Reference< XPropertySetInfo > const & xInfo )
+        : m_nFetchSizePropertyHandle( -1 )
+        , m_nFetchDirectionPropertyHandle( -1 )
+{
+    //initialize list of properties:
+
+    // it is required, that the received xInfo contains the two
+    // properties with names 'g_sPropertyNameForCount' and
+    // 'g_sPropertyNameForFinalCount'
+
+    if( xInfo.is() )
+    {
+        m_xProperties = xInfo->getProperties();
+    }
+    else
+    {
+        OSL_FAIL( "The received XPropertySetInfo doesn't contain required properties" );
+        m_xProperties.emplace();
+    }
+
+    //ensure, that we haven't got the Properties 'FetchSize' and 'Direction' twice:
+    sal_Int32 nFetchSize = impl_getPos( g_sPropertyNameForFetchSize );
+    sal_Int32 nFetchDirection = impl_getPos( g_sPropertyNameForFetchDirection );
+    sal_Int32 nDeleted = 0;
+    if( nFetchSize != -1 )
+        nDeleted++;
+    if( nFetchDirection != -1 )
+        nDeleted++;
+
+    Sequence< Property > aOrigProps( *m_xProperties );
+    sal_Int32 nOrigProps = aOrigProps.getLength();
+
+    m_xProperties->realloc( nOrigProps + 2 - nDeleted );//note that nDeleted is <= 2
+    auto pProperties = m_xProperties->getArray();
+    for( sal_Int32 n = 0, m = 0; n < nOrigProps; n++, m++ )
+    {
+        if( n == nFetchSize || n == nFetchDirection )
+            m--;
+        else
+            pProperties[ m ] = aOrigProps[ n ];
+    }
+    {
+        Property& rMyProp = pProperties[ nOrigProps - nDeleted ];
+        rMyProp.Name = g_sPropertyNameForFetchSize;
+        rMyProp.Type = cppu::UnoType<sal_Int32>::get();
+        rMyProp.Attributes = PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT;
+
+        if( nFetchSize != -1 )
+            m_nFetchSizePropertyHandle = aOrigProps[nFetchSize].Handle;
+        else
+            m_nFetchSizePropertyHandle = impl_getRemainedHandle();
+
+        rMyProp.Handle = m_nFetchSizePropertyHandle;
+
+    }
+    {
+        Property& rMyProp = pProperties[ nOrigProps - nDeleted + 1 ];
+        rMyProp.Name = g_sPropertyNameForFetchDirection;
+        rMyProp.Type = cppu::UnoType<sal_Bool>::get();
+        rMyProp.Attributes = PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT;
+
+        m_nFetchDirectionPropertyHandle = rMyProp.Handle;
+    }
+}
+
+// XInterface methods.
+
+void SAL_CALL CCRS_PropertySetInfo::acquire()
+    noexcept
+{
+    OWeakObject::acquire();
+}
+
+void SAL_CALL CCRS_PropertySetInfo::release()
+    noexcept
+{
+    OWeakObject::release();
+}
+
+css::uno::Any SAL_CALL CCRS_PropertySetInfo::queryInterface( const css::uno::Type & rType )
+{
+    css::uno::Any aRet = cppu::queryInterface( rType,
+                                               static_cast< XTypeProvider* >(this),
+                                               static_cast< XPropertySetInfo* >(this)
+                                               );
+    return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
+}
+
+// XTypeProvider methods.
+
+//list all interfaces exclusive baseclasses
+XTYPEPROVIDER_IMPL_2( CCRS_PropertySetInfo
+                    , XTypeProvider
+                    , XPropertySetInfo
+                    );
+
+// XPropertySetInfo methods.
+
+//virtual
+Sequence< Property > SAL_CALL CCRS_PropertySetInfo
+    ::getProperties()
+{
+    return *m_xProperties;
+}
+
+//virtual
+Property SAL_CALL CCRS_PropertySetInfo
+    ::getPropertyByName( const OUString& aName )
+{
+    Property aProp;
+    if ( impl_queryProperty( aName, aProp ) )
+        return aProp;
+
+    throw UnknownPropertyException(aName);
+}
+
+//virtual
+sal_Bool SAL_CALL CCRS_PropertySetInfo
+    ::hasPropertyByName( const OUString& Name )
+{
+    return ( impl_getPos( Name ) != -1 );
+}
+
+
+// impl_ methods.
+
+
+sal_Int32 CCRS_PropertySetInfo
+            ::impl_getPos( std::u16string_view rName ) const
+{
+    for( sal_Int32 nN = m_xProperties->getLength(); nN--; )
+    {
+        const Property& rMyProp = (*m_xProperties)[nN];
+        if( rMyProp.Name == rName )
+            return nN;
+    }
+    return -1;
+}
+
+bool CCRS_PropertySetInfo
+        ::impl_queryProperty( std::u16string_view rName, Property& rProp ) const
+{
+    for( const Property& rMyProp : std::as_const(*m_xProperties) )
+    {
+        if( rMyProp.Name == rName )
+        {
+            rProp.Name = rMyProp.Name;
+            rProp.Handle = rMyProp.Handle;
+            rProp.Type = rMyProp.Type;
+            rProp.Attributes = rMyProp.Attributes;
+
+            return true;
+        }
+    }
+    return false;
+}
+
+//static
+bool CCRS_PropertySetInfo
+        ::impl_isMyPropertyName( std::u16string_view rPropertyName )
+{
+    return ( rPropertyName == g_sPropertyNameForCount
+    || rPropertyName == g_sPropertyNameForFinalCount
+    || rPropertyName == g_sPropertyNameForFetchSize
+    || rPropertyName == g_sPropertyNameForFetchDirection );
+}
+
+sal_Int32 CCRS_PropertySetInfo
+            ::impl_getRemainedHandle( ) const
+{
+    sal_Int32 nHandle = 1;
+
+    if( !m_xProperties )
+    {
+        OSL_FAIL( "Properties not initialized yet" );
+        return nHandle;
+    }
+    bool bFound = true;
+    while( bFound )
+    {
+        bFound = false;
+        for( const auto & rProp : std::as_const(*m_xProperties) )
+        {
+            if( nHandle == rProp.Handle )
+            {
+                bFound = true;
+                nHandle++;
+                break;
+            }
+        }
+    }
+    return nHandle;
+}
+
+
+
+
+CachedContentResultSet::CachedContentResultSet(
+                  const Reference< XComponentContext > & rxContext
+                , const Reference< XResultSet > & xOrigin
+                , const Reference< XContentIdentifierMapping > &
+                    xContentIdentifierMapping )
+                : ContentResultSetWrapper( xOrigin )
+
+                , m_xContext( rxContext )
+
+                , m_xContentIdentifierMapping( xContentIdentifierMapping )
+                , m_nRow( 0 ) // Position is one-based. Zero means: before first element.
+                , m_bAfterLast( false )
+                , m_nLastAppliedPos( 0 )
+                , m_bAfterLastApplied( false )
+                , m_nKnownCount( 0 )
+                , m_bFinalCount( false )
+                , m_nFetchSize(
+                    COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE )
+                , m_nFetchDirection(
+                    COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION )
+
+                , m_bLastReadWasFromCache( false )
+                , m_bLastCachedReadWasNull( true )
+                , m_aCache( m_xContentIdentifierMapping )
+                , m_aCacheContentIdentifierString( m_xContentIdentifierMapping )
+                , m_aCacheContentIdentifier( m_xContentIdentifierMapping )
+                , m_aCacheContent( m_xContentIdentifierMapping )
+                , m_bTriedToGetTypeConverter( false )
+{
+    m_xFetchProvider.set( m_xResultSetOrigin, UNO_QUERY );
+    OSL_ENSURE( m_xFetchProvider.is(), "interface XFetchProvider is required" );
+
+    m_xFetchProviderForContentAccess.set( m_xResultSetOrigin, UNO_QUERY );
+    OSL_ENSURE( m_xFetchProviderForContentAccess.is(), "interface XFetchProviderForContentAccess is required" );
+
+    impl_init();
+};
+
+CachedContentResultSet::~CachedContentResultSet()
+{
+    impl_deinit();
+    //do not delete m_pMyPropSetInfo, cause it is hold via reference
+};
+
+
+// impl_ methods.
+
+
+bool CachedContentResultSet
+    ::applyPositionToOrigin( sal_Int32 nRow )
+{
+    impl_EnsureNotDisposed();
+
+    /**
+    @returns
+        <TRUE/> if the cursor is on a valid row; <FALSE/> if it is off
+        the result set.
+    */
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    OSL_ENSURE( nRow >= 0, "only positive values supported" );
+    if( !m_xResultSetOrigin.is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        return false;
+    }
+//  OSL_ENSURE( nRow <= m_nKnownCount, "don't step into regions you don't know with this method" );
+
+    sal_Int32 nLastAppliedPos = m_nLastAppliedPos;
+    bool bAfterLastApplied = m_bAfterLastApplied;
+    bool bAfterLast = m_bAfterLast;
+    sal_Int32 nForwardOnly = m_nForwardOnly;
+
+    aGuard.clear();
+
+    if( bAfterLastApplied || nLastAppliedPos != nRow )
+    {
+        if( nForwardOnly == 1 )
+        {
+            if( bAfterLastApplied || bAfterLast || !nRow || nRow < nLastAppliedPos )
+                throw SQLException();
+
+            sal_Int32 nN = nRow - nLastAppliedPos;
+            sal_Int32 nM;
+            for( nM = 0; nN--; nM++ )
+            {
+                if( !m_xResultSetOrigin->next() )
+                    break;
+            }
+
+            aGuard.reset();
+            m_nLastAppliedPos += nM;
+            m_bAfterLastApplied = nRow != m_nLastAppliedPos;
+            return nRow == m_nLastAppliedPos;
+        }
+
+        if( !nRow ) //absolute( 0 ) will throw exception
+        {
+            m_xResultSetOrigin->beforeFirst();
+
+            aGuard.reset();
+            m_nLastAppliedPos = 0;
+            m_bAfterLastApplied = false;
+            return false;
+        }
+        try
+        {
+            //move absolute, if !nLastAppliedPos
+            //because move relative would throw exception
+            if( !nLastAppliedPos || bAfterLast || bAfterLastApplied )
+            {
+                bool bValid = m_xResultSetOrigin->absolute( nRow );
+
+                aGuard.reset();
+                m_nLastAppliedPos = nRow;
+                m_bAfterLastApplied = !bValid;
+                return bValid;
+            }
+            else
+            {
+                bool bValid = m_xResultSetOrigin->relative( nRow - nLastAppliedPos );
+
+                aGuard.reset();
+                m_nLastAppliedPos += ( nRow - nLastAppliedPos );
+                m_bAfterLastApplied = !bValid;
+                return bValid;
+            }
+        }
+        catch (const SQLException&)
+        {
+            if( !bAfterLastApplied && !bAfterLast && nRow > nLastAppliedPos && impl_isForwardOnly() )
+            {
+                sal_Int32 nN = nRow - nLastAppliedPos;
+                sal_Int32 nM;
+                for( nM = 0; nN--; nM++ )
+                {
+                    if( !m_xResultSetOrigin->next() )
+                        break;
+                }
+
+                aGuard.reset();
+                m_nLastAppliedPos += nM;
+                m_bAfterLastApplied = nRow != m_nLastAppliedPos;
+            }
+            else
+                throw;
+        }
+
+        return nRow == m_nLastAppliedPos;
+    }
+    return true;
+};
+
+
+//define for fetching data
+
+
+#define FETCH_XXX( aCache, fetchInterface, fetchMethod )            \
+bool bDirection = !!(                                           \
+    nFetchDirection != FetchDirection::REVERSE );                   \
+FetchResult aResult =                                               \
+    fetchInterface->fetchMethod( nRow, nFetchSize, bDirection );    \
+osl::ClearableGuard< osl::Mutex > aGuard2( m_aMutex );              \
+aCache.loadData( aResult );                                         \
+sal_Int32 nMax = aCache.getMaxRow();                                \
+sal_Int32 nCurCount = m_nKnownCount;                                \
+bool bIsFinalCount = aCache.hasKnownLast();                     \
+bool bCurIsFinalCount = m_bFinalCount;                          \
+aGuard2.clear();                                                    \
+if( nMax > nCurCount )                                              \
+    impl_changeRowCount( nCurCount, nMax );                         \
+if( bIsFinalCount && !bCurIsFinalCount )                            \
+    impl_changeIsRowCountFinal( bCurIsFinalCount, bIsFinalCount );
+
+void CachedContentResultSet
+    ::impl_fetchData( sal_Int32 nRow
+        , sal_Int32 nFetchSize, sal_Int32 nFetchDirection )
+{
+    FETCH_XXX( m_aCache, m_xFetchProvider, fetch );
+}
+
+void CachedContentResultSet
+    ::impl_changeRowCount( sal_Int32 nOld, sal_Int32 nNew )
+{
+    OSL_ENSURE( nNew > nOld, "RowCount only can grow" );
+    if( nNew <= nOld )
+        return;
+
+    //create PropertyChangeEvent and set value
+    PropertyChangeEvent aEvt;
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aEvt.Source =  static_cast< XPropertySet * >( this );
+        aEvt.Further = false;
+        aEvt.OldValue <<= nOld;
+        aEvt.NewValue <<= nNew;
+
+        m_nKnownCount = nNew;
+    }
+
+    //send PropertyChangeEvent to listeners
+    impl_notifyPropertyChangeListeners( aEvt );
+}
+
+void CachedContentResultSet
+    ::impl_changeIsRowCountFinal( bool bOld, bool bNew )
+{
+    OSL_ENSURE( !bOld && bNew, "This change is not allowed for IsRowCountFinal" );
+    if( bOld || !bNew )
+        return;
+
+    //create PropertyChangeEvent and set value
+    PropertyChangeEvent aEvt;
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aEvt.Source =  static_cast< XPropertySet * >( this );
+        aEvt.Further = false;
+        aEvt.OldValue <<= bOld;
+        aEvt.NewValue <<= bNew;
+
+        m_bFinalCount = bNew;
+    }
+
+    //send PropertyChangeEvent to listeners
+    impl_notifyPropertyChangeListeners( aEvt );
+}
+
+bool CachedContentResultSet
+    ::impl_isKnownValidPosition( sal_Int32 nRow ) const
+{
+    return m_nKnownCount && nRow
+            && nRow <= m_nKnownCount;
+}
+
+bool CachedContentResultSet
+    ::impl_isKnownInvalidPosition( sal_Int32 nRow ) const
+{
+    if( !nRow )
+        return true;
+    if( !m_bFinalCount )
+        return false;
+    return nRow > m_nKnownCount;
+}
+
+
+//virtual
+void CachedContentResultSet
+    ::impl_initPropertySetInfo()
+{
+    ContentResultSetWrapper::impl_initPropertySetInfo();
+
+    osl::Guard< osl::Mutex > aGuard( m_aMutex );
+    if( m_xMyPropertySetInfo.is() )
+        return;
+    m_xMyPropertySetInfo = new CCRS_PropertySetInfo( m_xPropertySetInfo );
+    m_xPropertySetInfo = m_xMyPropertySetInfo.get();
+}
+
+
+// XInterface methods.
+void SAL_CALL CachedContentResultSet::acquire()
+    noexcept
+{
+    OWeakObject::acquire();
+}
+
+void SAL_CALL CachedContentResultSet::release()
+    noexcept
+{
+    OWeakObject::release();
+}
+
+Any SAL_CALL CachedContentResultSet
+    ::queryInterface( const Type&  rType )
+{
+    //list all interfaces inclusive baseclasses of interfaces
+
+    Any aRet = ContentResultSetWrapper::queryInterface( rType );
+    if( aRet.hasValue() )
+        return aRet;
+
+    aRet = cppu::queryInterface( rType,
+                static_cast< XTypeProvider* >( this ),
+                static_cast< XServiceInfo* >( this ) );
+
+    return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
+}
+
+
+// XTypeProvider methods.
+
+//list all interfaces exclusive baseclasses
+XTYPEPROVIDER_IMPL_11( CachedContentResultSet
+                    , XTypeProvider
+                    , XServiceInfo
+                    , XComponent
+                    , XCloseable
+                    , XResultSetMetaDataSupplier
+                    , XPropertySet
+
+                    , XPropertyChangeListener
+                    , XVetoableChangeListener
+
+                    , XContentAccess
+
+                    , XResultSet
+                    , XRow );
+
+
+// XServiceInfo methods.
+
+OUString SAL_CALL CachedContentResultSet::getImplementationName()
+{
+    return "com.sun.star.comp.ucb.CachedContentResultSet";
+}
+
+sal_Bool SAL_CALL CachedContentResultSet::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName );
+}
+
+css::uno::Sequence< OUString > SAL_CALL CachedContentResultSet::getSupportedServiceNames()
+{
+    return { "com.sun.star.ucb.CachedContentResultSet" };
+}
+
+
+
+// XPropertySet methods. ( inherited )
+
+
+// virtual
+void SAL_CALL CachedContentResultSet
+    ::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
+{
+    impl_EnsureNotDisposed();
+
+    if( !getPropertySetInfo().is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        throw UnknownPropertyException();
+    }
+
+    Property aProp = m_xMyPropertySetInfo->getPropertyByName( aPropertyName );
+        //throws UnknownPropertyException, if so
+
+    if( aProp.Attributes & PropertyAttribute::READONLY )
+    {
+        //It is assumed, that the properties
+        //'RowCount' and 'IsRowCountFinal' are readonly!
+        throw IllegalArgumentException();
+    }
+    if( aProp.Name == g_sPropertyNameForFetchDirection )
+    {
+        //check value
+        sal_Int32 nNew;
+        if( !( aValue >>= nNew ) )
+        {
+            throw IllegalArgumentException();
+        }
+
+        if( nNew == FetchDirection::UNKNOWN )
+        {
+            nNew = COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION;
+        }
+        else if( nNew != FetchDirection::FORWARD && nNew != FetchDirection::REVERSE )
+        {
+            throw IllegalArgumentException();
+        }
+
+        //create PropertyChangeEvent and set value
+        PropertyChangeEvent aEvt;
+        {
+            osl::Guard< osl::Mutex > aGuard( m_aMutex );
+            aEvt.Source =  static_cast< XPropertySet * >( this );
+            aEvt.PropertyName = aPropertyName;
+            aEvt.Further = false;
+            aEvt.PropertyHandle = m_xMyPropertySetInfo->
+                                    m_nFetchDirectionPropertyHandle;
+            aEvt.OldValue <<= m_nFetchDirection;
+            aEvt.NewValue <<= nNew;
+
+            m_nFetchDirection = nNew;
+        }
+
+        //send PropertyChangeEvent to listeners
+        impl_notifyPropertyChangeListeners( aEvt );
+    }
+    else if( aProp.Name == g_sPropertyNameForFetchSize )
+    {
+        //check value
+        sal_Int32 nNew;
+        if( !( aValue >>= nNew ) )
+        {
+            throw IllegalArgumentException();
+        }
+
+        if( nNew < 0 )
+        {
+            nNew = COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE;
+        }
+
+        //create PropertyChangeEvent and set value
+        PropertyChangeEvent aEvt;
+        {
+            osl::Guard< osl::Mutex > aGuard( m_aMutex );
+            aEvt.Source =  static_cast< XPropertySet * >( this );
+            aEvt.PropertyName = aPropertyName;
+            aEvt.Further = false;
+            aEvt.PropertyHandle = m_xMyPropertySetInfo->
+                                    m_nFetchSizePropertyHandle;
+            aEvt.OldValue <<= m_nFetchSize;
+            aEvt.NewValue <<= nNew;
+
+            m_nFetchSize = nNew;
+        }
+
+        //send PropertyChangeEvent to listeners
+        impl_notifyPropertyChangeListeners( aEvt );
+    }
+    else
+    {
+        impl_init_xPropertySetOrigin();
+        {
+            osl::Guard< osl::Mutex > aGuard( m_aMutex );
+            if( !m_xPropertySetOrigin.is() )
+            {
+                OSL_FAIL( "broadcaster was disposed already" );
+                return;
+            }
+        }
+        m_xPropertySetOrigin->setPropertyValue( aPropertyName, aValue );
+    }
+}
+
+
+// virtual
+Any SAL_CALL CachedContentResultSet
+    ::getPropertyValue( const OUString& rPropertyName )
+{
+    impl_EnsureNotDisposed();
+
+    if( !getPropertySetInfo().is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        throw UnknownPropertyException();
+    }
+
+    m_xMyPropertySetInfo->getPropertyByName( rPropertyName );
+        //throws UnknownPropertyException, if so
+
+    Any aValue;
+    if( rPropertyName == g_sPropertyNameForCount )
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aValue <<= m_nKnownCount;
+    }
+    else if( rPropertyName == g_sPropertyNameForFinalCount )
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aValue <<= m_bFinalCount;
+    }
+    else if( rPropertyName == g_sPropertyNameForFetchSize )
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aValue <<= m_nFetchSize;
+    }
+    else if( rPropertyName == g_sPropertyNameForFetchDirection )
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        aValue <<= m_nFetchDirection;
+    }
+    else
+    {
+        impl_init_xPropertySetOrigin();
+        {
+            osl::Guard< osl::Mutex > aGuard( m_aMutex );
+            if( !m_xPropertySetOrigin.is() )
+            {
+                OSL_FAIL( "broadcaster was disposed already" );
+                throw UnknownPropertyException();
+            }
+        }
+        aValue = m_xPropertySetOrigin->getPropertyValue( rPropertyName );
+    }
+    return aValue;
+}
+
+
+// own methods.  ( inherited )
+
+
+//virtual
+void CachedContentResultSet
+    ::impl_disposing( const EventObject& rEventObject )
+{
+    {
+        impl_EnsureNotDisposed();
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        //release all references to the broadcaster:
+        m_xFetchProvider.clear();
+        m_xFetchProviderForContentAccess.clear();
+    }
+    ContentResultSetWrapper::impl_disposing( rEventObject );
+}
+
+//virtual
+void CachedContentResultSet
+    ::impl_propertyChange( const PropertyChangeEvent& rEvt )
+{
+    impl_EnsureNotDisposed();
+
+    PropertyChangeEvent aEvt( rEvt );
+    aEvt.Source = static_cast< XPropertySet * >( this );
+    aEvt.Further = false;
+
+
+    if( CCRS_PropertySetInfo
+            ::impl_isMyPropertyName( rEvt.PropertyName ) )
+    {
+        //don't notify foreign events on fetchsize and fetchdirection
+        if( aEvt.PropertyName == g_sPropertyNameForFetchSize
+        || aEvt.PropertyName == g_sPropertyNameForFetchDirection )
+            return;
+
+        //adjust my props 'RowCount' and 'IsRowCountFinal'
+        if( aEvt.PropertyName == g_sPropertyNameForCount )
+        {//RowCount changed
+
+            //check value
+            sal_Int32 nNew = 0;
+            if( !( aEvt.NewValue >>= nNew ) )
+            {
+                OSL_FAIL( "PropertyChangeEvent contains wrong data" );
+                return;
+            }
+
+            impl_changeRowCount( m_nKnownCount, nNew );
+        }
+        else if( aEvt.PropertyName == g_sPropertyNameForFinalCount )
+        {//IsRowCountFinal changed
+
+            //check value
+            bool bNew = false;
+            if( !( aEvt.NewValue >>= bNew ) )
+            {
+                OSL_FAIL( "PropertyChangeEvent contains wrong data" );
+                return;
+            }
+            impl_changeIsRowCountFinal( m_bFinalCount, bNew );
+        }
+        return;
+    }
+
+
+    impl_notifyPropertyChangeListeners( aEvt );
+}
+
+
+//virtual
+void CachedContentResultSet
+    ::impl_vetoableChange( const PropertyChangeEvent& rEvt )
+{
+    impl_EnsureNotDisposed();
+
+    //don't notify events on my properties, cause they are not vetoable
+    if( CCRS_PropertySetInfo
+            ::impl_isMyPropertyName( rEvt.PropertyName ) )
+    {
+        return;
+    }
+
+
+    PropertyChangeEvent aEvt( rEvt );
+    aEvt.Source = static_cast< XPropertySet * >( this );
+    aEvt.Further = false;
+
+    impl_notifyVetoableChangeListeners( aEvt );
+}
+
+
+// XContentAccess methods. ( inherited ) ( -- position dependent )
+
+
+#define XCONTENTACCESS_queryXXX( queryXXX, XXX, TYPE )      \
+impl_EnsureNotDisposed();                                   \
+osl::ResettableMutexGuard aGuard(m_aMutex);                 \
+sal_Int32 nRow = m_nRow;                                    \
+sal_Int32 nFetchSize = m_nFetchSize;                        \
+sal_Int32 nFetchDirection = m_nFetchDirection;              \
+if( !m_aCache##XXX.hasRow( nRow ) )                         \
+{                                                           \
+    try                                                     \
+    {                                                       \
+        bool isCleared = false;                             \
+        if( !m_aCache##XXX.hasCausedException( nRow ) )     \
+        {                                                   \
+            if( !m_xFetchProviderForContentAccess.is() )    \
+            {                                               \
+                OSL_FAIL( "broadcaster was disposed already" ); \
+                throw RuntimeException();                   \
+            }                                               \
+            aGuard.clear();                                 \
+            isCleared = true;                               \
+            if( impl_isForwardOnly() )                      \
+                applyPositionToOrigin( nRow );              \
+                                                            \
+            FETCH_XXX( m_aCache##XXX, m_xFetchProviderForContentAccess, fetch##XXX##s ); \
+        }                                                   \
+        if (isCleared)                                      \
+        {                                                   \
+            aGuard.reset();                                 \
+        }                                                   \
+        if( !m_aCache##XXX.hasRow( nRow ) )                 \
+        {                                                   \
+            aGuard.clear();                                 \
+            applyPositionToOrigin( nRow );                  \
+            TYPE aRet = ContentResultSetWrapper::queryXXX();\
+            if( m_xContentIdentifierMapping.is() )          \
+                return m_xContentIdentifierMapping->map##XXX( aRet );\
+            return aRet;                                    \
+        }                                                   \
+    }                                                       \
+    catch (const RuntimeException&)                         \
+    {                                                       \
+        throw;                                              \
+    }                                                       \
+    catch (const Exception& e)                              \
+    {                                                       \
+        Any a(cppu::getCaughtException());                  \
+        throw WrappedTargetRuntimeException(                \
+            "wrapped Exception " + e.Message,               \
+            Reference<XInterface>(), a);                    \
+    }                                                       \
+}                                                           \
+return m_aCache##XXX.get##XXX( nRow );
+
+// virtual
+OUString SAL_CALL CachedContentResultSet
+    ::queryContentIdentifierString()
+{
+    XCONTENTACCESS_queryXXX( queryContentIdentifierString, ContentIdentifierString, OUString )
+}
+
+
+// virtual
+Reference< XContentIdentifier > SAL_CALL CachedContentResultSet
+    ::queryContentIdentifier()
+{
+    XCONTENTACCESS_queryXXX( queryContentIdentifier, ContentIdentifier, Reference< XContentIdentifier > )
+}
+
+
+// virtual
+Reference< XContent > SAL_CALL CachedContentResultSet
+    ::queryContent()
+{
+    XCONTENTACCESS_queryXXX( queryContent, Content, Reference< XContent > )
+}
+
+
+// XResultSet methods. ( inherited )
+
+//virtual
+
+sal_Bool SAL_CALL CachedContentResultSet
+    ::next()
+{
+    impl_EnsureNotDisposed();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    //after last
+    if( m_bAfterLast )
+        return false;
+    //last
+    aGuard.clear();
+    if( isLast() )
+    {
+        aGuard.reset();
+        m_nRow++;
+        m_bAfterLast = true;
+        return false;
+    }
+    aGuard.reset();
+    //known valid position
+    if( impl_isKnownValidPosition( m_nRow + 1 ) )
+    {
+        m_nRow++;
+        return true;
+    }
+
+    //unknown position
+    sal_Int32 nRow = m_nRow;
+    aGuard.clear();
+
+    bool bValid = applyPositionToOrigin( nRow + 1 );
+
+    aGuard.reset();
+    m_nRow = nRow + 1;
+    m_bAfterLast = !bValid;
+    return bValid;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::previous()
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    //before first ?:
+    if( !m_bAfterLast && !m_nRow )
+        return false;
+    //first ?:
+    if( !m_bAfterLast && m_nKnownCount && m_nRow == 1 )
+    {
+        m_nRow--;
+        m_bAfterLast = false;
+        return false;
+    }
+    //known valid position ?:
+    if( impl_isKnownValidPosition( m_nRow - 1 ) )
+    {
+        m_nRow--;
+        m_bAfterLast = false;
+        return true;
+    }
+    //unknown position:
+    sal_Int32 nRow = m_nRow;
+    aGuard.clear();
+
+    bool bValid = applyPositionToOrigin( nRow - 1  );
+
+    aGuard.reset();
+    m_nRow = nRow - 1;
+    m_bAfterLast = false;
+    return bValid;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::absolute( sal_Int32 row )
+{
+    impl_EnsureNotDisposed();
+
+    if( !row )
+        throw SQLException();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+
+    if( !m_xResultSetOrigin.is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        return false;
+    }
+    if( row < 0 )
+    {
+        if( m_bFinalCount )
+        {
+            sal_Int32 nNewRow = m_nKnownCount + 1 + row;
+            bool bValid = true;
+            if( nNewRow <= 0 )
+            {
+                nNewRow = 0;
+                bValid = false;
+            }
+            m_nRow = nNewRow;
+            m_bAfterLast = false;
+            return bValid;
+        }
+        //unknown final count:
+        aGuard.clear();
+
+        bool bValid = m_xResultSetOrigin->absolute( row );
+
+        aGuard.reset();
+        if( m_bFinalCount )
+        {
+            sal_Int32 nNewRow = m_nKnownCount + 1 + row;
+            if( nNewRow < 0 )
+                nNewRow = 0;
+            m_nLastAppliedPos = nNewRow;
+            m_nRow = nNewRow;
+            m_bAfterLastApplied = m_bAfterLast = false;
+            return bValid;
+        }
+        aGuard.clear();
+
+        sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
+
+        aGuard.reset();
+        m_nLastAppliedPos = nCurRow;
+        m_nRow = nCurRow;
+        m_bAfterLast = false;
+        return nCurRow != 0;
+    }
+    //row > 0:
+    if( m_bFinalCount )
+    {
+        if( row > m_nKnownCount )
+        {
+            m_nRow = m_nKnownCount + 1;
+            m_bAfterLast = true;
+            return false;
+        }
+        m_nRow = row;
+        m_bAfterLast = false;
+        return true;
+    }
+    //unknown new position:
+    aGuard.clear();
+
+    bool bValid = m_xResultSetOrigin->absolute( row );
+
+    aGuard.reset();
+    if( m_bFinalCount )
+    {
+        sal_Int32 nNewRow = row;
+        if( nNewRow > m_nKnownCount )
+        {
+            nNewRow = m_nKnownCount + 1;
+            m_bAfterLastApplied = m_bAfterLast = true;
+        }
+        else
+            m_bAfterLastApplied = m_bAfterLast = false;
+
+        m_nLastAppliedPos = nNewRow;
+        m_nRow = nNewRow;
+        return bValid;
+    }
+    aGuard.clear();
+
+    sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
+    bool bIsAfterLast = m_xResultSetOrigin->isAfterLast();
+
+    aGuard.reset();
+    m_nLastAppliedPos = nCurRow;
+    m_nRow = nCurRow;
+    m_bAfterLastApplied = m_bAfterLast = bIsAfterLast;
+    return nCurRow && !bIsAfterLast;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::relative( sal_Int32 rows )
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    if( m_bAfterLast || impl_isKnownInvalidPosition( m_nRow ) )
+        throw SQLException();
+
+    if( !rows )
+        return true;
+
+    sal_Int32 nNewRow = m_nRow + rows;
+    if( nNewRow < 0 )
+            nNewRow = 0;
+
+    if( impl_isKnownValidPosition( nNewRow ) )
+    {
+        m_nRow = nNewRow;
+        m_bAfterLast = false;
+        return true;
+    }
+    else
+    {
+        //known invalid new position:
+        if( nNewRow == 0 )
+        {
+            m_bAfterLast = false;
+            m_nRow = 0;
+            return false;
+        }
+        if( m_bFinalCount && nNewRow > m_nKnownCount )
+        {
+            m_bAfterLast = true;
+            m_nRow = m_nKnownCount + 1;
+            return false;
+        }
+        //unknown new position:
+        aGuard.clear();
+        bool bValid = applyPositionToOrigin( nNewRow );
+
+        aGuard.reset();
+        m_nRow = nNewRow;
+        m_bAfterLast = !bValid; // only nNewRow > 0 possible here
+        return bValid;
+    }
+}
+
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::first()
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    if( impl_isKnownValidPosition( 1 ) )
+    {
+        m_nRow = 1;
+        m_bAfterLast = false;
+        return true;
+    }
+    if( impl_isKnownInvalidPosition( 1 ) )
+    {
+        m_nRow = 1;
+        m_bAfterLast = false;
+        return false;
+    }
+    //unknown position
+    aGuard.clear();
+
+    bool bValid = applyPositionToOrigin( 1 );
+
+    aGuard.reset();
+    m_nRow = 1;
+    m_bAfterLast = false;
+    return bValid;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::last()
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    if( m_bFinalCount )
+    {
+        m_nRow = m_nKnownCount;
+        m_bAfterLast = false;
+        return m_nKnownCount != 0;
+    }
+    //unknown position
+    if( !m_xResultSetOrigin.is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        return false;
+    }
+    aGuard.clear();
+
+    bool bValid = m_xResultSetOrigin->last();
+
+    aGuard.reset();
+    m_bAfterLastApplied = m_bAfterLast = false;
+    if( m_bFinalCount )
+    {
+        m_nLastAppliedPos = m_nKnownCount;
+        m_nRow = m_nKnownCount;
+        return bValid;
+    }
+    aGuard.clear();
+
+    sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
+
+    aGuard.reset();
+    m_nLastAppliedPos = nCurRow;
+    m_nRow = nCurRow;
+    OSL_ENSURE( nCurRow >= m_nKnownCount, "position of last row < known Count, that could not be" );
+    m_nKnownCount = nCurRow;
+    m_bFinalCount = true;
+    return nCurRow != 0;
+}
+
+//virtual
+void SAL_CALL CachedContentResultSet
+    ::beforeFirst()
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::Guard< osl::Mutex > aGuard( m_aMutex );
+    m_nRow = 0;
+    m_bAfterLast = false;
+}
+
+//virtual
+void SAL_CALL CachedContentResultSet
+    ::afterLast()
+{
+    impl_EnsureNotDisposed();
+
+    if( impl_isForwardOnly() )
+        throw SQLException();
+
+    osl::Guard< osl::Mutex > aGuard( m_aMutex );
+    m_nRow = 1;
+    m_bAfterLast = true;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::isAfterLast()
+{
+    impl_EnsureNotDisposed();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    if( !m_bAfterLast )
+        return false;
+    if( m_nKnownCount )
+        return m_bAfterLast;
+    if( m_bFinalCount )
+        return false;
+
+    if( !m_xResultSetOrigin.is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        return false;
+    }
+    aGuard.clear();
+
+    //find out whether the original resultset contains rows or not
+    m_xResultSetOrigin->afterLast();
+
+    aGuard.reset();
+    m_bAfterLastApplied = true;
+    aGuard.clear();
+
+    return m_xResultSetOrigin->isAfterLast();
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::isBeforeFirst()
+{
+    impl_EnsureNotDisposed();
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    if( m_bAfterLast )
+        return false;
+    if( m_nRow )
+        return false;
+    if( m_nKnownCount )
+        return true;
+    if( m_bFinalCount )
+        return false;
+
+    if( !m_xResultSetOrigin.is() )
+    {
+        OSL_FAIL( "broadcaster was disposed already" );
+        return false;
+    }
+    aGuard.clear();
+
+    //find out whether the original resultset contains rows or not
+    m_xResultSetOrigin->beforeFirst();
+
+    aGuard.reset();
+    m_bAfterLastApplied = false;
+    m_nLastAppliedPos = 0;
+    aGuard.clear();
+
+    return m_xResultSetOrigin->isBeforeFirst();
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::isFirst()
+{
+    impl_EnsureNotDisposed();
+
+    sal_Int32 nRow = 0;
+    Reference< XResultSet > xResultSetOrigin;
+
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        if( m_bAfterLast )
+            return false;
+        if( m_nRow != 1 )
+            return false;
+        if( m_nKnownCount )
+            return true;
+        if( m_bFinalCount )
+            return false;
+
+        nRow = m_nRow;
+        xResultSetOrigin = m_xResultSetOrigin;
+    }
+
+    //need to ask origin
+    {
+        if( applyPositionToOrigin( nRow ) )
+            return xResultSetOrigin->isFirst();
+        else
+            return false;
+    }
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::isLast()
+{
+    impl_EnsureNotDisposed();
+
+    sal_Int32 nRow = 0;
+    Reference< XResultSet > xResultSetOrigin;
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        if( m_bAfterLast )
+            return false;
+        if( m_nRow < m_nKnownCount )
+            return false;
+        if( m_bFinalCount )
+            return m_nKnownCount && m_nRow == m_nKnownCount;
+
+        nRow = m_nRow;
+        xResultSetOrigin = m_xResultSetOrigin;
+    }
+
+    //need to ask origin
+    {
+        if( applyPositionToOrigin( nRow ) )
+            return xResultSetOrigin->isLast();
+        else
+            return false;
+    }
+}
+
+
+//virtual
+sal_Int32 SAL_CALL CachedContentResultSet
+    ::getRow()
+{
+    impl_EnsureNotDisposed();
+
+    osl::Guard< osl::Mutex > aGuard( m_aMutex );
+    if( m_bAfterLast )
+        return 0;
+    return m_nRow;
+}
+
+//virtual
+void SAL_CALL CachedContentResultSet
+    ::refreshRow()
+{
+    impl_EnsureNotDisposed();
+
+    //the ContentResultSet is static and will not change
+    //therefore we don't need to reload anything
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::rowUpdated()
+{
+    impl_EnsureNotDisposed();
+
+    //the ContentResultSet is static and will not change
+    return false;
+}
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::rowInserted()
+{
+    impl_EnsureNotDisposed();
+
+    //the ContentResultSet is static and will not change
+    return false;
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::rowDeleted()
+{
+    impl_EnsureNotDisposed();
+
+    //the ContentResultSet is static and will not change
+    return false;
+}
+
+//virtual
+Reference< XInterface > SAL_CALL CachedContentResultSet
+    ::getStatement()
+{
+    impl_EnsureNotDisposed();
+    //@todo ?return anything
+    return Reference< XInterface >();
+}
+
+
+// XRow methods. ( inherited )
+
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::wasNull()
+{
+    impl_EnsureNotDisposed();
+    impl_init_xRowOrigin();
+    {
+        osl::Guard< osl::Mutex > aGuard( m_aMutex );
+        if( m_bLastReadWasFromCache )
+            return m_bLastCachedReadWasNull;
+        if( !m_xRowOrigin.is() )
+        {
+            OSL_FAIL( "broadcaster was disposed already" );
+            return false;
+        }
+    }
+    return m_xRowOrigin->wasNull();
+}
+
+//virtual
+OUString SAL_CALL CachedContentResultSet
+    ::getString( sal_Int32 columnIndex )
+{
+    return rowOriginGet<OUString>(&css::sdbc::XRow::getString, columnIndex);
+}
+
+//virtual
+sal_Bool SAL_CALL CachedContentResultSet
+    ::getBoolean( sal_Int32 columnIndex )
+{
+    return rowOriginGet<sal_Bool>(&css::sdbc::XRow::getBoolean, columnIndex);
+}
+
+//virtual
+sal_Int8 SAL_CALL CachedContentResultSet
+    ::getByte( sal_Int32 columnIndex )
+{
+    return rowOriginGet<sal_Int8>(&css::sdbc::XRow::getByte, columnIndex);
+}
+
+//virtual
+sal_Int16 SAL_CALL CachedContentResultSet
+    ::getShort( sal_Int32 columnIndex )
+{
+    return rowOriginGet<sal_Int16>(&css::sdbc::XRow::getShort, columnIndex);
+}
+
+//virtual
+sal_Int32 SAL_CALL CachedContentResultSet
+    ::getInt( sal_Int32 columnIndex )
+{
+    return rowOriginGet<sal_Int32>(&css::sdbc::XRow::getInt, columnIndex);
+}
+
+//virtual
+sal_Int64 SAL_CALL CachedContentResultSet
+    ::getLong( sal_Int32 columnIndex )
+{
+    return rowOriginGet<sal_Int64>(&css::sdbc::XRow::getLong, columnIndex);
+}
+
+//virtual
+float SAL_CALL CachedContentResultSet
+    ::getFloat( sal_Int32 columnIndex )
+{
+    return rowOriginGet<float>(&css::sdbc::XRow::getFloat, columnIndex);
+}
+
+//virtual
+double SAL_CALL CachedContentResultSet
+    ::getDouble( sal_Int32 columnIndex )
+{
+    return rowOriginGet<double>(&css::sdbc::XRow::getDouble, columnIndex);
+}
+
+//virtual
+Sequence< sal_Int8 > SAL_CALL CachedContentResultSet
+    ::getBytes( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Sequence<sal_Int8> >(
+        &css::sdbc::XRow::getBytes, columnIndex);
+}
+
+//virtual
+Date SAL_CALL CachedContentResultSet
+    ::getDate( sal_Int32 columnIndex )
+{
+    return rowOriginGet<css::util::Date>(
+        &css::sdbc::XRow::getDate, columnIndex);
+}
+
+//virtual
+Time SAL_CALL CachedContentResultSet
+    ::getTime( sal_Int32 columnIndex )
+{
+    return rowOriginGet<css::util::Time>(
+        &css::sdbc::XRow::getTime, columnIndex);
+}
+
+//virtual
+DateTime SAL_CALL CachedContentResultSet
+    ::getTimestamp( sal_Int32 columnIndex )
+{
+    return rowOriginGet<css::util::DateTime>(
+        &css::sdbc::XRow::getTimestamp, columnIndex);
+}
+
+//virtual
+Reference< css::io::XInputStream >
+    SAL_CALL CachedContentResultSet
+    ::getBinaryStream( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::io::XInputStream> >(
+        &css::sdbc::XRow::getBinaryStream, columnIndex);
+}
+
+//virtual
+Reference< css::io::XInputStream >
+    SAL_CALL CachedContentResultSet
+    ::getCharacterStream( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::io::XInputStream> >(
+        &css::sdbc::XRow::getCharacterStream, columnIndex);
+}
+
+//virtual
+Any SAL_CALL CachedContentResultSet
+    ::getObject( sal_Int32 columnIndex,
+           const Reference<
+            css::container::XNameAccess >& typeMap )
+{
+    //if you change this function please pay attention to
+    //function template rowOriginGet, where this is similar implemented
+
+    osl::ResettableMutexGuard aGuard(m_aMutex);
+    sal_Int32 nRow = m_nRow;
+    sal_Int32 nFetchSize = m_nFetchSize;
+    sal_Int32 nFetchDirection = m_nFetchDirection;
+    if( !m_aCache.hasRow( nRow ) )
+    {
+        bool isCleared = false;
+        if( !m_aCache.hasCausedException( nRow ) )
+        {
+            if( !m_xFetchProvider.is() )
+            {
+                OSL_FAIL( "broadcaster was disposed already" );
+                return Any();
+            }
+            isCleared = true;
+            aGuard.clear();
+
+            impl_fetchData( nRow, nFetchSize, nFetchDirection );
+        }
+        if (isCleared)
+        {
+            aGuard.reset();
+        }
+        if( !m_aCache.hasRow( nRow ) )
+        {
+            m_bLastReadWasFromCache = false;
+            aGuard.clear();
+            applyPositionToOrigin( nRow );
+            impl_init_xRowOrigin();
+            return m_xRowOrigin->getObject( columnIndex, typeMap );
+        }
+    }
+    //@todo: pay attention to typeMap
+    const Any& rValue = m_aCache.getAny( nRow, columnIndex );
+    m_bLastReadWasFromCache = true;
+    m_bLastCachedReadWasNull = !rValue.hasValue();
+    return rValue;
+}
+
+//virtual
+Reference< XRef > SAL_CALL CachedContentResultSet
+    ::getRef( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::sdbc::XRef> >(
+        &css::sdbc::XRow::getRef, columnIndex);
+}
+
+//virtual
+Reference< XBlob > SAL_CALL CachedContentResultSet
+    ::getBlob( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::sdbc::XBlob> >(
+        &css::sdbc::XRow::getBlob, columnIndex);
+}
+
+//virtual
+Reference< XClob > SAL_CALL CachedContentResultSet
+    ::getClob( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::sdbc::XClob> >(
+        &css::sdbc::XRow::getClob, columnIndex);
+}
+
+//virtual
+Reference< XArray > SAL_CALL CachedContentResultSet
+    ::getArray( sal_Int32 columnIndex )
+{
+    return rowOriginGet< css::uno::Reference<css::sdbc::XArray> >(
+        &css::sdbc::XRow::getArray, columnIndex);
+}
+
+
+// Type Converter Support
+
+
+const Reference< XTypeConverter >& CachedContentResultSet::getTypeConverter()
+{
+    osl::Guard< osl::Mutex > aGuard( m_aMutex );
+
+    if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() )
+    {
+        m_bTriedToGetTypeConverter = true;
+        m_xTypeConverter.set( Converter::create(m_xContext) );
+
+        OSL_ENSURE( m_xTypeConverter.is(),
+                    "PropertyValueSet::getTypeConverter() - "
+                    "Service 'com.sun.star.script.Converter' n/a!" );
+    }
+    return m_xTypeConverter;
+}
+
+
+
+
+CachedContentResultSetFactory::CachedContentResultSetFactory(
+        const Reference< XComponentContext > & rxContext )
+{
+    m_xContext = rxContext;
+}
+
+CachedContentResultSetFactory::~CachedContentResultSetFactory()
+{
+}
+
+// CachedContentResultSetFactory XServiceInfo methods.
+
+OUString SAL_CALL CachedContentResultSetFactory::getImplementationName()
+{
+    return "com.sun.star.comp.ucb.CachedContentResultSetFactory";
+}
+sal_Bool SAL_CALL CachedContentResultSetFactory::supportsService( const OUString& ServiceName )
+{
+    return cppu::supportsService( this, ServiceName );
+}
+css::uno::Sequence< OUString > SAL_CALL CachedContentResultSetFactory::getSupportedServiceNames()
+{
+    return { "com.sun.star.ucb.CachedContentResultSetFactory" };
+}
+
+// Service factory implementation.
+
+
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+ucb_CachedContentResultSetFactory_get_implementation(
+    css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new CachedContentResultSetFactory(context));
+}
+
+
+// CachedContentResultSetFactory XCachedContentResultSetFactory methods.
+
+
+    //virtual
+Reference< XResultSet > SAL_CALL CachedContentResultSetFactory
+    ::createCachedContentResultSet(
+            const Reference< XResultSet > & xSource,
+            const Reference< XContentIdentifierMapping > & xMapping )
+{
+    Reference< XResultSet > xRet = new CachedContentResultSet( m_xContext, xSource, xMapping );
+    return xRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */