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 140 : 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 70 : SortedResultSet::SortedResultSet( Reference< XResultSet > aResult )
127 : {
128 70 : mpDisposeEventListeners = NULL;
129 70 : mpPropChangeListeners = NULL;
130 70 : mpVetoChangeListeners = NULL;
131 70 : mpPropSetInfo = NULL;
132 :
133 70 : mxOriginal = aResult;
134 70 : mpSortInfo = NULL;
135 70 : mnLastSort = 0;
136 70 : mnCurEntry = 0;
137 70 : mnCount = 0;
138 70 : mbIsCopy = false;
139 70 : }
140 :
141 :
142 210 : SortedResultSet::~SortedResultSet()
143 : {
144 70 : mxOriginal.clear();
145 70 : mxOther.clear();
146 :
147 70 : if ( !mbIsCopy )
148 : {
149 70 : SortInfo *pInfo = mpSortInfo;
150 210 : while ( pInfo )
151 : {
152 70 : mpSortInfo = pInfo->mpNext;
153 70 : delete pInfo;
154 70 : pInfo = mpSortInfo;
155 : }
156 : }
157 :
158 70 : mpSortInfo = NULL;
159 :
160 70 : if ( mpPropSetInfo )
161 0 : mpPropSetInfo->release();
162 :
163 70 : delete mpPropChangeListeners;
164 70 : delete mpVetoChangeListeners;
165 140 : }
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 ] = 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 0 : SortedResultSet::queryContentIdentifierString()
264 : throw( RuntimeException, std::exception )
265 : {
266 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
267 0 : 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 282 : sal_Bool SAL_CALL SortedResultSet::next()
293 : throw ( SQLException, RuntimeException, std::exception )
294 : {
295 282 : osl::Guard< osl::Mutex > aGuard( maMutex );
296 :
297 282 : mnCurEntry++;
298 :
299 282 : if ( mnCurEntry > 0 )
300 : {
301 282 : if ( mnCurEntry <= mnCount )
302 : {
303 212 : sal_Int32 nIndex = maS2O[ mnCurEntry ];
304 212 : return mxOriginal->absolute( nIndex );
305 : }
306 : else
307 : {
308 70 : mnCurEntry = mnCount + 1;
309 : }
310 : }
311 70 : 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 70 : void SAL_CALL SortedResultSet::beforeFirst()
356 : throw ( SQLException, RuntimeException, std::exception )
357 : {
358 70 : osl::Guard< osl::Mutex > aGuard( maMutex );
359 70 : mnCurEntry = 0;
360 70 : mxOriginal->beforeFirst();
361 70 : }
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 212 : OUString SAL_CALL SortedResultSet::getString( sal_Int32 columnIndex )
655 : throw( SQLException, RuntimeException, std::exception )
656 : {
657 212 : osl::Guard< osl::Mutex > aGuard( maMutex );
658 212 : 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 == "RowCount" || PropertyName == "IsRowCountFinal" )
863 0 : throw IllegalArgumentException();
864 : else
865 0 : throw UnknownPropertyException();
866 : }
867 :
868 :
869 0 : Any SAL_CALL SortedResultSet::getPropertyValue( const OUString& PropertyName )
870 : throw( UnknownPropertyException,
871 : WrappedTargetException,
872 : RuntimeException, std::exception )
873 : {
874 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
875 :
876 0 : Any aRet;
877 :
878 0 : if ( PropertyName == "RowCount" )
879 : {
880 0 : aRet <<= maS2O.Count();
881 : }
882 0 : else if ( PropertyName == "IsRowCountFinal" )
883 : {
884 0 : bool bOrgFinal = false;
885 0 : Any aOrgRet;
886 :
887 0 : aRet <<= false;
888 :
889 0 : aOrgRet = Reference< XPropertySet >::query(mxOriginal)->
890 0 : getPropertyValue( PropertyName );
891 0 : aOrgRet >>= bOrgFinal;
892 :
893 0 : if ( bOrgFinal )
894 : {
895 0 : aOrgRet = Reference< XPropertySet >::query(mxOriginal)->
896 0 : getPropertyValue("RowCount");
897 0 : sal_uInt32 nOrgCount = 0;
898 0 : aOrgRet >>= nOrgCount;
899 0 : if ( nOrgCount == maS2O.Count() )
900 0 : aRet <<= true;
901 0 : }
902 : }
903 : else
904 0 : throw UnknownPropertyException();
905 :
906 0 : return aRet;
907 : }
908 :
909 :
910 0 : void SAL_CALL SortedResultSet::addPropertyChangeListener(
911 : const OUString& PropertyName,
912 : const Reference< XPropertyChangeListener >& Listener )
913 : throw( UnknownPropertyException,
914 : WrappedTargetException,
915 : RuntimeException, std::exception )
916 : {
917 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
918 :
919 0 : if ( !mpPropChangeListeners )
920 : mpPropChangeListeners =
921 0 : new PropertyChangeListeners_Impl();
922 :
923 0 : mpPropChangeListeners->addInterface( PropertyName, Listener );
924 0 : }
925 :
926 :
927 0 : void SAL_CALL SortedResultSet::removePropertyChangeListener(
928 : const OUString& PropertyName,
929 : const Reference< XPropertyChangeListener >& Listener )
930 : throw( UnknownPropertyException,
931 : WrappedTargetException,
932 : RuntimeException, std::exception )
933 : {
934 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
935 :
936 0 : if ( mpPropChangeListeners )
937 0 : mpPropChangeListeners->removeInterface( PropertyName, Listener );
938 0 : }
939 :
940 :
941 0 : void SAL_CALL SortedResultSet::addVetoableChangeListener(
942 : const OUString& PropertyName,
943 : const Reference< XVetoableChangeListener >& Listener )
944 : throw( UnknownPropertyException,
945 : WrappedTargetException,
946 : RuntimeException, std::exception )
947 : {
948 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
949 :
950 0 : if ( !mpVetoChangeListeners )
951 : mpVetoChangeListeners =
952 0 : new PropertyChangeListeners_Impl();
953 :
954 0 : mpVetoChangeListeners->addInterface( PropertyName, Listener );
955 0 : }
956 :
957 :
958 0 : void SAL_CALL SortedResultSet::removeVetoableChangeListener(
959 : const OUString& PropertyName,
960 : const Reference< XVetoableChangeListener >& Listener )
961 : throw( UnknownPropertyException,
962 : WrappedTargetException,
963 : RuntimeException, std::exception )
964 : {
965 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
966 :
967 0 : if ( mpVetoChangeListeners )
968 0 : mpVetoChangeListeners->removeInterface( PropertyName, Listener );
969 0 : }
970 :
971 :
972 : // private methods
973 :
974 255 : sal_IntPtr SortedResultSet::CompareImpl( Reference < XResultSet > xResultOne,
975 : Reference < XResultSet > xResultTwo,
976 : sal_IntPtr nIndexOne, sal_IntPtr nIndexTwo,
977 : SortInfo* pSortInfo )
978 :
979 : throw( SQLException, RuntimeException )
980 : {
981 255 : Reference < XRow > xRowOne = Reference< XRow >::query( xResultOne );
982 510 : Reference < XRow > xRowTwo = Reference< XRow >::query( xResultTwo );
983 :
984 255 : sal_IntPtr nCompare = 0;
985 255 : sal_IntPtr nColumn = pSortInfo->mnColumn;
986 :
987 255 : switch ( pSortInfo->mnType )
988 : {
989 : case DataType::BIT :
990 : case DataType::TINYINT :
991 : case DataType::SMALLINT :
992 : case DataType::INTEGER :
993 : {
994 0 : sal_Int32 aOne = 0;
995 0 : sal_Int32 aTwo = 0;
996 :
997 0 : if ( xResultOne->absolute( nIndexOne ) )
998 0 : aOne = xRowOne->getInt( nColumn );
999 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1000 0 : aTwo = xRowTwo->getInt( nColumn );
1001 :
1002 0 : if ( aOne < aTwo )
1003 0 : nCompare = -1;
1004 0 : else if ( aOne == aTwo )
1005 0 : nCompare = 0;
1006 : else
1007 0 : nCompare = 1;
1008 :
1009 0 : break;
1010 : }
1011 : case DataType::BIGINT :
1012 : {
1013 0 : sal_Int64 aOne = 0;
1014 0 : sal_Int64 aTwo = 0;
1015 :
1016 0 : if ( xResultOne->absolute( nIndexOne ) )
1017 0 : aOne = xRowOne->getLong( nColumn );
1018 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1019 0 : aTwo = xRowTwo->getLong( nColumn );
1020 :
1021 0 : if ( aOne < aTwo )
1022 0 : nCompare = -1;
1023 0 : else if ( aOne == aTwo )
1024 0 : nCompare = 0;
1025 : else
1026 0 : nCompare = 1;
1027 :
1028 0 : break;
1029 : }
1030 : case DataType::CHAR :
1031 : case DataType::VARCHAR :
1032 : case DataType::LONGVARCHAR :
1033 : {
1034 510 : OUString aOne, aTwo;
1035 :
1036 255 : if ( xResultOne->absolute( nIndexOne ) )
1037 255 : aOne = xRowOne->getString( nColumn );
1038 255 : if ( xResultTwo->absolute( nIndexTwo ) )
1039 255 : aTwo = xRowTwo->getString( nColumn );
1040 :
1041 255 : if ( ! pSortInfo->mbCaseSensitive )
1042 : {
1043 255 : aOne = aOne.toAsciiLowerCase();
1044 255 : aTwo = aTwo.toAsciiLowerCase();
1045 : }
1046 :
1047 255 : nCompare = aOne.compareTo( aTwo );
1048 510 : break;
1049 : }
1050 : case DataType::DATE :
1051 : {
1052 0 : Date aOne, aTwo;
1053 : sal_Int32 nTmp;
1054 :
1055 0 : if ( xResultOne->absolute( nIndexOne ) )
1056 0 : aOne = xRowOne->getDate( nColumn );
1057 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1058 0 : aTwo = xRowTwo->getDate( nColumn );
1059 :
1060 0 : nTmp = (sal_Int32) aTwo.Year - (sal_Int32) aOne.Year;
1061 0 : if ( !nTmp ) {
1062 0 : nTmp = (sal_Int32) aTwo.Month - (sal_Int32) aOne.Month;
1063 0 : if ( !nTmp )
1064 0 : nTmp = (sal_Int32) aTwo.Day - (sal_Int32) aOne.Day;
1065 : }
1066 :
1067 0 : if ( nTmp < 0 )
1068 0 : nCompare = -1;
1069 0 : else if ( nTmp == 0 )
1070 0 : nCompare = 0;
1071 : else
1072 0 : nCompare = 1;
1073 :
1074 0 : break;
1075 : }
1076 : case DataType::TIME :
1077 : {
1078 0 : Time aOne, aTwo;
1079 : sal_Int32 nTmp;
1080 :
1081 0 : if ( xResultOne->absolute( nIndexOne ) )
1082 0 : aOne = xRowOne->getTime( nColumn );
1083 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1084 0 : aTwo = xRowTwo->getTime( nColumn );
1085 :
1086 0 : nTmp = (sal_Int32) aTwo.Hours - (sal_Int32) aOne.Hours;
1087 0 : if ( !nTmp ) {
1088 0 : nTmp = (sal_Int32) aTwo.Minutes - (sal_Int32) aOne.Minutes;
1089 0 : if ( !nTmp ) {
1090 0 : nTmp = (sal_Int32) aTwo.Seconds - (sal_Int32) aOne.Seconds;
1091 0 : if ( !nTmp )
1092 : nTmp = (sal_Int32) aTwo.NanoSeconds
1093 0 : - (sal_Int32) aOne.NanoSeconds;
1094 : }}
1095 :
1096 0 : if ( nTmp < 0 )
1097 0 : nCompare = -1;
1098 0 : else if ( nTmp == 0 )
1099 0 : nCompare = 0;
1100 : else
1101 0 : nCompare = 1;
1102 :
1103 0 : break;
1104 : }
1105 : case DataType::TIMESTAMP :
1106 : {
1107 0 : DateTime aOne, aTwo;
1108 : sal_Int32 nTmp;
1109 :
1110 0 : if ( xResultOne->absolute( nIndexOne ) )
1111 0 : aOne = xRowOne->getTimestamp( nColumn );
1112 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1113 0 : aTwo = xRowTwo->getTimestamp( nColumn );
1114 :
1115 0 : nTmp = (sal_Int32) aTwo.Year - (sal_Int32) aOne.Year;
1116 0 : if ( !nTmp ) {
1117 0 : nTmp = (sal_Int32) aTwo.Month - (sal_Int32) aOne.Month;
1118 0 : if ( !nTmp ) {
1119 0 : nTmp = (sal_Int32) aTwo.Day - (sal_Int32) aOne.Day;
1120 0 : if ( !nTmp ) {
1121 0 : nTmp = (sal_Int32) aTwo.Hours - (sal_Int32) aOne.Hours;
1122 0 : if ( !nTmp ) {
1123 0 : nTmp = (sal_Int32) aTwo.Minutes - (sal_Int32) aOne.Minutes;
1124 0 : if ( !nTmp ) {
1125 0 : nTmp = (sal_Int32) aTwo.Seconds - (sal_Int32) aOne.Seconds;
1126 0 : if ( !nTmp )
1127 : nTmp = (sal_Int32) aTwo.NanoSeconds
1128 0 : - (sal_Int32) aOne.NanoSeconds;
1129 : }}}}}
1130 :
1131 0 : if ( nTmp < 0 )
1132 0 : nCompare = -1;
1133 0 : else if ( nTmp == 0 )
1134 0 : nCompare = 0;
1135 : else
1136 0 : nCompare = 1;
1137 :
1138 0 : break;
1139 : }
1140 : case DataType::REAL :
1141 : {
1142 0 : float aOne = 0;
1143 0 : float aTwo = 0;
1144 :
1145 0 : if ( xResultOne->absolute( nIndexOne ) )
1146 0 : aOne = xRowOne->getFloat( nColumn );
1147 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1148 0 : aTwo = xRowTwo->getFloat( nColumn );
1149 :
1150 0 : if ( aOne < aTwo )
1151 0 : nCompare = -1;
1152 0 : else if ( aOne == aTwo )
1153 0 : nCompare = 0;
1154 : else
1155 0 : nCompare = 1;
1156 :
1157 0 : break;
1158 : }
1159 : case DataType::FLOAT :
1160 : case DataType::DOUBLE :
1161 : {
1162 0 : double aOne = 0;
1163 0 : double aTwo = 0;
1164 :
1165 0 : if ( xResultOne->absolute( nIndexOne ) )
1166 0 : aOne = xRowOne->getDouble( nColumn );
1167 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1168 0 : aTwo = xRowTwo->getDouble( nColumn );
1169 :
1170 0 : if ( aOne < aTwo )
1171 0 : nCompare = -1;
1172 0 : else if ( aOne == aTwo )
1173 0 : nCompare = 0;
1174 : else
1175 0 : nCompare = 1;
1176 :
1177 0 : break;
1178 : }
1179 : default:
1180 : {
1181 : OSL_FAIL( "DataType not supported for compare!" );
1182 : }
1183 : }
1184 :
1185 510 : return nCompare;
1186 : }
1187 :
1188 :
1189 255 : sal_IntPtr SortedResultSet::CompareImpl( Reference < XResultSet > xResultOne,
1190 : Reference < XResultSet > xResultTwo,
1191 : sal_IntPtr nIndexOne, sal_IntPtr nIndexTwo )
1192 : throw( SQLException, RuntimeException )
1193 : {
1194 255 : sal_IntPtr nCompare = 0;
1195 255 : SortInfo* pInfo = mpSortInfo;
1196 :
1197 765 : while ( !nCompare && pInfo )
1198 : {
1199 255 : if ( pInfo->mbUseOwnCompare )
1200 : {
1201 : nCompare = CompareImpl( xResultOne, xResultTwo,
1202 255 : nIndexOne, nIndexTwo, pInfo );
1203 : }
1204 : else
1205 : {
1206 0 : Any aOne, aTwo;
1207 :
1208 : Reference < XRow > xRowOne =
1209 0 : Reference< XRow >::query( xResultOne );
1210 : Reference < XRow > xRowTwo =
1211 0 : Reference< XRow >::query( xResultTwo );
1212 :
1213 0 : if ( xResultOne->absolute( nIndexOne ) )
1214 0 : aOne = xRowOne->getObject( pInfo->mnColumn, NULL );
1215 0 : if ( xResultTwo->absolute( nIndexTwo ) )
1216 0 : aTwo = xRowTwo->getObject( pInfo->mnColumn, NULL );
1217 :
1218 0 : nCompare = pInfo->mxCompareFunction->compare( aOne, aTwo );
1219 : }
1220 :
1221 255 : if ( ! pInfo->mbAscending )
1222 0 : nCompare = - nCompare;
1223 :
1224 255 : pInfo = pInfo->mpNext;
1225 : }
1226 :
1227 255 : return nCompare;
1228 : }
1229 :
1230 :
1231 255 : sal_IntPtr SortedResultSet::Compare( SortListData *pOne,
1232 : SortListData *pTwo )
1233 : throw( SQLException, RuntimeException )
1234 : {
1235 : sal_IntPtr nIndexOne;
1236 : sal_IntPtr nIndexTwo;
1237 :
1238 255 : Reference < XResultSet > xResultOne;
1239 510 : Reference < XResultSet > xResultTwo;
1240 :
1241 255 : if ( pOne->mbModified )
1242 : {
1243 0 : xResultOne = mxOther;
1244 0 : nIndexOne = pOne->mnOldPos;
1245 : }
1246 : else
1247 : {
1248 255 : xResultOne = mxOriginal;
1249 255 : nIndexOne = pOne->mnCurPos;
1250 : }
1251 :
1252 255 : if ( pTwo->mbModified )
1253 : {
1254 0 : xResultTwo = mxOther;
1255 0 : nIndexTwo = pTwo->mnOldPos;
1256 : }
1257 : else
1258 : {
1259 255 : xResultTwo = mxOriginal;
1260 255 : nIndexTwo = pTwo->mnCurPos;
1261 : }
1262 :
1263 : sal_IntPtr nCompare;
1264 : nCompare = CompareImpl( xResultOne, xResultTwo,
1265 255 : nIndexOne, nIndexTwo );
1266 510 : return nCompare;
1267 : }
1268 :
1269 :
1270 212 : sal_IntPtr SortedResultSet::FindPos( SortListData *pEntry,
1271 : sal_IntPtr _nStart, sal_IntPtr _nEnd )
1272 : throw( SQLException, RuntimeException )
1273 : {
1274 212 : if ( _nStart > _nEnd )
1275 70 : return _nStart + 1;
1276 :
1277 142 : sal_IntPtr nStart = _nStart;
1278 142 : sal_IntPtr nEnd = _nEnd;
1279 142 : sal_IntPtr nMid = 0, nCompare = 0;
1280 :
1281 :
1282 539 : while ( nStart <= nEnd )
1283 : {
1284 255 : nMid = ( nEnd - nStart ) / 2 + nStart;
1285 255 : SortListData *pMid = maS2O.GetData( nMid );
1286 255 : nCompare = Compare( pEntry, pMid );
1287 :
1288 255 : if ( !nCompare )
1289 0 : nCompare = (pEntry != pMid) ? ((pEntry < pMid) ? -1 : 1) : 0;
1290 :
1291 255 : if ( nCompare < 0 ) // pEntry < pMid
1292 125 : nEnd = nMid - 1;
1293 : else
1294 130 : nStart = nMid + 1;
1295 : }
1296 :
1297 142 : if ( nCompare < 0 ) // pEntry < pMid
1298 58 : return nMid;
1299 : else
1300 84 : return nMid+1;
1301 : }
1302 :
1303 :
1304 0 : void SortedResultSet::PropertyChanged( const PropertyChangeEvent& rEvt )
1305 : {
1306 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
1307 :
1308 0 : if ( !mpPropChangeListeners )
1309 0 : return;
1310 :
1311 : // Notify listeners interested especially in the changed property.
1312 : OInterfaceContainerHelper* pPropsContainer =
1313 0 : mpPropChangeListeners->getContainer( rEvt.PropertyName );
1314 0 : if ( pPropsContainer )
1315 : {
1316 0 : OInterfaceIteratorHelper aIter( *pPropsContainer );
1317 0 : while ( aIter.hasMoreElements() )
1318 : {
1319 : Reference< XPropertyChangeListener > xListener(
1320 0 : aIter.next(), UNO_QUERY );
1321 0 : if ( xListener.is() )
1322 0 : xListener->propertyChange( rEvt );
1323 0 : }
1324 : }
1325 :
1326 : // Notify listeners interested in all properties.
1327 0 : pPropsContainer = mpPropChangeListeners->getContainer( OUString() );
1328 0 : if ( pPropsContainer )
1329 : {
1330 0 : OInterfaceIteratorHelper aIter( *pPropsContainer );
1331 0 : while ( aIter.hasMoreElements() )
1332 : {
1333 : Reference< XPropertyChangeListener > xListener(
1334 0 : aIter.next(), UNO_QUERY );
1335 0 : if ( xListener.is() )
1336 0 : xListener->propertyChange( rEvt );
1337 0 : }
1338 0 : }
1339 : }
1340 :
1341 :
1342 :
1343 :
1344 : // public methods
1345 :
1346 :
1347 0 : void SortedResultSet::CopyData( SortedResultSet *pSource )
1348 : {
1349 0 : const SortedEntryList& rSrcS2O = pSource->GetS2OList();
1350 0 : const SimpleList& rSrcO2S = pSource->GetO2SList();
1351 :
1352 : sal_IntPtr i, nCount;
1353 :
1354 0 : maS2O.Clear();
1355 0 : maO2S.Clear();
1356 0 : maModList.Clear();
1357 :
1358 0 : maS2O.Insert( NULL, 0 );
1359 0 : maO2S.Insert( 0, (sal_uInt32) 0 ); // value, pos
1360 :
1361 0 : nCount = rSrcS2O.Count();
1362 :
1363 0 : for ( i=1; i<nCount; i++ )
1364 : {
1365 0 : maS2O.Insert( new SortListData( rSrcS2O[ i ] ), i );
1366 0 : maO2S.Insert( rSrcO2S.GetObject( i ), (sal_uInt32) i );
1367 : }
1368 :
1369 0 : mnLastSort = maS2O.Count();
1370 0 : mxOther = pSource->GetResultSet();
1371 :
1372 0 : if ( !mpSortInfo )
1373 : {
1374 0 : mpSortInfo = pSource->GetSortInfo();
1375 0 : mbIsCopy = true;
1376 : }
1377 0 : }
1378 :
1379 :
1380 70 : void SortedResultSet::Initialize(
1381 : const Sequence < NumberedSortingInfo > &xSortInfo,
1382 : const Reference< XAnyCompareFactory > &xCompFactory )
1383 : {
1384 70 : BuildSortInfo( mxOriginal, xSortInfo, xCompFactory );
1385 : // Insert dummy at pos 0
1386 70 : SortListData *pData = new SortListData( 0 );
1387 70 : maS2O.Insert( pData, 0 );
1388 :
1389 70 : sal_IntPtr nIndex = 1;
1390 :
1391 : // now fetch all the elements from the original result set,
1392 : // get there new position in the sorted result set and insert
1393 : // an entry in the sorted to original mapping list
1394 : try {
1395 352 : while ( mxOriginal->absolute( nIndex ) )
1396 : {
1397 212 : pData = new SortListData( nIndex );
1398 212 : sal_IntPtr nPos = FindPos( pData, 1, nIndex-1 );
1399 :
1400 212 : maS2O.Insert( pData, nPos );
1401 :
1402 212 : nIndex++;
1403 : }
1404 : }
1405 0 : catch (const SQLException&)
1406 : {
1407 : OSL_FAIL( "SortedResultSet::Initialize() : Got unexpected SQLException" );
1408 : }
1409 :
1410 : // when we have fetched all the elements, we can create the
1411 : // original to sorted mapping list from the s2o list
1412 70 : maO2S.Clear();
1413 70 : maO2S.Insert( NULL, (sal_uInt32) 0 );
1414 :
1415 : // insert some dummy entries first and replace then
1416 : // the entries with the right ones
1417 : size_t i;
1418 :
1419 282 : for ( i=1; i<maS2O.Count(); i++ )
1420 212 : maO2S.Insert( nullptr, i ); // Insert( data, pos )
1421 282 : for ( i=1; i<maS2O.Count(); i++ )
1422 212 : maO2S.Replace( reinterpret_cast<void*>(i), maS2O[ i ] ); // Insert( data, pos )
1423 :
1424 70 : mnCount = maS2O.Count() - 1;
1425 70 : }
1426 :
1427 :
1428 0 : void SortedResultSet::CheckProperties( sal_IntPtr nOldCount, bool bWasFinal )
1429 : {
1430 0 : osl::Guard< osl::Mutex > aGuard( maMutex );
1431 :
1432 0 : if ( !mpPropChangeListeners )
1433 0 : return;
1434 :
1435 : try {
1436 : // check for propertyChangeEvents
1437 0 : if ( nOldCount != GetCount() )
1438 : {
1439 0 : bool bIsFinal = false;
1440 0 : PropertyChangeEvent aEvt;
1441 :
1442 0 : aEvt.PropertyName = "RowCount";
1443 0 : aEvt.Further = sal_False;
1444 0 : aEvt.PropertyHandle = -1;
1445 0 : aEvt.OldValue <<= nOldCount;
1446 0 : aEvt.NewValue <<= GetCount();
1447 :
1448 0 : PropertyChanged( aEvt );
1449 :
1450 0 : OUString aName = "IsRowCountFinal";
1451 0 : Any aRet = getPropertyValue( aName );
1452 0 : if ( (aRet >>= bIsFinal) && bIsFinal != bWasFinal )
1453 : {
1454 0 : aEvt.PropertyName = aName;
1455 0 : aEvt.Further = sal_False;
1456 0 : aEvt.PropertyHandle = -1;
1457 0 : aEvt.OldValue <<= bWasFinal;
1458 0 : aEvt.NewValue <<= bIsFinal;
1459 0 : PropertyChanged( aEvt );
1460 0 : }
1461 : }
1462 : }
1463 0 : catch (const UnknownPropertyException&) {}
1464 0 : catch (const WrappedTargetException&) {}
1465 : }
1466 :
1467 :
1468 0 : void SortedResultSet::InsertNew( sal_IntPtr nPos, sal_IntPtr nCount )
1469 : {
1470 : // for all entries in the msS20-list, which are >= nPos, increase by nCount
1471 : SortListData *pData;
1472 : sal_IntPtr i, nEnd;
1473 :
1474 0 : nEnd = maS2O.Count();
1475 0 : for ( i=1; i<=nEnd; i++ )
1476 : {
1477 0 : pData = maS2O.GetData( i );
1478 0 : if ( pData->mnCurPos >= nPos )
1479 : {
1480 0 : pData->mnCurPos += nCount;
1481 : }
1482 : }
1483 :
1484 : // and append the new entries at the end of the maS20-list or insert at the
1485 : // position nPos in the maS2O-list
1486 0 : for ( i=0; i<nCount; i++ )
1487 : {
1488 0 : nEnd += 1;
1489 0 : pData = new SortListData( nEnd );
1490 :
1491 0 : maS2O.Insert( pData, nEnd ); // Insert( Value, Position )
1492 0 : maO2S.Insert( reinterpret_cast<void*>(nEnd), (sal_uInt32)(nPos+i) ); // Insert( Value, Position )
1493 : }
1494 :
1495 0 : mnCount += nCount;
1496 0 : }
1497 :
1498 :
1499 0 : void SortedResultSet::Remove( sal_IntPtr nPos, sal_IntPtr nCount, EventList *pEvents )
1500 : {
1501 : sal_uInt32 i, j;
1502 : sal_IntPtr nOldLastSort;
1503 :
1504 : // correct mnLastSort first
1505 0 : nOldLastSort = mnLastSort;
1506 0 : if ( nPos <= mnLastSort )
1507 : {
1508 0 : if ( nPos + nCount - 1 <= mnLastSort )
1509 0 : mnLastSort -= nCount;
1510 : else
1511 0 : mnLastSort = nPos - 1;
1512 : }
1513 :
1514 : // remove the entries from the lists and correct the positions
1515 : // in the original2sorted list
1516 0 : for ( i=0; i < (sal_uInt32) nCount; i++ )
1517 : {
1518 0 : sal_IntPtr nSortPos = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( nPos ) );
1519 0 : maO2S.Remove( (sal_uInt32) nPos );
1520 :
1521 0 : for ( j=1; j<=maO2S.Count(); j++ )
1522 : {
1523 0 : sal_IntPtr nVal = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( j ) );
1524 0 : if ( nVal > nSortPos )
1525 : {
1526 0 : --nVal;
1527 0 : maO2S.Replace( reinterpret_cast<void*>(nVal), j );
1528 : }
1529 : }
1530 :
1531 0 : SortListData *pData = maS2O.Remove( nSortPos );
1532 0 : if ( pData->mbModified )
1533 0 : maModList.Remove( static_cast<void*>(pData) );
1534 0 : delete pData;
1535 :
1536 : // generate remove Event, but not for new entries
1537 0 : if ( nSortPos <= nOldLastSort )
1538 0 : pEvents->AddEvent( ListActionType::REMOVED, nSortPos, 1 );
1539 : }
1540 :
1541 : // correct the positions in the sorted list
1542 0 : for ( i=1; i<= maS2O.Count(); i++ )
1543 : {
1544 0 : SortListData *pData = maS2O.GetData( i );
1545 0 : if ( pData->mnCurPos > nPos )
1546 0 : pData->mnCurPos -= nCount;
1547 : }
1548 :
1549 0 : mnCount -= nCount;
1550 0 : }
1551 :
1552 :
1553 0 : void SortedResultSet::Move( sal_IntPtr nPos, sal_IntPtr nCount, sal_IntPtr nOffset )
1554 : {
1555 0 : if ( !nOffset )
1556 0 : return;
1557 :
1558 : sal_IntPtr i, nSortPos, nTo;
1559 : SortListData *pData;
1560 :
1561 0 : for ( i=0; i<nCount; i++ )
1562 : {
1563 0 : nSortPos = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( nPos+i ));
1564 0 : pData = maS2O.GetData( nSortPos );
1565 0 : pData->mnCurPos += nOffset;
1566 : }
1567 :
1568 0 : if ( nOffset < 0 )
1569 : {
1570 0 : for ( i=nPos+nOffset; i<nPos; i++ )
1571 : {
1572 0 : nSortPos = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( i ));
1573 0 : pData = maS2O.GetData( nSortPos );
1574 0 : pData->mnCurPos += nCount;
1575 : }
1576 : }
1577 : else
1578 : {
1579 0 : sal_IntPtr nStart = nPos + nCount;
1580 0 : sal_IntPtr nEnd = nStart + nOffset;
1581 0 : for ( i=nStart; i<nEnd; i++ )
1582 : {
1583 0 : nSortPos = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( i ));
1584 0 : pData = maS2O.GetData( nSortPos );
1585 0 : pData->mnCurPos -= nCount;
1586 : }
1587 : }
1588 :
1589 : // remember the to be moved entries
1590 0 : boost::scoped_array<sal_IntPtr> pTmpArr(new sal_IntPtr[ nCount ]);
1591 0 : for ( i=0; i<nCount; i++ )
1592 0 : pTmpArr[i] = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( (sal_uInt32)( nPos+i ) ));
1593 :
1594 : // now move the entries, which are in the way
1595 0 : if ( nOffset < 0 )
1596 : {
1597 : // be carefully here, because nOffset is negative here, so an
1598 : // addition is a subtraction
1599 0 : sal_IntPtr nFrom = nPos - 1;
1600 0 : nTo = nPos + nCount - 1;
1601 :
1602 : // same for i here
1603 0 : for ( i=0; i>nOffset; i-- )
1604 : {
1605 0 : sal_IntPtr nVal = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( (sal_uInt32)( nFrom+i ) ) );
1606 0 : maO2S.Replace( reinterpret_cast<void*>(nVal), (sal_uInt32)( nTo+i ) );
1607 : }
1608 :
1609 : }
1610 : else
1611 : {
1612 0 : sal_IntPtr nStart = nPos + nCount;
1613 0 : for ( i=0; i<nOffset; i++ )
1614 : {
1615 0 : sal_IntPtr nVal = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( (sal_uInt32)( nStart+i ) ) );
1616 0 : maO2S.Replace( reinterpret_cast<void*>(nVal), (sal_uInt32)( nPos+i ) );
1617 : }
1618 : }
1619 :
1620 : // finally put the remembered entries at there new location
1621 0 : nTo = nPos + nOffset;
1622 0 : for ( i=0; i<nCount; i++ )
1623 : {
1624 0 : maO2S.Replace( reinterpret_cast<void*>(pTmpArr[ i ]), (sal_uInt32)( nTo+i ) );
1625 0 : }
1626 : }
1627 :
1628 :
1629 70 : void SortedResultSet::BuildSortInfo(
1630 : Reference< XResultSet > aResult,
1631 : const Sequence < NumberedSortingInfo > &xSortInfo,
1632 : const Reference< XAnyCompareFactory > &xCompFactory )
1633 : {
1634 70 : Reference < XResultSetMetaDataSupplier > xMeta ( aResult, UNO_QUERY );
1635 :
1636 70 : if ( ! xMeta.is() )
1637 : {
1638 : OSL_FAIL( "No MetaData, No Sorting!" );
1639 70 : return;
1640 : }
1641 :
1642 140 : Reference < XResultSetMetaData > xData = xMeta->getMetaData();
1643 70 : const NumberedSortingInfo *pSortInfo = xSortInfo.getConstArray();
1644 :
1645 : sal_Int32 nColumn;
1646 140 : OUString aPropName;
1647 : SortInfo *pInfo;
1648 :
1649 210 : for ( sal_IntPtr i=xSortInfo.getLength(); i > 0; )
1650 : {
1651 70 : --i;
1652 70 : nColumn = pSortInfo[ i ].ColumnIndex;
1653 70 : aPropName = xData->getColumnName( nColumn );
1654 70 : pInfo = new SortInfo;
1655 :
1656 70 : if ( xCompFactory.is() )
1657 0 : pInfo->mxCompareFunction = xCompFactory->createAnyCompareByName(
1658 0 : aPropName );
1659 :
1660 70 : if ( pInfo->mxCompareFunction.is() )
1661 : {
1662 0 : pInfo->mbUseOwnCompare = false;
1663 0 : pInfo->mnType = 0;
1664 : }
1665 : else
1666 : {
1667 70 : pInfo->mbUseOwnCompare = true;
1668 70 : pInfo->mnType = xData->getColumnType( nColumn );
1669 : }
1670 :
1671 70 : pInfo->mnColumn = nColumn;
1672 70 : pInfo->mbAscending = pSortInfo[ i ].Ascending;
1673 70 : pInfo->mbCaseSensitive = xData->isCaseSensitive( nColumn );
1674 70 : pInfo->mpNext = mpSortInfo;
1675 70 : mpSortInfo = pInfo;
1676 70 : }
1677 : }
1678 :
1679 :
1680 0 : void SortedResultSet::SetChanged( sal_IntPtr nPos, sal_IntPtr nCount )
1681 : {
1682 0 : for ( sal_IntPtr i=0; i<nCount; i++ )
1683 : {
1684 0 : sal_IntPtr nSortPos = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( nPos ));
1685 0 : if ( nSortPos < mnLastSort )
1686 : {
1687 0 : SortListData *pData = maS2O.GetData( nSortPos );
1688 0 : if ( ! pData->mbModified )
1689 : {
1690 0 : pData->mbModified = true;
1691 0 : maModList.Append( pData );
1692 : }
1693 : }
1694 0 : nPos += 1;
1695 : }
1696 0 : }
1697 :
1698 :
1699 0 : void SortedResultSet::ResortModified( EventList* pList )
1700 : {
1701 : sal_uInt32 i, j;
1702 : sal_IntPtr nCompare, nCurPos, nNewPos;
1703 : sal_IntPtr nStart, nEnd, nOffset, nVal;
1704 : SortListData *pData;
1705 : ListAction *pAction;
1706 :
1707 : try {
1708 0 : for ( i=0; i<maModList.Count(); i++ )
1709 : {
1710 0 : pData = static_cast<SortListData*>(maModList.GetObject( i ));
1711 : nCompare = CompareImpl( mxOther, mxOriginal,
1712 0 : pData->mnOldPos, pData->mnCurPos );
1713 0 : pData->mbModified = false;
1714 0 : if ( nCompare != 0 )
1715 : {
1716 0 : nCurPos = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( (sal_uInt32) pData->mnCurPos ) );
1717 0 : if ( nCompare < 0 )
1718 : {
1719 0 : nNewPos = FindPos( pData, 1, nCurPos-1 );
1720 0 : nStart = nNewPos;
1721 0 : nEnd = nCurPos;
1722 0 : nOffset = 1;
1723 : }
1724 : else
1725 : {
1726 0 : nNewPos = FindPos( pData, nCurPos+1, mnLastSort );
1727 0 : nStart = nCurPos;
1728 0 : nEnd = mnLastSort;
1729 0 : nOffset = -1;
1730 : }
1731 :
1732 0 : if ( nNewPos != nCurPos )
1733 : {
1734 : // correct the lists!
1735 0 : maS2O.Remove( (sal_uInt32) nCurPos );
1736 0 : maS2O.Insert( pData, nNewPos );
1737 0 : for ( j=1; j<maO2S.Count(); j++ )
1738 : {
1739 0 : nVal = reinterpret_cast<sal_IntPtr>( maO2S.GetObject( (sal_uInt32)j ) );
1740 0 : if ( ( nStart <= nVal ) && ( nVal <= nEnd ) )
1741 : {
1742 0 : nVal += nOffset;
1743 0 : maO2S.Replace( reinterpret_cast<void*>(nVal), (sal_uInt32)j );
1744 : }
1745 : }
1746 :
1747 0 : maO2S.Replace( reinterpret_cast<void*>(nNewPos), (sal_uInt32) pData->mnCurPos );
1748 :
1749 0 : pAction = new ListAction;
1750 0 : pAction->Position = nCurPos;
1751 0 : pAction->Count = 1;
1752 0 : pAction->ListActionType = ListActionType::MOVED;
1753 0 : pAction->ActionInfo <<= nNewPos-nCurPos;
1754 0 : pList->Insert( pAction );
1755 : }
1756 : pList->AddEvent( ListActionType::PROPERTIES_CHANGED,
1757 0 : nNewPos, 1 );
1758 : }
1759 : }
1760 : }
1761 0 : catch (const SQLException&)
1762 : {
1763 : OSL_FAIL( "SortedResultSet::ResortModified() : Got unexpected SQLException" );
1764 : }
1765 :
1766 0 : maModList.Clear();
1767 0 : }
1768 :
1769 :
1770 0 : void SortedResultSet::ResortNew( EventList* pList )
1771 : {
1772 : sal_IntPtr i, j, nNewPos, nVal;
1773 :
1774 : try {
1775 0 : for ( i = mnLastSort; i<(sal_IntPtr)maS2O.Count(); i++ )
1776 : {
1777 0 : SortListData *pData = static_cast<SortListData*>(maModList.GetObject( i ));
1778 0 : nNewPos = FindPos( pData, 1, mnLastSort );
1779 0 : if ( nNewPos != i )
1780 : {
1781 0 : maS2O.Remove( (sal_uInt32) i );
1782 0 : maS2O.Insert( pData, nNewPos );
1783 : // maO2S liste korigieren
1784 0 : for ( j=1; j<(sal_IntPtr)maO2S.Count(); j++ )
1785 : {
1786 0 : nVal = reinterpret_cast<sal_IntPtr>(maO2S.GetObject( (sal_uInt32)j ));
1787 0 : if ( nVal >= nNewPos )
1788 0 : maO2S.Replace( reinterpret_cast<void*>(nVal+1), (sal_uInt32)( j ) );
1789 : }
1790 0 : maO2S.Replace( reinterpret_cast<void*>(nNewPos), (sal_uInt32) pData->mnCurPos );
1791 : }
1792 0 : mnLastSort++;
1793 0 : pList->AddEvent( ListActionType::INSERTED, nNewPos, 1 );
1794 : }
1795 : }
1796 0 : catch (const SQLException&)
1797 : {
1798 : OSL_FAIL( "SortedResultSet::ResortNew() : Got unexpected SQLException" );
1799 : }
1800 0 : }
1801 :
1802 :
1803 :
1804 : // SortListData
1805 :
1806 :
1807 282 : SortListData::SortListData( sal_IntPtr nPos, bool bModified )
1808 : {
1809 282 : mbModified = bModified;
1810 282 : mnCurPos = nPos;
1811 282 : mnOldPos = nPos;
1812 282 : };
1813 :
1814 :
1815 :
1816 70 : void SortedEntryList::Clear()
1817 : {
1818 704 : for ( std::deque< ListAction* >::size_type i = 0;
1819 352 : i < maData.size(); ++i )
1820 : {
1821 282 : delete maData[i];
1822 : }
1823 :
1824 70 : maData.clear();
1825 70 : }
1826 :
1827 :
1828 282 : void SortedEntryList::Insert( SortListData *pEntry, sal_IntPtr nPos )
1829 : {
1830 282 : if ( nPos < (sal_IntPtr) maData.size() )
1831 61 : maData.insert( maData.begin() + nPos, pEntry );
1832 : else
1833 221 : maData.push_back( pEntry );
1834 282 : }
1835 :
1836 :
1837 0 : SortListData* SortedEntryList::Remove( sal_IntPtr nPos )
1838 : {
1839 : SortListData *pData;
1840 :
1841 0 : if ( nPos < (sal_IntPtr) maData.size() )
1842 : {
1843 0 : pData = maData[ nPos ];
1844 0 : maData.erase( maData.begin() + nPos );
1845 : }
1846 : else
1847 0 : pData = NULL;
1848 :
1849 0 : return pData;
1850 : }
1851 :
1852 :
1853 255 : SortListData* SortedEntryList::GetData( sal_IntPtr nPos )
1854 : {
1855 : SortListData *pData;
1856 :
1857 255 : if ( nPos < (sal_IntPtr) maData.size() )
1858 255 : pData = maData[ nPos ];
1859 : else
1860 0 : pData = NULL;
1861 :
1862 255 : return pData;
1863 : }
1864 :
1865 :
1866 424 : sal_IntPtr SortedEntryList::operator [] ( sal_IntPtr nPos ) const
1867 : {
1868 : SortListData *pData;
1869 :
1870 424 : if ( nPos < (sal_IntPtr) maData.size() )
1871 424 : pData = maData[ nPos ];
1872 : else
1873 0 : pData = NULL;
1874 :
1875 424 : if ( pData )
1876 424 : if ( ! pData->mbModified )
1877 424 : return pData->mnCurPos;
1878 : else
1879 : {
1880 : OSL_FAIL( "SortedEntryList: Can't get value for modified entry!");
1881 0 : return 0;
1882 : }
1883 : else
1884 : {
1885 : OSL_FAIL( "SortedEntryList: invalid pos!");
1886 0 : return 0;
1887 : }
1888 : }
1889 :
1890 :
1891 :
1892 :
1893 0 : void SimpleList::Remove( sal_uInt32 nPos )
1894 : {
1895 0 : if ( nPos < (sal_uInt32) maData.size() )
1896 : {
1897 0 : maData.erase( maData.begin() + nPos );
1898 : }
1899 0 : }
1900 :
1901 :
1902 0 : void SimpleList::Remove( void* pData )
1903 : {
1904 0 : bool bFound = false;
1905 : sal_uInt32 i;
1906 :
1907 0 : for ( i = 0; i < (sal_uInt32) maData.size(); i++ )
1908 : {
1909 0 : if ( maData[ i ] == pData )
1910 : {
1911 0 : bFound = true;
1912 0 : break;
1913 : }
1914 : }
1915 :
1916 0 : if ( bFound )
1917 0 : maData.erase( maData.begin() + i );
1918 0 : }
1919 :
1920 :
1921 282 : void SimpleList::Insert( void* pData, sal_uInt32 nPos )
1922 : {
1923 282 : if ( nPos < (sal_uInt32) maData.size() )
1924 0 : maData.insert( maData.begin() + nPos, pData );
1925 : else
1926 282 : maData.push_back( pData );
1927 282 : }
1928 :
1929 :
1930 0 : void* SimpleList::GetObject( sal_uInt32 nPos ) const
1931 : {
1932 0 : if ( nPos < (sal_uInt32) maData.size() )
1933 0 : return maData[ nPos ];
1934 : else
1935 0 : return NULL;
1936 : }
1937 :
1938 :
1939 212 : void SimpleList::Replace( void* pData, sal_uInt32 nPos )
1940 : {
1941 212 : if ( nPos < (sal_uInt32) maData.size() )
1942 212 : maData[ nPos ] = pData;
1943 212 : }
1944 :
1945 :
1946 :
1947 : // class SRSPropertySetInfo.
1948 :
1949 :
1950 :
1951 0 : SRSPropertySetInfo::SRSPropertySetInfo()
1952 : {
1953 0 : maProps[0].Name = "RowCount";
1954 0 : maProps[0].Handle = -1;
1955 0 : maProps[0].Type = cppu::UnoType<OUString>::get();
1956 0 : maProps[0].Attributes = -1;
1957 :
1958 0 : maProps[1].Name = "IsRowCountFinal";
1959 0 : maProps[1].Handle = -1;
1960 0 : maProps[1].Type = cppu::UnoType<bool>::get();
1961 0 : maProps[1].Attributes = -1;
1962 0 : }
1963 :
1964 :
1965 0 : SRSPropertySetInfo::~SRSPropertySetInfo()
1966 0 : {}
1967 :
1968 : // XPropertySetInfo methods.
1969 :
1970 : Sequence< Property > SAL_CALL
1971 0 : SRSPropertySetInfo::getProperties() throw( RuntimeException, std::exception )
1972 : {
1973 0 : return Sequence < Property > ( maProps, 2 );
1974 : }
1975 :
1976 :
1977 : Property SAL_CALL
1978 0 : SRSPropertySetInfo::getPropertyByName( const OUString& Name )
1979 : throw( UnknownPropertyException, RuntimeException, std::exception )
1980 : {
1981 0 : if ( Name == "RowCount" )
1982 0 : return maProps[0];
1983 0 : else if ( Name == "IsRowCountFinal" )
1984 0 : return maProps[1];
1985 : else
1986 0 : throw UnknownPropertyException();
1987 : }
1988 :
1989 :
1990 : sal_Bool SAL_CALL
1991 0 : SRSPropertySetInfo::hasPropertyByName( const OUString& Name )
1992 : throw( RuntimeException, std::exception )
1993 : {
1994 0 : if ( Name == "RowCount" )
1995 0 : return sal_True;
1996 0 : else if ( Name == "IsRowCountFinal" )
1997 0 : return sal_True;
1998 : else
1999 0 : return sal_False;
2000 : }
2001 :
2002 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
