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