ucb/source/ucp/file/filrset.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 #include <sal/config.h>
  21 #include <sal/log.hxx>
  22
  23 #include <com/sun/star/sdbc/SQLException.hpp>
  24 #include <com/sun/star/ucb/ListenerAlreadySetException.hpp>
  25 #include <com/sun/star/ucb/ServiceNotFoundException.hpp>
  26 #include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp>
  27 #include "filid.hxx"
  28 #include "filtask.hxx"
  29 #include "filprp.hxx"
  30 #include "filrset.hxx"
  31 #include <com/sun/star/ucb/OpenMode.hpp>
  32 #include "prov.hxx"
  33 #include <com/sun/star/uno/Reference.h>
  34
  35 #include <com/sun/star/beans/PropertyAttribute.hpp>
  36 #include <com/sun/star/ucb/ListActionType.hpp>
  37 #include <com/sun/star/ucb/XSourceInitialization.hpp>
  38 #include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp>
  39 #include <ucbhelper/resultsetmetadata.hxx>
  40
  41 using namespace fileaccess;
  42 using namespace com::sun::star;
  43
  44 #if OSL_DEBUG_LEVEL > 0
  45 #define THROW_WHERE SAL_WHERE
  46 #else
  47 #define THROW_WHERE ""
  48 #endif
  49
  50 XResultSet_impl::XResultSet_impl( TaskManager* pMyShell,
  51                                   const OUString& aUnqPath,
  52                                   sal_Int32 OpenMode,
  53                                   const uno::Sequence< beans::Property >& seq,
  54                                   const uno::Sequence< ucb::NumberedSortingInfo >& seqSort )
  55     : m_pMyShell( pMyShell )
  56     , m_nRow( -1 )
  57     , m_nWasNull ( false )
  58     , m_nOpenMode( OpenMode )
  59     , m_bRowCountFinal( false )
  60     , m_aBaseDirectory( aUnqPath )
  61     , m_aFolder( aUnqPath )
  62     , m_sProperty( seq )
  63     , m_sSortingInfo( seqSort )
  64     , m_nErrorCode( TASKHANDLER_NO_ERROR )
  65     , m_nMinorErrorCode( TASKHANDLER_NO_ERROR )
  66 {
  67     osl::FileBase::RC err = m_aFolder.open();
  68     if(  err != osl::FileBase::E_None )
  69     {
  70         m_nIsOpen = false;
  71         m_aFolder.close();
  72
  73         m_nErrorCode = TASKHANDLING_OPEN_FOR_DIRECTORYLISTING;
  74         m_nMinorErrorCode = err;
  75     }
  76     else
  77         m_nIsOpen = true;
  78 }
  79
  80
  81 XResultSet_impl::~XResultSet_impl()
  82 {
  83     if( m_nIsOpen )
  84         m_aFolder.close();
  85 }
  86
  87
  88 void SAL_CALL
  89 XResultSet_impl::disposing( const lang::EventObject& )
  90 {
  91     // To do, but what
  92 }
  93
  94
  95 void SAL_CALL
  96 XResultSet_impl::addEventListener(
  97     const uno::Reference< lang::XEventListener >& Listener )
  98 {
  99     osl::MutexGuard aGuard( m_aMutex );
 100
 101     if ( ! m_pDisposeEventListeners )
 102         m_pDisposeEventListeners.reset(
 103             new comphelper::OInterfaceContainerHelper2( m_aEventListenerMutex ) );
 104
 105     m_pDisposeEventListeners->addInterface( Listener );
 106 }
 107
 108
 109 void SAL_CALL
 110 XResultSet_impl::removeEventListener(
 111     const uno::Reference< lang::XEventListener >& Listener )
 112 {
 113     osl::MutexGuard aGuard( m_aMutex );
 114
 115     if ( m_pDisposeEventListeners )
 116         m_pDisposeEventListeners->removeInterface( Listener );
 117 }
 118
 119
 120 void SAL_CALL
 121 XResultSet_impl::dispose()
 122 {
 123     osl::MutexGuard aGuard( m_aMutex );
 124
 125     lang::EventObject aEvt;
 126     aEvt.Source = static_cast< lang::XComponent * >( this );
 127
 128     if ( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
 129     {
 130         m_pDisposeEventListeners->disposeAndClear( aEvt );
 131     }
 132     if( m_pRowCountListeners && m_pRowCountListeners->getLength() )
 133     {
 134         m_pRowCountListeners->disposeAndClear( aEvt );
 135     }
 136     if( m_pIsFinalListeners && m_pIsFinalListeners->getLength() )
 137     {
 138         m_pIsFinalListeners->disposeAndClear( aEvt );
 139     }
 140 }
 141
 142
 143 void XResultSet_impl::rowCountChanged()
 144 {
 145     sal_Int32 aOldValue,aNewValue;
 146     std::vector< uno::Reference< uno::XInterface > > seq;
 147     {
 148         osl::MutexGuard aGuard( m_aMutex );
 149         if( m_pRowCountListeners )
 150             seq = m_pRowCountListeners->getElements();
 151         aNewValue = m_aItems.size();
 152         aOldValue = aNewValue-1;
 153     }
 154     beans::PropertyChangeEvent aEv;
 155     aEv.PropertyName = "RowCount";
 156     aEv.Further = false;
 157     aEv.PropertyHandle = -1;
 158     aEv.OldValue <<= aOldValue;
 159     aEv.NewValue <<= aNewValue;
 160     for( const auto& r : seq )
 161     {
 162         uno::Reference< beans::XPropertyChangeListener > listener(
 163             r, uno::UNO_QUERY );
 164         if( listener.is() )
 165             listener->propertyChange( aEv );
 166     }
 167 }
 168
 169
 170 void XResultSet_impl::isFinalChanged()
 171 {
 172     std::vector< uno::Reference< XInterface > > seq;
 173     {
 174         osl::MutexGuard aGuard( m_aMutex );
 175         if( m_pIsFinalListeners )
 176             seq = m_pIsFinalListeners->getElements();
 177         m_bRowCountFinal = true;
 178     }
 179     beans::PropertyChangeEvent aEv;
 180     aEv.PropertyName = "IsRowCountFinal";
 181     aEv.Further = false;
 182     aEv.PropertyHandle = -1;
 183     aEv.OldValue <<= false;
 184     aEv.NewValue <<= true;
 185     for( const auto& r : seq )
 186     {
 187         uno::Reference< beans::XPropertyChangeListener > listener(
 188             r, uno::UNO_QUERY );
 189         if( listener.is() )
 190             listener->propertyChange( aEv );
 191     }
 192 }
 193
 194
 195 bool
 196 XResultSet_impl::OneMore()
 197 {
 198     if( ! m_nIsOpen )
 199         return false;
 200
 201     osl::FileBase::RC err;
 202     bool IsRegular;
 203     OUString aUnqPath;
 204     osl::DirectoryItem  aDirIte;
 205     uno::Reference< sdbc::XRow > aRow;
 206
 207     while( true )
 208     {
 209         err = m_aFolder.getNextItem( aDirIte );
 210
 211         if( err == osl::FileBase::E_NOENT || err == osl::FileBase::E_INVAL )
 212         {
 213             m_aFolder.close();
 214             isFinalChanged();
 215             return ( m_nIsOpen = false );
 216         }
 217         else if( err == osl::FileBase::E_None )
 218         {
 219             if (!m_pMyShell->getv( m_sProperty, aDirIte, aUnqPath, IsRegular, aRow ))
 220             {
 221                 SAL_WARN(
 222                     "ucb.ucp.file",
 223                     "getting dir item in <" << m_aBaseDirectory << "> failed");
 224                 continue;
 225             }
 226
 227             if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && IsRegular )
 228             {
 229                 osl::MutexGuard aGuard( m_aMutex );
 230                 m_aItems.push_back( aRow );
 231                 m_aIdents.emplace_back( );
 232                 m_aUnqPath.push_back( aUnqPath );
 233                 rowCountChanged();
 234                 return true;
 235
 236             }
 237             else if( m_nOpenMode == ucb::OpenMode::DOCUMENTS && ! IsRegular )
 238             {
 239                 continue;
 240             }
 241             else if( m_nOpenMode == ucb::OpenMode::FOLDERS && ! IsRegular )
 242             {
 243                 osl::MutexGuard aGuard( m_aMutex );
 244                 m_aItems.push_back( aRow );
 245                 m_aIdents.emplace_back( );
 246                 m_aUnqPath.push_back( aUnqPath );
 247                 rowCountChanged();
 248                 return true;
 249             }
 250             else if( m_nOpenMode == ucb::OpenMode::FOLDERS && IsRegular )
 251             {
 252                 continue;
 253             }
 254             else
 255             {
 256                 osl::MutexGuard aGuard( m_aMutex );
 257                 m_aItems.push_back( aRow );
 258                 m_aIdents.emplace_back( );
 259                 m_aUnqPath.push_back( aUnqPath );
 260                 rowCountChanged();
 261                 return true;
 262             }
 263         }
 264         else  // error fetching anything
 265         {
 266             throw sdbc::SQLException( THROW_WHERE, uno::Reference< uno::XInterface >(), OUString(), 0, uno::Any() );
 267         }
 268     }
 269 }
 270
 271
 272 sal_Bool SAL_CALL
 273 XResultSet_impl::next()
 274 {
 275     bool test;
 276     if( ++m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) ) test = true;
 277     else
 278         test = OneMore();
 279     return test;
 280 }
 281
 282
 283 sal_Bool SAL_CALL
 284 XResultSet_impl::isBeforeFirst()
 285 {
 286     return m_nRow == -1;
 287 }
 288
 289
 290 sal_Bool SAL_CALL
 291 XResultSet_impl::isAfterLast()
 292 {
 293     return m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size());   // Cannot happen, if m_aFolder.isOpen()
 294 }
 295
 296
 297 sal_Bool SAL_CALL
 298 XResultSet_impl::isFirst()
 299 {
 300     return m_nRow == 0;
 301 }
 302
 303
 304 sal_Bool SAL_CALL
 305 XResultSet_impl::isLast()
 306 {
 307     if( m_nRow ==  sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1 )
 308         return ! OneMore();
 309     else
 310         return false;
 311 }
 312
 313
 314 void SAL_CALL
 315 XResultSet_impl::beforeFirst()
 316 {
 317     m_nRow = -1;
 318 }
 319
 320
 321 void SAL_CALL
 322 XResultSet_impl::afterLast()
 323 {
 324     m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size());
 325     while( OneMore() )
 326         ++m_nRow;
 327 }
 328
 329
 330 sal_Bool SAL_CALL
 331 XResultSet_impl::first()
 332 {
 333     m_nRow = -1;
 334     return next();
 335 }
 336
 337
 338 sal_Bool SAL_CALL
 339 XResultSet_impl::last()
 340 {
 341     m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size()) - 1;
 342     while( OneMore() )
 343         ++m_nRow;
 344     return true;
 345 }
 346
 347
 348 sal_Int32 SAL_CALL
 349 XResultSet_impl::getRow()
 350 {
 351     // Test, whether behind last row
 352     if( -1 == m_nRow || m_nRow >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 353         return 0;
 354     else
 355         return m_nRow+1;
 356 }
 357
 358
 359 sal_Bool SAL_CALL XResultSet_impl::absolute( sal_Int32 row )
 360 {
 361     if( row >= 0 )
 362     {
 363         m_nRow = row - 1;
 364         if( row >= sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 365             while( row-- && OneMore() )
 366                 ;
 367     }
 368     else
 369     {
 370         last();
 371         m_nRow += ( row + 1 );
 372         if( m_nRow < -1 )
 373             m_nRow = -1;
 374     }
 375
 376     return 0<= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 377 }
 378
 379
 380 sal_Bool SAL_CALL
 381 XResultSet_impl::relative( sal_Int32 row )
 382 {
 383     if( isAfterLast() || isBeforeFirst() )
 384         throw sdbc::SQLException( THROW_WHERE, uno::Reference< uno::XInterface >(), OUString(), 0, uno::Any() );
 385     if( row > 0 )
 386         while( row-- ) next();
 387     else if( row < 0 )
 388         while( row++ && m_nRow > - 1 ) previous();
 389
 390     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 391 }
 392
 393
 394 sal_Bool SAL_CALL
 395 XResultSet_impl::previous()
 396 {
 397     if( m_nRow > sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 398         m_nRow = sal::static_int_cast<sal_Int32>(m_aItems.size());  // Correct Handling of afterLast
 399     if( 0 <= m_nRow ) -- m_nRow;
 400
 401     return 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size());
 402 }
 403
 404
 405 void SAL_CALL
 406 XResultSet_impl::refreshRow()
 407 {
 408     // get the row from the filesystem
 409 }
 410
 411
 412 sal_Bool SAL_CALL
 413 XResultSet_impl::rowUpdated()
 414 {
 415     return false;
 416 }
 417
 418 sal_Bool SAL_CALL
 419 XResultSet_impl::rowInserted()
 420 {
 421     return false;
 422 }
 423
 424 sal_Bool SAL_CALL
 425 XResultSet_impl::rowDeleted()
 426 {
 427     return false;
 428 }
 429
 430
 431 uno::Reference< uno::XInterface > SAL_CALL
 432 XResultSet_impl::getStatement()
 433 {
 434     return uno::Reference< uno::XInterface >();
 435 }
 436
 437
 438 // XCloseable
 439
 440 void SAL_CALL
 441 XResultSet_impl::close()
 442 {
 443     if( m_nIsOpen )
 444     {
 445         m_aFolder.close();
 446         isFinalChanged();
 447         osl::MutexGuard aGuard( m_aMutex );
 448         m_nIsOpen = false;
 449     }
 450 }
 451
 452
 453 OUString SAL_CALL
 454 XResultSet_impl::queryContentIdentifierString()
 455 {
 456     uno::Reference< ucb::XContentIdentifier > xContentId
 457         = queryContentIdentifier();
 458
 459     if( xContentId.is() )
 460         return xContentId->getContentIdentifier();
 461     else
 462         return OUString();
 463 }
 464
 465
 466 uno::Reference< ucb::XContentIdentifier > SAL_CALL
 467 XResultSet_impl::queryContentIdentifier()
 468 {
 469     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 470     {
 471         if( ! m_aIdents[m_nRow].is() )
 472         {
 473             m_aIdents[m_nRow].set( new FileContentIdentifier( m_aUnqPath[  m_nRow ] ) );
 474         }
 475         return m_aIdents[m_nRow];
 476     }
 477     return uno::Reference< ucb::XContentIdentifier >();
 478 }
 479
 480
 481 uno::Reference< ucb::XContent > SAL_CALL
 482 XResultSet_impl::queryContent()
 483 {
 484     if( 0 <= m_nRow && m_nRow < sal::static_int_cast<sal_Int32>(m_aItems.size()) )
 485         return m_pMyShell->m_pProvider->queryContent( queryContentIdentifier() );
 486     else
 487         return uno::Reference< ucb::XContent >();
 488 }
 489
 490
 491 // XDynamicResultSet
 492
 493
 494 // virtual
 495 uno::Reference< sdbc::XResultSet > SAL_CALL
 496 XResultSet_impl::getStaticResultSet()
 497 {
 498     osl::MutexGuard aGuard( m_aMutex );
 499
 500     if ( m_xListener.is() )
 501         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 502
 503     return uno::Reference< sdbc::XResultSet >( this );
 504 }
 505
 506
 507 // virtual
 508 void SAL_CALL
 509 XResultSet_impl::setListener(
 510     const uno::Reference< ucb::XDynamicResultSetListener >& Listener )
 511 {
 512     osl::ClearableMutexGuard aGuard( m_aMutex );
 513
 514     if ( m_xListener.is() )
 515         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 516
 517     m_xListener = Listener;
 518
 519
 520     // Create "welcome event" and send it to listener.
 521
 522
 523     // Note: We only have the implementation for a static result set at the
 524     //       moment (src590). The dynamic result sets passed to the listener
 525     //       are a fake. This implementation will never call "notify" at the
 526     //       listener to propagate any changes!!!
 527
 528     uno::Any aInfo;
 529     aInfo <<= ucb::WelcomeDynamicResultSetStruct( this, /* "old" */
 530                                                   this /* "new" */ );
 531
 532     uno::Sequence< ucb::ListAction > aActions( 1 );
 533     aActions.getArray()[ 0 ] = ucb::ListAction( 0, // Position; not used
 534                                                 0, // Count; not used
 535                                                 ucb::ListActionType::WELCOME,
 536                                                 aInfo );
 537     aGuard.clear();
 538
 539     Listener->notify(
 540         ucb::ListEvent(
 541             static_cast< cppu::OWeakObject * >( this ), aActions ) );
 542 }
 543
 544
 545 // virtual
 546 void SAL_CALL
 547 XResultSet_impl::connectToCache(
 548     const uno::Reference< ucb::XDynamicResultSet > & xCache )
 549 {
 550     if( m_xListener.is() )
 551         throw ucb::ListenerAlreadySetException( THROW_WHERE );
 552
 553     uno::Reference< ucb::XSourceInitialization > xTarget(
 554         xCache, uno::UNO_QUERY );
 555     if( xTarget.is() && m_pMyShell->m_xContext.is() )
 556     {
 557         uno::Reference< ucb::XCachedDynamicResultSetStubFactory > xStubFactory;
 558         try
 559         {
 560             xStubFactory
 561                 = ucb::CachedDynamicResultSetStubFactory::create(
 562                     m_pMyShell->m_xContext );
 563         }
 564         catch ( uno::Exception const & )
 565         {
 566         }
 567
 568         if( xStubFactory.is() )
 569         {
 570             xStubFactory->connectToCache(
 571                 this, xCache,m_sSortingInfo, nullptr );
 572             return;
 573         }
 574     }
 575     throw ucb::ServiceNotFoundException( THROW_WHERE );
 576 }
 577
 578
 579 // virtual
 580 sal_Int16 SAL_CALL
 581 XResultSet_impl::getCapabilities()
 582 {
 583     // Never set ucb::ContentResultSetCapability::SORTED
 584     //  - Underlying content cannot provide sorted data...
 585     return 0;
 586 }
 587
 588 // XResultSetMetaDataSupplier
 589 uno::Reference< sdbc::XResultSetMetaData > SAL_CALL
 590 XResultSet_impl::getMetaData()
 591 {
 592     auto pProp = std::find_if(m_sProperty.begin(), m_sProperty.end(),
 593         [](const beans::Property& rProp) { return rProp.Name == "Title"; });
 594     if (pProp != m_sProperty.end())
 595     {
 596         std::vector< ::ucbhelper::ResultSetColumnData >
 597                                 aColumnData( m_sProperty.getLength() );
 598         auto n = std::distance(m_sProperty.begin(), pProp);
 599         // @@@ #82177# - Determine correct value!
 600         aColumnData[ n ].isCaseSensitive = false;
 601
 602         ::ucbhelper::ResultSetMetaData* p =
 603             new ::ucbhelper::ResultSetMetaData(
 604                 m_pMyShell->m_xContext,
 605                 m_sProperty,
 606                 aColumnData );
 607         return uno::Reference< sdbc::XResultSetMetaData >( p );
 608     }
 609
 610     ::ucbhelper::ResultSetMetaData* p =
 611             new ::ucbhelper::ResultSetMetaData( m_pMyShell->m_xContext, m_sProperty );
 612     return uno::Reference< sdbc::XResultSetMetaData >( p );
 613 }
 614
 615
 616 // XPropertySet
 617 uno::Reference< beans::XPropertySetInfo > SAL_CALL
 618 XResultSet_impl::getPropertySetInfo()
 619 {
 620
 621     uno::Sequence< beans::Property > seq(2);
 622     seq[0].Name = "RowCount";
 623     seq[0].Handle = -1;
 624     seq[0].Type = cppu::UnoType<sal_Int32>::get();
 625     seq[0].Attributes = beans::PropertyAttribute::READONLY;
 626
 627     seq[1].Name = "IsRowCountFinal";
 628     seq[1].Handle = -1;
 629     seq[1].Type = cppu::UnoType<sal_Bool>::get();
 630     seq[1].Attributes = beans::PropertyAttribute::READONLY;
 631
 632     XPropertySetInfo_impl* p = new XPropertySetInfo_impl( m_pMyShell,
 633                                                           seq );
 634     return uno::Reference< beans::XPropertySetInfo > ( p );
 635 }
 636
 637
 638 void SAL_CALL XResultSet_impl::setPropertyValue(
 639     const OUString& aPropertyName, const uno::Any& )
 640 {
 641     if( aPropertyName == "IsRowCountFinal" ||
 642         aPropertyName == "RowCount" )
 643         return;
 644     throw beans::UnknownPropertyException( aPropertyName );
 645 }
 646
 647
 648 uno::Any SAL_CALL XResultSet_impl::getPropertyValue(
 649     const OUString& PropertyName )
 650 {
 651     if( PropertyName == "IsRowCountFinal" )
 652     {
 653         return uno::Any(m_bRowCountFinal);
 654     }
 655     else if ( PropertyName == "RowCount" )
 656     {
 657         sal_Int32 count = sal::static_int_cast<sal_Int32>(m_aItems.size());
 658         return uno::Any(count);
 659     }
 660     else
 661         throw beans::UnknownPropertyException( PropertyName );
 662 }
 663
 664
 665 void SAL_CALL XResultSet_impl::addPropertyChangeListener(
 666     const OUString& aPropertyName,
 667     const uno::Reference< beans::XPropertyChangeListener >& xListener )
 668 {
 669     if( aPropertyName == "IsRowCountFinal" )
 670     {
 671         osl::MutexGuard aGuard( m_aMutex );
 672         if ( ! m_pIsFinalListeners )
 673             m_pIsFinalListeners.reset(
 674                 new comphelper::OInterfaceContainerHelper2( m_aEventListenerMutex ) );
 675
 676         m_pIsFinalListeners->addInterface( xListener );
 677     }
 678     else if ( aPropertyName == "RowCount" )
 679     {
 680         osl::MutexGuard aGuard( m_aMutex );
 681         if ( ! m_pRowCountListeners )
 682             m_pRowCountListeners.reset(
 683                 new comphelper::OInterfaceContainerHelper2( m_aEventListenerMutex ) );
 684         m_pRowCountListeners->addInterface( xListener );
 685     }
 686     else
 687         throw beans::UnknownPropertyException( aPropertyName );
 688 }
 689
 690
 691 void SAL_CALL XResultSet_impl::removePropertyChangeListener(
 692     const OUString& aPropertyName,
 693     const uno::Reference< beans::XPropertyChangeListener >& aListener )
 694 {
 695     if( aPropertyName == "IsRowCountFinal" &&
 696         m_pIsFinalListeners )
 697     {
 698         osl::MutexGuard aGuard( m_aMutex );
 699         m_pIsFinalListeners->removeInterface( aListener );
 700     }
 701     else if ( aPropertyName == "RowCount" &&
 702               m_pRowCountListeners )
 703     {
 704         osl::MutexGuard aGuard( m_aMutex );
 705
 706         m_pRowCountListeners->removeInterface( aListener );
 707     }
 708     else
 709         throw beans::UnknownPropertyException( aPropertyName );
 710 }
 711
 712 void SAL_CALL XResultSet_impl::addVetoableChangeListener(
 713     const OUString&,
 714     const uno::Reference< beans::XVetoableChangeListener >& )
 715 {
 716 }
 717
 718
 719 void SAL_CALL XResultSet_impl::removeVetoableChangeListener(
 720     const OUString&,
 721     const uno::Reference< beans::XVetoableChangeListener >& )
 722 {
 723 }
 724
 725 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */