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