ucb/source/sorter/sortresult.cxx

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