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