LCOV - code coverage report
Current view: top level - libreoffice/ucb/source/cacher - cachedcontentresultset.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 845 0.0 %
Date: 2012-12-27 Functions: 0 117 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <cachedcontentresultset.hxx>
      22             : #include <com/sun/star/sdbc/FetchDirection.hpp>
      23             : #include <com/sun/star/ucb/FetchError.hpp>
      24             : #include <com/sun/star/ucb/ResultSetException.hpp>
      25             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      26             : #include <com/sun/star/script/Converter.hpp>
      27             : #include <com/sun/star/sdbc/ResultSetType.hpp>
      28             : #include <rtl/ustring.hxx>
      29             : #include <osl/diagnose.h>
      30             : #include <comphelper/processfactory.hxx>
      31             : 
      32             : using namespace com::sun::star::beans;
      33             : using namespace com::sun::star::lang;
      34             : using namespace com::sun::star::script;
      35             : using namespace com::sun::star::sdbc;
      36             : using namespace com::sun::star::ucb;
      37             : using namespace com::sun::star::uno;
      38             : using namespace com::sun::star::util;
      39             : using namespace cppu;
      40             : 
      41             : using ::rtl::OUString;
      42             : 
      43             : #define COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE 256
      44             : #define COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION FetchDirection::FORWARD
      45             : 
      46             : //--------------------------------------------------------------------------
      47             : //--------------------------------------------------------------------------
      48             : //define for getXXX methods of interface XRow
      49             : //--------------------------------------------------------------------------
      50             : //--------------------------------------------------------------------------
      51             : 
      52             : //if you change this macro please pay attention to
      53             : //function ::getObject, where this is similar implemented
      54             : 
      55             : #define XROW_GETXXX( getXXX, Type )                     \
      56             : impl_EnsureNotDisposed();                               \
      57             : ReacquireableGuard aGuard( m_aMutex );                  \
      58             : sal_Int32 nRow = m_nRow;                                \
      59             : sal_Int32 nFetchSize = m_nFetchSize;                    \
      60             : sal_Int32 nFetchDirection = m_nFetchDirection;          \
      61             : if( !m_aCache.hasRow( nRow ) )                          \
      62             : {                                                       \
      63             :     if( !m_aCache.hasCausedException( nRow ) )          \
      64             : {                                                       \
      65             :         if( !m_xFetchProvider.is() )                    \
      66             :         {                                               \
      67             :             OSL_FAIL( "broadcaster was disposed already" ); \
      68             :             throw SQLException();                       \
      69             :         }                                               \
      70             :         aGuard.clear();                                 \
      71             :         if( impl_isForwardOnly() )                      \
      72             :             applyPositionToOrigin( nRow );              \
      73             :                                                         \
      74             :         impl_fetchData( nRow, nFetchSize, nFetchDirection ); \
      75             :     }                                                   \
      76             :     aGuard.reacquire();                                 \
      77             :     if( !m_aCache.hasRow( nRow ) )                      \
      78             :     {                                                   \
      79             :         m_bLastReadWasFromCache = sal_False;            \
      80             :         aGuard.clear();                                 \
      81             :         applyPositionToOrigin( nRow );                  \
      82             :         impl_init_xRowOrigin();                         \
      83             :         return m_xRowOrigin->getXXX( columnIndex );     \
      84             :     }                                                   \
      85             : }                                                       \
      86             : const Any& rValue = m_aCache.getAny( nRow, columnIndex );\
      87             : Type aRet = Type();                                     \
      88             : m_bLastReadWasFromCache = sal_True;                     \
      89             : m_bLastCachedReadWasNull = !( rValue >>= aRet );        \
      90             : /* Last chance. Try type converter service... */        \
      91             : if ( m_bLastCachedReadWasNull && rValue.hasValue() )    \
      92             : {                                                       \
      93             :     Reference< XTypeConverter > xConverter              \
      94             :                                 = getTypeConverter();   \
      95             :     if ( xConverter.is() )                              \
      96             :     {                                                   \
      97             :         try                                             \
      98             :         {                                               \
      99             :             Any aConvAny = xConverter->convertTo(       \
     100             :                 rValue,                                 \
     101             :                 getCppuType( static_cast<               \
     102             :                     const Type * >( 0 ) ) );            \
     103             :             m_bLastCachedReadWasNull = !( aConvAny >>= aRet ); \
     104             :         }                                               \
     105             :         catch (const IllegalArgumentException&)         \
     106             :         {                                               \
     107             :         }                                               \
     108             :         catch (const CannotConvertException&)           \
     109             :         {                                               \
     110             :         }                                               \
     111             :     }                                                   \
     112             : }                                                       \
     113             : return aRet;
     114             : 
     115             : //--------------------------------------------------------------------------
     116             : //--------------------------------------------------------------------------
     117             : // CCRS_Cache methoeds.
     118             : //--------------------------------------------------------------------------
     119             : //--------------------------------------------------------------------------
     120             : 
     121           0 : CachedContentResultSet::CCRS_Cache::CCRS_Cache(
     122             :     const Reference< XContentIdentifierMapping > & xMapping )
     123             :     : m_pResult( NULL )
     124             :     , m_xContentIdentifierMapping( xMapping )
     125           0 :     , m_pMappedReminder( NULL )
     126             : {
     127           0 : }
     128             : 
     129           0 : CachedContentResultSet::CCRS_Cache::~CCRS_Cache()
     130             : {
     131           0 :     delete m_pResult;
     132           0 : }
     133             : 
     134           0 : void SAL_CALL CachedContentResultSet::CCRS_Cache
     135             :     ::clear()
     136             : {
     137           0 :     if( m_pResult )
     138             :     {
     139           0 :         delete m_pResult;
     140           0 :         m_pResult = NULL;
     141             :     }
     142           0 :     clearMappedReminder();
     143           0 : }
     144             : 
     145           0 : void SAL_CALL CachedContentResultSet::CCRS_Cache
     146             :     ::loadData( const FetchResult& rResult )
     147             : {
     148           0 :     clear();
     149           0 :     m_pResult = new FetchResult( rResult );
     150           0 : }
     151             : 
     152           0 : sal_Bool SAL_CALL CachedContentResultSet::CCRS_Cache
     153             :     ::hasRow( sal_Int32 row )
     154             : {
     155           0 :     if( !m_pResult )
     156           0 :         return sal_False;
     157           0 :     long nStart = m_pResult->StartIndex;
     158           0 :     long nEnd = nStart;
     159           0 :     if( m_pResult->Orientation )
     160           0 :         nEnd += m_pResult->Rows.getLength() - 1;
     161             :     else
     162           0 :         nStart -= m_pResult->Rows.getLength() + 1;
     163             : 
     164           0 :     return nStart <= row && row <= nEnd;
     165             : }
     166             : 
     167           0 : sal_Int32 SAL_CALL CachedContentResultSet::CCRS_Cache
     168             :     ::getMaxRow()
     169             : {
     170           0 :     if( !m_pResult )
     171           0 :         return 0;
     172           0 :     long nEnd = m_pResult->StartIndex;
     173           0 :     if( m_pResult->Orientation )
     174           0 :         return nEnd += m_pResult->Rows.getLength() - 1;
     175             :     else
     176           0 :         return nEnd;
     177             : }
     178             : 
     179           0 : sal_Bool SAL_CALL CachedContentResultSet::CCRS_Cache
     180             :     ::hasKnownLast()
     181             : {
     182           0 :     if( !m_pResult )
     183           0 :         return sal_False;
     184             : 
     185           0 :     if( ( m_pResult->FetchError & FetchError::ENDOFDATA )
     186             :         && m_pResult->Orientation
     187           0 :         && m_pResult->Rows.getLength() )
     188           0 :         return sal_True;
     189             : 
     190           0 :     return sal_False;
     191             : }
     192             : 
     193           0 : sal_Bool SAL_CALL CachedContentResultSet::CCRS_Cache
     194             :     ::hasCausedException( sal_Int32 nRow )
     195             : {
     196           0 :     if( !m_pResult )
     197           0 :         return sal_False;
     198           0 :     if( !( m_pResult->FetchError & FetchError::EXCEPTION ) )
     199           0 :         return sal_False;
     200             : 
     201           0 :     long nEnd = m_pResult->StartIndex;
     202           0 :     if( m_pResult->Orientation )
     203           0 :         nEnd += m_pResult->Rows.getLength();
     204             : 
     205           0 :     return nRow == nEnd+1;
     206             : }
     207             : 
     208           0 : Any& SAL_CALL CachedContentResultSet::CCRS_Cache
     209             :     ::getRowAny( sal_Int32 nRow )
     210             :     throw( SQLException,
     211             :     RuntimeException )
     212             : {
     213           0 :     if( !nRow )
     214           0 :         throw SQLException();
     215           0 :     if( !m_pResult )
     216           0 :         throw SQLException();
     217           0 :     if( !hasRow( nRow ) )
     218           0 :         throw SQLException();
     219             : 
     220           0 :     long nDiff = nRow - m_pResult->StartIndex;
     221           0 :     if( nDiff < 0 )
     222           0 :         nDiff *= -1;
     223             : 
     224           0 :     return (m_pResult->Rows)[nDiff];
     225             : }
     226             : 
     227           0 : void SAL_CALL CachedContentResultSet::CCRS_Cache
     228             :     ::remindMapped( sal_Int32 nRow )
     229             : {
     230             :     //remind that this row was mapped
     231           0 :     if( !m_pResult )
     232           0 :         return;
     233           0 :     long nDiff = nRow - m_pResult->StartIndex;
     234           0 :     if( nDiff < 0 )
     235           0 :         nDiff *= -1;
     236           0 :     Sequence< sal_Bool >* pMappedReminder = getMappedReminder();
     237           0 :     if( nDiff < pMappedReminder->getLength() )
     238           0 :         (*pMappedReminder)[nDiff] = sal_True;
     239             : }
     240             : 
     241           0 : sal_Bool SAL_CALL CachedContentResultSet::CCRS_Cache
     242             :     ::isRowMapped( sal_Int32 nRow )
     243             : {
     244           0 :     if( !m_pMappedReminder || !m_pResult )
     245           0 :         return sal_False;
     246           0 :     long nDiff = nRow - m_pResult->StartIndex;
     247           0 :     if( nDiff < 0 )
     248           0 :         nDiff *= -1;
     249           0 :     if( nDiff < m_pMappedReminder->getLength() )
     250           0 :         return (*m_pMappedReminder)[nDiff];
     251           0 :     return sal_False;
     252             : }
     253             : 
     254           0 : void SAL_CALL CachedContentResultSet::CCRS_Cache
     255             :     ::clearMappedReminder()
     256             : {
     257           0 :     delete m_pMappedReminder;
     258           0 :     m_pMappedReminder = NULL;
     259           0 : }
     260             : 
     261           0 : Sequence< sal_Bool >* SAL_CALL CachedContentResultSet::CCRS_Cache
     262             :     ::getMappedReminder()
     263             : {
     264           0 :     if( !m_pMappedReminder )
     265             :     {
     266           0 :         sal_Int32 nCount = m_pResult->Rows.getLength();
     267           0 :         m_pMappedReminder = new Sequence< sal_Bool >( nCount );
     268           0 :         for( ;nCount; nCount-- )
     269           0 :             (*m_pMappedReminder)[nCount] = sal_False;
     270             :     }
     271           0 :     return m_pMappedReminder;
     272             : }
     273             : 
     274           0 : const Any& SAL_CALL CachedContentResultSet::CCRS_Cache
     275             :     ::getAny( sal_Int32 nRow, sal_Int32 nColumnIndex )
     276             :     throw( SQLException,
     277             :     RuntimeException )
     278             : {
     279           0 :     if( !nColumnIndex )
     280           0 :         throw SQLException();
     281           0 :     if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
     282             :     {
     283           0 :         Any& rRow = getRowAny( nRow );
     284           0 :         Sequence< Any > aValue;
     285           0 :         rRow >>= aValue;
     286           0 :         if( m_xContentIdentifierMapping->mapRow( aValue ) )
     287             :         {
     288           0 :             rRow <<= aValue;
     289           0 :             remindMapped( nRow );
     290             :         }
     291             :         else
     292           0 :             m_xContentIdentifierMapping.clear();
     293             :     }
     294             :     const Sequence< Any >& rRow =
     295             :         (* reinterpret_cast< const Sequence< Any > * >
     296           0 :         (getRowAny( nRow ).getValue() ));
     297             : 
     298           0 :     if( nColumnIndex > rRow.getLength() )
     299           0 :         throw SQLException();
     300           0 :     return rRow[nColumnIndex-1];
     301             : }
     302             : 
     303           0 : const OUString& SAL_CALL CachedContentResultSet::CCRS_Cache
     304             :     ::getContentIdentifierString( sal_Int32 nRow )
     305             :     throw( com::sun::star::uno::RuntimeException )
     306             : {
     307             :     try
     308             :     {
     309           0 :         if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
     310             :         {
     311           0 :             Any& rRow = getRowAny( nRow );
     312           0 :             OUString aValue;
     313           0 :             rRow >>= aValue;
     314           0 :             rRow <<= m_xContentIdentifierMapping->mapContentIdentifierString( aValue );
     315           0 :             remindMapped( nRow );
     316             :         }
     317             :         return (* reinterpret_cast< const OUString * >
     318           0 :                 (getRowAny( nRow ).getValue() ));
     319             :     }
     320           0 :     catch(const SQLException&)
     321             :     {
     322           0 :         throw RuntimeException();
     323             :     }
     324             : }
     325             : 
     326           0 : const Reference< XContentIdentifier >& SAL_CALL CachedContentResultSet::CCRS_Cache
     327             :     ::getContentIdentifier( sal_Int32 nRow )
     328             :     throw( com::sun::star::uno::RuntimeException )
     329             : {
     330             :     try
     331             :     {
     332           0 :         if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
     333             :         {
     334           0 :             Any& rRow = getRowAny( nRow );
     335           0 :             Reference< XContentIdentifier > aValue;
     336           0 :             rRow >>= aValue;
     337           0 :             rRow <<= m_xContentIdentifierMapping->mapContentIdentifier( aValue );
     338           0 :             remindMapped( nRow );
     339             :         }
     340             :         return (* reinterpret_cast< const Reference< XContentIdentifier > * >
     341           0 :                 (getRowAny( nRow ).getValue() ));
     342             :     }
     343           0 :     catch(const SQLException&)
     344             :     {
     345           0 :         throw RuntimeException();
     346             :     }
     347             : }
     348             : 
     349           0 : const Reference< XContent >& SAL_CALL CachedContentResultSet::CCRS_Cache
     350             :     ::getContent( sal_Int32 nRow )
     351             :     throw( com::sun::star::uno::RuntimeException )
     352             : {
     353             :     try
     354             :     {
     355           0 :         if( m_xContentIdentifierMapping.is() && !isRowMapped( nRow ) )
     356             :         {
     357           0 :             Any& rRow = getRowAny( nRow );
     358           0 :             Reference< XContent > aValue;
     359           0 :             rRow >>= aValue;
     360           0 :             rRow <<= m_xContentIdentifierMapping->mapContent( aValue );
     361           0 :             remindMapped( nRow );
     362             :         }
     363             :         return (* reinterpret_cast< const Reference< XContent > * >
     364           0 :                 (getRowAny( nRow ).getValue() ));
     365             :     }
     366           0 :     catch (const SQLException&)
     367             :     {
     368           0 :         throw RuntimeException();
     369             :     }
     370             : }
     371             : 
     372             : //--------------------------------------------------------------------------
     373             : //--------------------------------------------------------------------------
     374             : // class CCRS_PropertySetInfo
     375             : //--------------------------------------------------------------------------
     376             : //--------------------------------------------------------------------------
     377             : 
     378             : class CCRS_PropertySetInfo :
     379             :                 public cppu::OWeakObject,
     380             :                 public com::sun::star::lang::XTypeProvider,
     381             :                 public com::sun::star::beans::XPropertySetInfo
     382             : {
     383             :     friend class CachedContentResultSet;
     384             : 
     385             :     //my Properties
     386             :     Sequence< com::sun::star::beans::Property >*
     387             :                             m_pProperties;
     388             : 
     389             :     //some helping variables ( names for my special properties )
     390             :     static OUString m_aPropertyNameForCount;
     391             :     static OUString m_aPropertyNameForFinalCount;
     392             :     static OUString m_aPropertyNameForFetchSize;
     393             :     static OUString m_aPropertyNameForFetchDirection;
     394             : 
     395             :     long                    m_nFetchSizePropertyHandle;
     396             :     long                    m_nFetchDirectionPropertyHandle;
     397             : 
     398             : private:
     399             :     sal_Int32 SAL_CALL
     400             :     impl_getRemainedHandle() const;
     401             : 
     402             :     sal_Bool SAL_CALL
     403             :     impl_queryProperty(
     404             :             const OUString& rName
     405             :             , com::sun::star::beans::Property& rProp ) const;
     406             :     sal_Int32 SAL_CALL
     407             :     impl_getPos( const OUString& rName ) const;
     408             : 
     409             :     static sal_Bool SAL_CALL
     410             :     impl_isMyPropertyName( const OUString& rName );
     411             : 
     412             : public:
     413             :     CCRS_PropertySetInfo(   Reference<
     414             :             XPropertySetInfo > xPropertySetInfoOrigin );
     415             : 
     416             :     virtual ~CCRS_PropertySetInfo();
     417             : 
     418             :     // XInterface
     419             :     XINTERFACE_DECL()
     420             : 
     421             :     // XTypeProvider
     422             :     XTYPEPROVIDER_DECL()
     423             : 
     424             :     // XPropertySetInfo
     425             :     virtual Sequence< com::sun::star::beans::Property > SAL_CALL
     426             :     getProperties()
     427             :         throw( RuntimeException );
     428             : 
     429             :     virtual com::sun::star::beans::Property SAL_CALL
     430             :     getPropertyByName( const OUString& aName )
     431             :         throw( com::sun::star::beans::UnknownPropertyException, RuntimeException );
     432             : 
     433             :     virtual sal_Bool SAL_CALL
     434             :     hasPropertyByName( const OUString& Name )
     435             :         throw( RuntimeException );
     436             : };
     437             : 
     438           0 : OUString    CCRS_PropertySetInfo::m_aPropertyNameForCount( "RowCount" );
     439           0 : OUString    CCRS_PropertySetInfo::m_aPropertyNameForFinalCount( "IsRowCountFinal" );
     440           0 : OUString    CCRS_PropertySetInfo::m_aPropertyNameForFetchSize( "FetchSize" );
     441           0 : OUString    CCRS_PropertySetInfo::m_aPropertyNameForFetchDirection( "FetchDirection" );
     442             : 
     443           0 : CCRS_PropertySetInfo::CCRS_PropertySetInfo(
     444             :         Reference< XPropertySetInfo > xInfo )
     445             :         : m_pProperties( NULL )
     446             :         , m_nFetchSizePropertyHandle( -1 )
     447           0 :         , m_nFetchDirectionPropertyHandle( -1 )
     448             : {
     449             :     //initialize list of properties:
     450             : 
     451             :     // it is required, that the received xInfo contains the two
     452             :     // properties with names 'm_aPropertyNameForCount' and
     453             :     // 'm_aPropertyNameForFinalCount'
     454             : 
     455           0 :     if( xInfo.is() )
     456             :     {
     457           0 :         Sequence<Property> aProps = xInfo->getProperties();
     458           0 :         m_pProperties = new Sequence<Property> ( aProps );
     459             :     }
     460             :     else
     461             :     {
     462             :         OSL_FAIL( "The received XPropertySetInfo doesn't contain required properties" );
     463           0 :         m_pProperties = new Sequence<Property>;
     464             :     }
     465             : 
     466             :     //ensure, that we haven't got the Properties 'FetchSize' and 'Direction' twice:
     467           0 :     sal_Int32 nFetchSize = impl_getPos( m_aPropertyNameForFetchSize );
     468           0 :     sal_Int32 nFetchDirection = impl_getPos( m_aPropertyNameForFetchDirection );
     469           0 :     sal_Int32 nDeleted = 0;
     470           0 :     if( nFetchSize != -1 )
     471           0 :         nDeleted++;
     472           0 :     if( nFetchDirection != -1 )
     473           0 :         nDeleted++;
     474             : 
     475           0 :     Sequence< Property >* pOrigProps = new Sequence<Property> ( *m_pProperties );
     476           0 :     sal_Int32 nOrigProps = pOrigProps->getLength();
     477             : 
     478           0 :     m_pProperties->realloc( nOrigProps + 2 - nDeleted );//note that nDeleted is <= 2
     479           0 :     for( sal_Int32 n = 0, m = 0; n < nOrigProps; n++, m++ )
     480             :     {
     481           0 :         if( n == nFetchSize || n == nFetchDirection )
     482           0 :             m--;
     483             :         else
     484           0 :             (*m_pProperties)[ m ] = (*pOrigProps)[ n ];
     485             :     }
     486             :     {
     487           0 :         Property& rMyProp = (*m_pProperties)[ nOrigProps - nDeleted ];
     488           0 :         rMyProp.Name = m_aPropertyNameForFetchSize;
     489           0 :         rMyProp.Type = getCppuType( static_cast< const sal_Int32 * >( 0 ) );
     490           0 :         rMyProp.Attributes = PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT;
     491             : 
     492           0 :         if( nFetchSize != -1 )
     493           0 :             m_nFetchSizePropertyHandle = (*pOrigProps)[nFetchSize].Handle;
     494             :         else
     495           0 :             m_nFetchSizePropertyHandle = impl_getRemainedHandle();
     496             : 
     497           0 :         rMyProp.Handle = m_nFetchSizePropertyHandle;
     498             : 
     499             :     }
     500             :     {
     501           0 :         Property& rMyProp = (*m_pProperties)[ nOrigProps - nDeleted + 1 ];
     502           0 :         rMyProp.Name = m_aPropertyNameForFetchDirection;
     503           0 :         rMyProp.Type = getCppuType( static_cast< const sal_Bool * >( 0 ) );
     504           0 :         rMyProp.Attributes = PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT;
     505             : 
     506           0 :         if( nFetchSize != -1 )
     507           0 :             m_nFetchDirectionPropertyHandle = (*pOrigProps)[nFetchDirection].Handle;
     508             :         else
     509           0 :             m_nFetchDirectionPropertyHandle = impl_getRemainedHandle();
     510             : 
     511           0 :         m_nFetchDirectionPropertyHandle = rMyProp.Handle;
     512             :     }
     513           0 :     delete pOrigProps;
     514           0 : }
     515             : 
     516           0 : CCRS_PropertySetInfo::~CCRS_PropertySetInfo()
     517             : {
     518           0 :     delete m_pProperties;
     519           0 : }
     520             : 
     521             : //--------------------------------------------------------------------------
     522             : // XInterface methods.
     523             : //--------------------------------------------------------------------------
     524             : //list all interfaces inclusive baseclasses of interfaces
     525           0 : XINTERFACE_IMPL_2( CCRS_PropertySetInfo
     526             :                   , XTypeProvider
     527             :                   , XPropertySetInfo
     528             :                   );
     529             : 
     530             : //--------------------------------------------------------------------------
     531             : // XTypeProvider methods.
     532             : //--------------------------------------------------------------------------
     533             : //list all interfaces exclusive baseclasses
     534           0 : XTYPEPROVIDER_IMPL_2( CCRS_PropertySetInfo
     535             :                     , XTypeProvider
     536             :                     , XPropertySetInfo
     537             :                     );
     538             : //--------------------------------------------------------------------------
     539             : // XPropertySetInfo methods.
     540             : //--------------------------------------------------------------------------
     541             : //virtual
     542           0 : Sequence< Property > SAL_CALL CCRS_PropertySetInfo
     543             :     ::getProperties() throw( RuntimeException )
     544             : {
     545           0 :     return *m_pProperties;
     546             : }
     547             : 
     548             : //virtual
     549           0 : Property SAL_CALL CCRS_PropertySetInfo
     550             :     ::getPropertyByName( const OUString& aName )
     551             :         throw( UnknownPropertyException, RuntimeException )
     552             : {
     553           0 :     if ( aName.isEmpty() )
     554           0 :         throw UnknownPropertyException();
     555             : 
     556           0 :     Property aProp;
     557           0 :     if ( impl_queryProperty( aName, aProp ) )
     558           0 :         return aProp;
     559             : 
     560           0 :     throw UnknownPropertyException();
     561             : }
     562             : 
     563             : //virtual
     564           0 : sal_Bool SAL_CALL CCRS_PropertySetInfo
     565             :     ::hasPropertyByName( const OUString& Name )
     566             :         throw( RuntimeException )
     567             : {
     568           0 :     return ( impl_getPos( Name ) != -1 );
     569             : }
     570             : 
     571             : //--------------------------------------------------------------------------
     572             : // impl_ methods.
     573             : //--------------------------------------------------------------------------
     574             : 
     575           0 : sal_Int32 SAL_CALL CCRS_PropertySetInfo
     576             :             ::impl_getPos( const OUString& rName ) const
     577             : {
     578           0 :     for( sal_Int32 nN = m_pProperties->getLength(); nN--; )
     579             :     {
     580           0 :         const Property& rMyProp = (*m_pProperties)[nN];
     581           0 :         if( rMyProp.Name == rName )
     582           0 :             return nN;
     583             :     }
     584           0 :     return -1;
     585             : }
     586             : 
     587           0 : sal_Bool SAL_CALL CCRS_PropertySetInfo
     588             :         ::impl_queryProperty( const OUString& rName, Property& rProp ) const
     589             : {
     590           0 :     for( sal_Int32 nN = m_pProperties->getLength(); nN--; )
     591             :     {
     592           0 :         const Property& rMyProp = (*m_pProperties)[nN];
     593           0 :         if( rMyProp.Name == rName )
     594             :         {
     595           0 :             rProp.Name = rMyProp.Name;
     596           0 :             rProp.Handle = rMyProp.Handle;
     597           0 :             rProp.Type = rMyProp.Type;
     598           0 :             rProp.Attributes = rMyProp.Attributes;
     599             : 
     600           0 :             return sal_True;
     601             :         }
     602             :     }
     603           0 :     return sal_False;
     604             : }
     605             : 
     606             : //static
     607           0 : sal_Bool SAL_CALL CCRS_PropertySetInfo
     608             :         ::impl_isMyPropertyName( const OUString& rPropertyName )
     609             : {
     610           0 :     return ( rPropertyName == m_aPropertyNameForCount
     611           0 :     || rPropertyName == m_aPropertyNameForFinalCount
     612           0 :     || rPropertyName == m_aPropertyNameForFetchSize
     613           0 :     || rPropertyName == m_aPropertyNameForFetchDirection );
     614             : }
     615             : 
     616           0 : sal_Int32 SAL_CALL CCRS_PropertySetInfo
     617             :             ::impl_getRemainedHandle( ) const
     618             : {
     619           0 :     sal_Int32 nHandle = 1;
     620             : 
     621           0 :     if( !m_pProperties )
     622             :     {
     623             :         OSL_FAIL( "Properties not initialized yet" );
     624           0 :         return nHandle;
     625             :     }
     626           0 :     sal_Bool bFound = sal_True;
     627           0 :     while( bFound )
     628             :     {
     629           0 :         bFound = sal_False;
     630           0 :         for( sal_Int32 nN = m_pProperties->getLength(); nN--; )
     631             :         {
     632           0 :             if( nHandle == (*m_pProperties)[nN].Handle )
     633             :             {
     634           0 :                 bFound = sal_True;
     635           0 :                 nHandle++;
     636           0 :                 break;
     637             :             }
     638             :         }
     639             :     }
     640           0 :     return nHandle;
     641             : }
     642             : 
     643             : //--------------------------------------------------------------------------
     644             : //--------------------------------------------------------------------------
     645             : // class CachedContentResultSet
     646             : //--------------------------------------------------------------------------
     647             : //--------------------------------------------------------------------------
     648             : 
     649           0 : CachedContentResultSet::CachedContentResultSet(
     650             :                   const Reference< XComponentContext > & rxContext
     651             :                 , const Reference< XResultSet > & xOrigin
     652             :                 , const Reference< XContentIdentifierMapping > &
     653             :                     xContentIdentifierMapping )
     654             :                 : ContentResultSetWrapper( xOrigin )
     655             : 
     656             :                 , m_xContext( rxContext )
     657             :                 , m_xFetchProvider( NULL )
     658             :                 , m_xFetchProviderForContentAccess( NULL )
     659             : 
     660             :                 , m_xMyPropertySetInfo( NULL )
     661             :                 , m_pMyPropSetInfo( NULL )
     662             : 
     663             :                 , m_xContentIdentifierMapping( xContentIdentifierMapping )
     664             :                 , m_nRow( 0 ) // Position is one-based. Zero means: before first element.
     665             :                 , m_bAfterLast( sal_False )
     666             :                 , m_nLastAppliedPos( 0 )
     667             :                 , m_bAfterLastApplied( sal_False )
     668             :                 , m_nKnownCount( 0 )
     669             :                 , m_bFinalCount( sal_False )
     670             :                 , m_nFetchSize(
     671             :                     COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE )
     672             :                 , m_nFetchDirection(
     673             :                     COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION )
     674             : 
     675             :                 , m_bLastReadWasFromCache( sal_False )
     676             :                 , m_bLastCachedReadWasNull( sal_True )
     677             :                 , m_aCache( m_xContentIdentifierMapping )
     678             :                 , m_aCacheContentIdentifierString( m_xContentIdentifierMapping )
     679             :                 , m_aCacheContentIdentifier( m_xContentIdentifierMapping )
     680             :                 , m_aCacheContent( m_xContentIdentifierMapping )
     681             :                 , m_bTriedToGetTypeConverter( sal_False )
     682           0 :                 , m_xTypeConverter( NULL )
     683             : {
     684           0 :     m_xFetchProvider = Reference< XFetchProvider >( m_xResultSetOrigin, UNO_QUERY );
     685             :     OSL_ENSURE( m_xFetchProvider.is(), "interface XFetchProvider is required" );
     686             : 
     687           0 :     m_xFetchProviderForContentAccess = Reference< XFetchProviderForContentAccess >( m_xResultSetOrigin, UNO_QUERY );
     688             :     OSL_ENSURE( m_xFetchProviderForContentAccess.is(), "interface XFetchProviderForContentAccess is required" );
     689             : 
     690           0 :     impl_init();
     691           0 : };
     692             : 
     693           0 : CachedContentResultSet::~CachedContentResultSet()
     694             : {
     695           0 :     impl_deinit();
     696             :     //do not delete m_pMyPropSetInfo, cause it is hold via reference
     697           0 : };
     698             : 
     699             : //--------------------------------------------------------------------------
     700             : // impl_ methods.
     701             : //--------------------------------------------------------------------------
     702             : 
     703           0 : sal_Bool SAL_CALL CachedContentResultSet
     704             :     ::applyPositionToOrigin( sal_Int32 nRow )
     705             :     throw( SQLException,
     706             :            RuntimeException )
     707             : {
     708           0 :     impl_EnsureNotDisposed();
     709             :     //-------------------------------------------------------------------------
     710             :     /**
     711             :     @returns
     712             :         <TRUE/> if the cursor is on a valid row; <FALSE/> if it is off
     713             :         the result set.
     714             :     */
     715             : 
     716           0 :     ReacquireableGuard aGuard( m_aMutex );
     717             :     OSL_ENSURE( nRow >= 0, "only positive values supported" );
     718           0 :     if( !m_xResultSetOrigin.is() )
     719             :     {
     720             :         OSL_FAIL( "broadcaster was disposed already" );
     721           0 :         return sal_False;
     722             :     }
     723             : //  OSL_ENSURE( nRow <= m_nKnownCount, "don't step into regions you don't know with this method" );
     724             : 
     725           0 :     sal_Int32 nLastAppliedPos = m_nLastAppliedPos;
     726           0 :     sal_Bool bAfterLastApplied = m_bAfterLastApplied;
     727           0 :     sal_Bool bAfterLast = m_bAfterLast;
     728           0 :     sal_Int32 nForwardOnly = m_nForwardOnly;
     729             : 
     730           0 :     aGuard.clear();
     731             : 
     732           0 :     if( bAfterLastApplied || nLastAppliedPos != nRow )
     733             :     {
     734           0 :         if( nForwardOnly == 1 )
     735             :         {
     736           0 :             if( bAfterLastApplied || bAfterLast || !nRow || nRow < nLastAppliedPos )
     737           0 :                 throw SQLException();
     738             : 
     739           0 :             sal_Int32 nN = nRow - nLastAppliedPos;
     740             :             sal_Int32 nM;
     741           0 :             for( nM = 0; nN--; nM++ )
     742             :             {
     743           0 :                 if( !m_xResultSetOrigin->next() )
     744           0 :                     break;
     745             :             }
     746             : 
     747           0 :             aGuard.reacquire();
     748           0 :             m_nLastAppliedPos += nM;
     749           0 :             m_bAfterLastApplied = nRow != m_nLastAppliedPos;
     750           0 :             return nRow == m_nLastAppliedPos;
     751             :         }
     752             : 
     753           0 :         if( !nRow ) //absolute( 0 ) will throw exception
     754             :         {
     755           0 :             m_xResultSetOrigin->beforeFirst();
     756             : 
     757           0 :             aGuard.reacquire();
     758           0 :             m_nLastAppliedPos = 0;
     759           0 :             m_bAfterLastApplied = sal_False;
     760           0 :             return sal_False;
     761             :         }
     762             :         try
     763             :         {
     764             :             //move absolute, if !nLastAppliedPos
     765             :             //because move relative would throw exception
     766           0 :             if( !nLastAppliedPos || bAfterLast || bAfterLastApplied )
     767             :             {
     768           0 :                 sal_Bool bValid = m_xResultSetOrigin->absolute( nRow );
     769             : 
     770           0 :                 aGuard.reacquire();
     771           0 :                 m_nLastAppliedPos = nRow;
     772           0 :                 m_bAfterLastApplied = !bValid;
     773           0 :                 return bValid;
     774             :             }
     775             :             else
     776             :             {
     777           0 :                 sal_Bool bValid = m_xResultSetOrigin->relative( nRow - nLastAppliedPos );
     778             : 
     779           0 :                 aGuard.reacquire();
     780           0 :                 m_nLastAppliedPos += ( nRow - nLastAppliedPos );
     781           0 :                 m_bAfterLastApplied = !bValid;
     782           0 :                 return bValid;
     783             :             }
     784             :         }
     785           0 :         catch (const SQLException&)
     786             :         {
     787           0 :             if( !bAfterLastApplied && !bAfterLast && nRow > nLastAppliedPos && impl_isForwardOnly() )
     788             :             {
     789           0 :                 sal_Int32 nN = nRow - nLastAppliedPos;
     790             :                 sal_Int32 nM;
     791           0 :                 for( nM = 0; nN--; nM++ )
     792             :                 {
     793           0 :                     if( !m_xResultSetOrigin->next() )
     794           0 :                         break;
     795             :                 }
     796             : 
     797           0 :                 aGuard.reacquire();
     798           0 :                 m_nLastAppliedPos += nM;
     799           0 :                 m_bAfterLastApplied = nRow != m_nLastAppliedPos;
     800             :             }
     801             :             else
     802           0 :                 throw;
     803             :         }
     804             : 
     805           0 :         return nRow == m_nLastAppliedPos;
     806             :     }
     807           0 :     return sal_True;
     808             : };
     809             : 
     810             : //--------------------------------------------------------------------------
     811             : //--------------------------------------------------------------------------
     812             : //define for fetching data
     813             : //--------------------------------------------------------------------------
     814             : //--------------------------------------------------------------------------
     815             : 
     816             : #define FETCH_XXX( aCache, fetchInterface, fetchMethod )            \
     817             : sal_Bool bDirection = !!(                                           \
     818             :     nFetchDirection != FetchDirection::REVERSE );                   \
     819             : FetchResult aResult =                                               \
     820             :     fetchInterface->fetchMethod( nRow, nFetchSize, bDirection );    \
     821             : osl::ClearableGuard< osl::Mutex > aGuard2( m_aMutex );              \
     822             : aCache.loadData( aResult );                                         \
     823             : sal_Int32 nMax = aCache.getMaxRow();                                \
     824             : sal_Int32 nCurCount = m_nKnownCount;                                \
     825             : sal_Bool bIsFinalCount = aCache.hasKnownLast();                     \
     826             : sal_Bool bCurIsFinalCount = m_bFinalCount;                          \
     827             : aGuard2.clear();                                                    \
     828             : if( nMax > nCurCount )                                              \
     829             :     impl_changeRowCount( nCurCount, nMax );                         \
     830             : if( bIsFinalCount && !bCurIsFinalCount )                            \
     831             :     impl_changeIsRowCountFinal( bCurIsFinalCount, bIsFinalCount );
     832             : 
     833           0 : void SAL_CALL CachedContentResultSet
     834             :     ::impl_fetchData( sal_Int32 nRow
     835             :         , sal_Int32 nFetchSize, sal_Int32 nFetchDirection )
     836             :         throw( com::sun::star::uno::RuntimeException )
     837             : {
     838           0 :     FETCH_XXX( m_aCache, m_xFetchProvider, fetch );
     839           0 : }
     840             : 
     841           0 : void SAL_CALL CachedContentResultSet
     842             :     ::impl_changeRowCount( sal_Int32 nOld, sal_Int32 nNew )
     843             : {
     844             :     OSL_ENSURE( nNew > nOld, "RowCount only can grow" );
     845           0 :     if( nNew <= nOld )
     846           0 :         return;
     847             : 
     848             :     //create PropertyChangeEvent and set value
     849           0 :     PropertyChangeEvent aEvt;
     850             :     {
     851           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
     852           0 :         aEvt.Source =  static_cast< XPropertySet * >( this );
     853           0 :         aEvt.Further = sal_False;
     854           0 :         aEvt.OldValue <<= nOld;
     855           0 :         aEvt.NewValue <<= nNew;
     856             : 
     857           0 :         m_nKnownCount = nNew;
     858             :     }
     859             : 
     860             :     //send PropertyChangeEvent to listeners
     861           0 :     impl_notifyPropertyChangeListeners( aEvt );
     862             : }
     863             : 
     864           0 : void SAL_CALL CachedContentResultSet
     865             :     ::impl_changeIsRowCountFinal( sal_Bool bOld, sal_Bool bNew )
     866             : {
     867             :     OSL_ENSURE( !bOld && bNew, "This change is not allowed for IsRowCountFinal" );
     868           0 :     if( ! (!bOld && bNew ) )
     869           0 :         return;
     870             : 
     871             :     //create PropertyChangeEvent and set value
     872           0 :     PropertyChangeEvent aEvt;
     873             :     {
     874           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
     875           0 :         aEvt.Source =  static_cast< XPropertySet * >( this );
     876           0 :         aEvt.Further = sal_False;
     877           0 :         aEvt.OldValue <<= bOld;
     878           0 :         aEvt.NewValue <<= bNew;
     879             : 
     880           0 :         m_bFinalCount = bNew;
     881             :     }
     882             : 
     883             :     //send PropertyChangeEvent to listeners
     884           0 :     impl_notifyPropertyChangeListeners( aEvt );
     885             : }
     886             : 
     887           0 : sal_Bool SAL_CALL CachedContentResultSet
     888             :     ::impl_isKnownValidPosition( sal_Int32 nRow )
     889             : {
     890             :     return m_nKnownCount && nRow
     891           0 :             && nRow <= m_nKnownCount;
     892             : }
     893             : 
     894           0 : sal_Bool SAL_CALL CachedContentResultSet
     895             :     ::impl_isKnownInvalidPosition( sal_Int32 nRow )
     896             : {
     897           0 :     if( !nRow )
     898           0 :         return sal_True;
     899           0 :     if( !m_bFinalCount )
     900           0 :         return sal_False;
     901           0 :     return nRow > m_nKnownCount;
     902             : }
     903             : 
     904             : 
     905             : //virtual
     906           0 : void SAL_CALL CachedContentResultSet
     907             :     ::impl_initPropertySetInfo()
     908             : {
     909           0 :     ContentResultSetWrapper::impl_initPropertySetInfo();
     910             : 
     911           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
     912           0 :     if( m_pMyPropSetInfo )
     913           0 :         return;
     914           0 :     m_pMyPropSetInfo = new CCRS_PropertySetInfo( m_xPropertySetInfo );
     915           0 :     m_xMyPropertySetInfo = m_pMyPropSetInfo;
     916           0 :     m_xPropertySetInfo = m_xMyPropertySetInfo;
     917             : }
     918             : 
     919             : //--------------------------------------------------------------------------
     920             : // XInterface methods. ( inherited )
     921             : //--------------------------------------------------------------------------
     922           0 : XINTERFACE_COMMON_IMPL( CachedContentResultSet )
     923             : 
     924           0 : Any SAL_CALL CachedContentResultSet
     925             :     ::queryInterface( const Type&  rType )
     926             :     throw ( RuntimeException )
     927             : {
     928             :     //list all interfaces inclusive baseclasses of interfaces
     929             : 
     930           0 :     Any aRet = ContentResultSetWrapper::queryInterface( rType );
     931           0 :     if( aRet.hasValue() )
     932           0 :         return aRet;
     933             : 
     934             :     aRet = cppu::queryInterface( rType,
     935             :                 static_cast< XTypeProvider* >( this ),
     936           0 :                 static_cast< XServiceInfo* >( this ) );
     937             : 
     938           0 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     939             : }
     940             : 
     941             : //--------------------------------------------------------------------------
     942             : // XTypeProvider methods.
     943             : //--------------------------------------------------------------------------
     944             : //list all interfaces exclusive baseclasses
     945           0 : XTYPEPROVIDER_IMPL_11( CachedContentResultSet
     946             :                     , XTypeProvider
     947             :                     , XServiceInfo
     948             :                     , XComponent
     949             :                     , XCloseable
     950             :                     , XResultSetMetaDataSupplier
     951             :                     , XPropertySet
     952             : 
     953             :                     , XPropertyChangeListener
     954             :                     , XVetoableChangeListener
     955             : 
     956             :                     , XContentAccess
     957             : 
     958             :                     , XResultSet
     959             :                     , XRow );
     960             : 
     961             : //--------------------------------------------------------------------------
     962             : // XServiceInfo methods.
     963             : //--------------------------------------------------------------------------
     964             : 
     965           0 : XSERVICEINFO_NOFACTORY_IMPL_1( CachedContentResultSet,
     966             :                                OUString(
     967             :                             "com.sun.star.comp.ucb.CachedContentResultSet" ),
     968             :                             OUString(
     969             :                             CACHED_CONTENT_RESULTSET_SERVICE_NAME ) );
     970             : 
     971             : //--------------------------------------------------------------------------
     972             : // XPropertySet methods. ( inherited )
     973             : //--------------------------------------------------------------------------
     974             : 
     975             : // virtual
     976           0 : void SAL_CALL CachedContentResultSet
     977             :     ::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
     978             :     throw( UnknownPropertyException,
     979             :            PropertyVetoException,
     980             :            IllegalArgumentException,
     981             :            WrappedTargetException,
     982             :            RuntimeException )
     983             : {
     984           0 :     impl_EnsureNotDisposed();
     985             : 
     986           0 :     if( !getPropertySetInfo().is() )
     987             :     {
     988             :         OSL_FAIL( "broadcaster was disposed already" );
     989           0 :         throw UnknownPropertyException();
     990             :     }
     991             : 
     992           0 :     Property aProp = m_pMyPropSetInfo->getPropertyByName( aPropertyName );
     993             :         //throws UnknownPropertyException, if so
     994             : 
     995           0 :     if( aProp.Attributes & PropertyAttribute::READONLY )
     996             :     {
     997             :         //It is assumed, that the properties
     998             :         //'RowCount' and 'IsRowCountFinal' are readonly!
     999           0 :         throw IllegalArgumentException();
    1000             :     }
    1001           0 :     if( aProp.Name == CCRS_PropertySetInfo
    1002           0 :                         ::m_aPropertyNameForFetchDirection )
    1003             :     {
    1004             :         //check value
    1005             :         sal_Int32 nNew;
    1006           0 :         if( !( aValue >>= nNew ) )
    1007             :         {
    1008           0 :             throw IllegalArgumentException();
    1009             :         }
    1010             : 
    1011           0 :         if( nNew == FetchDirection::UNKNOWN )
    1012             :         {
    1013           0 :             nNew = COMSUNSTARUCBCCRS_DEFAULT_FETCH_DIRECTION;
    1014             :         }
    1015           0 :         else if( !( nNew == FetchDirection::FORWARD
    1016           0 :                 || nNew == FetchDirection::REVERSE ) )
    1017             :         {
    1018           0 :             throw IllegalArgumentException();
    1019             :         }
    1020             : 
    1021             :         //create PropertyChangeEvent and set value
    1022           0 :         PropertyChangeEvent aEvt;
    1023             :         {
    1024           0 :             osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1025           0 :             aEvt.Source =  static_cast< XPropertySet * >( this );
    1026           0 :             aEvt.PropertyName = aPropertyName;
    1027           0 :             aEvt.Further = sal_False;
    1028             :             aEvt.PropertyHandle = m_pMyPropSetInfo->
    1029           0 :                                     m_nFetchDirectionPropertyHandle;
    1030           0 :             aEvt.OldValue <<= m_nFetchDirection;
    1031           0 :             aEvt.NewValue <<= nNew;
    1032             : 
    1033           0 :             m_nFetchDirection = nNew;
    1034             :         }
    1035             : 
    1036             :         //send PropertyChangeEvent to listeners
    1037           0 :         impl_notifyPropertyChangeListeners( aEvt );
    1038             :     }
    1039           0 :     else if( aProp.Name == CCRS_PropertySetInfo
    1040           0 :                         ::m_aPropertyNameForFetchSize )
    1041             :     {
    1042             :         //check value
    1043             :         sal_Int32 nNew;
    1044           0 :         if( !( aValue >>= nNew ) )
    1045             :         {
    1046           0 :             throw IllegalArgumentException();
    1047             :         }
    1048             : 
    1049           0 :         if( nNew < 0 )
    1050             :         {
    1051           0 :             nNew = COMSUNSTARUCBCCRS_DEFAULT_FETCH_SIZE;
    1052             :         }
    1053             : 
    1054             :         //create PropertyChangeEvent and set value
    1055           0 :         PropertyChangeEvent aEvt;
    1056             :         {
    1057           0 :             osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1058           0 :             aEvt.Source =  static_cast< XPropertySet * >( this );
    1059           0 :             aEvt.PropertyName = aPropertyName;
    1060           0 :             aEvt.Further = sal_False;
    1061             :             aEvt.PropertyHandle = m_pMyPropSetInfo->
    1062           0 :                                     m_nFetchSizePropertyHandle;
    1063           0 :             aEvt.OldValue <<= m_nFetchSize;
    1064           0 :             aEvt.NewValue <<= nNew;
    1065             : 
    1066           0 :             m_nFetchSize = nNew;
    1067             :         }
    1068             : 
    1069             :         //send PropertyChangeEvent to listeners
    1070           0 :         impl_notifyPropertyChangeListeners( aEvt );
    1071             :     }
    1072             :     else
    1073             :     {
    1074           0 :         impl_init_xPropertySetOrigin();
    1075             :         {
    1076           0 :             osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1077           0 :             if( !m_xPropertySetOrigin.is() )
    1078             :             {
    1079             :                 OSL_FAIL( "broadcaster was disposed already" );
    1080           0 :                 return;
    1081           0 :             }
    1082             :         }
    1083           0 :         m_xPropertySetOrigin->setPropertyValue( aPropertyName, aValue );
    1084           0 :     }
    1085             : }
    1086             : 
    1087             : //--------------------------------------------------------------------------
    1088             : // virtual
    1089           0 : Any SAL_CALL CachedContentResultSet
    1090             :     ::getPropertyValue( const OUString& rPropertyName )
    1091             :     throw( UnknownPropertyException,
    1092             :            WrappedTargetException,
    1093             :            RuntimeException )
    1094             : {
    1095           0 :     impl_EnsureNotDisposed();
    1096             : 
    1097           0 :     if( !getPropertySetInfo().is() )
    1098             :     {
    1099             :         OSL_FAIL( "broadcaster was disposed already" );
    1100           0 :         throw UnknownPropertyException();
    1101             :     }
    1102             : 
    1103           0 :     Property aProp = m_pMyPropSetInfo->getPropertyByName( rPropertyName );
    1104             :         //throws UnknownPropertyException, if so
    1105             : 
    1106           0 :     Any aValue;
    1107           0 :     if( rPropertyName == CCRS_PropertySetInfo
    1108           0 :                         ::m_aPropertyNameForCount )
    1109             :     {
    1110           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1111           0 :         aValue <<= m_nKnownCount;
    1112             :     }
    1113           0 :     else if( rPropertyName == CCRS_PropertySetInfo
    1114           0 :                             ::m_aPropertyNameForFinalCount )
    1115             :     {
    1116           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1117           0 :         aValue <<= m_bFinalCount;
    1118             :     }
    1119           0 :     else if( rPropertyName == CCRS_PropertySetInfo
    1120           0 :                             ::m_aPropertyNameForFetchSize )
    1121             :     {
    1122           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1123           0 :         aValue <<= m_nFetchSize;
    1124             :     }
    1125           0 :     else if( rPropertyName == CCRS_PropertySetInfo
    1126           0 :                             ::m_aPropertyNameForFetchDirection )
    1127             :     {
    1128           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1129           0 :         aValue <<= m_nFetchDirection;
    1130             :     }
    1131             :     else
    1132             :     {
    1133           0 :         impl_init_xPropertySetOrigin();
    1134             :         {
    1135           0 :             osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1136           0 :             if( !m_xPropertySetOrigin.is() )
    1137             :             {
    1138             :                 OSL_FAIL( "broadcaster was disposed already" );
    1139           0 :                 throw UnknownPropertyException();
    1140           0 :             }
    1141             :         }
    1142           0 :         aValue = m_xPropertySetOrigin->getPropertyValue( rPropertyName );
    1143             :     }
    1144           0 :     return aValue;
    1145             : }
    1146             : 
    1147             : //--------------------------------------------------------------------------
    1148             : // own methods.  ( inherited )
    1149             : //--------------------------------------------------------------------------
    1150             : 
    1151             : //virtual
    1152           0 : void SAL_CALL CachedContentResultSet
    1153             :     ::impl_disposing( const EventObject& rEventObject )
    1154             :     throw( RuntimeException )
    1155             : {
    1156             :     {
    1157           0 :         impl_EnsureNotDisposed();
    1158           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1159             :         //release all references to the broadcaster:
    1160           0 :         m_xFetchProvider.clear();
    1161           0 :         m_xFetchProviderForContentAccess.clear();
    1162             :     }
    1163           0 :     ContentResultSetWrapper::impl_disposing( rEventObject );
    1164           0 : }
    1165             : 
    1166             : //virtual
    1167           0 : void SAL_CALL CachedContentResultSet
    1168             :     ::impl_propertyChange( const PropertyChangeEvent& rEvt )
    1169             :     throw( RuntimeException )
    1170             : {
    1171           0 :     impl_EnsureNotDisposed();
    1172             : 
    1173           0 :     PropertyChangeEvent aEvt( rEvt );
    1174           0 :     aEvt.Source = static_cast< XPropertySet * >( this );
    1175           0 :     aEvt.Further = sal_False;
    1176             :     //---------
    1177             : 
    1178           0 :     if( CCRS_PropertySetInfo
    1179           0 :             ::impl_isMyPropertyName( rEvt.PropertyName ) )
    1180             :     {
    1181             :         //don't notify foreign events on fetchsize and fetchdirection
    1182           0 :         if( aEvt.PropertyName == CCRS_PropertySetInfo
    1183           0 :                                 ::m_aPropertyNameForFetchSize
    1184             :         || aEvt.PropertyName == CCRS_PropertySetInfo
    1185           0 :                                 ::m_aPropertyNameForFetchDirection )
    1186             :             return;
    1187             : 
    1188             :         //adjust my props 'RowCount' and 'IsRowCountFinal'
    1189           0 :         if( aEvt.PropertyName == CCRS_PropertySetInfo
    1190           0 :                             ::m_aPropertyNameForCount )
    1191             :         {//RowCount changed
    1192             : 
    1193             :             //check value
    1194           0 :             sal_Int32 nNew = 0;
    1195           0 :             if( !( aEvt.NewValue >>= nNew ) )
    1196             :             {
    1197             :                 OSL_FAIL( "PropertyChangeEvent contains wrong data" );
    1198             :                 return;
    1199             :             }
    1200             : 
    1201           0 :             impl_changeRowCount( m_nKnownCount, nNew );
    1202             :         }
    1203           0 :         else if( aEvt.PropertyName == CCRS_PropertySetInfo
    1204           0 :                                 ::m_aPropertyNameForFinalCount )
    1205             :         {//IsRowCountFinal changed
    1206             : 
    1207             :             //check value
    1208           0 :             sal_Bool bNew = sal_False;
    1209           0 :             if( !( aEvt.NewValue >>= bNew ) )
    1210             :             {
    1211             :                 OSL_FAIL( "PropertyChangeEvent contains wrong data" );
    1212             :                 return;
    1213             :             }
    1214           0 :             impl_changeIsRowCountFinal( m_bFinalCount, bNew );
    1215             :         }
    1216             :         return;
    1217             :     }
    1218             : 
    1219             :     //-----------
    1220           0 :     impl_notifyPropertyChangeListeners( aEvt );
    1221             : }
    1222             : 
    1223             : 
    1224             : //virtual
    1225           0 : void SAL_CALL CachedContentResultSet
    1226             :     ::impl_vetoableChange( const PropertyChangeEvent& rEvt )
    1227             :     throw( PropertyVetoException,
    1228             :            RuntimeException )
    1229             : {
    1230           0 :     impl_EnsureNotDisposed();
    1231             : 
    1232             :     //don't notify events on my properties, cause they are not vetoable
    1233           0 :     if( CCRS_PropertySetInfo
    1234           0 :             ::impl_isMyPropertyName( rEvt.PropertyName ) )
    1235             :     {
    1236           0 :         return;
    1237             :     }
    1238             : 
    1239             : 
    1240           0 :     PropertyChangeEvent aEvt( rEvt );
    1241           0 :     aEvt.Source = static_cast< XPropertySet * >( this );
    1242           0 :     aEvt.Further = sal_False;
    1243             : 
    1244           0 :     impl_notifyVetoableChangeListeners( aEvt );
    1245             : }
    1246             : 
    1247             : //--------------------------------------------------------------------------
    1248             : // XContentAccess methods. ( inherited ) ( -- position dependent )
    1249             : //--------------------------------------------------------------------------
    1250             : 
    1251             : #define XCONTENTACCESS_queryXXX( queryXXX, XXX, TYPE )              \
    1252             : impl_EnsureNotDisposed();                                   \
    1253             : ReacquireableGuard aGuard( m_aMutex );                      \
    1254             : sal_Int32 nRow = m_nRow;                                    \
    1255             : sal_Int32 nFetchSize = m_nFetchSize;                        \
    1256             : sal_Int32 nFetchDirection = m_nFetchDirection;              \
    1257             : if( !m_aCache##XXX.hasRow( nRow ) )                         \
    1258             : {                                                           \
    1259             :     if( !m_aCache##XXX.hasCausedException( nRow ) )         \
    1260             : {                                                           \
    1261             :         if( !m_xFetchProviderForContentAccess.is() )        \
    1262             :         {                                                   \
    1263             :             OSL_FAIL( "broadcaster was disposed already" );\
    1264             :             throw RuntimeException();                       \
    1265             :         }                                                   \
    1266             :         aGuard.clear();                                     \
    1267             :         if( impl_isForwardOnly() )                          \
    1268             :             applyPositionToOrigin( nRow );                  \
    1269             :                                                             \
    1270             :         FETCH_XXX( m_aCache##XXX, m_xFetchProviderForContentAccess, fetch##XXX##s ); \
    1271             :     }                                                       \
    1272             :     aGuard.reacquire();                                     \
    1273             :     if( !m_aCache##XXX.hasRow( nRow ) )                     \
    1274             :     {                                                       \
    1275             :         aGuard.clear();                                     \
    1276             :         applyPositionToOrigin( nRow );                      \
    1277             :         TYPE aRet = ContentResultSetWrapper::queryXXX();    \
    1278             :         if( m_xContentIdentifierMapping.is() )              \
    1279             :             return m_xContentIdentifierMapping->map##XXX( aRet );\
    1280             :         return aRet;                                        \
    1281             :     }                                                       \
    1282             : }                                                           \
    1283             : return m_aCache##XXX.get##XXX( nRow );
    1284             : 
    1285             : //--------------------------------------------------------------------------
    1286             : // virtual
    1287           0 : OUString SAL_CALL CachedContentResultSet
    1288             :     ::queryContentIdentifierString()
    1289             :     throw( RuntimeException )
    1290             : {
    1291           0 :     XCONTENTACCESS_queryXXX( queryContentIdentifierString, ContentIdentifierString, OUString )
    1292             : }
    1293             : 
    1294             : //--------------------------------------------------------------------------
    1295             : // virtual
    1296           0 : Reference< XContentIdentifier > SAL_CALL CachedContentResultSet
    1297             :     ::queryContentIdentifier()
    1298             :     throw( RuntimeException )
    1299             : {
    1300           0 :     XCONTENTACCESS_queryXXX( queryContentIdentifier, ContentIdentifier, Reference< XContentIdentifier > )
    1301             : }
    1302             : 
    1303             : //--------------------------------------------------------------------------
    1304             : // virtual
    1305           0 : Reference< XContent > SAL_CALL CachedContentResultSet
    1306             :     ::queryContent()
    1307             :     throw( RuntimeException )
    1308             : {
    1309           0 :     XCONTENTACCESS_queryXXX( queryContent, Content, Reference< XContent > )
    1310             : }
    1311             : 
    1312             : //-----------------------------------------------------------------
    1313             : // XResultSet methods. ( inherited )
    1314             : //-----------------------------------------------------------------
    1315             : //virtual
    1316             : 
    1317           0 : sal_Bool SAL_CALL CachedContentResultSet
    1318             :     ::next()
    1319             :     throw( SQLException,
    1320             :            RuntimeException )
    1321             : {
    1322           0 :     impl_EnsureNotDisposed();
    1323             : 
    1324           0 :     ReacquireableGuard aGuard( m_aMutex );
    1325             :     //after last
    1326           0 :     if( m_bAfterLast )
    1327           0 :         return sal_False;
    1328             :     //last
    1329           0 :     aGuard.clear();
    1330           0 :     if( isLast() )
    1331             :     {
    1332           0 :         aGuard.reacquire();
    1333           0 :         m_nRow++;
    1334           0 :         m_bAfterLast = sal_True;
    1335           0 :         return sal_False;
    1336             :     }
    1337           0 :     aGuard.reacquire();
    1338             :     //known valid position
    1339           0 :     if( impl_isKnownValidPosition( m_nRow + 1 ) )
    1340             :     {
    1341           0 :         m_nRow++;
    1342           0 :         return sal_True;
    1343             :     }
    1344             : 
    1345             :     //unknown position
    1346           0 :     sal_Int32 nRow = m_nRow;
    1347           0 :     aGuard.clear();
    1348             : 
    1349           0 :     sal_Bool bValid = applyPositionToOrigin( nRow + 1 );
    1350             : 
    1351           0 :     aGuard.reacquire();
    1352           0 :     m_nRow = nRow + 1;
    1353           0 :     m_bAfterLast = !bValid;
    1354           0 :     return bValid;
    1355             : }
    1356             : 
    1357             : //virtual
    1358           0 : sal_Bool SAL_CALL CachedContentResultSet
    1359             :     ::previous()
    1360             :     throw( SQLException,
    1361             :            RuntimeException )
    1362             : {
    1363           0 :     impl_EnsureNotDisposed();
    1364             : 
    1365           0 :     if( impl_isForwardOnly() )
    1366           0 :         throw SQLException();
    1367             : 
    1368           0 :     ReacquireableGuard aGuard( m_aMutex );
    1369             :     //before first ?:
    1370           0 :     if( !m_bAfterLast && !m_nRow )
    1371           0 :         return sal_False;
    1372             :     //first ?:
    1373           0 :     if( !m_bAfterLast && m_nKnownCount && m_nRow == 1 )
    1374             :     {
    1375           0 :         m_nRow--;
    1376           0 :         m_bAfterLast = sal_False;
    1377           0 :         return sal_False;
    1378             :     }
    1379             :     //known valid position ?:
    1380           0 :     if( impl_isKnownValidPosition( m_nRow - 1 ) )
    1381             :     {
    1382           0 :         m_nRow--;
    1383           0 :         m_bAfterLast = sal_False;
    1384           0 :         return sal_True;
    1385             :     }
    1386             :     //unknown position:
    1387           0 :     sal_Int32 nRow = m_nRow;
    1388           0 :     aGuard.clear();
    1389             : 
    1390           0 :     sal_Bool bValid = applyPositionToOrigin( nRow - 1  );
    1391             : 
    1392           0 :     aGuard.reacquire();
    1393           0 :     m_nRow = nRow - 1;
    1394           0 :     m_bAfterLast = sal_False;
    1395           0 :     return bValid;
    1396             : }
    1397             : 
    1398             : //virtual
    1399           0 : sal_Bool SAL_CALL CachedContentResultSet
    1400             :     ::absolute( sal_Int32 row )
    1401             :     throw( SQLException,
    1402             :            RuntimeException )
    1403             : {
    1404           0 :     impl_EnsureNotDisposed();
    1405             : 
    1406           0 :     if( !row )
    1407           0 :         throw SQLException();
    1408             : 
    1409           0 :     if( impl_isForwardOnly() )
    1410           0 :         throw SQLException();
    1411             : 
    1412           0 :     ReacquireableGuard aGuard( m_aMutex );
    1413             : 
    1414           0 :     if( !m_xResultSetOrigin.is() )
    1415             :     {
    1416             :         OSL_FAIL( "broadcaster was disposed already" );
    1417           0 :         return sal_False;
    1418             :     }
    1419           0 :     if( row < 0 )
    1420             :     {
    1421           0 :         if( m_bFinalCount )
    1422             :         {
    1423           0 :             sal_Int32 nNewRow = m_nKnownCount + 1 + row;
    1424           0 :             sal_Bool bValid = sal_True;
    1425           0 :             if( nNewRow <= 0 )
    1426             :             {
    1427           0 :                 nNewRow = 0;
    1428           0 :                 bValid = sal_False;
    1429             :             }
    1430           0 :             m_nRow = nNewRow;
    1431           0 :             m_bAfterLast = sal_False;
    1432           0 :             return bValid;
    1433             :         }
    1434             :         //unknown final count:
    1435           0 :         aGuard.clear();
    1436             : 
    1437             :         // Solaris has problems catching or propagating derived exceptions
    1438             :         // when only the base class is known, so make ResultSetException
    1439             :         // (derived from SQLException) known here:
    1440             :         sal_Bool bValid;
    1441             :         try
    1442             :         {
    1443           0 :             bValid = m_xResultSetOrigin->absolute( row );
    1444             :         }
    1445           0 :         catch (const ResultSetException&)
    1446             :         {
    1447           0 :             throw;
    1448             :         }
    1449             : 
    1450           0 :         aGuard.reacquire();
    1451           0 :         if( m_bFinalCount )
    1452             :         {
    1453           0 :             sal_Int32 nNewRow = m_nKnownCount + 1 + row;
    1454           0 :             if( nNewRow < 0 )
    1455           0 :                 nNewRow = 0;
    1456           0 :             m_nLastAppliedPos = nNewRow;
    1457           0 :             m_nRow = nNewRow;
    1458           0 :             m_bAfterLastApplied = m_bAfterLast = sal_False;
    1459           0 :             return bValid;
    1460             :         }
    1461           0 :         aGuard.clear();
    1462             : 
    1463           0 :         sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
    1464             : 
    1465           0 :         aGuard.reacquire();
    1466           0 :         m_nLastAppliedPos = nCurRow;
    1467           0 :         m_nRow = nCurRow;
    1468           0 :         m_bAfterLast = sal_False;
    1469           0 :         return nCurRow != 0;
    1470             :     }
    1471             :     //row > 0:
    1472           0 :     if( m_bFinalCount )
    1473             :     {
    1474           0 :         if( row > m_nKnownCount )
    1475             :         {
    1476           0 :             m_nRow = m_nKnownCount + 1;
    1477           0 :             m_bAfterLast = sal_True;
    1478           0 :             return sal_False;
    1479             :         }
    1480           0 :         m_nRow = row;
    1481           0 :         m_bAfterLast = sal_False;
    1482           0 :         return sal_True;
    1483             :     }
    1484             :     //unknown new position:
    1485           0 :     aGuard.clear();
    1486             : 
    1487           0 :     sal_Bool bValid = m_xResultSetOrigin->absolute( row );
    1488             : 
    1489           0 :     aGuard.reacquire();
    1490           0 :     if( m_bFinalCount )
    1491             :     {
    1492           0 :         sal_Int32 nNewRow = row;
    1493           0 :         if( nNewRow > m_nKnownCount )
    1494             :         {
    1495           0 :             nNewRow = m_nKnownCount + 1;
    1496           0 :             m_bAfterLastApplied = m_bAfterLast = sal_True;
    1497             :         }
    1498             :         else
    1499           0 :             m_bAfterLastApplied = m_bAfterLast = sal_False;
    1500             : 
    1501           0 :         m_nLastAppliedPos = nNewRow;
    1502           0 :         m_nRow = nNewRow;
    1503           0 :         return bValid;
    1504             :     }
    1505           0 :     aGuard.clear();
    1506             : 
    1507           0 :     sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
    1508           0 :     sal_Bool bIsAfterLast = m_xResultSetOrigin->isAfterLast();
    1509             : 
    1510           0 :     aGuard.reacquire();
    1511           0 :     m_nLastAppliedPos = nCurRow;
    1512           0 :     m_nRow = nCurRow;
    1513           0 :     m_bAfterLastApplied = m_bAfterLast = bIsAfterLast;
    1514           0 :     return nCurRow && !bIsAfterLast;
    1515             : }
    1516             : 
    1517             : //virtual
    1518           0 : sal_Bool SAL_CALL CachedContentResultSet
    1519             :     ::relative( sal_Int32 rows )
    1520             :     throw( SQLException,
    1521             :            RuntimeException )
    1522             : {
    1523           0 :     impl_EnsureNotDisposed();
    1524             : 
    1525           0 :     if( impl_isForwardOnly() )
    1526           0 :         throw SQLException();
    1527             : 
    1528           0 :     ReacquireableGuard aGuard( m_aMutex );
    1529           0 :     if( m_bAfterLast || impl_isKnownInvalidPosition( m_nRow ) )
    1530           0 :         throw SQLException();
    1531             : 
    1532           0 :     if( !rows )
    1533           0 :         return sal_True;
    1534             : 
    1535           0 :     sal_Int32 nNewRow = m_nRow + rows;
    1536           0 :         if( nNewRow < 0 )
    1537           0 :             nNewRow = 0;
    1538             : 
    1539           0 :     if( impl_isKnownValidPosition( nNewRow ) )
    1540             :     {
    1541           0 :         m_nRow = nNewRow;
    1542           0 :         m_bAfterLast = sal_False;
    1543           0 :         return sal_True;
    1544             :     }
    1545             :     else
    1546             :     {
    1547             :         //known invalid new position:
    1548           0 :         if( nNewRow == 0 )
    1549             :         {
    1550           0 :             m_bAfterLast = sal_False;
    1551           0 :             m_nRow = 0;
    1552           0 :             return sal_False;
    1553             :         }
    1554           0 :         if( m_bFinalCount && nNewRow > m_nKnownCount )
    1555             :         {
    1556           0 :             m_bAfterLast = sal_True;
    1557           0 :             m_nRow = m_nKnownCount + 1;
    1558           0 :             return sal_False;
    1559             :         }
    1560             :         //unknown new position:
    1561           0 :         aGuard.clear();
    1562           0 :         sal_Bool bValid = applyPositionToOrigin( nNewRow );
    1563             : 
    1564           0 :         aGuard.reacquire();
    1565           0 :         m_nRow = nNewRow;
    1566           0 :         m_bAfterLast = !bValid && nNewRow > 0;
    1567           0 :         return bValid;
    1568           0 :     }
    1569             : }
    1570             : 
    1571             : 
    1572             : //virtual
    1573           0 : sal_Bool SAL_CALL CachedContentResultSet
    1574             :     ::first()
    1575             :     throw( SQLException,
    1576             :            RuntimeException )
    1577             : {
    1578           0 :     impl_EnsureNotDisposed();
    1579             : 
    1580           0 :     if( impl_isForwardOnly() )
    1581           0 :         throw SQLException();
    1582             : 
    1583           0 :     ReacquireableGuard aGuard( m_aMutex );
    1584           0 :     if( impl_isKnownValidPosition( 1 ) )
    1585             :     {
    1586           0 :         m_nRow = 1;
    1587           0 :         m_bAfterLast = sal_False;
    1588           0 :         return sal_True;
    1589             :     }
    1590           0 :     if( impl_isKnownInvalidPosition( 1 ) )
    1591             :     {
    1592           0 :         m_nRow = 1;
    1593           0 :         m_bAfterLast = sal_False;
    1594           0 :         return sal_False;
    1595             :     }
    1596             :     //unknown position
    1597           0 :     aGuard.clear();
    1598             : 
    1599           0 :     sal_Bool bValid = applyPositionToOrigin( 1 );
    1600             : 
    1601           0 :     aGuard.reacquire();
    1602           0 :     m_nRow = 1;
    1603           0 :     m_bAfterLast = sal_False;
    1604           0 :     return bValid;
    1605             : }
    1606             : 
    1607             : //virtual
    1608           0 : sal_Bool SAL_CALL CachedContentResultSet
    1609             :     ::last()
    1610             :     throw( SQLException,
    1611             :            RuntimeException )
    1612             : {
    1613           0 :     impl_EnsureNotDisposed();
    1614             : 
    1615           0 :     if( impl_isForwardOnly() )
    1616           0 :         throw SQLException();
    1617             : 
    1618           0 :     ReacquireableGuard aGuard( m_aMutex );
    1619           0 :     if( m_bFinalCount )
    1620             :     {
    1621           0 :         m_nRow = m_nKnownCount;
    1622           0 :         m_bAfterLast = sal_False;
    1623           0 :         return m_nKnownCount != 0;
    1624             :     }
    1625             :     //unknown position
    1626           0 :     if( !m_xResultSetOrigin.is() )
    1627             :     {
    1628             :         OSL_FAIL( "broadcaster was disposed already" );
    1629           0 :         return sal_False;
    1630             :     }
    1631           0 :     aGuard.clear();
    1632             : 
    1633           0 :     sal_Bool bValid = m_xResultSetOrigin->last();
    1634             : 
    1635           0 :     aGuard.reacquire();
    1636           0 :     m_bAfterLastApplied = m_bAfterLast = sal_False;
    1637           0 :     if( m_bFinalCount )
    1638             :     {
    1639           0 :         m_nLastAppliedPos = m_nKnownCount;
    1640           0 :         m_nRow = m_nKnownCount;
    1641           0 :         return bValid;
    1642             :     }
    1643           0 :     aGuard.clear();
    1644             : 
    1645           0 :     sal_Int32 nCurRow = m_xResultSetOrigin->getRow();
    1646             : 
    1647           0 :     aGuard.reacquire();
    1648           0 :     m_nLastAppliedPos = nCurRow;
    1649           0 :     m_nRow = nCurRow;
    1650             :     OSL_ENSURE( nCurRow >= m_nKnownCount, "position of last row < known Count, that could not be" );
    1651           0 :     m_nKnownCount = nCurRow;
    1652           0 :     m_bFinalCount = sal_True;
    1653           0 :     return nCurRow != 0;
    1654             : }
    1655             : 
    1656             : //virtual
    1657           0 : void SAL_CALL CachedContentResultSet
    1658             :     ::beforeFirst()
    1659             :     throw( SQLException,
    1660             :            RuntimeException )
    1661             : {
    1662           0 :     impl_EnsureNotDisposed();
    1663             : 
    1664           0 :     if( impl_isForwardOnly() )
    1665           0 :         throw SQLException();
    1666             : 
    1667           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1668           0 :     m_nRow = 0;
    1669           0 :     m_bAfterLast = sal_False;
    1670           0 : }
    1671             : 
    1672             : //virtual
    1673           0 : void SAL_CALL CachedContentResultSet
    1674             :     ::afterLast()
    1675             :     throw( SQLException,
    1676             :            RuntimeException )
    1677             : {
    1678           0 :     impl_EnsureNotDisposed();
    1679             : 
    1680           0 :     if( impl_isForwardOnly() )
    1681           0 :         throw SQLException();
    1682             : 
    1683           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1684           0 :     m_nRow = 1;
    1685           0 :     m_bAfterLast = sal_True;
    1686           0 : }
    1687             : 
    1688             : //virtual
    1689           0 : sal_Bool SAL_CALL CachedContentResultSet
    1690             :     ::isAfterLast()
    1691             :     throw( SQLException,
    1692             :            RuntimeException )
    1693             : {
    1694           0 :     impl_EnsureNotDisposed();
    1695             : 
    1696           0 :     ReacquireableGuard aGuard( m_aMutex );
    1697           0 :     if( !m_bAfterLast )
    1698           0 :         return sal_False;
    1699           0 :     if( m_nKnownCount )
    1700           0 :         return m_bAfterLast;
    1701           0 :     if( m_bFinalCount )
    1702           0 :         return sal_False;
    1703             : 
    1704           0 :     if( !m_xResultSetOrigin.is() )
    1705             :     {
    1706             :         OSL_FAIL( "broadcaster was disposed already" );
    1707           0 :         return sal_False;
    1708             :     }
    1709           0 :     aGuard.clear();
    1710             : 
    1711             :     //find out whethter the original resultset contains rows or not
    1712           0 :     m_xResultSetOrigin->afterLast();
    1713             : 
    1714           0 :     aGuard.reacquire();
    1715           0 :     m_bAfterLastApplied = sal_True;
    1716           0 :     aGuard.clear();
    1717             : 
    1718           0 :     return m_xResultSetOrigin->isAfterLast();
    1719             : }
    1720             : 
    1721             : //virtual
    1722           0 : sal_Bool SAL_CALL CachedContentResultSet
    1723             :     ::isBeforeFirst()
    1724             :     throw( SQLException,
    1725             :            RuntimeException )
    1726             : {
    1727           0 :     impl_EnsureNotDisposed();
    1728             : 
    1729           0 :     ReacquireableGuard aGuard( m_aMutex );
    1730           0 :     if( m_bAfterLast )
    1731           0 :         return sal_False;
    1732           0 :     if( m_nRow )
    1733           0 :         return sal_False;
    1734           0 :     if( m_nKnownCount )
    1735           0 :         return !m_nRow;
    1736           0 :     if( m_bFinalCount )
    1737           0 :         return sal_False;
    1738             : 
    1739           0 :     if( !m_xResultSetOrigin.is() )
    1740             :     {
    1741             :         OSL_FAIL( "broadcaster was disposed already" );
    1742           0 :         return sal_False;
    1743             :     }
    1744           0 :     aGuard.clear();
    1745             : 
    1746             :     //find out whethter the original resultset contains rows or not
    1747           0 :     m_xResultSetOrigin->beforeFirst();
    1748             : 
    1749           0 :     aGuard.reacquire();
    1750           0 :     m_bAfterLastApplied = sal_False;
    1751           0 :     m_nLastAppliedPos = 0;
    1752           0 :     aGuard.clear();
    1753             : 
    1754           0 :     return m_xResultSetOrigin->isBeforeFirst();
    1755             : }
    1756             : 
    1757             : //virtual
    1758           0 : sal_Bool SAL_CALL CachedContentResultSet
    1759             :     ::isFirst()
    1760             :     throw( SQLException,
    1761             :            RuntimeException )
    1762             : {
    1763           0 :     impl_EnsureNotDisposed();
    1764             : 
    1765           0 :     sal_Int32 nRow = 0;
    1766           0 :     Reference< XResultSet > xResultSetOrigin;
    1767             : 
    1768             :     {
    1769           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1770           0 :         if( m_bAfterLast )
    1771           0 :             return sal_False;
    1772           0 :         if( m_nRow != 1 )
    1773           0 :             return sal_False;
    1774           0 :         if( m_nKnownCount )
    1775           0 :             return m_nRow == 1;
    1776           0 :         if( m_bFinalCount )
    1777           0 :             return sal_False;
    1778             : 
    1779           0 :         nRow = m_nRow;
    1780           0 :         xResultSetOrigin = m_xResultSetOrigin;
    1781             :     }
    1782             : 
    1783             :     //need to ask origin
    1784             :     {
    1785           0 :         if( applyPositionToOrigin( nRow ) )
    1786           0 :             return xResultSetOrigin->isFirst();
    1787             :         else
    1788           0 :             return sal_False;
    1789           0 :     }
    1790             : }
    1791             : 
    1792             : //virtual
    1793           0 : sal_Bool SAL_CALL CachedContentResultSet
    1794             :     ::isLast()
    1795             :     throw( SQLException,
    1796             :            RuntimeException )
    1797             : {
    1798           0 :     impl_EnsureNotDisposed();
    1799             : 
    1800           0 :     sal_Int32 nRow = 0;
    1801           0 :     Reference< XResultSet > xResultSetOrigin;
    1802             :     {
    1803           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1804           0 :         if( m_bAfterLast )
    1805           0 :             return sal_False;
    1806           0 :         if( m_nRow < m_nKnownCount )
    1807           0 :             return sal_False;
    1808           0 :         if( m_bFinalCount )
    1809           0 :             return m_nKnownCount && m_nRow == m_nKnownCount;
    1810             : 
    1811           0 :         nRow = m_nRow;
    1812           0 :         xResultSetOrigin = m_xResultSetOrigin;
    1813             :     }
    1814             : 
    1815             :     //need to ask origin
    1816             :     {
    1817           0 :         if( applyPositionToOrigin( nRow ) )
    1818           0 :             return xResultSetOrigin->isLast();
    1819             :         else
    1820           0 :             return sal_False;
    1821           0 :     }
    1822             : }
    1823             : 
    1824             : 
    1825             : //virtual
    1826           0 : sal_Int32 SAL_CALL CachedContentResultSet
    1827             :     ::getRow()
    1828             :     throw( SQLException,
    1829             :            RuntimeException )
    1830             : {
    1831           0 :     impl_EnsureNotDisposed();
    1832             : 
    1833           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1834           0 :     if( m_bAfterLast )
    1835           0 :         return 0;
    1836           0 :     return m_nRow;
    1837             : }
    1838             : 
    1839             : //virtual
    1840           0 : void SAL_CALL CachedContentResultSet
    1841             :     ::refreshRow()
    1842             :     throw( SQLException,
    1843             :            RuntimeException )
    1844             : {
    1845           0 :     impl_EnsureNotDisposed();
    1846             : 
    1847             :     //the ContentResultSet is static and will not change
    1848             :     //therefore we don't need to reload anything
    1849           0 : }
    1850             : 
    1851             : //virtual
    1852           0 : sal_Bool SAL_CALL CachedContentResultSet
    1853             :     ::rowUpdated()
    1854             :     throw( SQLException,
    1855             :            RuntimeException )
    1856             : {
    1857           0 :     impl_EnsureNotDisposed();
    1858             : 
    1859             :     //the ContentResultSet is static and will not change
    1860           0 :     return sal_False;
    1861             : }
    1862             : //virtual
    1863           0 : sal_Bool SAL_CALL CachedContentResultSet
    1864             :     ::rowInserted()
    1865             :     throw( SQLException,
    1866             :            RuntimeException )
    1867             : {
    1868           0 :     impl_EnsureNotDisposed();
    1869             : 
    1870             :     //the ContentResultSet is static and will not change
    1871           0 :     return sal_False;
    1872             : }
    1873             : 
    1874             : //virtual
    1875           0 : sal_Bool SAL_CALL CachedContentResultSet
    1876             :     ::rowDeleted()
    1877             :     throw( SQLException,
    1878             :            RuntimeException )
    1879             : {
    1880           0 :     impl_EnsureNotDisposed();
    1881             : 
    1882             :     //the ContentResultSet is static and will not change
    1883           0 :     return sal_False;
    1884             : }
    1885             : 
    1886             : //virtual
    1887           0 : Reference< XInterface > SAL_CALL CachedContentResultSet
    1888             :     ::getStatement()
    1889             :     throw( SQLException,
    1890             :            RuntimeException )
    1891             : {
    1892           0 :     impl_EnsureNotDisposed();
    1893             :     //@todo ?return anything
    1894           0 :     return Reference< XInterface >();
    1895             : }
    1896             : 
    1897             : //-----------------------------------------------------------------
    1898             : // XRow methods. ( inherited )
    1899             : //-----------------------------------------------------------------
    1900             : 
    1901             : //virtual
    1902           0 : sal_Bool SAL_CALL CachedContentResultSet
    1903             :     ::wasNull()
    1904             :     throw( SQLException,
    1905             :            RuntimeException )
    1906             : {
    1907           0 :     impl_EnsureNotDisposed();
    1908           0 :     impl_init_xRowOrigin();
    1909             :     {
    1910           0 :         osl::Guard< osl::Mutex > aGuard( m_aMutex );
    1911           0 :         if( m_bLastReadWasFromCache )
    1912           0 :             return m_bLastCachedReadWasNull;
    1913           0 :         if( !m_xRowOrigin.is() )
    1914             :         {
    1915             :             OSL_FAIL( "broadcaster was disposed already" );
    1916           0 :             return sal_False;
    1917           0 :         }
    1918             :     }
    1919           0 :     return m_xRowOrigin->wasNull();
    1920             : }
    1921             : 
    1922             : //virtual
    1923           0 : OUString SAL_CALL CachedContentResultSet
    1924             :     ::getString( sal_Int32 columnIndex )
    1925             :     throw( SQLException,
    1926             :            RuntimeException )
    1927             : {
    1928           0 :     XROW_GETXXX( getString, OUString );
    1929             : }
    1930             : 
    1931             : //virtual
    1932           0 : sal_Bool SAL_CALL CachedContentResultSet
    1933             :     ::getBoolean( sal_Int32 columnIndex )
    1934             :     throw( SQLException,
    1935             :            RuntimeException )
    1936             : {
    1937           0 :     XROW_GETXXX( getBoolean, sal_Bool );
    1938             : }
    1939             : 
    1940             : //virtual
    1941           0 : sal_Int8 SAL_CALL CachedContentResultSet
    1942             :     ::getByte( sal_Int32 columnIndex )
    1943             :     throw( SQLException,
    1944             :            RuntimeException )
    1945             : {
    1946           0 :     XROW_GETXXX( getByte, sal_Int8 );
    1947             : }
    1948             : 
    1949             : //virtual
    1950           0 : sal_Int16 SAL_CALL CachedContentResultSet
    1951             :     ::getShort( sal_Int32 columnIndex )
    1952             :     throw( SQLException,
    1953             :            RuntimeException )
    1954             : {
    1955           0 :     XROW_GETXXX( getShort, sal_Int16 );
    1956             : }
    1957             : 
    1958             : //virtual
    1959           0 : sal_Int32 SAL_CALL CachedContentResultSet
    1960             :     ::getInt( sal_Int32 columnIndex )
    1961             :     throw( SQLException,
    1962             :            RuntimeException )
    1963             : {
    1964           0 :     XROW_GETXXX( getInt, sal_Int32 );
    1965             : }
    1966             : 
    1967             : //virtual
    1968           0 : sal_Int64 SAL_CALL CachedContentResultSet
    1969             :     ::getLong( sal_Int32 columnIndex )
    1970             :     throw( SQLException,
    1971             :            RuntimeException )
    1972             : {
    1973           0 :     XROW_GETXXX( getLong, sal_Int64 );
    1974             : }
    1975             : 
    1976             : //virtual
    1977           0 : float SAL_CALL CachedContentResultSet
    1978             :     ::getFloat( sal_Int32 columnIndex )
    1979             :     throw( SQLException,
    1980             :            RuntimeException )
    1981             : {
    1982           0 :     XROW_GETXXX( getFloat, float );
    1983             : }
    1984             : 
    1985             : //virtual
    1986           0 : double SAL_CALL CachedContentResultSet
    1987             :     ::getDouble( sal_Int32 columnIndex )
    1988             :     throw( SQLException,
    1989             :            RuntimeException )
    1990             : {
    1991           0 :     XROW_GETXXX( getDouble, double );
    1992             : }
    1993             : 
    1994             : //virtual
    1995           0 : Sequence< sal_Int8 > SAL_CALL CachedContentResultSet
    1996             :     ::getBytes( sal_Int32 columnIndex )
    1997             :     throw( SQLException,
    1998             :            RuntimeException )
    1999             : {
    2000           0 :     XROW_GETXXX( getBytes, Sequence< sal_Int8 > );
    2001             : }
    2002             : 
    2003             : //virtual
    2004           0 : Date SAL_CALL CachedContentResultSet
    2005             :     ::getDate( sal_Int32 columnIndex )
    2006             :     throw( SQLException,
    2007             :            RuntimeException )
    2008             : {
    2009           0 :     XROW_GETXXX( getDate, Date );
    2010             : }
    2011             : 
    2012             : //virtual
    2013           0 : Time SAL_CALL CachedContentResultSet
    2014             :     ::getTime( sal_Int32 columnIndex )
    2015             :     throw( SQLException,
    2016             :            RuntimeException )
    2017             : {
    2018           0 :     XROW_GETXXX( getTime, Time );
    2019             : }
    2020             : 
    2021             : //virtual
    2022           0 : DateTime SAL_CALL CachedContentResultSet
    2023             :     ::getTimestamp( sal_Int32 columnIndex )
    2024             :     throw( SQLException,
    2025             :            RuntimeException )
    2026             : {
    2027           0 :     XROW_GETXXX( getTimestamp, DateTime );
    2028             : }
    2029             : 
    2030             : //virtual
    2031             : Reference< com::sun::star::io::XInputStream >
    2032           0 :     SAL_CALL CachedContentResultSet
    2033             :     ::getBinaryStream( sal_Int32 columnIndex )
    2034             :     throw( SQLException,
    2035             :            RuntimeException )
    2036             : {
    2037           0 :     XROW_GETXXX( getBinaryStream, Reference< com::sun::star::io::XInputStream > );
    2038             : }
    2039             : 
    2040             : //virtual
    2041             : Reference< com::sun::star::io::XInputStream >
    2042           0 :     SAL_CALL CachedContentResultSet
    2043             :     ::getCharacterStream( sal_Int32 columnIndex )
    2044             :     throw( SQLException,
    2045             :            RuntimeException )
    2046             : {
    2047           0 :     XROW_GETXXX( getCharacterStream, Reference< com::sun::star::io::XInputStream > );
    2048             : }
    2049             : 
    2050             : //virtual
    2051           0 : Any SAL_CALL CachedContentResultSet
    2052             :     ::getObject( sal_Int32 columnIndex,
    2053             :            const Reference<
    2054             :             com::sun::star::container::XNameAccess >& typeMap )
    2055             :     throw( SQLException,
    2056             :            RuntimeException )
    2057             : {
    2058             :     //if you change this macro please pay attention to
    2059             :     //define XROW_GETXXX, where this is similar implemented
    2060             : 
    2061           0 :     ReacquireableGuard aGuard( m_aMutex );
    2062           0 :     sal_Int32 nRow = m_nRow;
    2063           0 :     sal_Int32 nFetchSize = m_nFetchSize;
    2064           0 :     sal_Int32 nFetchDirection = m_nFetchDirection;
    2065           0 :     if( !m_aCache.hasRow( nRow ) )
    2066             :     {
    2067           0 :         if( !m_aCache.hasCausedException( nRow ) )
    2068             :         {
    2069           0 :             if( !m_xFetchProvider.is() )
    2070             :             {
    2071             :                 OSL_FAIL( "broadcaster was disposed already" );
    2072           0 :                 return Any();
    2073             :             }
    2074           0 :             aGuard.clear();
    2075             : 
    2076           0 :             impl_fetchData( nRow, nFetchSize, nFetchDirection );
    2077             :         }
    2078           0 :         aGuard.reacquire();
    2079           0 :         if( !m_aCache.hasRow( nRow ) )
    2080             :         {
    2081           0 :             m_bLastReadWasFromCache = sal_False;
    2082           0 :             aGuard.clear();
    2083           0 :             applyPositionToOrigin( nRow );
    2084           0 :             impl_init_xRowOrigin();
    2085           0 :             return m_xRowOrigin->getObject( columnIndex, typeMap );
    2086             :         }
    2087             :     }
    2088             :     //@todo: pay attention to typeMap
    2089           0 :     const Any& rValue = m_aCache.getAny( nRow, columnIndex );
    2090           0 :     Any aRet;
    2091           0 :     m_bLastReadWasFromCache = sal_True;
    2092           0 :     m_bLastCachedReadWasNull = !( rValue >>= aRet );
    2093           0 :     return aRet;
    2094             : }
    2095             : 
    2096             : //virtual
    2097           0 : Reference< XRef > SAL_CALL CachedContentResultSet
    2098             :     ::getRef( sal_Int32 columnIndex )
    2099             :     throw( SQLException,
    2100             :            RuntimeException )
    2101             : {
    2102           0 :     XROW_GETXXX( getRef, Reference< XRef > );
    2103             : }
    2104             : 
    2105             : //virtual
    2106           0 : Reference< XBlob > SAL_CALL CachedContentResultSet
    2107             :     ::getBlob( sal_Int32 columnIndex )
    2108             :     throw( SQLException,
    2109             :            RuntimeException )
    2110             : {
    2111           0 :     XROW_GETXXX( getBlob, Reference< XBlob > );
    2112             : }
    2113             : 
    2114             : //virtual
    2115           0 : Reference< XClob > SAL_CALL CachedContentResultSet
    2116             :     ::getClob( sal_Int32 columnIndex )
    2117             :     throw( SQLException,
    2118             :            RuntimeException )
    2119             : {
    2120           0 :     XROW_GETXXX( getClob, Reference< XClob > );
    2121             : }
    2122             : 
    2123             : //virtual
    2124           0 : Reference< XArray > SAL_CALL CachedContentResultSet
    2125             :     ::getArray( sal_Int32 columnIndex )
    2126             :     throw( SQLException,
    2127             :            RuntimeException )
    2128             : {
    2129           0 :     XROW_GETXXX( getArray, Reference< XArray > );
    2130             : }
    2131             : 
    2132             : //-----------------------------------------------------------------
    2133             : // Type Converter Support
    2134             : //-----------------------------------------------------------------
    2135             : 
    2136           0 : const Reference< XTypeConverter >& CachedContentResultSet::getTypeConverter()
    2137             : {
    2138           0 :     osl::Guard< osl::Mutex > aGuard( m_aMutex );
    2139             : 
    2140           0 :     if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() )
    2141             :     {
    2142           0 :         m_bTriedToGetTypeConverter = sal_True;
    2143           0 :         m_xTypeConverter = Reference< XTypeConverter >( Converter::create(m_xContext) );
    2144             : 
    2145             :         OSL_ENSURE( m_xTypeConverter.is(),
    2146             :                     "PropertyValueSet::getTypeConverter() - "
    2147             :                     "Service 'com.sun.star.script.Converter' n/a!" );
    2148             :     }
    2149           0 :     return m_xTypeConverter;
    2150             : }
    2151             : 
    2152             : //--------------------------------------------------------------------------
    2153             : //--------------------------------------------------------------------------
    2154             : // class CachedContentResultSetFactory
    2155             : //--------------------------------------------------------------------------
    2156             : //--------------------------------------------------------------------------
    2157             : 
    2158           0 : CachedContentResultSetFactory::CachedContentResultSetFactory(
    2159           0 :         const Reference< XComponentContext > & rxContext )
    2160             : {
    2161           0 :     m_xContext = rxContext;
    2162           0 : }
    2163             : 
    2164           0 : CachedContentResultSetFactory::~CachedContentResultSetFactory()
    2165             : {
    2166           0 : }
    2167             : 
    2168             : //--------------------------------------------------------------------------
    2169             : // CachedContentResultSetFactory XInterface methods.
    2170             : //--------------------------------------------------------------------------
    2171             : 
    2172           0 : XINTERFACE_IMPL_3( CachedContentResultSetFactory,
    2173             :                    XTypeProvider,
    2174             :                    XServiceInfo,
    2175             :                    XCachedContentResultSetFactory );
    2176             : 
    2177             : //--------------------------------------------------------------------------
    2178             : // CachedContentResultSetFactory XTypeProvider methods.
    2179             : //--------------------------------------------------------------------------
    2180             : 
    2181           0 : XTYPEPROVIDER_IMPL_3( CachedContentResultSetFactory,
    2182             :                       XTypeProvider,
    2183             :                          XServiceInfo,
    2184             :                       XCachedContentResultSetFactory );
    2185             : 
    2186             : //--------------------------------------------------------------------------
    2187             : // CachedContentResultSetFactory XServiceInfo methods.
    2188             : //--------------------------------------------------------------------------
    2189             : 
    2190           0 : XSERVICEINFO_IMPL_1_CTX( CachedContentResultSetFactory,
    2191             :                      OUString( "com.sun.star.comp.ucb.CachedContentResultSetFactory" ),
    2192           0 :                      OUString( CACHED_CONTENT_RESULTSET_FACTORY_NAME ) );
    2193             : 
    2194             : //--------------------------------------------------------------------------
    2195             : // Service factory implementation.
    2196             : //--------------------------------------------------------------------------
    2197             : 
    2198           0 : ONE_INSTANCE_SERVICE_FACTORY_IMPL( CachedContentResultSetFactory );
    2199             : 
    2200             : //--------------------------------------------------------------------------
    2201             : // CachedContentResultSetFactory XCachedContentResultSetFactory methods.
    2202             : //--------------------------------------------------------------------------
    2203             : 
    2204             :     //virtual
    2205           0 : Reference< XResultSet > SAL_CALL CachedContentResultSetFactory
    2206             :     ::createCachedContentResultSet(
    2207             :             const Reference< XResultSet > & xSource,
    2208             :             const Reference< XContentIdentifierMapping > & xMapping )
    2209             :             throw( com::sun::star::uno::RuntimeException )
    2210             : {
    2211           0 :     Reference< XResultSet > xRet;
    2212           0 :     xRet = new CachedContentResultSet( m_xContext, xSource, xMapping );
    2213           0 :     return xRet;
    2214           0 : }
    2215             : 
    2216             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10