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 <vector>
22 : #include <sortresult.hxx>
23 : #include <com/sun/star/sdbc/DataType.hpp>
24 : #include <com/sun/star/sdbc/XResultSetMetaData.hpp>
25 : #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
26 : #include <com/sun/star/ucb/ListActionType.hpp>
27 : #include <com/sun/star/ucb/XAnyCompare.hpp>
28 : #include <com/sun/star/ucb/XAnyCompareFactory.hpp>
29 : #include <cppuhelper/implbase1.hxx>
30 : #include <cppuhelper/interfacecontainer.hxx>
31 : #include <cppuhelper/supportsservice.hxx>
32 : #include <osl/diagnose.h>
33 :
34 : using namespace com::sun::star::beans;
35 : using namespace com::sun::star::container;
36 : using namespace com::sun::star::io;
37 : using namespace com::sun::star::lang;
38 : using namespace com::sun::star::sdbc;
39 : using namespace com::sun::star::ucb;
40 : using namespace com::sun::star::uno;
41 : using namespace com::sun::star::util;
42 : using namespace cppu;
43 :
44 :
45 :
46 :
47 : // The mutex to synchronize access to containers.
48 0 : static osl::Mutex& getContainerMutex()
49 : {
50 : static osl::Mutex* pMutex = NULL;
51 0 : if( !pMutex )
52 : {
53 0 : osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
54 0 : if( !pMutex )
55 : {
56 0 : static osl::Mutex aMutex;
57 0 : pMutex = &aMutex;
58 0 : }
59 : }
60 :
61 0 : return *pMutex;
62 : }
63 :
64 :
65 :
66 0 : struct SortInfo
67 : {
68 : sal_Bool mbUseOwnCompare;
69 : sal_Bool mbAscending;
70 : sal_Bool mbCaseSensitive;
71 : sal_Int32 mnColumn;
72 : sal_Int32 mnType;
73 : SortInfo* mpNext;
74 : Reference < XAnyCompare > mxCompareFunction;
75 : };
76 :
77 :
78 :
79 : struct SortListData
80 : {
81 : sal_Bool mbModified;
82 : sal_IntPtr mnCurPos;
83 : sal_IntPtr mnOldPos;
84 :
85 : SortListData( sal_IntPtr nPos, sal_Bool bModified = sal_False );
86 : };
87 :
88 :
89 :
90 : // class SRSPropertySetInfo.
91 :
92 :
93 :
94 : class SRSPropertySetInfo : public cppu::WeakImplHelper1 <
95 : XPropertySetInfo >
96 : {
97 : Property maProps[2];
98 :
99 : private:
100 :
101 : public:
102 : SRSPropertySetInfo();
103 : virtual ~SRSPropertySetInfo();
104 :
105 : // XPropertySetInfo
106 : virtual Sequence< Property > SAL_CALL getProperties()
107 : throw( RuntimeException, std::exception ) SAL_OVERRIDE;
108 : virtual Property SAL_CALL getPropertyByName( const OUString& aName )
109 : throw( UnknownPropertyException, RuntimeException, std::exception ) SAL_OVERRIDE;
110 : virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
111 : throw( RuntimeException, std::exception ) SAL_OVERRIDE;
112 : };
113 :
114 :
115 :
116 : // PropertyChangeListenerContainer_Impl.
117 :
118 :
119 :
120 : struct equalStr_Impl
121 : {
122 0 : bool operator()( const OUString& s1, const OUString& s2 ) const
123 : {
124 0 : return !!( s1 == s2 );
125 : }
126 : };
127 :
128 : struct hashStr_Impl
129 : {
130 : size_t operator()( const OUString& rName ) const
131 : {
132 : return rName.hashCode();
133 : }
134 : };
135 :
136 : typedef OMultiTypeInterfaceContainerHelperVar
137 : <
138 : OUString,
139 : hashStr_Impl,
140 : equalStr_Impl
141 : > PropertyChangeListenerContainer_Impl;
142 :
143 :
144 :
145 : // class PropertyChangeListeners_Impl
146 :
147 :
148 :
149 0 : class PropertyChangeListeners_Impl : public PropertyChangeListenerContainer_Impl
150 : {
151 : public:
152 0 : PropertyChangeListeners_Impl()
153 0 : : PropertyChangeListenerContainer_Impl( getContainerMutex() ) {}
154 : };
155 :
156 :
157 0 : SortedResultSet::SortedResultSet( Reference< XResultSet > aResult )
158 : {
159 0 : mpDisposeEventListeners = NULL;
160 0 : mpPropChangeListeners = NULL;
161 0 : mpVetoChangeListeners = NULL;
162 0 : mpPropSetInfo = NULL;
163 :
164 0 : mxOriginal = aResult;
165 0 : mpSortInfo = NULL;
166 0 : mnLastSort = 0;
167 0 : mnCurEntry = 0;
168 0 : mnCount = 0;
169 0 : mbIsCopy = sal_False;
170 0 : }
171 :
172 :
173 0 : SortedResultSet::~SortedResultSet()
174 : {
175 0 : mxOriginal.clear();
176 0 : mxOther.clear();
177 :
178 0 : if ( !mbIsCopy )
179 : {
180 0 : SortInfo *pInfo = mpSortInfo;
181 0 : while ( pInfo )
182 : {
183 0 : mpSortInfo = pInfo->mpNext;
184 0 : delete pInfo;
185 0 : pInfo = mpSortInfo;
186 : }
187 : }
188 :
189 0 : mpSortInfo = NULL;
190 :
191 0 : if ( mpPropSetInfo )
192 0 : mpPropSetInfo->release();
193 :
194 0 : delete mpPropChangeListeners;
195 0 : delete mpVetoChangeListeners;
196 0 : }
197 :
198 :
199 : // XServiceInfo methods.
200 :
201 0 : OUString SAL_CALL SortedResultSet::getImplementationName()
202 : throw( css::uno::RuntimeException, std::exception )
203 : {
204 0 : return getImplementationName_Static();
205 : }
206 :
207 0 : OUString SortedResultSet::getImplementationName_Static()
208 : {
209 0 : return OUString( "com.sun.star.comp.ucb.SortedResultSet" );
210 : }
211 :
212 0 : sal_Bool SAL_CALL SortedResultSet::supportsService( const OUString& ServiceName )
213 : throw( css::uno::RuntimeException, std::exception )
214 : {
215 0 : return cppu::supportsService( this, ServiceName );
216 : }
217 :
218 0 : css::uno::Sequence< OUString > SAL_CALL SortedResultSet::getSupportedServiceNames()
219 : throw( css::uno::RuntimeException, std::exception )
220 : {
221 0 : return getSupportedServiceNames_Static();
222 : }
223 :
224 0 : css::uno::Sequence< OUString >SortedResultSet::getSupportedServiceNames_Static()
225 : {
226 0 : css::uno::Sequence< OUString > aSNS( 1 );
227 0 : aSNS.getArray()[ 0 ] = OUString( RESULTSET_SERVICE_NAME );
228 0 : return aSNS;
229 : }
230 :
231 :
232 : // XComponent methods.
233 :
234 0 : void SAL_CALL SortedResultSet::dispose()
235 : throw( RuntimeException, std::exception )
236 : {
237 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
238 :
239 0 : if ( mpDisposeEventListeners && mpDisposeEventListeners->getLength() )
240 : {
241 0 : EventObject aEvt;
242 0 : aEvt.Source = static_cast< XComponent * >( this );
243 0 : mpDisposeEventListeners->disposeAndClear( aEvt );
244 : }
245 :
246 0 : if ( mpPropChangeListeners )
247 : {
248 0 : EventObject aEvt;
249 0 : aEvt.Source = static_cast< XPropertySet * >( this );
250 0 : mpPropChangeListeners->disposeAndClear( aEvt );
251 : }
252 :
253 0 : if ( mpVetoChangeListeners )
254 : {
255 0 : EventObject aEvt;
256 0 : aEvt.Source = static_cast< XPropertySet * >( this );
257 0 : mpVetoChangeListeners->disposeAndClear( aEvt );
258 : }
259 :
260 0 : mxOriginal.clear();
261 0 : mxOther.clear();
262 0 : }
263 :
264 :
265 0 : void SAL_CALL SortedResultSet::addEventListener(
266 : const Reference< XEventListener >& Listener )
267 : throw( RuntimeException, std::exception )
268 : {
269 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
270 :
271 0 : if ( !mpDisposeEventListeners )
272 : mpDisposeEventListeners =
273 0 : new OInterfaceContainerHelper( getContainerMutex() );
274 :
275 0 : mpDisposeEventListeners->addInterface( Listener );
276 0 : }
277 :
278 :
279 0 : void SAL_CALL SortedResultSet::removeEventListener(
280 : const Reference< XEventListener >& Listener )
281 : throw( RuntimeException, std::exception )
282 : {
283 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
284 :
285 0 : if ( mpDisposeEventListeners )
286 0 : mpDisposeEventListeners->removeInterface( Listener );
287 0 : }
288 :
289 :
290 : // XContentAccess methods.
291 :
292 :
293 : OUString SAL_CALL
294 0 : SortedResultSet::queryContentIdentifierString()
295 : throw( RuntimeException, std::exception )
296 : {
297 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
298 0 : return Reference< XContentAccess >::query(mxOriginal)->queryContentIdentifierString();
299 : }
300 :
301 :
302 : Reference< XContentIdentifier > SAL_CALL
303 0 : SortedResultSet::queryContentIdentifier()
304 : throw( RuntimeException, std::exception )
305 : {
306 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
307 0 : return Reference< XContentAccess >::query(mxOriginal)->queryContentIdentifier();
308 : }
309 :
310 :
311 : Reference< XContent > SAL_CALL
312 0 : SortedResultSet::queryContent()
313 : throw( RuntimeException, std::exception )
314 : {
315 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
316 0 : return Reference< XContentAccess >::query(mxOriginal)->queryContent();
317 : }
318 :
319 :
320 :
321 : // XResultSet methods.
322 :
323 0 : sal_Bool SAL_CALL SortedResultSet::next()
324 : throw ( SQLException, RuntimeException, std::exception )
325 : {
326 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
327 :
328 0 : mnCurEntry++;
329 :
330 0 : if ( mnCurEntry > 0 )
331 : {
332 0 : if ( mnCurEntry <= mnCount )
333 : {
334 0 : sal_Int32 nIndex = maS2O[ mnCurEntry ];
335 0 : return mxOriginal->absolute( nIndex );
336 : }
337 : else
338 : {
339 0 : mnCurEntry = mnCount + 1;
340 : }
341 : }
342 0 : return sal_False;
343 : }
344 :
345 :
346 0 : sal_Bool SAL_CALL SortedResultSet::isBeforeFirst()
347 : throw ( SQLException, RuntimeException, std::exception )
348 : {
349 0 : if ( mnCurEntry )
350 0 : return sal_False;
351 : else
352 0 : return sal_True;
353 : }
354 :
355 :
356 0 : sal_Bool SAL_CALL SortedResultSet::isAfterLast()
357 : throw ( SQLException, RuntimeException, std::exception )
358 : {
359 0 : if ( mnCurEntry > mnCount )
360 0 : return sal_True;
361 : else
362 0 : return sal_False;
363 : }
364 :
365 :
366 0 : sal_Bool SAL_CALL SortedResultSet::isFirst()
367 : throw ( SQLException, RuntimeException, std::exception )
368 : {
369 0 : if ( mnCurEntry == 1 )
370 0 : return sal_True;
371 : else
372 0 : return sal_False;
373 : }
374 :
375 :
376 0 : sal_Bool SAL_CALL SortedResultSet::isLast()
377 : throw ( SQLException, RuntimeException, std::exception )
378 : {
379 0 : if ( mnCurEntry == mnCount )
380 0 : return sal_True;
381 : else
382 0 : return sal_False;
383 : }
384 :
385 :
386 0 : void SAL_CALL SortedResultSet::beforeFirst()
387 : throw ( SQLException, RuntimeException, std::exception )
388 : {
389 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
390 0 : mnCurEntry = 0;
391 0 : mxOriginal->beforeFirst();
392 0 : }
393 :
394 :
395 0 : void SAL_CALL SortedResultSet::afterLast()
396 : throw ( SQLException, RuntimeException, std::exception )
397 : {
398 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
399 0 : mnCurEntry = mnCount+1;
400 0 : mxOriginal->afterLast();
401 0 : }
402 :
403 :
404 0 : sal_Bool SAL_CALL SortedResultSet::first()
405 : throw ( SQLException, RuntimeException, std::exception )
406 : {
407 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
408 :
409 0 : if ( mnCount )
410 : {
411 0 : mnCurEntry = 1;
412 0 : sal_Int32 nIndex = maS2O[ mnCurEntry ];
413 0 : return mxOriginal->absolute( nIndex );
414 : }
415 : else
416 : {
417 0 : mnCurEntry = 0;
418 0 : return sal_False;
419 0 : }
420 : }
421 :
422 :
423 0 : sal_Bool SAL_CALL SortedResultSet::last()
424 : throw ( SQLException, RuntimeException, std::exception )
425 : {
426 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
427 :
428 0 : if ( mnCount )
429 : {
430 0 : mnCurEntry = mnCount;
431 0 : sal_Int32 nIndex = maS2O[ mnCurEntry ];
432 0 : return mxOriginal->absolute( nIndex );
433 : }
434 : else
435 : {
436 0 : mnCurEntry = 0;
437 0 : return sal_False;
438 0 : }
439 : }
440 :
441 :
442 0 : sal_Int32 SAL_CALL SortedResultSet::getRow()
443 : throw ( SQLException, RuntimeException, std::exception )
444 : {
445 0 : return mnCurEntry;
446 : }
447 :
448 :
449 : /**
450 : moves the cursor to the given row number in the result set.
451 : <p>If the row number is positive, the cursor moves to the given row
452 : number with respect to the beginning of the result set. The first
453 : row is row 1, the second is row 2, and so on.
454 : <p>If the given row number is negative, the cursor moves to an
455 : absolute row position with respect to the end of the result set.
456 : For example, calling <code>moveToPosition(-1)</code> positions the
457 : cursor on the last row, <code>moveToPosition(-2)</code> indicates the
458 : next-to-last row, and so on.
459 : <p>An attempt to position the cursor beyond the first/last row in the
460 : result set leaves the cursor before/after the first/last row,
461 : respectively.
462 : <p>Note: Calling <code>moveToPosition(1)</code> is the same
463 : as calling <code>moveToFirst()</code>. Calling
464 : <code>moveToPosition(-1)</code> is the same as calling
465 : <code>moveToLast()</code>.
466 : @param row
467 : is the number of rows to move. Could be negative.
468 : @returns
469 : <TRUE/> if the cursor is on a row; <FALSE/> otherwise
470 : @throws SQLException
471 : if a database access error occurs or if row is 0, or the result set
472 : type is FORWARD_ONLY.
473 : */
474 0 : sal_Bool SAL_CALL SortedResultSet::absolute( sal_Int32 row )
475 : throw ( SQLException, RuntimeException, std::exception )
476 : {
477 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
478 :
479 : sal_Int32 nIndex;
480 :
481 0 : if ( row > 0 )
482 : {
483 0 : if ( row <= mnCount )
484 : {
485 0 : mnCurEntry = row;
486 0 : nIndex = maS2O[ mnCurEntry ];
487 0 : return mxOriginal->absolute( nIndex );
488 : }
489 : else
490 : {
491 0 : mnCurEntry = mnCount + 1;
492 0 : return sal_False;
493 : }
494 : }
495 0 : else if ( row == 0 )
496 : {
497 0 : throw SQLException();
498 : }
499 : else
500 : {
501 0 : if ( mnCount + row + 1 > 0 )
502 : {
503 0 : mnCurEntry = mnCount + row + 1;
504 0 : nIndex = maS2O[ mnCurEntry ];
505 0 : return mxOriginal->absolute( nIndex );
506 : }
507 : else
508 : {
509 0 : mnCurEntry = 0;
510 0 : return sal_False;
511 : }
512 0 : }
513 : }
514 :
515 :
516 : /**
517 : moves the cursor a relative number of rows, either positive or negative.
518 : <p>
519 : Attempting to move beyond the first/last row in the result set positions
520 : the cursor before/after the first/last row. Calling
521 : <code>moveRelative(0)</code> is valid, but does not change the cursor
522 : position.
523 : <p>Note: Calling <code>moveRelative(1)</code> is different from calling
524 : <code>moveNext()</code> because is makes sense to call
525 : <code>moveNext()</code> when there is no current row, for example,
526 : when the cursor is positioned before the first row or after the last
527 : row of the result set.
528 : @param rows
529 : is the number of rows to move. Could be negative.
530 : @returns
531 : <TRUE/> if the cursor is on a valid row; <FALSE/> if it is off
532 : the result set.
533 : @throws SQLException
534 : if a database access error occurs or if there is no
535 : current row, or the result set type is FORWARD_ONLY.
536 : */
537 0 : sal_Bool SAL_CALL SortedResultSet::relative( sal_Int32 rows )
538 : throw ( SQLException, RuntimeException, std::exception )
539 : {
540 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
541 :
542 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
543 : {
544 0 : throw SQLException();
545 : }
546 :
547 0 : if ( rows == 0 )
548 0 : return sal_True;
549 :
550 0 : sal_Int32 nTmp = mnCurEntry + rows;
551 :
552 0 : if ( nTmp <= 0 )
553 : {
554 0 : mnCurEntry = 0;
555 0 : return sal_False;
556 : }
557 0 : else if ( nTmp > mnCount )
558 : {
559 0 : mnCurEntry = mnCount + 1;
560 0 : return sal_False;
561 : }
562 : else
563 : {
564 0 : mnCurEntry = nTmp;
565 0 : nTmp = maS2O[ mnCurEntry ];
566 0 : return mxOriginal->absolute( nTmp );
567 0 : }
568 : }
569 :
570 :
571 : /**
572 : moves the cursor to the previous row in the result set.
573 : <p>Note: <code>previous()</code> is not the same as
574 : <code>relative(-1)</code> because it makes sense to call
575 : <code>previous()</code> when there is no current row.
576 : @returns <TRUE/> if the cursor is on a valid row; <FALSE/> if it is off
577 : the result set.
578 : @throws SQLException
579 : if a database access error occurs or the result set type
580 : is FORWARD_ONLY.
581 : */
582 0 : sal_Bool SAL_CALL SortedResultSet::previous()
583 : throw ( SQLException, RuntimeException, std::exception )
584 : {
585 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
586 :
587 0 : mnCurEntry -= 1;
588 :
589 0 : if ( mnCurEntry > 0 )
590 : {
591 0 : if ( mnCurEntry <= mnCount )
592 : {
593 0 : sal_Int32 nIndex = maS2O[ mnCurEntry ];
594 0 : return mxOriginal->absolute( nIndex );
595 : }
596 : }
597 : else
598 0 : mnCurEntry = 0;
599 :
600 0 : return sal_False;
601 : }
602 :
603 :
604 0 : void SAL_CALL SortedResultSet::refreshRow()
605 : throw ( SQLException, RuntimeException, std::exception )
606 : {
607 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
608 :
609 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
610 : {
611 0 : throw SQLException();
612 : }
613 :
614 0 : mxOriginal->refreshRow();
615 0 : }
616 :
617 :
618 0 : sal_Bool SAL_CALL SortedResultSet::rowUpdated()
619 : throw ( SQLException, RuntimeException, std::exception )
620 : {
621 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
622 :
623 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
624 : {
625 0 : throw SQLException();
626 : }
627 :
628 0 : return mxOriginal->rowUpdated();
629 : }
630 :
631 :
632 0 : sal_Bool SAL_CALL SortedResultSet::rowInserted()
633 : throw ( SQLException, RuntimeException, std::exception )
634 : {
635 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
636 :
637 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
638 : {
639 0 : throw SQLException();
640 : }
641 :
642 0 : return mxOriginal->rowInserted();
643 : }
644 :
645 :
646 0 : sal_Bool SAL_CALL SortedResultSet::rowDeleted()
647 : throw ( SQLException, RuntimeException, std::exception )
648 : {
649 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
650 :
651 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
652 : {
653 0 : throw SQLException();
654 : }
655 :
656 0 : return mxOriginal->rowDeleted();
657 : }
658 :
659 :
660 0 : Reference< XInterface > SAL_CALL SortedResultSet::getStatement()
661 : throw ( SQLException, RuntimeException, std::exception )
662 : {
663 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
664 :
665 0 : if ( ( mnCurEntry <= 0 ) || ( mnCurEntry > mnCount ) )
666 : {
667 0 : throw SQLException();
668 : }
669 :
670 0 : return mxOriginal->getStatement();
671 : }
672 :
673 :
674 : // XRow methods.
675 :
676 :
677 0 : sal_Bool SAL_CALL SortedResultSet::wasNull()
678 : throw( SQLException, RuntimeException, std::exception )
679 : {
680 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
681 0 : return Reference< XRow >::query(mxOriginal)->wasNull();
682 : }
683 :
684 :
685 0 : OUString SAL_CALL SortedResultSet::getString( sal_Int32 columnIndex )
686 : throw( SQLException, RuntimeException, std::exception )
687 : {
688 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
689 0 : return Reference< XRow >::query(mxOriginal)->getString( columnIndex );
690 : }
691 :
692 :
693 0 : sal_Bool SAL_CALL SortedResultSet::getBoolean( sal_Int32 columnIndex )
694 : throw( SQLException, RuntimeException, std::exception )
695 : {
696 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
697 0 : return Reference< XRow >::query(mxOriginal)->getBoolean( columnIndex );
698 : }
699 :
700 :
701 0 : sal_Int8 SAL_CALL SortedResultSet::getByte( sal_Int32 columnIndex )
702 : throw( SQLException, RuntimeException, std::exception )
703 : {
704 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
705 0 : return Reference< XRow >::query(mxOriginal)->getByte( columnIndex );
706 : }
707 :
708 :
709 0 : sal_Int16 SAL_CALL SortedResultSet::getShort( sal_Int32 columnIndex )
710 : throw( SQLException, RuntimeException, std::exception )
711 : {
712 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
713 0 : return Reference< XRow >::query(mxOriginal)->getShort( columnIndex );
714 : }
715 :
716 :
717 0 : sal_Int32 SAL_CALL SortedResultSet::getInt( sal_Int32 columnIndex )
718 : throw( SQLException, RuntimeException, std::exception )
719 : {
720 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
721 0 : return Reference< XRow >::query(mxOriginal)->getInt( columnIndex );
722 : }
723 :
724 0 : sal_Int64 SAL_CALL SortedResultSet::getLong( sal_Int32 columnIndex )
725 : throw( SQLException, RuntimeException, std::exception )
726 : {
727 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
728 0 : return Reference< XRow >::query(mxOriginal)->getLong( columnIndex );
729 : }
730 :
731 :
732 0 : float SAL_CALL SortedResultSet::getFloat( sal_Int32 columnIndex )
733 : throw( SQLException, RuntimeException, std::exception )
734 : {
735 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
736 0 : return Reference< XRow >::query(mxOriginal)->getFloat( columnIndex );
737 : }
738 :
739 :
740 0 : double SAL_CALL SortedResultSet::getDouble( sal_Int32 columnIndex )
741 : throw( SQLException, RuntimeException, std::exception )
742 : {
743 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
744 0 : return Reference< XRow >::query(mxOriginal)->getDouble( columnIndex );
745 : }
746 :
747 :
748 0 : Sequence< sal_Int8 > SAL_CALL SortedResultSet::getBytes( sal_Int32 columnIndex )
749 : throw( SQLException, RuntimeException, std::exception )
750 : {
751 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
752 0 : return Reference< XRow >::query(mxOriginal)->getBytes( columnIndex );
753 : }
754 :
755 :
756 0 : Date SAL_CALL SortedResultSet::getDate( sal_Int32 columnIndex )
757 : throw( SQLException, RuntimeException, std::exception )
758 : {
759 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
760 0 : return Reference< XRow >::query(mxOriginal)->getDate( columnIndex );
761 : }
762 :
763 :
764 0 : Time SAL_CALL SortedResultSet::getTime( sal_Int32 columnIndex )
765 : throw( SQLException, RuntimeException, std::exception )
766 : {
767 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
768 0 : return Reference< XRow >::query(mxOriginal)->getTime( columnIndex );
769 : }
770 :
771 :
772 0 : DateTime SAL_CALL SortedResultSet::getTimestamp( sal_Int32 columnIndex )
773 : throw( SQLException, RuntimeException, std::exception )
774 : {
775 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
776 0 : return Reference< XRow >::query(mxOriginal)->getTimestamp( columnIndex );
777 : }
778 :
779 :
780 : Reference< XInputStream > SAL_CALL
781 0 : SortedResultSet::getBinaryStream( sal_Int32 columnIndex )
782 : throw( SQLException, RuntimeException, std::exception )
783 : {
784 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
785 0 : return Reference< XRow >::query(mxOriginal)->getBinaryStream( columnIndex );
786 : }
787 :
788 :
789 : Reference< XInputStream > SAL_CALL
790 0 : SortedResultSet::getCharacterStream( sal_Int32 columnIndex )
791 : throw( SQLException, RuntimeException, std::exception )
792 : {
793 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
794 0 : return Reference< XRow >::query(mxOriginal)->getCharacterStream( columnIndex );
795 : }
796 :
797 :
798 0 : Any SAL_CALL SortedResultSet::getObject( sal_Int32 columnIndex,
799 : const Reference< XNameAccess >& typeMap )
800 : throw( SQLException, RuntimeException, std::exception )
801 : {
802 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
803 0 : return Reference< XRow >::query(mxOriginal)->getObject( columnIndex,
804 0 : typeMap);
805 : }
806 :
807 :
808 0 : Reference< XRef > SAL_CALL SortedResultSet::getRef( sal_Int32 columnIndex )
809 : throw( SQLException, RuntimeException, std::exception )
810 : {
811 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
812 0 : return Reference< XRow >::query(mxOriginal)->getRef( columnIndex );
813 : }
814 :
815 :
816 0 : Reference< XBlob > SAL_CALL SortedResultSet::getBlob( sal_Int32 columnIndex )
817 : throw( SQLException, RuntimeException, std::exception )
818 : {
819 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
820 0 : return Reference< XRow >::query(mxOriginal)->getBlob( columnIndex );
821 : }
822 :
823 :
824 0 : Reference< XClob > SAL_CALL SortedResultSet::getClob( sal_Int32 columnIndex )
825 : throw( SQLException, RuntimeException, std::exception )
826 : {
827 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
828 0 : return Reference< XRow >::query(mxOriginal)->getClob( columnIndex );
829 : }
830 :
831 :
832 0 : Reference< XArray > SAL_CALL SortedResultSet::getArray( sal_Int32 columnIndex )
833 : throw( SQLException, RuntimeException, std::exception )
834 : {
835 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
836 0 : return Reference< XRow >::query(mxOriginal)->getArray( columnIndex );
837 : }
838 :
839 :
840 :
841 : // XCloseable methods.
842 :
843 :
844 0 : void SAL_CALL SortedResultSet::close()
845 : throw( SQLException, RuntimeException, std::exception )
846 : {
847 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
848 0 : Reference< XCloseable >::query(mxOriginal)->close();
849 0 : }
850 :
851 :
852 : // XResultSetMetaDataSupplier methods.
853 :
854 :
855 0 : Reference< XResultSetMetaData > SAL_CALL SortedResultSet::getMetaData()
856 : throw( SQLException, RuntimeException, std::exception )
857 : {
858 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
859 0 : return Reference< XResultSetMetaDataSupplier >::query(mxOriginal)->getMetaData();
860 : }
861 :
862 :
863 :
864 : // XPropertySet methods.
865 :
866 :
867 : Reference< XPropertySetInfo > SAL_CALL
868 0 : SortedResultSet::getPropertySetInfo() throw( RuntimeException, std::exception )
869 : {
870 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
871 :
872 0 : if ( !mpPropSetInfo )
873 : {
874 0 : mpPropSetInfo = new SRSPropertySetInfo();
875 0 : mpPropSetInfo->acquire();
876 : }
877 :
878 0 : return Reference< XPropertySetInfo >( mpPropSetInfo );
879 : }
880 :
881 :
882 0 : void SAL_CALL SortedResultSet::setPropertyValue(
883 : const OUString& PropertyName,
884 : const Any& )
885 : throw( UnknownPropertyException,
886 : PropertyVetoException,
887 : IllegalArgumentException,
888 : WrappedTargetException,
889 : RuntimeException, std::exception )
890 : {
891 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
892 :
893 0 : if ( PropertyName.equalsAscii( "RowCount" ) ||
894 0 : PropertyName.equalsAscii( "IsRowCountFinal" ) )
895 0 : throw IllegalArgumentException();
896 : else
897 0 : throw UnknownPropertyException();
898 : }
899 :
900 :
901 0 : Any SAL_CALL SortedResultSet::getPropertyValue( const OUString& PropertyName )
902 : throw( UnknownPropertyException,
903 : WrappedTargetException,
904 : RuntimeException, std::exception )
905 : {
906 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
907 :
908 0 : Any aRet;
909 :
910 0 : if ( PropertyName.equalsAscii( "RowCount" ) )
911 : {
912 0 : aRet <<= maS2O.Count();
913 : }
914 0 : else if ( PropertyName.equalsAscii( "IsRowCountFinal" ) )
915 : {
916 0 : sal_Bool bOrgFinal = false;
917 0 : Any aOrgRet;
918 :
919 0 : aRet <<= (sal_Bool) sal_False;
920 :
921 0 : aOrgRet = Reference< XPropertySet >::query(mxOriginal)->
922 0 : getPropertyValue( PropertyName );
923 0 : aOrgRet >>= bOrgFinal;
924 :
925 0 : if ( bOrgFinal )
926 : {
927 0 : aOrgRet = Reference< XPropertySet >::query(mxOriginal)->
928 0 : getPropertyValue("RowCount");
929 0 : sal_uInt32 nOrgCount = 0;
930 0 : aOrgRet >>= nOrgCount;
931 0 : if ( nOrgCount == maS2O.Count() )
932 0 : aRet <<= (sal_Bool) sal_True;
933 0 : }
934 : }
935 : else
936 0 : throw UnknownPropertyException();
937 :
938 0 : return aRet;
939 : }
940 :
941 :
942 0 : void SAL_CALL SortedResultSet::addPropertyChangeListener(
943 : const OUString& PropertyName,
944 : const Reference< XPropertyChangeListener >& Listener )
945 : throw( UnknownPropertyException,
946 : WrappedTargetException,
947 : RuntimeException, std::exception )
948 : {
949 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
950 :
951 0 : if ( !mpPropChangeListeners )
952 : mpPropChangeListeners =
953 0 : new PropertyChangeListeners_Impl();
954 :
955 0 : mpPropChangeListeners->addInterface( PropertyName, Listener );
956 0 : }
957 :
958 :
959 0 : void SAL_CALL SortedResultSet::removePropertyChangeListener(
960 : const OUString& PropertyName,
961 : const Reference< XPropertyChangeListener >& Listener )
962 : throw( UnknownPropertyException,
963 : WrappedTargetException,
964 : RuntimeException, std::exception )
965 : {
966 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
967 :
968 0 : if ( mpPropChangeListeners )
969 0 : mpPropChangeListeners->removeInterface( PropertyName, Listener );
970 0 : }
971 :
972 :
973 0 : void SAL_CALL SortedResultSet::addVetoableChangeListener(
974 : const OUString& PropertyName,
975 : const Reference< XVetoableChangeListener >& Listener )
976 : throw( UnknownPropertyException,
977 : WrappedTargetException,
978 : RuntimeException, std::exception )
979 : {
980 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
981 :
982 0 : if ( !mpVetoChangeListeners )
983 : mpVetoChangeListeners =
984 0 : new PropertyChangeListeners_Impl();
985 :
986 0 : mpVetoChangeListeners->addInterface( PropertyName, Listener );
987 0 : }
988 :
989 :
990 0 : void SAL_CALL SortedResultSet::removeVetoableChangeListener(
991 : const OUString& PropertyName,
992 : const Reference< XVetoableChangeListener >& Listener )
993 : throw( UnknownPropertyException,
994 : WrappedTargetException,
995 : RuntimeException, std::exception )
996 : {
997 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
998 :
999 0 : if ( mpVetoChangeListeners )
1000 0 : mpVetoChangeListeners->removeInterface( PropertyName, Listener );
1001 0 : }
1002 :
1003 :
1004 : // private methods
1005 :
1006 0 : sal_IntPtr SortedResultSet::CompareImpl( Reference < XResultSet > xResultOne,
1007 : Reference < XResultSet > xResultTwo,
1008 : sal_IntPtr nIndexOne, sal_IntPtr nIndexTwo,
1009 : SortInfo* pSortInfo )
1010 :
1011 : throw( SQLException, RuntimeException )
1012 : {
1013 0 : Reference < XRow > xRowOne = Reference< XRow >::query( xResultOne );
1014 0 : Reference < XRow > xRowTwo = Reference< XRow >::query( xResultTwo );
1015 :
1016 0 : sal_IntPtr nCompare = 0;
1017 0 : sal_IntPtr nColumn = pSortInfo->mnColumn;
1018 :
1019 0 : switch ( pSortInfo->mnType )
1020 : {
1021 : case DataType::BIT :
1022 : case DataType::TINYINT :
1023 : case DataType::SMALLINT :
1024 : case DataType::INTEGER :
1025 : {
1026 0 : sal_Int32 aOne = 0;
1027 0 : sal_Int32 aTwo = 0;
1028 :
1029 0 : if ( xResultOne->absolute( nIndexOne ) )
1030 0 : aOne = xRowOne->getInt( nColumn );
1031 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1032 0 : aTwo = xRowTwo->getInt( nColumn );
1033 :
1034 0 : if ( aOne < aTwo )
1035 0 : nCompare = -1;
1036 0 : else if ( aOne == aTwo )
1037 0 : nCompare = 0;
1038 : else
1039 0 : nCompare = 1;
1040 :
1041 0 : break;
1042 : }
1043 : case DataType::BIGINT :
1044 : {
1045 0 : sal_Int64 aOne = 0;
1046 0 : sal_Int64 aTwo = 0;
1047 :
1048 0 : if ( xResultOne->absolute( nIndexOne ) )
1049 0 : aOne = xRowOne->getLong( nColumn );
1050 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1051 0 : aTwo = xRowTwo->getLong( nColumn );
1052 :
1053 0 : if ( aOne < aTwo )
1054 0 : nCompare = -1;
1055 0 : else if ( aOne == aTwo )
1056 0 : nCompare = 0;
1057 : else
1058 0 : nCompare = 1;
1059 :
1060 0 : break;
1061 : }
1062 : case DataType::CHAR :
1063 : case DataType::VARCHAR :
1064 : case DataType::LONGVARCHAR :
1065 : {
1066 0 : OUString aOne, aTwo;
1067 :
1068 0 : if ( xResultOne->absolute( nIndexOne ) )
1069 0 : aOne = xRowOne->getString( nColumn );
1070 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1071 0 : aTwo = xRowTwo->getString( nColumn );
1072 :
1073 0 : if ( ! pSortInfo->mbCaseSensitive )
1074 : {
1075 0 : aOne = aOne.toAsciiLowerCase();
1076 0 : aTwo = aTwo.toAsciiLowerCase();
1077 : }
1078 :
1079 0 : nCompare = aOne.compareTo( aTwo );
1080 0 : break;
1081 : }
1082 : case DataType::DATE :
1083 : {
1084 0 : Date aOne, aTwo;
1085 : sal_Int32 nTmp;
1086 :
1087 0 : if ( xResultOne->absolute( nIndexOne ) )
1088 0 : aOne = xRowOne->getDate( nColumn );
1089 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1090 0 : aTwo = xRowTwo->getDate( nColumn );
1091 :
1092 0 : nTmp = (sal_Int32) aTwo.Year - (sal_Int32) aOne.Year;
1093 0 : if ( !nTmp ) {
1094 0 : nTmp = (sal_Int32) aTwo.Month - (sal_Int32) aOne.Month;
1095 0 : if ( !nTmp )
1096 0 : nTmp = (sal_Int32) aTwo.Day - (sal_Int32) aOne.Day;
1097 : }
1098 :
1099 0 : if ( nTmp < 0 )
1100 0 : nCompare = -1;
1101 0 : else if ( nTmp == 0 )
1102 0 : nCompare = 0;
1103 : else
1104 0 : nCompare = 1;
1105 :
1106 0 : break;
1107 : }
1108 : case DataType::TIME :
1109 : {
1110 0 : Time aOne, aTwo;
1111 : sal_Int32 nTmp;
1112 :
1113 0 : if ( xResultOne->absolute( nIndexOne ) )
1114 0 : aOne = xRowOne->getTime( nColumn );
1115 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1116 0 : aTwo = xRowTwo->getTime( nColumn );
1117 :
1118 0 : nTmp = (sal_Int32) aTwo.Hours - (sal_Int32) aOne.Hours;
1119 0 : if ( !nTmp ) {
1120 0 : nTmp = (sal_Int32) aTwo.Minutes - (sal_Int32) aOne.Minutes;
1121 0 : if ( !nTmp ) {
1122 0 : nTmp = (sal_Int32) aTwo.Seconds - (sal_Int32) aOne.Seconds;
1123 0 : if ( !nTmp )
1124 : nTmp = (sal_Int32) aTwo.NanoSeconds
1125 0 : - (sal_Int32) aOne.NanoSeconds;
1126 : }}
1127 :
1128 0 : if ( nTmp < 0 )
1129 0 : nCompare = -1;
1130 0 : else if ( nTmp == 0 )
1131 0 : nCompare = 0;
1132 : else
1133 0 : nCompare = 1;
1134 :
1135 0 : break;
1136 : }
1137 : case DataType::TIMESTAMP :
1138 : {
1139 0 : DateTime aOne, aTwo;
1140 : sal_Int32 nTmp;
1141 :
1142 0 : if ( xResultOne->absolute( nIndexOne ) )
1143 0 : aOne = xRowOne->getTimestamp( nColumn );
1144 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1145 0 : aTwo = xRowTwo->getTimestamp( nColumn );
1146 :
1147 0 : nTmp = (sal_Int32) aTwo.Year - (sal_Int32) aOne.Year;
1148 0 : if ( !nTmp ) {
1149 0 : nTmp = (sal_Int32) aTwo.Month - (sal_Int32) aOne.Month;
1150 0 : if ( !nTmp ) {
1151 0 : nTmp = (sal_Int32) aTwo.Day - (sal_Int32) aOne.Day;
1152 0 : if ( !nTmp ) {
1153 0 : nTmp = (sal_Int32) aTwo.Hours - (sal_Int32) aOne.Hours;
1154 0 : if ( !nTmp ) {
1155 0 : nTmp = (sal_Int32) aTwo.Minutes - (sal_Int32) aOne.Minutes;
1156 0 : if ( !nTmp ) {
1157 0 : nTmp = (sal_Int32) aTwo.Seconds - (sal_Int32) aOne.Seconds;
1158 0 : if ( !nTmp )
1159 : nTmp = (sal_Int32) aTwo.NanoSeconds
1160 0 : - (sal_Int32) aOne.NanoSeconds;
1161 : }}}}}
1162 :
1163 0 : if ( nTmp < 0 )
1164 0 : nCompare = -1;
1165 0 : else if ( nTmp == 0 )
1166 0 : nCompare = 0;
1167 : else
1168 0 : nCompare = 1;
1169 :
1170 0 : break;
1171 : }
1172 : case DataType::REAL :
1173 : {
1174 0 : float aOne = 0;
1175 0 : float aTwo = 0;
1176 :
1177 0 : if ( xResultOne->absolute( nIndexOne ) )
1178 0 : aOne = xRowOne->getFloat( nColumn );
1179 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1180 0 : aTwo = xRowTwo->getFloat( nColumn );
1181 :
1182 0 : if ( aOne < aTwo )
1183 0 : nCompare = -1;
1184 0 : else if ( aOne == aTwo )
1185 0 : nCompare = 0;
1186 : else
1187 0 : nCompare = 1;
1188 :
1189 0 : break;
1190 : }
1191 : case DataType::FLOAT :
1192 : case DataType::DOUBLE :
1193 : {
1194 0 : double aOne = 0;
1195 0 : double aTwo = 0;
1196 :
1197 0 : if ( xResultOne->absolute( nIndexOne ) )
1198 0 : aOne = xRowOne->getDouble( nColumn );
1199 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1200 0 : aTwo = xRowTwo->getDouble( nColumn );
1201 :
1202 0 : if ( aOne < aTwo )
1203 0 : nCompare = -1;
1204 0 : else if ( aOne == aTwo )
1205 0 : nCompare = 0;
1206 : else
1207 0 : nCompare = 1;
1208 :
1209 0 : break;
1210 : }
1211 : default:
1212 : {
1213 : OSL_FAIL( "DataType not supported for compare!" );
1214 : }
1215 : }
1216 :
1217 0 : return nCompare;
1218 : }
1219 :
1220 :
1221 0 : sal_IntPtr SortedResultSet::CompareImpl( Reference < XResultSet > xResultOne,
1222 : Reference < XResultSet > xResultTwo,
1223 : sal_IntPtr nIndexOne, sal_IntPtr nIndexTwo )
1224 : throw( SQLException, RuntimeException )
1225 : {
1226 0 : sal_IntPtr nCompare = 0;
1227 0 : SortInfo* pInfo = mpSortInfo;
1228 :
1229 0 : while ( !nCompare && pInfo )
1230 : {
1231 0 : if ( pInfo->mbUseOwnCompare )
1232 : {
1233 : nCompare = CompareImpl( xResultOne, xResultTwo,
1234 0 : nIndexOne, nIndexTwo, pInfo );
1235 : }
1236 : else
1237 : {
1238 0 : Any aOne, aTwo;
1239 :
1240 : Reference < XRow > xRowOne =
1241 0 : Reference< XRow >::query( xResultOne );
1242 : Reference < XRow > xRowTwo =
1243 0 : Reference< XRow >::query( xResultTwo );
1244 :
1245 0 : if ( xResultOne->absolute( nIndexOne ) )
1246 0 : aOne = xRowOne->getObject( pInfo->mnColumn, NULL );
1247 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1248 0 : aTwo = xRowTwo->getObject( pInfo->mnColumn, NULL );
1249 :
1250 0 : nCompare = pInfo->mxCompareFunction->compare( aOne, aTwo );
1251 : }
1252 :
1253 0 : if ( ! pInfo->mbAscending )
1254 0 : nCompare = - nCompare;
1255 :
1256 0 : pInfo = pInfo->mpNext;
1257 : }
1258 :
1259 0 : return nCompare;
1260 : }
1261 :
1262 :
1263 0 : sal_IntPtr SortedResultSet::Compare( SortListData *pOne,
1264 : SortListData *pTwo )
1265 : throw( SQLException, RuntimeException )
1266 : {
1267 : sal_IntPtr nIndexOne;
1268 : sal_IntPtr nIndexTwo;
1269 :
1270 0 : Reference < XResultSet > xResultOne;
1271 0 : Reference < XResultSet > xResultTwo;
1272 :
1273 0 : if ( pOne->mbModified )
1274 : {
1275 0 : xResultOne = mxOther;
1276 0 : nIndexOne = pOne->mnOldPos;
1277 : }
1278 : else
1279 : {
1280 0 : xResultOne = mxOriginal;
1281 0 : nIndexOne = pOne->mnCurPos;
1282 : }
1283 :
1284 0 : if ( pTwo->mbModified )
1285 : {
1286 0 : xResultTwo = mxOther;
1287 0 : nIndexTwo = pTwo->mnOldPos;
1288 : }
1289 : else
1290 : {
1291 0 : xResultTwo = mxOriginal;
1292 0 : nIndexTwo = pTwo->mnCurPos;
1293 : }
1294 :
1295 : sal_IntPtr nCompare;
1296 : nCompare = CompareImpl( xResultOne, xResultTwo,
1297 0 : nIndexOne, nIndexTwo );
1298 0 : return nCompare;
1299 : }
1300 :
1301 :
1302 0 : sal_IntPtr SortedResultSet::FindPos( SortListData *pEntry,
1303 : sal_IntPtr _nStart, sal_IntPtr _nEnd )
1304 : throw( SQLException, RuntimeException )
1305 : {
1306 0 : if ( _nStart > _nEnd )
1307 0 : return _nStart + 1;
1308 :
1309 0 : sal_IntPtr nStart = _nStart;
1310 0 : sal_IntPtr nEnd = _nEnd;
1311 0 : sal_IntPtr nMid = 0, nCompare = 0;
1312 :
1313 : SortListData *pMid;
1314 :
1315 0 : while ( nStart <= nEnd )
1316 : {
1317 0 : nMid = ( nEnd - nStart ) / 2 + nStart;
1318 0 : pMid = maS2O.GetData( nMid );
1319 0 : nCompare = Compare( pEntry, pMid );
1320 :
1321 0 : if ( !nCompare )
1322 0 : nCompare = ((sal_IntPtr) pEntry ) - ( (sal_IntPtr) pMid );
1323 :
1324 0 : if ( nCompare < 0 ) // pEntry < pMid
1325 0 : nEnd = nMid - 1;
1326 : else
1327 0 : nStart = nMid + 1;
1328 : }
1329 :
1330 0 : if ( nCompare < 0 ) // pEntry < pMid
1331 0 : return nMid;
1332 : else
1333 0 : return nMid+1;
1334 : }
1335 :
1336 :
1337 0 : void SortedResultSet::PropertyChanged( const PropertyChangeEvent& rEvt )
1338 : {
1339 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
1340 :
1341 0 : if ( !mpPropChangeListeners )
1342 0 : return;
1343 :
1344 : // Notify listeners interested especially in the changed property.
1345 : OInterfaceContainerHelper* pPropsContainer =
1346 0 : mpPropChangeListeners->getContainer( rEvt.PropertyName );
1347 0 : if ( pPropsContainer )
1348 : {
1349 0 : OInterfaceIteratorHelper aIter( *pPropsContainer );
1350 0 : while ( aIter.hasMoreElements() )
1351 : {
1352 : Reference< XPropertyChangeListener > xListener(
1353 0 : aIter.next(), UNO_QUERY );
1354 0 : if ( xListener.is() )
1355 0 : xListener->propertyChange( rEvt );
1356 0 : }
1357 : }
1358 :
1359 : // Notify listeners interested in all properties.
1360 0 : pPropsContainer = mpPropChangeListeners->getContainer( OUString() );
1361 0 : if ( pPropsContainer )
1362 : {
1363 0 : OInterfaceIteratorHelper aIter( *pPropsContainer );
1364 0 : while ( aIter.hasMoreElements() )
1365 : {
1366 : Reference< XPropertyChangeListener > xListener(
1367 0 : aIter.next(), UNO_QUERY );
1368 0 : if ( xListener.is() )
1369 0 : xListener->propertyChange( rEvt );
1370 0 : }
1371 0 : }
1372 : }
1373 :
1374 :
1375 :
1376 :
1377 : // public methods
1378 :
1379 :
1380 0 : void SortedResultSet::CopyData( SortedResultSet *pSource )
1381 : {
1382 0 : const SortedEntryList *pSrcS2O = pSource->GetS2OList();
1383 0 : const SimpleList *pSrcO2S = pSource->GetO2SList();
1384 :
1385 : sal_IntPtr i, nCount;
1386 :
1387 0 : maS2O.Clear();
1388 0 : maO2S.Clear();
1389 0 : maModList.Clear();
1390 :
1391 0 : maS2O.Insert( NULL, 0 );
1392 0 : maO2S.Insert( 0, (sal_uInt32) 0 ); // value, pos
1393 :
1394 0 : nCount = pSrcS2O->Count();
1395 :
1396 0 : for ( i=1; i<nCount; i++ )
1397 : {
1398 0 : maS2O.Insert( new SortListData( (*pSrcS2O)[ i ] ), i );
1399 0 : maO2S.Insert( pSrcO2S->GetObject( i ), (sal_uInt32) i );
1400 : }
1401 :
1402 0 : mnLastSort = maS2O.Count();
1403 0 : mxOther = pSource->GetResultSet();
1404 :
1405 0 : if ( !mpSortInfo )
1406 : {
1407 0 : mpSortInfo = pSource->GetSortInfo();
1408 0 : mbIsCopy = sal_True;
1409 : }
1410 0 : }
1411 :
1412 :
1413 0 : void SortedResultSet::Initialize(
1414 : const Sequence < NumberedSortingInfo > &xSortInfo,
1415 : const Reference< XAnyCompareFactory > &xCompFactory )
1416 : {
1417 0 : BuildSortInfo( mxOriginal, xSortInfo, xCompFactory );
1418 : // Insert dummy at pos 0
1419 0 : SortListData *pData = new SortListData( 0 );
1420 0 : maS2O.Insert( pData, 0 );
1421 :
1422 0 : sal_IntPtr nIndex = 1;
1423 :
1424 : // now fetch all the elements from the original result set,
1425 : // get there new position in the sorted result set and insert
1426 : // an entry in the sorted to original mapping list
1427 : try {
1428 0 : while ( mxOriginal->absolute( nIndex ) )
1429 : {
1430 0 : pData = new SortListData( nIndex );
1431 0 : sal_IntPtr nPos = FindPos( pData, 1, nIndex-1 );
1432 :
1433 0 : maS2O.Insert( pData, nPos );
1434 :
1435 0 : nIndex++;
1436 : }
1437 : }
1438 0 : catch (const SQLException&)
1439 : {
1440 : OSL_FAIL( "SortedResultSet::Initialize() : Got unexpected SQLException" );
1441 : }
1442 :
1443 : // when we have fetched all the elements, we can create the
1444 : // original to sorted mapping list from the s2o list
1445 0 : maO2S.Clear();
1446 0 : maO2S.Insert( NULL, (sal_uInt32) 0 );
1447 :
1448 : // insert some dummy entries first and replace then
1449 : // the entries with the right ones
1450 : size_t i;
1451 :
1452 0 : for ( i=1; i<maS2O.Count(); i++ )
1453 0 : maO2S.Insert( (void*) 0, i ); // Insert( data, pos )
1454 0 : for ( i=1; i<maS2O.Count(); i++ )
1455 0 : maO2S.Replace( (void*) i, maS2O[ i ] ); // Insert( data, pos )
1456 :
1457 0 : mnCount = maS2O.Count() - 1;
1458 0 : }
1459 :
1460 :
1461 0 : void SortedResultSet::CheckProperties( sal_IntPtr nOldCount, sal_Bool bWasFinal )
1462 : {
1463 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
1464 :
1465 0 : if ( !mpPropChangeListeners )
1466 0 : return;
1467 :
1468 : try {
1469 : // check for propertyChangeEvents
1470 0 : if ( nOldCount != GetCount() )
1471 : {
1472 0 : sal_Bool bIsFinal = sal_False;
1473 0 : PropertyChangeEvent aEvt;
1474 :
1475 0 : aEvt.PropertyName = "RowCount";
1476 0 : aEvt.Further = sal_False;
1477 0 : aEvt.PropertyHandle = -1;
1478 0 : aEvt.OldValue <<= nOldCount;
1479 0 : aEvt.NewValue <<= GetCount();
1480 :
1481 0 : PropertyChanged( aEvt );
1482 :
1483 0 : OUString aName = "IsRowCountFinal";
1484 0 : Any aRet = getPropertyValue( aName );
1485 0 : if ( (aRet >>= bIsFinal) && bIsFinal != bWasFinal )
1486 : {
1487 0 : aEvt.PropertyName = aName;
1488 0 : aEvt.Further = sal_False;
1489 0 : aEvt.PropertyHandle = -1;
1490 0 : aEvt.OldValue <<= (sal_Bool) bWasFinal;
1491 0 : aEvt.NewValue <<= (sal_Bool) bIsFinal;
1492 0 : PropertyChanged( aEvt );
1493 0 : }
1494 : }
1495 : }
1496 0 : catch (const UnknownPropertyException&) {}
1497 0 : catch (const WrappedTargetException&) {}
1498 : }
1499 :
1500 :
1501 0 : void SortedResultSet::InsertNew( sal_IntPtr nPos, sal_IntPtr nCount )
1502 : {
1503 : // for all entries in the msS20-list, which are >= nPos, increase by nCount
1504 : SortListData *pData;
1505 : sal_IntPtr i, nEnd;
1506 :
1507 0 : nEnd = maS2O.Count();
1508 0 : for ( i=1; i<=nEnd; i++ )
1509 : {
1510 0 : pData = maS2O.GetData( i );
1511 0 : if ( pData->mnCurPos >= nPos )
1512 : {
1513 0 : pData->mnCurPos += nCount;
1514 : }
1515 : }
1516 :
1517 : // and append the new entries at the end of the maS20-list or insert at the
1518 : // position nPos in the maS2O-list
1519 0 : for ( i=0; i<nCount; i++ )
1520 : {
1521 0 : nEnd += 1;
1522 0 : pData = new SortListData( nEnd );
1523 :
1524 0 : maS2O.Insert( pData, nEnd ); // Insert( Value, Position )
1525 0 : maO2S.Insert( (void*)nEnd, (sal_uInt32)(nPos+i) ); // Insert( Value, Position )
1526 : }
1527 :
1528 0 : mnCount += nCount;
1529 0 : }
1530 :
1531 :
1532 0 : void SortedResultSet::Remove( sal_IntPtr nPos, sal_IntPtr nCount, EventList *pEvents )
1533 : {
1534 : sal_uInt32 i, j;
1535 : sal_IntPtr nOldLastSort;
1536 :
1537 : // correct mnLastSort first
1538 0 : nOldLastSort = mnLastSort;
1539 0 : if ( nPos <= mnLastSort )
1540 : {
1541 0 : if ( nPos + nCount - 1 <= mnLastSort )
1542 0 : mnLastSort -= nCount;
1543 : else
1544 0 : mnLastSort = nPos - 1;
1545 : }
1546 :
1547 : // remove the entries from the lists and correct the positions
1548 : // in the original2sorted list
1549 0 : for ( i=0; i < (sal_uInt32) nCount; i++ )
1550 : {
1551 0 : sal_IntPtr nSortPos = (sal_IntPtr) maO2S.GetObject( nPos );
1552 0 : maO2S.Remove( (sal_uInt32) nPos );
1553 :
1554 0 : for ( j=1; j<=maO2S.Count(); j++ )
1555 : {
1556 0 : sal_IntPtr nVal = (sal_IntPtr) maO2S.GetObject( j );
1557 0 : if ( nVal > nSortPos )
1558 : {
1559 0 : --nVal;
1560 0 : maO2S.Replace( (void*) nVal, j );
1561 : }
1562 : }
1563 :
1564 0 : SortListData *pData = maS2O.Remove( nSortPos );
1565 0 : if ( pData->mbModified )
1566 0 : maModList.Remove( (void*) pData );
1567 0 : delete pData;
1568 :
1569 : // generate remove Event, but not for new entries
1570 0 : if ( nSortPos <= nOldLastSort )
1571 0 : pEvents->AddEvent( ListActionType::REMOVED, nSortPos, 1 );
1572 : }
1573 :
1574 : // correct the positions in the sorted list
1575 0 : for ( i=1; i<= maS2O.Count(); i++ )
1576 : {
1577 0 : SortListData *pData = maS2O.GetData( i );
1578 0 : if ( pData->mnCurPos > nPos )
1579 0 : pData->mnCurPos -= nCount;
1580 : }
1581 :
1582 0 : mnCount -= nCount;
1583 0 : }
1584 :
1585 :
1586 0 : void SortedResultSet::Move( sal_IntPtr nPos, sal_IntPtr nCount, sal_IntPtr nOffset )
1587 : {
1588 0 : if ( !nOffset )
1589 0 : return;
1590 :
1591 : sal_IntPtr i, nSortPos, nTo;
1592 : SortListData *pData;
1593 :
1594 0 : for ( i=0; i<nCount; i++ )
1595 : {
1596 0 : nSortPos = (sal_IntPtr) maO2S.GetObject( nPos+i );
1597 0 : pData = maS2O.GetData( nSortPos );
1598 0 : pData->mnCurPos += nOffset;
1599 : }
1600 :
1601 0 : if ( nOffset < 0 )
1602 : {
1603 0 : for ( i=nPos+nOffset; i<nPos; i++ )
1604 : {
1605 0 : nSortPos = (sal_IntPtr) maO2S.GetObject( i );
1606 0 : pData = maS2O.GetData( nSortPos );
1607 0 : pData->mnCurPos += nCount;
1608 : }
1609 : }
1610 : else
1611 : {
1612 0 : sal_IntPtr nStart = nPos + nCount;
1613 0 : sal_IntPtr nEnd = nStart + nOffset;
1614 0 : for ( i=nStart; i<nEnd; i++ )
1615 : {
1616 0 : nSortPos = (sal_IntPtr) maO2S.GetObject( i );
1617 0 : pData = maS2O.GetData( nSortPos );
1618 0 : pData->mnCurPos -= nCount;
1619 : }
1620 : }
1621 :
1622 : // remember the to be moved entries
1623 0 : sal_IntPtr *pTmpArr = new sal_IntPtr[ nCount ];
1624 0 : for ( i=0; i<nCount; i++ )
1625 0 : pTmpArr[i] = (sal_IntPtr)maO2S.GetObject( (sal_uInt32)( nPos+i ) );
1626 :
1627 : // now move the entries, which are in the way
1628 0 : if ( nOffset < 0 )
1629 : {
1630 : // be carefully here, because nOffset is negative here, so an
1631 : // addition is a subtraction
1632 0 : sal_IntPtr nFrom = nPos - 1;
1633 0 : nTo = nPos + nCount - 1;
1634 :
1635 : // same for i here
1636 0 : for ( i=0; i>nOffset; i-- )
1637 : {
1638 0 : sal_IntPtr nVal = (sal_IntPtr) maO2S.GetObject( (sal_uInt32)( nFrom+i ) );
1639 0 : maO2S.Replace( (void*) nVal, (sal_uInt32)( nTo+i ) );
1640 : }
1641 :
1642 : }
1643 : else
1644 : {
1645 0 : sal_IntPtr nStart = nPos + nCount;
1646 0 : for ( i=0; i<nOffset; i++ )
1647 : {
1648 0 : sal_IntPtr nVal = (sal_IntPtr) maO2S.GetObject( (sal_uInt32)( nStart+i ) );
1649 0 : maO2S.Replace( (void*) nVal, (sal_uInt32)( nPos+i ) );
1650 : }
1651 : }
1652 :
1653 : // finally put the remembered entries at there new location
1654 0 : nTo = nPos + nOffset;
1655 0 : for ( i=0; i<nCount; i++ )
1656 : {
1657 0 : maO2S.Replace( (void*)pTmpArr[ i ], (sal_uInt32)( nTo+i ) );
1658 : }
1659 :
1660 0 : delete [] pTmpArr;
1661 : }
1662 :
1663 :
1664 0 : void SortedResultSet::BuildSortInfo(
1665 : Reference< XResultSet > aResult,
1666 : const Sequence < NumberedSortingInfo > &xSortInfo,
1667 : const Reference< XAnyCompareFactory > &xCompFactory )
1668 : {
1669 0 : Reference < XResultSetMetaDataSupplier > xMeta ( aResult, UNO_QUERY );
1670 :
1671 0 : if ( ! xMeta.is() )
1672 : {
1673 : OSL_FAIL( "No MetaData, No Sorting!" );
1674 0 : return;
1675 : }
1676 :
1677 0 : Reference < XResultSetMetaData > xData = xMeta->getMetaData();
1678 0 : const NumberedSortingInfo *pSortInfo = xSortInfo.getConstArray();
1679 :
1680 : sal_Int32 nColumn;
1681 0 : OUString aPropName;
1682 : SortInfo *pInfo;
1683 :
1684 0 : for ( sal_IntPtr i=xSortInfo.getLength(); i > 0; )
1685 : {
1686 0 : --i;
1687 0 : nColumn = pSortInfo[ i ].ColumnIndex;
1688 0 : aPropName = xData->getColumnName( nColumn );
1689 0 : pInfo = new SortInfo;
1690 :
1691 0 : if ( xCompFactory.is() )
1692 0 : pInfo->mxCompareFunction = xCompFactory->createAnyCompareByName(
1693 0 : aPropName );
1694 :
1695 0 : if ( pInfo->mxCompareFunction.is() )
1696 : {
1697 0 : pInfo->mbUseOwnCompare = sal_False;
1698 0 : pInfo->mnType = 0;
1699 : }
1700 : else
1701 : {
1702 0 : pInfo->mbUseOwnCompare = sal_True;
1703 0 : pInfo->mnType = xData->getColumnType( nColumn );
1704 : }
1705 :
1706 0 : pInfo->mnColumn = nColumn;
1707 0 : pInfo->mbAscending = pSortInfo[ i ].Ascending;
1708 0 : pInfo->mbCaseSensitive = xData->isCaseSensitive( nColumn );
1709 0 : pInfo->mpNext = mpSortInfo;
1710 0 : mpSortInfo = pInfo;
1711 0 : }
1712 : }
1713 :
1714 :
1715 0 : void SortedResultSet::SetChanged( sal_IntPtr nPos, sal_IntPtr nCount )
1716 : {
1717 0 : for ( sal_IntPtr i=0; i<nCount; i++ )
1718 : {
1719 0 : sal_IntPtr nSortPos = (sal_IntPtr) maO2S.GetObject( nPos );
1720 0 : if ( nSortPos < mnLastSort )
1721 : {
1722 0 : SortListData *pData = maS2O.GetData( nSortPos );
1723 0 : if ( ! pData->mbModified )
1724 : {
1725 0 : pData->mbModified = sal_True;
1726 0 : maModList.Append( pData );
1727 : }
1728 : }
1729 0 : nPos += 1;
1730 : }
1731 0 : }
1732 :
1733 :
1734 0 : void SortedResultSet::ResortModified( EventList* pList )
1735 : {
1736 : sal_uInt32 i, j;
1737 : sal_IntPtr nCompare, nCurPos, nNewPos;
1738 : sal_IntPtr nStart, nEnd, nOffset, nVal;
1739 : SortListData *pData;
1740 : ListAction *pAction;
1741 :
1742 : try {
1743 0 : for ( i=0; i<maModList.Count(); i++ )
1744 : {
1745 0 : pData = (SortListData*) maModList.GetObject( i );
1746 : nCompare = CompareImpl( mxOther, mxOriginal,
1747 0 : pData->mnOldPos, pData->mnCurPos );
1748 0 : pData->mbModified = sal_False;
1749 0 : if ( nCompare != 0 )
1750 : {
1751 0 : nCurPos = (sal_IntPtr) maO2S.GetObject( (sal_uInt32) pData->mnCurPos );
1752 0 : if ( nCompare < 0 )
1753 : {
1754 0 : nNewPos = FindPos( pData, 1, nCurPos-1 );
1755 0 : nStart = nNewPos;
1756 0 : nEnd = nCurPos;
1757 0 : nOffset = 1;
1758 : }
1759 : else
1760 : {
1761 0 : nNewPos = FindPos( pData, nCurPos+1, mnLastSort );
1762 0 : nStart = nCurPos;
1763 0 : nEnd = mnLastSort;
1764 0 : nOffset = -1;
1765 : }
1766 :
1767 0 : if ( nNewPos != nCurPos )
1768 : {
1769 : // correct the lists!
1770 0 : maS2O.Remove( (sal_uInt32) nCurPos );
1771 0 : maS2O.Insert( pData, nNewPos );
1772 0 : for ( j=1; j<maO2S.Count(); j++ )
1773 : {
1774 0 : nVal = (sal_IntPtr) maO2S.GetObject( (sal_uInt32)( j ) );
1775 0 : if ( ( nStart <= nVal ) && ( nVal <= nEnd ) )
1776 : {
1777 0 : nVal += nOffset;
1778 0 : maO2S.Replace( (void*) (nVal), (sal_uInt32)( j ) );
1779 : }
1780 : }
1781 :
1782 0 : maO2S.Replace( (void*) nNewPos, (sal_uInt32) pData->mnCurPos );
1783 :
1784 0 : pAction = new ListAction;
1785 0 : pAction->Position = nCurPos;
1786 0 : pAction->Count = 1;
1787 0 : pAction->ListActionType = ListActionType::MOVED;
1788 0 : pAction->ActionInfo <<= nNewPos-nCurPos;
1789 0 : pList->Insert( pAction );
1790 : }
1791 : pList->AddEvent( ListActionType::PROPERTIES_CHANGED,
1792 0 : nNewPos, 1 );
1793 : }
1794 : }
1795 : }
1796 0 : catch (const SQLException&)
1797 : {
1798 : OSL_FAIL( "SortedResultSet::ResortModified() : Got unexpected SQLException" );
1799 : }
1800 :
1801 0 : maModList.Clear();
1802 0 : }
1803 :
1804 :
1805 0 : void SortedResultSet::ResortNew( EventList* pList )
1806 : {
1807 : sal_IntPtr i, j, nNewPos, nVal;
1808 : SortListData *pData;
1809 :
1810 : try {
1811 0 : for ( i = mnLastSort; i<(sal_IntPtr)maS2O.Count(); i++ )
1812 : {
1813 0 : pData = (SortListData*) maModList.GetObject( i );
1814 0 : nNewPos = FindPos( pData, 1, mnLastSort );
1815 0 : if ( nNewPos != i )
1816 : {
1817 0 : maS2O.Remove( (sal_uInt32) i );
1818 0 : maS2O.Insert( pData, nNewPos );
1819 : // maO2S liste korigieren
1820 0 : for ( j=1; j<(sal_IntPtr)maO2S.Count(); j++ )
1821 : {
1822 0 : nVal = (sal_IntPtr) maO2S.GetObject( (sal_uInt32)( j ) );
1823 0 : if ( nVal >= nNewPos )
1824 0 : maO2S.Replace( (void*) (nVal+1), (sal_uInt32)( j ) );
1825 : }
1826 0 : maO2S.Replace( (void*) nNewPos, (sal_uInt32) pData->mnCurPos );
1827 : }
1828 0 : mnLastSort++;
1829 0 : pList->AddEvent( ListActionType::INSERTED, nNewPos, 1 );
1830 : }
1831 : }
1832 0 : catch (const SQLException&)
1833 : {
1834 : OSL_FAIL( "SortedResultSet::ResortNew() : Got unexpected SQLException" );
1835 : }
1836 0 : }
1837 :
1838 :
1839 :
1840 : // SortListData
1841 :
1842 :
1843 0 : SortListData::SortListData( sal_IntPtr nPos, sal_Bool bModified )
1844 : {
1845 0 : mbModified = bModified;
1846 0 : mnCurPos = nPos;
1847 0 : mnOldPos = nPos;
1848 0 : };
1849 :
1850 :
1851 :
1852 0 : void SortedEntryList::Clear()
1853 : {
1854 0 : for ( std::deque< ListAction* >::size_type i = 0;
1855 0 : i < maData.size(); ++i )
1856 : {
1857 0 : delete maData[i];
1858 : }
1859 :
1860 0 : maData.clear();
1861 0 : }
1862 :
1863 :
1864 0 : void SortedEntryList::Insert( SortListData *pEntry, sal_IntPtr nPos )
1865 : {
1866 0 : if ( nPos < (sal_IntPtr) maData.size() )
1867 0 : maData.insert( maData.begin() + nPos, pEntry );
1868 : else
1869 0 : maData.push_back( pEntry );
1870 0 : }
1871 :
1872 :
1873 0 : SortListData* SortedEntryList::Remove( sal_IntPtr nPos )
1874 : {
1875 : SortListData *pData;
1876 :
1877 0 : if ( nPos < (sal_IntPtr) maData.size() )
1878 : {
1879 0 : pData = maData[ nPos ];
1880 0 : maData.erase( maData.begin() + nPos );
1881 : }
1882 : else
1883 0 : pData = NULL;
1884 :
1885 0 : return pData;
1886 : }
1887 :
1888 :
1889 0 : SortListData* SortedEntryList::GetData( sal_IntPtr nPos )
1890 : {
1891 : SortListData *pData;
1892 :
1893 0 : if ( nPos < (sal_IntPtr) maData.size() )
1894 0 : pData = maData[ nPos ];
1895 : else
1896 0 : pData = NULL;
1897 :
1898 0 : return pData;
1899 : }
1900 :
1901 :
1902 0 : sal_IntPtr SortedEntryList::operator [] ( sal_IntPtr nPos ) const
1903 : {
1904 : SortListData *pData;
1905 :
1906 0 : if ( nPos < (sal_IntPtr) maData.size() )
1907 0 : pData = maData[ nPos ];
1908 : else
1909 0 : pData = NULL;
1910 :
1911 0 : if ( pData )
1912 0 : if ( ! pData->mbModified )
1913 0 : return pData->mnCurPos;
1914 : else
1915 : {
1916 : OSL_FAIL( "SortedEntryList: Can't get value for modified entry!");
1917 0 : return 0;
1918 : }
1919 : else
1920 : {
1921 : OSL_FAIL( "SortedEntryList: invalid pos!");
1922 0 : return 0;
1923 : }
1924 : }
1925 :
1926 :
1927 :
1928 :
1929 0 : void SimpleList::Remove( sal_uInt32 nPos )
1930 : {
1931 0 : if ( nPos < (sal_uInt32) maData.size() )
1932 : {
1933 0 : maData.erase( maData.begin() + nPos );
1934 : }
1935 0 : }
1936 :
1937 :
1938 0 : void SimpleList::Remove( void* pData )
1939 : {
1940 0 : sal_Bool bFound = sal_False;
1941 : sal_uInt32 i;
1942 :
1943 0 : for ( i = 0; i < (sal_uInt32) maData.size(); i++ )
1944 : {
1945 0 : if ( maData[ i ] == pData )
1946 : {
1947 0 : bFound = sal_True;
1948 0 : break;
1949 : }
1950 : }
1951 :
1952 0 : if ( bFound )
1953 0 : maData.erase( maData.begin() + i );
1954 0 : }
1955 :
1956 :
1957 0 : void SimpleList::Insert( void* pData, sal_uInt32 nPos )
1958 : {
1959 0 : if ( nPos < (sal_uInt32) maData.size() )
1960 0 : maData.insert( maData.begin() + nPos, pData );
1961 : else
1962 0 : maData.push_back( pData );
1963 0 : }
1964 :
1965 :
1966 0 : void* SimpleList::GetObject( sal_uInt32 nPos ) const
1967 : {
1968 0 : if ( nPos < (sal_uInt32) maData.size() )
1969 0 : return maData[ nPos ];
1970 : else
1971 0 : return NULL;
1972 : }
1973 :
1974 :
1975 0 : void SimpleList::Replace( void* pData, sal_uInt32 nPos )
1976 : {
1977 0 : if ( nPos < (sal_uInt32) maData.size() )
1978 0 : maData[ nPos ] = pData;
1979 0 : }
1980 :
1981 :
1982 :
1983 : // class SRSPropertySetInfo.
1984 :
1985 :
1986 :
1987 0 : SRSPropertySetInfo::SRSPropertySetInfo()
1988 : {
1989 0 : maProps[0].Name = "RowCount";
1990 0 : maProps[0].Handle = -1;
1991 0 : maProps[0].Type = ::getCppuType( (const OUString*) NULL );
1992 0 : maProps[0].Attributes = -1;
1993 :
1994 0 : maProps[1].Name = "IsRowCountFinal";
1995 0 : maProps[1].Handle = -1;
1996 0 : maProps[1].Type = ::getBooleanCppuType();
1997 0 : maProps[1].Attributes = -1;
1998 0 : }
1999 :
2000 :
2001 0 : SRSPropertySetInfo::~SRSPropertySetInfo()
2002 0 : {}
2003 :
2004 : // XPropertySetInfo methods.
2005 :
2006 : Sequence< Property > SAL_CALL
2007 0 : SRSPropertySetInfo::getProperties() throw( RuntimeException, std::exception )
2008 : {
2009 0 : return Sequence < Property > ( maProps, 2 );
2010 : }
2011 :
2012 :
2013 : Property SAL_CALL
2014 0 : SRSPropertySetInfo::getPropertyByName( const OUString& Name )
2015 : throw( UnknownPropertyException, RuntimeException, std::exception )
2016 : {
2017 0 : if ( Name.equalsAscii( "RowCount" ) )
2018 0 : return maProps[0];
2019 0 : else if ( Name.equalsAscii( "IsRowCountFinal" ) )
2020 0 : return maProps[1];
2021 : else
2022 0 : throw UnknownPropertyException();
2023 : }
2024 :
2025 :
2026 : sal_Bool SAL_CALL
2027 0 : SRSPropertySetInfo::hasPropertyByName( const OUString& Name )
2028 : throw( RuntimeException, std::exception )
2029 : {
2030 0 : if ( Name.equalsAscii( "RowCount" ) )
2031 0 : return sal_True;
2032 0 : else if ( Name.equalsAscii( "IsRowCountFinal" ) )
2033 0 : return sal_True;
2034 : else
2035 0 : return sal_False;
2036 : }
2037 :
2038 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
