ucbhelper/source/provider/resultset.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 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26 #include <cppuhelper/interfacecontainer.hxx>
  27 #include <com/sun/star/beans/PropertyAttribute.hpp>
  28 #include <ucbhelper/getcomponentcontext.hxx>
  29 #include <ucbhelper/resultset.hxx>
  30 #include <ucbhelper/resultsetmetadata.hxx>
  31
  32 using namespace com::sun::star;
  33
  34
  35
  36 namespace ucbhelper_impl
  37 {
  38
  39 struct PropertyInfo
  40 {
  41     const char* pName;
  42     sal_Int32   nHandle;
  43     sal_Int16   nAttributes;
  44     const uno::Type& (*pGetCppuType)();
  45 };
  46
  47 static const uno::Type& sal_Int32_getCppuType()
  48 {
  49     return cppu::UnoType<sal_Int32>::get();
  50 }
  51
  52 static const uno::Type& sal_Bool_getCppuType()
  53 {
  54     return cppu::UnoType<bool>::get();
  55 }
  56
  57 static const PropertyInfo aPropertyTable[] =
  58 {
  59     { "IsRowCountFinal",
  60       1000,
  61       beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY,
  62       &sal_Bool_getCppuType
  63     },
  64     { "RowCount",
  65       1001,
  66       beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY,
  67       &sal_Int32_getCppuType
  68     },
  69     { 0,
  70       0,
  71       0,
  72       0
  73     }
  74 };
  75
  76 #define RESULTSET_PROPERTY_COUNT 2
  77
  78
  79
  80 // class PropertySetInfo
  81
  82
  83
  84 class PropertySetInfo :
  85         public cppu::OWeakObject,
  86         public lang::XTypeProvider,
  87         public beans::XPropertySetInfo
  88 {
  89     uno::Sequence< beans::Property >*            m_pProps;
  90
  91 private:
  92     bool queryProperty(
  93         const OUString& aName, beans::Property& rProp );
  94
  95 public:
  96     PropertySetInfo(
  97         const PropertyInfo* pProps,
  98         sal_Int32 nProps );
  99     virtual ~PropertySetInfo();
 100
 101     // XInterface
 102     virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType )
 103         throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 104     virtual void SAL_CALL acquire()
 105         throw() SAL_OVERRIDE;
 106     virtual void SAL_CALL release()
 107         throw() SAL_OVERRIDE;
 108
 109     // XTypeProvider
 110     virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId()
 111         throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 112     virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes()
 113         throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 114
 115     // XPropertySetInfo
 116     virtual uno::Sequence< beans::Property > SAL_CALL getProperties()
 117         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 118     virtual beans::Property SAL_CALL getPropertyByName(
 119             const OUString& aName )
 120         throw( beans::UnknownPropertyException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 121     virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
 122         throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
 123 };
 124
 125 typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString>
 126     PropertyChangeListenerContainer;
 127
 128 class PropertyChangeListeners : public PropertyChangeListenerContainer
 129 {
 130 public:
 131     PropertyChangeListeners( osl::Mutex& rMtx )
 132     : PropertyChangeListenerContainer( rMtx ) {}
 133 };
 134
 135 } // namespace ucbhelper_impl
 136
 137 using namespace ucbhelper_impl;
 138
 139 namespace ucbhelper
 140 {
 141
 142
 143
 144 // struct ResultSet_Impl.
 145
 146
 147
 148 struct ResultSet_Impl
 149 {
 150     uno::Reference< uno::XComponentContext >    m_xContext;
 151     uno::Reference< com::sun::star::ucb::XCommandEnvironment >  m_xEnv;
 152     uno::Reference< beans::XPropertySetInfo >       m_xPropSetInfo;
 153     uno::Reference< sdbc::XResultSetMetaData >      m_xMetaData;
 154     uno::Sequence< beans::Property >                m_aProperties;
 155     rtl::Reference< ResultSetDataSupplier >         m_xDataSupplier;
 156     osl::Mutex                          m_aMutex;
 157     cppu::OInterfaceContainerHelper*    m_pDisposeEventListeners;
 158     PropertyChangeListeners*            m_pPropertyChangeListeners;
 159     sal_Int32                           m_nPos;
 160     bool                            m_bWasNull;
 161     bool                            m_bAfterLast;
 162
 163     inline ResultSet_Impl(
 164         const uno::Reference< uno::XComponentContext >& rxContext,
 165         const uno::Sequence< beans::Property >& rProperties,
 166         const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
 167         const uno::Reference< com::sun::star::ucb::XCommandEnvironment >&
 168             rxEnv );
 169     inline ~ResultSet_Impl();
 170 };
 171
 172 inline ResultSet_Impl::ResultSet_Impl(
 173     const uno::Reference< uno::XComponentContext >& rxContext,
 174     const uno::Sequence< beans::Property >& rProperties,
 175     const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
 176     const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv )
 177 : m_xContext( rxContext ),
 178   m_xEnv( rxEnv ),
 179   m_aProperties( rProperties ),
 180   m_xDataSupplier( rDataSupplier ),
 181   m_pDisposeEventListeners( 0 ),
 182   m_pPropertyChangeListeners( 0 ),
 183   m_nPos( 0 ), // Position is one-based. Zero means: before first element.
 184   m_bWasNull( false ),
 185   m_bAfterLast( false )
 186 {
 187 }
 188
 189
 190 inline ResultSet_Impl::~ResultSet_Impl()
 191 {
 192     delete m_pDisposeEventListeners;
 193     delete m_pPropertyChangeListeners;
 194 }
 195
 196
 197
 198
 199 // ResultSet Implementation.
 200
 201
 202
 203
 204 ResultSet::ResultSet(
 205     const uno::Reference< uno::XComponentContext >& rxContext,
 206     const uno::Sequence< beans::Property >& rProperties,
 207     const rtl::Reference< ResultSetDataSupplier >& rDataSupplier )
 208 : m_pImpl( new ResultSet_Impl(
 209                rxContext,
 210                rProperties,
 211                rDataSupplier,
 212                uno::Reference< com::sun::star::ucb::XCommandEnvironment >() ) )
 213 {
 214     rDataSupplier->m_pResultSet = this;
 215 }
 216
 217
 218 ResultSet::ResultSet(
 219     const uno::Reference< uno::XComponentContext >& rxContext,
 220     const uno::Sequence< beans::Property >& rProperties,
 221     const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
 222     const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv )
 223 : m_pImpl( new ResultSet_Impl( rxContext, rProperties, rDataSupplier, rxEnv ) )
 224 {
 225     rDataSupplier->m_pResultSet = this;
 226 }
 227
 228
 229 // virtual
 230 ResultSet::~ResultSet()
 231 {
 232     delete m_pImpl;
 233 }
 234
 235
 236
 237 // XInterface methods.
 238
 239 void SAL_CALL ResultSet::acquire()
 240     throw()
 241 {
 242     OWeakObject::acquire();
 243 }
 244
 245 void SAL_CALL ResultSet::release()
 246     throw()
 247 {
 248     OWeakObject::release();
 249 }
 250
 251 css::uno::Any SAL_CALL ResultSet::queryInterface( const css::uno::Type & rType )
 252     throw( css::uno::RuntimeException, std::exception )
 253 {
 254     css::uno::Any aRet = cppu::queryInterface( rType,
 255                                                (static_cast< lang::XTypeProvider* >(this)),
 256                                                (static_cast< lang::XServiceInfo* >(this)),
 257                                                (static_cast< lang::XComponent* >(this)),
 258                                                (static_cast< css::ucb::XContentAccess* >(this)),
 259                                                (static_cast< sdbc::XResultSet* >(this)),
 260                                                (static_cast< sdbc::XResultSetMetaDataSupplier* >(this)),
 261                                                (static_cast< sdbc::XRow* >(this)),
 262                                                (static_cast< sdbc::XCloseable* >(this)),
 263                                                (static_cast< beans::XPropertySet* >(this))
 264                                                );
 265     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 266 }
 267
 268 // XTypeProvider methods.
 269
 270
 271
 272 XTYPEPROVIDER_IMPL_9( ResultSet,
 273                       lang::XTypeProvider,
 274                          lang::XServiceInfo,
 275                       lang::XComponent,
 276                       com::sun::star::ucb::XContentAccess,
 277                       sdbc::XResultSet,
 278                       sdbc::XResultSetMetaDataSupplier,
 279                       sdbc::XRow,
 280                       sdbc::XCloseable,
 281                       beans::XPropertySet );
 282
 283
 284
 285 // XServiceInfo methods.
 286
 287
 288
 289 XSERVICEINFO_NOFACTORY_IMPL_1( ResultSet,
 290                     OUString("ResultSet"),
 291                     RESULTSET_SERVICE_NAME );
 292
 293
 294
 295 // XComponent methods.
 296
 297
 298
 299 // virtual
 300 void SAL_CALL ResultSet::dispose()
 301     throw( uno::RuntimeException, std::exception )
 302 {
 303     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 304
 305     if ( m_pImpl->m_pDisposeEventListeners &&
 306          m_pImpl->m_pDisposeEventListeners->getLength() )
 307     {
 308         lang::EventObject aEvt;
 309         aEvt.Source = static_cast< lang::XComponent * >( this );
 310         m_pImpl->m_pDisposeEventListeners->disposeAndClear( aEvt );
 311     }
 312
 313     if ( m_pImpl->m_pPropertyChangeListeners )
 314     {
 315         lang::EventObject aEvt;
 316         aEvt.Source = static_cast< beans::XPropertySet * >( this );
 317         m_pImpl->m_pPropertyChangeListeners->disposeAndClear( aEvt );
 318     }
 319
 320     m_pImpl->m_xDataSupplier->close();
 321 }
 322
 323
 324 // virtual
 325 void SAL_CALL ResultSet::addEventListener(
 326         const uno::Reference< lang::XEventListener >& Listener )
 327     throw( uno::RuntimeException, std::exception )
 328 {
 329     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 330
 331     if ( !m_pImpl->m_pDisposeEventListeners )
 332         m_pImpl->m_pDisposeEventListeners =
 333             new cppu::OInterfaceContainerHelper( m_pImpl->m_aMutex );
 334
 335     m_pImpl->m_pDisposeEventListeners->addInterface( Listener );
 336 }
 337
 338
 339 // virtual
 340 void SAL_CALL ResultSet::removeEventListener(
 341         const uno::Reference< lang::XEventListener >& Listener )
 342     throw( uno::RuntimeException, std::exception )
 343 {
 344     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 345
 346     if ( m_pImpl->m_pDisposeEventListeners )
 347         m_pImpl->m_pDisposeEventListeners->removeInterface( Listener );
 348 }
 349
 350
 351
 352 // XResultSetMetaDataSupplier methods.
 353
 354
 355
 356 // virtual
 357 uno::Reference< sdbc::XResultSetMetaData > SAL_CALL ResultSet::getMetaData()
 358     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 359 {
 360     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 361
 362     if ( !m_pImpl->m_xMetaData.is() )
 363         m_pImpl->m_xMetaData = new ResultSetMetaData( m_pImpl->m_xContext,
 364                                                       m_pImpl->m_aProperties );
 365
 366     return m_pImpl->m_xMetaData;
 367 }
 368
 369
 370
 371 // XResultSet methods.
 372
 373
 374
 375 // virtual
 376 sal_Bool SAL_CALL ResultSet::next()
 377     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 378 {
 379     // Note: Cursor is initially positioned before the first row.
 380     //       First call to 'next()' moves it to first row.
 381
 382     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 383
 384     if ( m_pImpl->m_bAfterLast )
 385     {
 386         m_pImpl->m_xDataSupplier->validate();
 387         return sal_False;
 388     }
 389
 390     // getResult works zero-based!
 391     if ( !m_pImpl->m_xDataSupplier->getResult( m_pImpl->m_nPos ) )
 392     {
 393         m_pImpl->m_bAfterLast = true;
 394         m_pImpl->m_xDataSupplier->validate();
 395         return sal_False;
 396     }
 397
 398     m_pImpl->m_nPos++;
 399     m_pImpl->m_xDataSupplier->validate();
 400     return sal_True;
 401 }
 402
 403
 404 // virtual
 405 sal_Bool SAL_CALL ResultSet::isBeforeFirst()
 406     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 407 {
 408     if ( m_pImpl->m_bAfterLast )
 409     {
 410         m_pImpl->m_xDataSupplier->validate();
 411         return sal_False;
 412     }
 413
 414     // getResult works zero-based!
 415     if ( !m_pImpl->m_xDataSupplier->getResult( 0 ) )
 416     {
 417         m_pImpl->m_xDataSupplier->validate();
 418         return sal_False;
 419     }
 420
 421     m_pImpl->m_xDataSupplier->validate();
 422     return ( m_pImpl->m_nPos == 0 );
 423 }
 424
 425
 426 // virtual
 427 sal_Bool SAL_CALL ResultSet::isAfterLast()
 428     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 429 {
 430     m_pImpl->m_xDataSupplier->validate();
 431     return m_pImpl->m_bAfterLast;
 432 }
 433
 434
 435 // virtual
 436 sal_Bool SAL_CALL ResultSet::isFirst()
 437     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 438 {
 439     if ( m_pImpl->m_bAfterLast )
 440     {
 441         m_pImpl->m_xDataSupplier->validate();
 442         return sal_False;
 443     }
 444
 445     m_pImpl->m_xDataSupplier->validate();
 446     return ( m_pImpl->m_nPos == 1 );
 447 }
 448
 449
 450 // virtual
 451 sal_Bool SAL_CALL ResultSet::isLast()
 452     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 453 {
 454     if ( m_pImpl->m_bAfterLast )
 455     {
 456         m_pImpl->m_xDataSupplier->validate();
 457         return sal_False;
 458     }
 459
 460     sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 461     if ( !nCount )
 462     {
 463         m_pImpl->m_xDataSupplier->validate();
 464         return sal_False;
 465     }
 466
 467     m_pImpl->m_xDataSupplier->validate();
 468     return ( m_pImpl->m_nPos == nCount );
 469 }
 470
 471
 472 // virtual
 473 void SAL_CALL ResultSet::beforeFirst()
 474     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 475 {
 476     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 477     m_pImpl->m_bAfterLast = false;
 478     m_pImpl->m_nPos = 0;
 479     m_pImpl->m_xDataSupplier->validate();
 480 }
 481
 482
 483 // virtual
 484 void SAL_CALL ResultSet::afterLast()
 485     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 486 {
 487     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 488     m_pImpl->m_bAfterLast = true;
 489     m_pImpl->m_xDataSupplier->validate();
 490 }
 491
 492
 493 // virtual
 494 sal_Bool SAL_CALL ResultSet::first()
 495     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 496 {
 497     // getResult works zero-based!
 498     if ( m_pImpl->m_xDataSupplier->getResult( 0 ) )
 499     {
 500         osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 501         m_pImpl->m_bAfterLast = false;
 502         m_pImpl->m_nPos = 1;
 503         m_pImpl->m_xDataSupplier->validate();
 504         return sal_True;
 505     }
 506
 507     m_pImpl->m_xDataSupplier->validate();
 508     return sal_False;
 509 }
 510
 511
 512 // virtual
 513 sal_Bool SAL_CALL ResultSet::last()
 514     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 515 {
 516     sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 517     if ( nCount )
 518     {
 519         osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 520         m_pImpl->m_bAfterLast = false;
 521         m_pImpl->m_nPos = nCount;
 522         m_pImpl->m_xDataSupplier->validate();
 523         return sal_True;
 524     }
 525
 526     m_pImpl->m_xDataSupplier->validate();
 527     return sal_False;
 528 }
 529
 530
 531 // virtual
 532 sal_Int32 SAL_CALL ResultSet::getRow()
 533     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 534 {
 535     if ( m_pImpl->m_bAfterLast )
 536     {
 537         m_pImpl->m_xDataSupplier->validate();
 538         return 0;
 539     }
 540
 541     m_pImpl->m_xDataSupplier->validate();
 542     return m_pImpl->m_nPos;
 543 }
 544
 545
 546 // virtual
 547 sal_Bool SAL_CALL ResultSet::absolute( sal_Int32 row )
 548     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 549 {
 550 /*
 551     If the row number is positive, the cursor moves to the given row number
 552     with respect to the beginning of the result set. The first row is row 1,
 553     the second is row 2, and so on.
 554
 555     If the given row number is negative, the cursor moves to an absolute row
 556     position with respect to the end of the result set. For example, calling
 557     absolaute( -1 ) positions the cursor on the last row, absolaute( -2 )
 558     indicates the next-to-last row, and so on.
 559
 560     An attempt to position the cursor beyond the first/last row in the result
 561     set leaves the cursor before/after the first/last row, respectively.
 562
 563     Calling absolute( 1 ) is the same as calling first().
 564
 565     Calling absolute( -1 ) is the same as calling last().
 566 */
 567     if ( row < 0 )
 568     {
 569         sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 570
 571         if ( ( row * -1 ) > nCount )
 572         {
 573             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 574             m_pImpl->m_bAfterLast = false;
 575             m_pImpl->m_nPos = 0;
 576             m_pImpl->m_xDataSupplier->validate();
 577             return sal_False;
 578         }
 579         else // |row| <= nCount
 580         {
 581             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 582             m_pImpl->m_bAfterLast = false;
 583             m_pImpl->m_nPos = ( nCount + row + 1 );
 584             m_pImpl->m_xDataSupplier->validate();
 585             return sal_True;
 586         }
 587     }
 588     else if ( row == 0 )
 589     {
 590         // @throws SQLException
 591         //      ... if row is 0 ...
 592         throw sdbc::SQLException();
 593     }
 594     else // row > 0
 595     {
 596         sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 597
 598         if ( row <= nCount )
 599         {
 600             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 601             m_pImpl->m_bAfterLast = false;
 602             m_pImpl->m_nPos = row;
 603             m_pImpl->m_xDataSupplier->validate();
 604             return sal_True;
 605         }
 606         else // row > nCount
 607         {
 608             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 609             m_pImpl->m_bAfterLast = true;
 610             m_pImpl->m_xDataSupplier->validate();
 611             return sal_False;
 612         }
 613     }
 614
 615     // unreachable...
 616 }
 617
 618
 619 // virtual
 620 sal_Bool SAL_CALL ResultSet::relative( sal_Int32 rows )
 621     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 622 {
 623 /*
 624     Attempting to move beyond the first/last row in the result set
 625     positions the cursor before/after the first/last row.
 626
 627     Calling relative( 0 ) is valid, but does not change the cursor position.
 628
 629     Calling relative( 1 ) is different from calling next() because it makes
 630     sense to call next() when there is no current row, for example, when
 631     the cursor is positioned before the first row or after the last row of
 632     the result set.
 633 */
 634     if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) )
 635     {
 636         // "No current row".
 637         throw sdbc::SQLException();
 638     }
 639
 640     if ( rows < 0 )
 641     {
 642         if ( ( m_pImpl->m_nPos + rows ) > 0 )
 643         {
 644             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 645             m_pImpl->m_bAfterLast = false;
 646             m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows );
 647             m_pImpl->m_xDataSupplier->validate();
 648             return sal_True;
 649         }
 650         else
 651         {
 652             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 653             m_pImpl->m_bAfterLast = false;
 654             m_pImpl->m_nPos = 0;
 655             m_pImpl->m_xDataSupplier->validate();
 656             return sal_False;
 657         }
 658     }
 659     else if ( rows == 0 )
 660     {
 661         // nop.
 662         m_pImpl->m_xDataSupplier->validate();
 663         return sal_True;
 664     }
 665     else // rows > 0
 666     {
 667         sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 668         if ( ( m_pImpl->m_nPos + rows ) <= nCount )
 669         {
 670             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 671             m_pImpl->m_bAfterLast = false;
 672             m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows );
 673             m_pImpl->m_xDataSupplier->validate();
 674             return sal_True;
 675         }
 676         else
 677         {
 678             osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 679             m_pImpl->m_bAfterLast = true;
 680             m_pImpl->m_xDataSupplier->validate();
 681             return sal_False;
 682         }
 683     }
 684
 685     // unreachable...
 686 }
 687
 688
 689 // virtual
 690 sal_Bool SAL_CALL ResultSet::previous()
 691     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 692 {
 693 /*
 694     previous() is not the same as relative( -1 ) because it makes sense
 695     to call previous() when there is no current row.
 696 */
 697     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 698
 699     if ( m_pImpl->m_bAfterLast )
 700     {
 701         m_pImpl->m_bAfterLast = false;
 702         sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
 703         m_pImpl->m_nPos = nCount;
 704     }
 705     else if ( m_pImpl->m_nPos )
 706         m_pImpl->m_nPos--;
 707
 708     if ( m_pImpl->m_nPos )
 709     {
 710         m_pImpl->m_xDataSupplier->validate();
 711         return sal_True;
 712     }
 713
 714     m_pImpl->m_xDataSupplier->validate();
 715     return sal_False;
 716 }
 717
 718
 719 // virtual
 720 void SAL_CALL ResultSet::refreshRow()
 721     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 722 {
 723     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
 724     if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) )
 725         return;
 726
 727     m_pImpl->m_xDataSupplier->releasePropertyValues( m_pImpl->m_nPos );
 728     m_pImpl->m_xDataSupplier->validate();
 729 }
 730
 731
 732 // virtual
 733 sal_Bool SAL_CALL ResultSet::rowUpdated()
 734     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 735 {
 736     m_pImpl->m_xDataSupplier->validate();
 737     return sal_False;
 738 }
 739
 740
 741 // virtual
 742 sal_Bool SAL_CALL ResultSet::rowInserted()
 743     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 744 {
 745     m_pImpl->m_xDataSupplier->validate();
 746     return sal_False;
 747 }
 748
 749
 750 // virtual
 751 sal_Bool SAL_CALL ResultSet::rowDeleted()
 752     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 753 {
 754     m_pImpl->m_xDataSupplier->validate();
 755     return sal_False;
 756 }
 757
 758
 759 // virtual
 760 uno::Reference< uno::XInterface > SAL_CALL ResultSet::getStatement()
 761     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 762 {
 763 /*
 764     returns the Statement that produced this ResultSet object. If the
 765     result set was generated some other way, ... this method returns null.
 766 */
 767     m_pImpl->m_xDataSupplier->validate();
 768     return uno::Reference< uno::XInterface >();
 769 }
 770
 771
 772
 773 // XRow methods.
 774
 775
 776
 777 // virtual
 778 sal_Bool SAL_CALL ResultSet::wasNull()
 779     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 780 {
 781     // This method can not be implemented correctly!!! Imagine different
 782     // threads doing a getXYZ - wasNull calling sequence on the same
 783     // implementation object...
 784
 785     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 786     {
 787         uno::Reference< sdbc::XRow > xValues
 788             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 789                                                         m_pImpl->m_nPos - 1 );
 790         if ( xValues.is() )
 791         {
 792             m_pImpl->m_xDataSupplier->validate();
 793             return xValues->wasNull();
 794         }
 795     }
 796
 797     m_pImpl->m_xDataSupplier->validate();
 798     return m_pImpl->m_bWasNull;
 799 }
 800
 801
 802 // virtual
 803 OUString SAL_CALL ResultSet::getString( sal_Int32 columnIndex )
 804     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 805 {
 806     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 807     {
 808         uno::Reference< sdbc::XRow > xValues
 809             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 810                                                         m_pImpl->m_nPos - 1 );
 811         if ( xValues.is() )
 812         {
 813             m_pImpl->m_bWasNull = false;
 814             m_pImpl->m_xDataSupplier->validate();
 815             return xValues->getString( columnIndex );
 816         }
 817     }
 818
 819     m_pImpl->m_bWasNull = true;
 820     m_pImpl->m_xDataSupplier->validate();
 821     return OUString();
 822 }
 823
 824
 825 // virtual
 826 sal_Bool SAL_CALL ResultSet::getBoolean( sal_Int32 columnIndex )
 827     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 828 {
 829     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 830     {
 831         uno::Reference< sdbc::XRow > xValues
 832             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 833                                                         m_pImpl->m_nPos - 1 );
 834         if ( xValues.is() )
 835         {
 836             m_pImpl->m_bWasNull = false;
 837             m_pImpl->m_xDataSupplier->validate();
 838             return xValues->getBoolean( columnIndex );
 839         }
 840     }
 841
 842     m_pImpl->m_bWasNull = true;
 843     m_pImpl->m_xDataSupplier->validate();
 844     return sal_False;
 845 }
 846
 847
 848 // virtual
 849 sal_Int8 SAL_CALL ResultSet::getByte( sal_Int32 columnIndex )
 850     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 851 {
 852     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 853     {
 854         uno::Reference< sdbc::XRow > xValues
 855             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 856                                                         m_pImpl->m_nPos - 1 );
 857         if ( xValues.is() )
 858         {
 859             m_pImpl->m_bWasNull = false;
 860             m_pImpl->m_xDataSupplier->validate();
 861             return xValues->getByte( columnIndex );
 862         }
 863     }
 864
 865     m_pImpl->m_bWasNull = true;
 866     m_pImpl->m_xDataSupplier->validate();
 867     return 0;
 868 }
 869
 870
 871 // virtual
 872 sal_Int16 SAL_CALL ResultSet::getShort( sal_Int32 columnIndex )
 873     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 874 {
 875     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 876     {
 877         uno::Reference< sdbc::XRow > xValues
 878             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 879                                                         m_pImpl->m_nPos - 1 );
 880         if ( xValues.is() )
 881         {
 882             m_pImpl->m_bWasNull = false;
 883             m_pImpl->m_xDataSupplier->validate();
 884             return xValues->getShort( columnIndex );
 885         }
 886     }
 887
 888     m_pImpl->m_bWasNull = true;
 889     m_pImpl->m_xDataSupplier->validate();
 890     return 0;
 891 }
 892
 893
 894 // virtual
 895 sal_Int32 SAL_CALL ResultSet::getInt( sal_Int32 columnIndex )
 896     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 897 {
 898     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 899     {
 900         uno::Reference< sdbc::XRow > xValues
 901             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 902                                                         m_pImpl->m_nPos - 1 );
 903         if ( xValues.is() )
 904         {
 905             m_pImpl->m_bWasNull = false;
 906             m_pImpl->m_xDataSupplier->validate();
 907             return xValues->getInt( columnIndex );
 908         }
 909     }
 910
 911     m_pImpl->m_bWasNull = true;
 912     m_pImpl->m_xDataSupplier->validate();
 913     return 0;
 914 }
 915
 916
 917 // virtual
 918 sal_Int64 SAL_CALL ResultSet::getLong( sal_Int32 columnIndex )
 919     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 920 {
 921     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 922     {
 923         uno::Reference< sdbc::XRow > xValues
 924             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 925                                                         m_pImpl->m_nPos - 1 );
 926         if ( xValues.is() )
 927         {
 928             m_pImpl->m_bWasNull = false;
 929             m_pImpl->m_xDataSupplier->validate();
 930             return xValues->getLong( columnIndex );
 931         }
 932     }
 933
 934     m_pImpl->m_bWasNull = true;
 935     m_pImpl->m_xDataSupplier->validate();
 936     return 0;
 937 }
 938
 939
 940 // virtual
 941 float SAL_CALL ResultSet::getFloat( sal_Int32 columnIndex )
 942     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 943 {
 944     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 945     {
 946         uno::Reference< sdbc::XRow > xValues
 947             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 948                                                         m_pImpl->m_nPos - 1 );
 949         if ( xValues.is() )
 950         {
 951             m_pImpl->m_bWasNull = false;
 952             m_pImpl->m_xDataSupplier->validate();
 953             return xValues->getFloat( columnIndex );
 954         }
 955     }
 956
 957     m_pImpl->m_bWasNull = true;
 958     m_pImpl->m_xDataSupplier->validate();
 959     return 0;
 960 }
 961
 962
 963 // virtual
 964 double SAL_CALL ResultSet::getDouble( sal_Int32 columnIndex )
 965     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 966 {
 967     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 968     {
 969         uno::Reference< sdbc::XRow > xValues
 970             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 971                                                         m_pImpl->m_nPos - 1 );
 972         if ( xValues.is() )
 973         {
 974             m_pImpl->m_bWasNull = false;
 975             m_pImpl->m_xDataSupplier->validate();
 976             return xValues->getDouble( columnIndex );
 977         }
 978     }
 979
 980     m_pImpl->m_bWasNull = true;
 981     m_pImpl->m_xDataSupplier->validate();
 982     return 0;
 983 }
 984
 985
 986 // virtual
 987 uno::Sequence< sal_Int8 > SAL_CALL
 988 ResultSet::getBytes( sal_Int32 columnIndex )
 989     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
 990 {
 991     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
 992     {
 993         uno::Reference< sdbc::XRow > xValues
 994             = m_pImpl->m_xDataSupplier->queryPropertyValues(
 995                                                         m_pImpl->m_nPos - 1 );
 996         if ( xValues.is() )
 997         {
 998             m_pImpl->m_bWasNull = false;
 999             m_pImpl->m_xDataSupplier->validate();
1000             return xValues->getBytes( columnIndex );
1001         }
1002     }
1003
1004     m_pImpl->m_bWasNull = true;
1005     m_pImpl->m_xDataSupplier->validate();
1006     return uno::Sequence< sal_Int8 >();
1007 }
1008
1009
1010 // virtual
1011 util::Date SAL_CALL ResultSet::getDate( sal_Int32 columnIndex )
1012     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1013 {
1014     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1015     {
1016         uno::Reference< sdbc::XRow > xValues
1017             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1018                                                         m_pImpl->m_nPos - 1 );
1019         if ( xValues.is() )
1020         {
1021             m_pImpl->m_bWasNull = false;
1022             m_pImpl->m_xDataSupplier->validate();
1023             return xValues->getDate( columnIndex );
1024         }
1025     }
1026
1027     m_pImpl->m_bWasNull = true;
1028     m_pImpl->m_xDataSupplier->validate();
1029     return util::Date();
1030 }
1031
1032
1033 // virtual
1034 util::Time SAL_CALL ResultSet::getTime( sal_Int32 columnIndex )
1035     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1036 {
1037     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1038     {
1039         uno::Reference< sdbc::XRow > xValues
1040             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1041                                                         m_pImpl->m_nPos - 1 );
1042         if ( xValues.is() )
1043         {
1044             m_pImpl->m_bWasNull = false;
1045             m_pImpl->m_xDataSupplier->validate();
1046             return xValues->getTime( columnIndex );
1047         }
1048     }
1049
1050     m_pImpl->m_bWasNull = true;
1051     m_pImpl->m_xDataSupplier->validate();
1052     return util::Time();
1053 }
1054
1055
1056 // virtual
1057 util::DateTime SAL_CALL
1058 ResultSet::getTimestamp( sal_Int32 columnIndex )
1059     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1060 {
1061     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1062     {
1063         uno::Reference< sdbc::XRow > xValues
1064             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1065                                                         m_pImpl->m_nPos - 1 );
1066         if ( xValues.is() )
1067         {
1068             m_pImpl->m_bWasNull = false;
1069             m_pImpl->m_xDataSupplier->validate();
1070             return xValues->getTimestamp( columnIndex );
1071         }
1072     }
1073
1074     m_pImpl->m_bWasNull = true;
1075     m_pImpl->m_xDataSupplier->validate();
1076     return util::DateTime();
1077 }
1078
1079
1080 // virtual
1081 uno::Reference< io::XInputStream > SAL_CALL
1082 ResultSet::getBinaryStream( sal_Int32 columnIndex )
1083     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1084 {
1085     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1086     {
1087         uno::Reference< sdbc::XRow > xValues
1088             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1089                                                         m_pImpl->m_nPos - 1 );
1090         if ( xValues.is() )
1091         {
1092             m_pImpl->m_bWasNull = false;
1093             m_pImpl->m_xDataSupplier->validate();
1094             return xValues->getBinaryStream( columnIndex );
1095         }
1096     }
1097
1098     m_pImpl->m_bWasNull = true;
1099     m_pImpl->m_xDataSupplier->validate();
1100     return uno::Reference< io::XInputStream >();
1101 }
1102
1103
1104 // virtual
1105 uno::Reference< io::XInputStream > SAL_CALL
1106 ResultSet::getCharacterStream( sal_Int32 columnIndex )
1107     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1108 {
1109     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1110     {
1111         uno::Reference< sdbc::XRow > xValues
1112             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1113                                                         m_pImpl->m_nPos - 1 );
1114         if ( xValues.is() )
1115         {
1116             m_pImpl->m_bWasNull = false;
1117             m_pImpl->m_xDataSupplier->validate();
1118             return xValues->getCharacterStream( columnIndex );
1119         }
1120     }
1121
1122     m_pImpl->m_bWasNull = true;
1123     m_pImpl->m_xDataSupplier->validate();
1124     return uno::Reference< io::XInputStream >();
1125 }
1126
1127
1128 // virtual
1129 uno::Any SAL_CALL ResultSet::getObject(
1130         sal_Int32 columnIndex,
1131         const uno::Reference< container::XNameAccess >& typeMap )
1132     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1133 {
1134     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1135     {
1136         uno::Reference< sdbc::XRow > xValues
1137             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1138                                                         m_pImpl->m_nPos - 1 );
1139         if ( xValues.is() )
1140         {
1141             m_pImpl->m_bWasNull = false;
1142             m_pImpl->m_xDataSupplier->validate();
1143             return xValues->getObject( columnIndex, typeMap );
1144         }
1145     }
1146
1147     m_pImpl->m_bWasNull = true;
1148     m_pImpl->m_xDataSupplier->validate();
1149     return uno::Any();
1150 }
1151
1152
1153 // virtual
1154 uno::Reference< sdbc::XRef > SAL_CALL
1155 ResultSet::getRef( sal_Int32 columnIndex )
1156     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1157 {
1158     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1159     {
1160         uno::Reference< sdbc::XRow > xValues
1161             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1162                                                         m_pImpl->m_nPos - 1 );
1163         if ( xValues.is() )
1164         {
1165             m_pImpl->m_bWasNull = false;
1166             m_pImpl->m_xDataSupplier->validate();
1167             return xValues->getRef( columnIndex );
1168         }
1169     }
1170
1171     m_pImpl->m_bWasNull = true;
1172     m_pImpl->m_xDataSupplier->validate();
1173     return uno::Reference< sdbc::XRef >();
1174 }
1175
1176
1177 // virtual
1178 uno::Reference< sdbc::XBlob > SAL_CALL
1179 ResultSet::getBlob( sal_Int32 columnIndex )
1180     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1181 {
1182     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1183     {
1184         uno::Reference< sdbc::XRow > xValues
1185             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1186                                                         m_pImpl->m_nPos - 1 );
1187         if ( xValues.is() )
1188         {
1189             m_pImpl->m_bWasNull = false;
1190             m_pImpl->m_xDataSupplier->validate();
1191             return xValues->getBlob( columnIndex );
1192         }
1193     }
1194
1195     m_pImpl->m_bWasNull = true;
1196     m_pImpl->m_xDataSupplier->validate();
1197     return uno::Reference< sdbc::XBlob >();
1198 }
1199
1200
1201 // virtual
1202 uno::Reference< sdbc::XClob > SAL_CALL
1203 ResultSet::getClob( sal_Int32 columnIndex )
1204     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1205 {
1206     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1207     {
1208         uno::Reference< sdbc::XRow > xValues
1209             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1210                                                         m_pImpl->m_nPos - 1 );
1211         if ( xValues.is() )
1212         {
1213             m_pImpl->m_bWasNull = false;
1214             m_pImpl->m_xDataSupplier->validate();
1215             return xValues->getClob( columnIndex );
1216         }
1217     }
1218
1219     m_pImpl->m_bWasNull = true;
1220     m_pImpl->m_xDataSupplier->validate();
1221     return uno::Reference< sdbc::XClob >();
1222 }
1223
1224
1225 // virtual
1226 uno::Reference< sdbc::XArray > SAL_CALL
1227 ResultSet::getArray( sal_Int32 columnIndex )
1228     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1229 {
1230     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1231     {
1232         uno::Reference< sdbc::XRow > xValues
1233             = m_pImpl->m_xDataSupplier->queryPropertyValues(
1234                                                         m_pImpl->m_nPos - 1 );
1235         if ( xValues.is() )
1236         {
1237             m_pImpl->m_bWasNull = false;
1238             m_pImpl->m_xDataSupplier->validate();
1239             return xValues->getArray( columnIndex );
1240         }
1241     }
1242
1243     m_pImpl->m_bWasNull = true;
1244     m_pImpl->m_xDataSupplier->validate();
1245     return uno::Reference< sdbc::XArray >();
1246 }
1247
1248
1249
1250 // XCloseable methods.
1251
1252
1253
1254 // virtual
1255 void SAL_CALL ResultSet::close()
1256     throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1257 {
1258     m_pImpl->m_xDataSupplier->close();
1259     m_pImpl->m_xDataSupplier->validate();
1260 }
1261
1262
1263
1264 // XContentAccess methods.
1265
1266
1267
1268 // virtual
1269 OUString SAL_CALL ResultSet::queryContentIdentifierString()
1270     throw( uno::RuntimeException, std::exception )
1271 {
1272     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1273         return m_pImpl->m_xDataSupplier->queryContentIdentifierString(
1274                                                         m_pImpl->m_nPos - 1 );
1275
1276     return OUString();
1277 }
1278
1279
1280 // virtual
1281 uno::Reference< com::sun::star::ucb::XContentIdentifier > SAL_CALL
1282 ResultSet::queryContentIdentifier()
1283     throw( uno::RuntimeException, std::exception )
1284 {
1285     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1286         return m_pImpl->m_xDataSupplier->queryContentIdentifier(
1287                                                         m_pImpl->m_nPos - 1 );
1288
1289     return uno::Reference< com::sun::star::ucb::XContentIdentifier >();
1290 }
1291
1292
1293 // virtual
1294 uno::Reference< com::sun::star::ucb::XContent > SAL_CALL
1295 ResultSet::queryContent()
1296     throw( uno::RuntimeException, std::exception )
1297 {
1298     if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1299         return m_pImpl->m_xDataSupplier->queryContent( m_pImpl->m_nPos - 1 );
1300
1301     return uno::Reference< com::sun::star::ucb::XContent >();
1302 }
1303
1304
1305
1306 // XPropertySet methods.
1307
1308
1309
1310 // virtual
1311 uno::Reference< beans::XPropertySetInfo > SAL_CALL
1312 ResultSet::getPropertySetInfo()
1313     throw( uno::RuntimeException, std::exception )
1314 {
1315     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1316
1317     if ( !m_pImpl->m_xPropSetInfo.is() )
1318         m_pImpl->m_xPropSetInfo
1319             = new PropertySetInfo( aPropertyTable,
1320                                    RESULTSET_PROPERTY_COUNT );
1321     return m_pImpl->m_xPropSetInfo;
1322 }
1323
1324
1325 // virtual
1326 void SAL_CALL ResultSet::setPropertyValue( const OUString& aPropertyName,
1327                                            const uno::Any& )
1328     throw( beans::UnknownPropertyException,
1329            beans::PropertyVetoException,
1330            lang::IllegalArgumentException,
1331            lang::WrappedTargetException,
1332            uno::RuntimeException, std::exception )
1333 {
1334     if ( aPropertyName.isEmpty() )
1335         throw beans::UnknownPropertyException();
1336
1337     if ( aPropertyName == "RowCount" )
1338     {
1339         // property is read-only.
1340         throw lang::IllegalArgumentException();
1341     }
1342     else if ( aPropertyName == "IsRowCountFinal" )
1343     {
1344         // property is read-only.
1345         throw lang::IllegalArgumentException();
1346     }
1347     else
1348     {
1349         throw beans::UnknownPropertyException();
1350     }
1351 }
1352
1353
1354 // virtual
1355 uno::Any SAL_CALL ResultSet::getPropertyValue(
1356         const OUString& PropertyName )
1357     throw( beans::UnknownPropertyException,
1358            lang::WrappedTargetException,
1359            uno::RuntimeException, std::exception )
1360 {
1361     if ( PropertyName.isEmpty() )
1362         throw beans::UnknownPropertyException();
1363
1364     uno::Any aValue;
1365
1366     if ( PropertyName == "RowCount" )
1367     {
1368         aValue <<= m_pImpl->m_xDataSupplier->currentCount();
1369     }
1370     else if ( PropertyName == "IsRowCountFinal" )
1371     {
1372         aValue <<= m_pImpl->m_xDataSupplier->isCountFinal();
1373     }
1374     else
1375     {
1376         throw beans::UnknownPropertyException();
1377     }
1378
1379     return aValue;
1380 }
1381
1382
1383 // virtual
1384 void SAL_CALL ResultSet::addPropertyChangeListener(
1385         const OUString& aPropertyName,
1386         const uno::Reference< beans::XPropertyChangeListener >& xListener )
1387     throw( beans::UnknownPropertyException,
1388            lang::WrappedTargetException,
1389            uno::RuntimeException, std::exception )
1390 {
1391     // Note: An empty property name means a listener for "all" properties.
1392
1393     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1394
1395     if ( !aPropertyName.isEmpty() &&
1396          aPropertyName != "RowCount" &&
1397          aPropertyName != "IsRowCountFinal" )
1398         throw beans::UnknownPropertyException();
1399
1400     if ( !m_pImpl->m_pPropertyChangeListeners )
1401         m_pImpl->m_pPropertyChangeListeners
1402             = new PropertyChangeListeners( m_pImpl->m_aMutex );
1403
1404     m_pImpl->m_pPropertyChangeListeners->addInterface(
1405                                                 aPropertyName, xListener );
1406 }
1407
1408
1409 // virtual
1410 void SAL_CALL ResultSet::removePropertyChangeListener(
1411         const OUString& aPropertyName,
1412         const uno::Reference< beans::XPropertyChangeListener >& xListener )
1413     throw( beans::UnknownPropertyException,
1414            lang::WrappedTargetException,
1415            uno::RuntimeException, std::exception )
1416 {
1417     osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1418
1419     if ( !aPropertyName.isEmpty() &&
1420          aPropertyName != "RowCount" &&
1421          aPropertyName != "IsRowCountFinal" )
1422         throw beans::UnknownPropertyException();
1423
1424     if ( m_pImpl->m_pPropertyChangeListeners )
1425         m_pImpl->m_pPropertyChangeListeners->removeInterface(
1426                                                     aPropertyName, xListener );
1427
1428 }
1429
1430
1431 // virtual
1432 void SAL_CALL ResultSet::addVetoableChangeListener(
1433         const OUString&,
1434         const uno::Reference< beans::XVetoableChangeListener >& )
1435     throw( beans::UnknownPropertyException,
1436            lang::WrappedTargetException,
1437            uno::RuntimeException, std::exception )
1438 {
1439     //  No constrained props, at the moment.
1440 }
1441
1442
1443 // virtual
1444 void SAL_CALL ResultSet::removeVetoableChangeListener(
1445         const OUString&,
1446         const uno::Reference< beans::XVetoableChangeListener >& )
1447     throw( beans::UnknownPropertyException,
1448            lang::WrappedTargetException,
1449            uno::RuntimeException, std::exception )
1450 {
1451     //  No constrained props, at the moment.
1452 }
1453
1454
1455
1456 // Non-interface methods.
1457
1458
1459
1460 void ResultSet::propertyChanged( const beans::PropertyChangeEvent& rEvt )
1461 {
1462     if ( !m_pImpl->m_pPropertyChangeListeners )
1463         return;
1464
1465     // Notify listeners interested especially in the changed property.
1466     cppu::OInterfaceContainerHelper* pPropsContainer
1467         = m_pImpl->m_pPropertyChangeListeners->getContainer(
1468                                                         rEvt.PropertyName );
1469     if ( pPropsContainer )
1470     {
1471         cppu::OInterfaceIteratorHelper aIter( *pPropsContainer );
1472         while ( aIter.hasMoreElements() )
1473         {
1474             uno::Reference< beans::XPropertyChangeListener > xListener(
1475                 aIter.next(), uno::UNO_QUERY );
1476             if ( xListener.is() )
1477                 xListener->propertyChange( rEvt );
1478         }
1479     }
1480
1481     // Notify listeners interested in all properties.
1482     pPropsContainer
1483         = m_pImpl->m_pPropertyChangeListeners->getContainer( OUString() );
1484     if ( pPropsContainer )
1485     {
1486         cppu::OInterfaceIteratorHelper aIter( *pPropsContainer );
1487         while ( aIter.hasMoreElements() )
1488         {
1489             uno::Reference< beans::XPropertyChangeListener > xListener(
1490                 aIter.next(), uno::UNO_QUERY );
1491             if ( xListener.is() )
1492                 xListener->propertyChange( rEvt );
1493         }
1494     }
1495 }
1496
1497
1498 void ResultSet::rowCountChanged( sal_uInt32 nOld, sal_uInt32 nNew )
1499 {
1500     OSL_ENSURE( nOld < nNew, "ResultSet::rowCountChanged - nOld >= nNew!" );
1501
1502     if ( !m_pImpl->m_pPropertyChangeListeners )
1503         return;
1504
1505     propertyChanged(
1506         beans::PropertyChangeEvent(
1507             static_cast< cppu::OWeakObject * >( this ),
1508             OUString("RowCount"),
1509             sal_False,
1510             1001,
1511             uno::makeAny( nOld ),     // old value
1512             uno::makeAny( nNew ) ) ); // new value
1513 }
1514
1515
1516 void ResultSet::rowCountFinal()
1517 {
1518     if ( !m_pImpl->m_pPropertyChangeListeners )
1519         return;
1520
1521     propertyChanged(
1522         beans::PropertyChangeEvent(
1523             static_cast< cppu::OWeakObject * >( this ),
1524             OUString("IsRowCountFinal"),
1525             sal_False,
1526             1000,
1527             uno:: makeAny( sal_False ),   // old value
1528             uno::makeAny( sal_True ) ) ); // new value
1529 }
1530
1531
1532 const uno::Sequence< beans::Property >& ResultSet::getProperties()
1533 {
1534     return m_pImpl->m_aProperties;
1535 }
1536
1537
1538 const uno::Reference< com::sun::star::ucb::XCommandEnvironment >&
1539 ResultSet::getEnvironment()
1540 {
1541     return m_pImpl->m_xEnv;
1542 }
1543
1544 } // namespace ucbhelper
1545
1546 namespace ucbhelper_impl {
1547
1548
1549
1550
1551 // PropertySetInfo Implementation.
1552
1553
1554
1555
1556 PropertySetInfo::PropertySetInfo(
1557     const PropertyInfo* pProps,
1558     sal_Int32 nProps )
1559 {
1560     m_pProps = new uno::Sequence< beans::Property >( nProps );
1561
1562     if ( nProps )
1563     {
1564         const PropertyInfo* pEntry = pProps;
1565         beans::Property* pProperties = m_pProps->getArray();
1566
1567         for ( sal_Int32 n = 0; n < nProps; ++n )
1568         {
1569             beans::Property& rProp = pProperties[ n ];
1570
1571             rProp.Name       = OUString::createFromAscii( pEntry->pName );
1572             rProp.Handle     = pEntry->nHandle;
1573             rProp.Type       = pEntry->pGetCppuType();
1574             rProp.Attributes = pEntry->nAttributes;
1575
1576             pEntry++;
1577         }
1578     }
1579 }
1580
1581
1582 // virtual
1583 PropertySetInfo::~PropertySetInfo()
1584 {
1585     delete m_pProps;
1586 }
1587
1588
1589
1590 // XInterface methods.
1591 void SAL_CALL PropertySetInfo::acquire()
1592     throw()
1593 {
1594     OWeakObject::acquire();
1595 }
1596
1597 void SAL_CALL PropertySetInfo::release()
1598     throw()
1599 {
1600     OWeakObject::release();
1601 }
1602
1603 css::uno::Any SAL_CALL PropertySetInfo::queryInterface(
1604                                 const css::uno::Type & rType )
1605     throw( css::uno::RuntimeException, std::exception )
1606 {
1607     css::uno::Any aRet = cppu::queryInterface( rType,
1608                                                (static_cast< lang::XTypeProvider* >(this)),
1609                                                (static_cast< beans::XPropertySetInfo* >(this))
1610                                                );
1611     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
1612 }
1613
1614 // XTypeProvider methods.
1615
1616
1617
1618 XTYPEPROVIDER_IMPL_2( PropertySetInfo,
1619                          lang::XTypeProvider,
1620                          beans::XPropertySetInfo );
1621
1622
1623
1624 // XPropertySetInfo methods.
1625
1626
1627
1628 // virtual
1629 uno::Sequence< beans::Property > SAL_CALL PropertySetInfo::getProperties()
1630     throw( uno::RuntimeException, std::exception )
1631 {
1632     return uno::Sequence< beans::Property >( *m_pProps );
1633 }
1634
1635
1636 // virtual
1637 beans::Property SAL_CALL PropertySetInfo::getPropertyByName(
1638         const OUString& aName )
1639     throw( beans::UnknownPropertyException, uno::RuntimeException, std::exception )
1640 {
1641     beans::Property aProp;
1642     if ( queryProperty( aName, aProp ) )
1643         return aProp;
1644
1645     throw beans::UnknownPropertyException();
1646 }
1647
1648
1649 // virtual
1650 sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName(
1651         const OUString& Name )
1652     throw( uno::RuntimeException, std::exception )
1653 {
1654     beans::Property aProp;
1655     return queryProperty( Name, aProp );
1656 }
1657
1658
1659 bool PropertySetInfo::queryProperty(
1660     const OUString& aName, beans::Property& rProp )
1661 {
1662     sal_Int32 nCount = m_pProps->getLength();
1663     const beans::Property* pProps = m_pProps->getConstArray();
1664     for ( sal_Int32 n = 0; n < nCount; ++n )
1665     {
1666         const beans::Property& rCurr = pProps[ n ];
1667         if ( rCurr.Name == aName )
1668         {
1669             rProp = rCurr;
1670             return true;
1671         }
1672     }
1673
1674     return false;
1675 }
1676
1677 } // namespace ucbhelper_impl
1678
1679 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */