ucb/source/cacher/contentresultsetwrapper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: contentresultsetwrapper.cxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_ucb.hxx"
  33
  34 #include <contentresultsetwrapper.hxx>
  35 #include <com/sun/star/sdbc/FetchDirection.hpp>
  36 #include <com/sun/star/ucb/FetchError.hpp>
  37 #include <com/sun/star/beans/PropertyAttribute.hpp>
  38 #include <com/sun/star/sdbc/ResultSetType.hpp>
  39 #include <com/sun/star/lang/DisposedException.hpp>
  40 #include <rtl/ustring.hxx>
  41 #include <osl/diagnose.h>
  42
  43 using namespace com::sun::star::beans;
  44 using namespace com::sun::star::lang;
  45 using namespace com::sun::star::sdbc;
  46 using namespace com::sun::star::ucb;
  47 using namespace com::sun::star::uno;
  48 using namespace com::sun::star::util;
  49 using namespace cppu;
  50 using namespace rtl;
  51
  52 //--------------------------------------------------------------------------
  53 //--------------------------------------------------------------------------
  54 // class ContentResultSetWrapper
  55 //--------------------------------------------------------------------------
  56 //--------------------------------------------------------------------------
  57
  58 ContentResultSetWrapper::ContentResultSetWrapper(
  59                                 Reference< XResultSet > xOrigin )
  60                 : m_xResultSetOrigin( xOrigin )
  61                 , m_xRowOrigin( NULL )
  62                 , m_xContentAccessOrigin( NULL )
  63                 , m_xPropertySetOrigin( NULL )
  64                 , m_xPropertySetInfo( NULL )
  65                 , m_nForwardOnly( 2 )
  66                 , m_xMetaDataFromOrigin( NULL )
  67                 , m_bDisposed( sal_False )
  68                 , m_bInDispose( sal_False )
  69                 , m_pDisposeEventListeners( NULL )
  70                 , m_pPropertyChangeListeners( NULL )
  71                 , m_pVetoableChangeListeners( NULL )
  72 {
  73     m_pMyListenerImpl = new ContentResultSetWrapperListener( this );
  74     m_xMyListenerImpl = Reference< XPropertyChangeListener >( m_pMyListenerImpl );
  75
  76     OSL_ENSURE( m_xResultSetOrigin.is(), "XResultSet is required" );
  77
  78     //!! call impl_init() at the end of constructor of derived class
  79 };
  80
  81
  82 void SAL_CALL ContentResultSetWrapper::impl_init_xRowOrigin()
  83 {
  84     {
  85         osl::Guard< osl::Mutex > aGuard( m_aMutex );
  86         if(m_xRowOrigin.is())
  87             return;
  88     }
  89
  90     Reference< XRow > xOrgig =
  91         Reference< XRow >( m_xResultSetOrigin, UNO_QUERY );
  92
  93     {
  94         osl::Guard< osl::Mutex > aGuard( m_aMutex );
  95         m_xRowOrigin = xOrgig;
  96         OSL_ENSURE( m_xRowOrigin.is(), "interface XRow is required" );
  97     }
  98 }
  99
 100 void SAL_CALL ContentResultSetWrapper::impl_init_xContentAccessOrigin()
 101 {
 102     {
 103         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 104         if(m_xContentAccessOrigin.is())
 105             return;
 106     }
 107
 108     Reference< XContentAccess > xOrgig =
 109         Reference< XContentAccess >( m_xResultSetOrigin, UNO_QUERY );
 110
 111     {
 112         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 113         m_xContentAccessOrigin = xOrgig;
 114         OSL_ENSURE( m_xContentAccessOrigin.is(), "interface XContentAccess is required" );
 115     }
 116 }
 117
 118
 119 void SAL_CALL ContentResultSetWrapper::impl_init_xPropertySetOrigin()
 120 {
 121     {
 122         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 123         if( m_xPropertySetOrigin.is() )
 124             return;
 125     }
 126
 127     Reference< XPropertySet > xOrig =
 128         Reference< XPropertySet >( m_xResultSetOrigin, UNO_QUERY );
 129
 130     {
 131         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 132         m_xPropertySetOrigin = xOrig;
 133         OSL_ENSURE( m_xPropertySetOrigin.is(), "interface XPropertySet is required" );
 134     }
 135 }
 136
 137 void SAL_CALL ContentResultSetWrapper::impl_init()
 138 {
 139     //call this at the end of constructor of derived class
 140     //
 141
 142     //listen to disposing from Origin:
 143     Reference< XComponent > xComponentOrigin( m_xResultSetOrigin, UNO_QUERY );
 144     OSL_ENSURE( xComponentOrigin.is(), "interface XComponent is required" );
 145     xComponentOrigin->addEventListener( static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
 146 }
 147
 148 ContentResultSetWrapper::~ContentResultSetWrapper()
 149 {
 150     //call impl_deinit() at start of destructor of derived class
 151
 152     delete m_pDisposeEventListeners;
 153     delete m_pPropertyChangeListeners;
 154     delete m_pVetoableChangeListeners;
 155 };
 156
 157 void SAL_CALL ContentResultSetWrapper::impl_deinit()
 158 {
 159     //call this at start of destructor of derived class
 160     //
 161     m_pMyListenerImpl->impl_OwnerDies();
 162 }
 163
 164 //virtual
 165 void SAL_CALL ContentResultSetWrapper
 166     ::impl_initPropertySetInfo()
 167 {
 168     {
 169         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 170         if( m_xPropertySetInfo.is() )
 171             return;
 172
 173         impl_init_xPropertySetOrigin();
 174         if( !m_xPropertySetOrigin.is() )
 175             return;
 176     }
 177
 178     Reference< XPropertySetInfo > xOrig =
 179             m_xPropertySetOrigin->getPropertySetInfo();
 180
 181     {
 182         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 183         m_xPropertySetInfo = xOrig;
 184     }
 185 }
 186
 187 void SAL_CALL ContentResultSetWrapper
 188 ::impl_EnsureNotDisposed()
 189     throw( DisposedException, RuntimeException )
 190 {
 191     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 192     if( m_bDisposed )
 193         throw DisposedException();
 194 }
 195
 196 ContentResultSetWrapper::PropertyChangeListenerContainer_Impl* SAL_CALL
 197     ContentResultSetWrapper
 198     ::impl_getPropertyChangeListenerContainer()
 199 {
 200     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 201     if ( !m_pPropertyChangeListeners )
 202         m_pPropertyChangeListeners =
 203             new PropertyChangeListenerContainer_Impl( m_aContainerMutex );
 204     return m_pPropertyChangeListeners;
 205 }
 206
 207 ContentResultSetWrapper::PropertyChangeListenerContainer_Impl* SAL_CALL
 208     ContentResultSetWrapper
 209     ::impl_getVetoableChangeListenerContainer()
 210 {
 211     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 212     if ( !m_pVetoableChangeListeners )
 213         m_pVetoableChangeListeners =
 214             new PropertyChangeListenerContainer_Impl( m_aContainerMutex );
 215     return m_pVetoableChangeListeners;
 216 }
 217
 218 void SAL_CALL ContentResultSetWrapper
 219     ::impl_notifyPropertyChangeListeners(
 220                     const PropertyChangeEvent& rEvt )
 221 {
 222     {
 223         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 224         if( !m_pPropertyChangeListeners )
 225             return;
 226     }
 227
 228     // Notify listeners interested especially in the changed property.
 229     OInterfaceContainerHelper* pContainer =
 230             m_pPropertyChangeListeners->getContainer( rEvt.PropertyName );
 231     if( pContainer )
 232     {
 233         OInterfaceIteratorHelper aIter( *pContainer );
 234         while( aIter.hasMoreElements() )
 235         {
 236             Reference< XPropertyChangeListener > xListener(
 237                                                     aIter.next(), UNO_QUERY );
 238             if( xListener.is() )
 239                 xListener->propertyChange( rEvt );
 240         }
 241     }
 242
 243     // Notify listeners interested in all properties.
 244     pContainer = m_pPropertyChangeListeners->getContainer( OUString() );
 245     if( pContainer )
 246     {
 247         OInterfaceIteratorHelper aIter( *pContainer );
 248         while( aIter.hasMoreElements() )
 249         {
 250             Reference< XPropertyChangeListener > xListener(
 251                                                     aIter.next(), UNO_QUERY );
 252             if( xListener.is() )
 253                 xListener->propertyChange( rEvt );
 254         }
 255     }
 256 }
 257
 258 void SAL_CALL ContentResultSetWrapper
 259     ::impl_notifyVetoableChangeListeners( const PropertyChangeEvent& rEvt )
 260     throw( PropertyVetoException,
 261            RuntimeException )
 262 {
 263     {
 264         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 265         if( !m_pVetoableChangeListeners )
 266             return;
 267     }
 268
 269     // Notify listeners interested especially in the changed property.
 270     OInterfaceContainerHelper* pContainer =
 271             m_pVetoableChangeListeners->getContainer( rEvt.PropertyName );
 272     if( pContainer )
 273     {
 274         OInterfaceIteratorHelper aIter( *pContainer );
 275         while( aIter.hasMoreElements() )
 276         {
 277             Reference< XVetoableChangeListener > xListener(
 278                                                     aIter.next(), UNO_QUERY );
 279             if( xListener.is() )
 280                 xListener->vetoableChange( rEvt );
 281         }
 282     }
 283
 284     // Notify listeners interested in all properties.
 285     pContainer = m_pVetoableChangeListeners->getContainer( OUString() );
 286     if( pContainer )
 287     {
 288         OInterfaceIteratorHelper aIter( *pContainer );
 289         while( aIter.hasMoreElements() )
 290         {
 291             Reference< XVetoableChangeListener > xListener(
 292                                                     aIter.next(), UNO_QUERY );
 293             if( xListener.is() )
 294                 xListener->vetoableChange( rEvt );
 295         }
 296     }
 297 }
 298
 299 sal_Bool SAL_CALL ContentResultSetWrapper
 300     ::impl_isForwardOnly()
 301 {
 302     //m_nForwardOnly == 2 -> don't know
 303     //m_nForwardOnly == 1 -> YES
 304     //m_nForwardOnly == 0 -> NO
 305
 306     //@todo replace this with lines in comment
 307     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 308     m_nForwardOnly = 0;
 309     return false;
 310
 311
 312     /*
 313     ReacquireableGuard aGuard( m_aMutex );
 314     if( m_nForwardOnly == 2 )
 315     {
 316         aGuard.clear();
 317         if( !getPropertySetInfo().is() )
 318         {
 319             aGuard.reacquire();
 320             m_nForwardOnly = 0;
 321             return m_nForwardOnly;
 322         }
 323         aGuard.reacquire();
 324
 325         rtl::OUString aName = OUString::createFromAscii( "ResultSetType" );
 326         //find out, if we are ForwardOnly and cache the value:
 327
 328         impl_init_xPropertySetOrigin();
 329         if( !m_xPropertySetOrigin.is() )
 330         {
 331             OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 332             m_nForwardOnly = 0;
 333             return m_nForwardOnly;
 334         }
 335
 336         aGuard.clear();
 337         Any aAny = m_xPropertySetOrigin->getPropertyValue( aName );
 338
 339         aGuard.reacquire();
 340         long nResultSetType;
 341         if( ( aAny >>= nResultSetType ) &&
 342             ( nResultSetType == ResultSetType::FORWARD_ONLY ) )
 343             m_nForwardOnly = 1;
 344         else
 345             m_nForwardOnly = 0;
 346     }
 347     return m_nForwardOnly;
 348     */
 349 }
 350
 351 //--------------------------------------------------------------------------
 352 // XInterface methods.
 353 //--------------------------------------------------------------------------
 354 //list all interfaces inclusive baseclasses of interfaces
 355 QUERYINTERFACE_IMPL_START( ContentResultSetWrapper )
 356
 357     SAL_STATIC_CAST( XComponent*, this ),
 358     SAL_STATIC_CAST( XCloseable*, this ),
 359     SAL_STATIC_CAST( XResultSetMetaDataSupplier*, this ),
 360     SAL_STATIC_CAST( XPropertySet*, this ),
 361
 362     SAL_STATIC_CAST( XContentAccess*, this ),
 363     SAL_STATIC_CAST( XResultSet*, this ),
 364     SAL_STATIC_CAST( XRow*, this )
 365
 366 QUERYINTERFACE_IMPL_END
 367
 368 //--------------------------------------------------------------------------
 369 // XComponent methods.
 370 //--------------------------------------------------------------------------
 371 // virtual
 372 void SAL_CALL ContentResultSetWrapper
 373     ::dispose() throw( RuntimeException )
 374 {
 375     impl_EnsureNotDisposed();
 376
 377     ReacquireableGuard aGuard( m_aMutex );
 378     if( m_bInDispose || m_bDisposed )
 379         return;
 380     m_bInDispose = sal_True;
 381
 382     if( m_xPropertySetOrigin.is() )
 383     {
 384         aGuard.clear();
 385         try
 386         {
 387             m_xPropertySetOrigin->removePropertyChangeListener(
 388                 OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
 389         }
 390         catch( Exception& )
 391         {
 392             OSL_ENSURE( sal_False, "could not remove PropertyChangeListener" );
 393         }
 394         try
 395         {
 396             m_xPropertySetOrigin->removeVetoableChangeListener(
 397                 OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
 398         }
 399         catch( Exception& )
 400         {
 401             OSL_ENSURE( sal_False, "could not remove VetoableChangeListener" );
 402         }
 403
 404         Reference< XComponent > xComponentOrigin( m_xResultSetOrigin, UNO_QUERY );
 405         OSL_ENSURE( xComponentOrigin.is(), "interface XComponent is required" );
 406         xComponentOrigin->removeEventListener( static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
 407     }
 408
 409     aGuard.reacquire();
 410     if( m_pDisposeEventListeners && m_pDisposeEventListeners->getLength() )
 411     {
 412         EventObject aEvt;
 413         aEvt.Source = static_cast< XComponent * >( this );
 414
 415         aGuard.clear();
 416         m_pDisposeEventListeners->disposeAndClear( aEvt );
 417     }
 418
 419     aGuard.reacquire();
 420     if( m_pPropertyChangeListeners )
 421     {
 422         EventObject aEvt;
 423         aEvt.Source = static_cast< XPropertySet * >( this );
 424
 425         aGuard.clear();
 426         m_pPropertyChangeListeners->disposeAndClear( aEvt );
 427     }
 428
 429     aGuard.reacquire();
 430     if( m_pVetoableChangeListeners )
 431     {
 432         EventObject aEvt;
 433         aEvt.Source = static_cast< XPropertySet * >( this );
 434
 435         aGuard.clear();
 436         m_pVetoableChangeListeners->disposeAndClear( aEvt );
 437     }
 438
 439     aGuard.reacquire();
 440     m_bDisposed = sal_True;
 441     m_bInDispose = sal_False;
 442 }
 443
 444 //--------------------------------------------------------------------------
 445 // virtual
 446 void SAL_CALL ContentResultSetWrapper
 447     ::addEventListener( const Reference< XEventListener >& Listener )
 448     throw( RuntimeException )
 449 {
 450     impl_EnsureNotDisposed();
 451     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 452
 453     if ( !m_pDisposeEventListeners )
 454         m_pDisposeEventListeners =
 455                     new OInterfaceContainerHelper( m_aContainerMutex );
 456
 457     m_pDisposeEventListeners->addInterface( Listener );
 458 }
 459
 460 //--------------------------------------------------------------------------
 461 // virtual
 462 void SAL_CALL ContentResultSetWrapper
 463     ::removeEventListener( const Reference< XEventListener >& Listener )
 464     throw( RuntimeException )
 465 {
 466     impl_EnsureNotDisposed();
 467     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 468
 469     if ( m_pDisposeEventListeners )
 470         m_pDisposeEventListeners->removeInterface( Listener );
 471 }
 472
 473 //--------------------------------------------------------------------------
 474 //XCloseable methods.
 475 //--------------------------------------------------------------------------
 476 //virtual
 477 void SAL_CALL ContentResultSetWrapper
 478     ::close()
 479     throw( SQLException,
 480            RuntimeException )
 481 {
 482     impl_EnsureNotDisposed();
 483     dispose();
 484 }
 485
 486 //--------------------------------------------------------------------------
 487 //XResultSetMetaDataSupplier methods.
 488 //--------------------------------------------------------------------------
 489 //virtual
 490 Reference< XResultSetMetaData > SAL_CALL ContentResultSetWrapper
 491     ::getMetaData()
 492     throw( SQLException,
 493            RuntimeException )
 494 {
 495     impl_EnsureNotDisposed();
 496
 497     ReacquireableGuard aGuard( m_aMutex );
 498     if( !m_xMetaDataFromOrigin.is() && m_xResultSetOrigin.is() )
 499     {
 500         Reference< XResultSetMetaDataSupplier > xMetaDataSupplier
 501             = Reference< XResultSetMetaDataSupplier >(
 502                 m_xResultSetOrigin, UNO_QUERY );
 503
 504         if( xMetaDataSupplier.is() )
 505         {
 506             aGuard.clear();
 507
 508             Reference< XResultSetMetaData > xMetaData
 509                 = xMetaDataSupplier->getMetaData();
 510
 511             aGuard.reacquire();
 512             m_xMetaDataFromOrigin = xMetaData;
 513         }
 514     }
 515     return m_xMetaDataFromOrigin;
 516 }
 517
 518
 519 //--------------------------------------------------------------------------
 520 // XPropertySet methods.
 521 //--------------------------------------------------------------------------
 522 // virtual
 523 Reference< XPropertySetInfo > SAL_CALL ContentResultSetWrapper
 524     ::getPropertySetInfo() throw( RuntimeException )
 525 {
 526     impl_EnsureNotDisposed();
 527     {
 528         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 529         if( m_xPropertySetInfo.is() )
 530             return m_xPropertySetInfo;
 531     }
 532     impl_initPropertySetInfo();
 533     return m_xPropertySetInfo;
 534 }
 535 //--------------------------------------------------------------------------
 536 // virtual
 537 void SAL_CALL ContentResultSetWrapper
 538     ::setPropertyValue( const OUString& rPropertyName, const Any& rValue )
 539     throw( UnknownPropertyException,
 540            PropertyVetoException,
 541            IllegalArgumentException,
 542            WrappedTargetException,
 543            RuntimeException )
 544 {
 545     impl_EnsureNotDisposed();
 546     impl_init_xPropertySetOrigin();
 547     if( !m_xPropertySetOrigin.is() )
 548     {
 549         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 550         throw UnknownPropertyException();
 551     }
 552     m_xPropertySetOrigin->setPropertyValue( rPropertyName, rValue );
 553 }
 554
 555 //--------------------------------------------------------------------------
 556 // virtual
 557 Any SAL_CALL ContentResultSetWrapper
 558     ::getPropertyValue( const OUString& rPropertyName )
 559     throw( UnknownPropertyException,
 560            WrappedTargetException,
 561            RuntimeException )
 562 {
 563     impl_EnsureNotDisposed();
 564     impl_init_xPropertySetOrigin();
 565     if( !m_xPropertySetOrigin.is() )
 566     {
 567         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 568         throw UnknownPropertyException();
 569     }
 570     return m_xPropertySetOrigin->getPropertyValue( rPropertyName );
 571 }
 572
 573 //--------------------------------------------------------------------------
 574 // virtual
 575 void SAL_CALL ContentResultSetWrapper
 576     ::addPropertyChangeListener(
 577             const OUString& aPropertyName,
 578             const Reference< XPropertyChangeListener >& xListener )
 579     throw( UnknownPropertyException,
 580            WrappedTargetException,
 581            RuntimeException )
 582 {
 583     impl_EnsureNotDisposed();
 584
 585     if( !getPropertySetInfo().is() )
 586     {
 587         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 588         throw UnknownPropertyException();
 589     }
 590
 591     if( aPropertyName.getLength() )
 592     {
 593         m_xPropertySetInfo->getPropertyByName( aPropertyName );
 594         //throws UnknownPropertyException, if so
 595     }
 596
 597     impl_getPropertyChangeListenerContainer();
 598     sal_Bool bNeedRegister = !m_pPropertyChangeListeners->
 599                         getContainedTypes().getLength();
 600     m_pPropertyChangeListeners->addInterface( aPropertyName, xListener );
 601     if( bNeedRegister )
 602     {
 603         impl_init_xPropertySetOrigin();
 604         {
 605             osl::Guard< osl::Mutex > aGuard( m_aMutex );
 606             if( !m_xPropertySetOrigin.is() )
 607             {
 608                 OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 609                 return;
 610             }
 611         }
 612         try
 613         {
 614             m_xPropertySetOrigin->addPropertyChangeListener(
 615                 OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
 616         }
 617         catch( Exception& rEx )
 618         {
 619             m_pPropertyChangeListeners->removeInterface( aPropertyName, xListener );
 620             throw rEx;
 621         }
 622     }
 623 }
 624
 625 //--------------------------------------------------------------------------
 626 // virtual
 627 void SAL_CALL ContentResultSetWrapper
 628     ::addVetoableChangeListener(
 629             const OUString& rPropertyName,
 630             const Reference< XVetoableChangeListener >& xListener )
 631     throw( UnknownPropertyException,
 632            WrappedTargetException,
 633            RuntimeException )
 634 {
 635     impl_EnsureNotDisposed();
 636
 637     if( !getPropertySetInfo().is() )
 638     {
 639         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 640         throw UnknownPropertyException();
 641     }
 642     if( rPropertyName.getLength() )
 643     {
 644         m_xPropertySetInfo->getPropertyByName( rPropertyName );
 645         //throws UnknownPropertyException, if so
 646     }
 647
 648     impl_getVetoableChangeListenerContainer();
 649     sal_Bool bNeedRegister = !m_pVetoableChangeListeners->
 650                         getContainedTypes().getLength();
 651     m_pVetoableChangeListeners->addInterface( rPropertyName, xListener );
 652     if( bNeedRegister )
 653     {
 654         impl_init_xPropertySetOrigin();
 655         {
 656             osl::Guard< osl::Mutex > aGuard( m_aMutex );
 657             if( !m_xPropertySetOrigin.is() )
 658             {
 659                 OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 660                 return;
 661             }
 662         }
 663         try
 664         {
 665             m_xPropertySetOrigin->addVetoableChangeListener(
 666                 OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
 667         }
 668         catch( Exception& rEx )
 669         {
 670             m_pVetoableChangeListeners->removeInterface( rPropertyName, xListener );
 671             throw rEx;
 672         }
 673     }
 674 }
 675
 676 //--------------------------------------------------------------------------
 677 // virtual
 678 void SAL_CALL ContentResultSetWrapper
 679     ::removePropertyChangeListener(
 680             const OUString& rPropertyName,
 681             const Reference< XPropertyChangeListener >& xListener )
 682     throw( UnknownPropertyException,
 683            WrappedTargetException,
 684            RuntimeException )
 685 {
 686     impl_EnsureNotDisposed();
 687
 688     {
 689         //noop, if no listener registered
 690         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 691         if( !m_pPropertyChangeListeners )
 692             return;
 693     }
 694     OInterfaceContainerHelper* pContainer =
 695         m_pPropertyChangeListeners->getContainer( rPropertyName );
 696
 697     if( !pContainer )
 698     {
 699         if( rPropertyName.getLength() )
 700         {
 701             if( !getPropertySetInfo().is() )
 702                 throw UnknownPropertyException();
 703
 704             m_xPropertySetInfo->getPropertyByName( rPropertyName );
 705             //throws UnknownPropertyException, if so
 706         }
 707         return; //the listener was not registered
 708     }
 709
 710     m_pPropertyChangeListeners->removeInterface( rPropertyName, xListener );
 711
 712     if( !m_pPropertyChangeListeners->getContainedTypes().getLength() )
 713     {
 714         impl_init_xPropertySetOrigin();
 715         {
 716             osl::Guard< osl::Mutex > aGuard( m_aMutex );
 717             if( !m_xPropertySetOrigin.is() )
 718             {
 719                 OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 720                 return;
 721             }
 722         }
 723         try
 724         {
 725             m_xPropertySetOrigin->removePropertyChangeListener(
 726                 OUString(), static_cast< XPropertyChangeListener * >( m_pMyListenerImpl ) );
 727         }
 728         catch( Exception& )
 729         {
 730             OSL_ENSURE( sal_False, "could not remove PropertyChangeListener" );
 731         }
 732     }
 733 }
 734
 735 //--------------------------------------------------------------------------
 736 // virtual
 737 void SAL_CALL ContentResultSetWrapper
 738     ::removeVetoableChangeListener(
 739             const OUString& rPropertyName,
 740             const Reference< XVetoableChangeListener >& xListener )
 741     throw( UnknownPropertyException,
 742            WrappedTargetException,
 743            RuntimeException )
 744 {
 745     impl_EnsureNotDisposed();
 746
 747     {
 748         //noop, if no listener registered
 749         osl::Guard< osl::Mutex > aGuard( m_aMutex );
 750         if( !m_pVetoableChangeListeners )
 751             return;
 752     }
 753     OInterfaceContainerHelper* pContainer =
 754         m_pVetoableChangeListeners->getContainer( rPropertyName );
 755
 756     if( !pContainer )
 757     {
 758         if( rPropertyName.getLength() )
 759         {
 760             if( !getPropertySetInfo().is() )
 761                 throw UnknownPropertyException();
 762
 763             m_xPropertySetInfo->getPropertyByName( rPropertyName );
 764             //throws UnknownPropertyException, if so
 765         }
 766         return; //the listener was not registered
 767     }
 768
 769     m_pVetoableChangeListeners->removeInterface( rPropertyName, xListener );
 770
 771     if( !m_pVetoableChangeListeners->getContainedTypes().getLength() )
 772     {
 773         impl_init_xPropertySetOrigin();
 774         {
 775             osl::Guard< osl::Mutex > aGuard( m_aMutex );
 776             if( !m_xPropertySetOrigin.is() )
 777             {
 778                 OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 779                 return;
 780             }
 781         }
 782         try
 783         {
 784             m_xPropertySetOrigin->removeVetoableChangeListener(
 785                 OUString(), static_cast< XVetoableChangeListener * >( m_pMyListenerImpl ) );
 786         }
 787         catch( Exception& )
 788         {
 789             OSL_ENSURE( sal_False, "could not remove VetoableChangeListener" );
 790         }
 791     }
 792 }
 793
 794 //--------------------------------------------------------------------------
 795 // own methods.
 796 //--------------------------------------------------------------------------
 797
 798 //virtual
 799 void SAL_CALL ContentResultSetWrapper
 800     ::impl_disposing( const EventObject& )
 801     throw( RuntimeException )
 802 {
 803     impl_EnsureNotDisposed();
 804
 805     osl::Guard< osl::Mutex > aGuard( m_aMutex );
 806
 807     if( !m_xResultSetOrigin.is() )
 808         return;
 809
 810     //release all references to the broadcaster:
 811     m_xResultSetOrigin.clear();
 812     if(m_xRowOrigin.is())
 813         m_xRowOrigin.clear();
 814     if(m_xContentAccessOrigin.is())
 815         m_xContentAccessOrigin.clear();
 816     if(m_xPropertySetOrigin.is())
 817         m_xPropertySetOrigin.clear();
 818     m_xMetaDataFromOrigin.clear();
 819     if(m_xPropertySetInfo.is())
 820         m_xPropertySetInfo.clear();
 821 }
 822
 823 //virtual
 824 void SAL_CALL ContentResultSetWrapper
 825     ::impl_propertyChange( const PropertyChangeEvent& rEvt )
 826     throw( RuntimeException )
 827 {
 828     impl_EnsureNotDisposed();
 829
 830     PropertyChangeEvent aEvt( rEvt );
 831     aEvt.Source = static_cast< XPropertySet * >( this );
 832     aEvt.Further = sal_False;
 833     impl_notifyPropertyChangeListeners( aEvt );
 834 }
 835
 836 //virtual
 837 void SAL_CALL ContentResultSetWrapper
 838     ::impl_vetoableChange( const PropertyChangeEvent& rEvt )
 839     throw( PropertyVetoException,
 840            RuntimeException )
 841 {
 842     impl_EnsureNotDisposed();
 843
 844     PropertyChangeEvent aEvt( rEvt );
 845     aEvt.Source = static_cast< XPropertySet * >( this );
 846     aEvt.Further = sal_False;
 847
 848     impl_notifyVetoableChangeListeners( aEvt );
 849 }
 850
 851 //--------------------------------------------------------------------------
 852 // XContentAccess methods.      ( -- position dependent )
 853 //--------------------------------------------------------------------------
 854
 855 // virtual
 856 OUString SAL_CALL ContentResultSetWrapper
 857     ::queryContentIdentifierString()
 858     throw( RuntimeException )
 859 {
 860     impl_EnsureNotDisposed();
 861     impl_init_xContentAccessOrigin();
 862     if( !m_xContentAccessOrigin.is() )
 863     {
 864         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 865         throw RuntimeException();
 866     }
 867     return m_xContentAccessOrigin->queryContentIdentifierString();
 868 }
 869
 870 //--------------------------------------------------------------------------
 871 // virtual
 872 Reference< XContentIdentifier > SAL_CALL ContentResultSetWrapper
 873     ::queryContentIdentifier()
 874     throw( RuntimeException )
 875 {
 876     impl_EnsureNotDisposed();
 877     impl_init_xContentAccessOrigin();
 878     if( !m_xContentAccessOrigin.is() )
 879     {
 880         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 881         throw RuntimeException();
 882     }
 883     return m_xContentAccessOrigin->queryContentIdentifier();
 884 }
 885
 886 //--------------------------------------------------------------------------
 887 // virtual
 888 Reference< XContent > SAL_CALL ContentResultSetWrapper
 889     ::queryContent()
 890     throw( RuntimeException )
 891 {
 892     impl_EnsureNotDisposed();
 893     impl_init_xContentAccessOrigin();
 894     if( !m_xContentAccessOrigin.is() )
 895     {
 896         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 897         throw RuntimeException();
 898     }
 899     return m_xContentAccessOrigin->queryContent();
 900 }
 901
 902 //-----------------------------------------------------------------
 903 // XResultSet methods.
 904 //-----------------------------------------------------------------
 905 //virtual
 906
 907 sal_Bool SAL_CALL ContentResultSetWrapper
 908     ::next()
 909     throw( SQLException,
 910            RuntimeException )
 911 {
 912     impl_EnsureNotDisposed();
 913
 914     if( !m_xResultSetOrigin.is() )
 915     {
 916         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 917         throw RuntimeException();
 918     }
 919     return m_xResultSetOrigin->next();
 920 }
 921
 922 //virtual
 923 sal_Bool SAL_CALL ContentResultSetWrapper
 924     ::previous()
 925     throw( SQLException,
 926            RuntimeException )
 927 {
 928     impl_EnsureNotDisposed();
 929
 930     if( !m_xResultSetOrigin.is() )
 931     {
 932         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 933         throw RuntimeException();
 934     }
 935     return m_xResultSetOrigin->previous();
 936 }
 937
 938 //virtual
 939 sal_Bool SAL_CALL ContentResultSetWrapper
 940     ::absolute( sal_Int32 row )
 941     throw( SQLException,
 942            RuntimeException )
 943 {
 944     impl_EnsureNotDisposed();
 945
 946     if( !m_xResultSetOrigin.is() )
 947     {
 948         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 949         throw RuntimeException();
 950     }
 951     return m_xResultSetOrigin->absolute( row );
 952 }
 953
 954 //virtual
 955 sal_Bool SAL_CALL ContentResultSetWrapper
 956     ::relative( sal_Int32 rows )
 957     throw( SQLException,
 958            RuntimeException )
 959 {
 960     impl_EnsureNotDisposed();
 961
 962     if( !m_xResultSetOrigin.is() )
 963     {
 964         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 965         throw RuntimeException();
 966     }
 967     return m_xResultSetOrigin->relative( rows );
 968 }
 969
 970
 971 //virtual
 972 sal_Bool SAL_CALL ContentResultSetWrapper
 973     ::first()
 974     throw( SQLException,
 975            RuntimeException )
 976 {
 977     impl_EnsureNotDisposed();
 978
 979     if( !m_xResultSetOrigin.is() )
 980     {
 981         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 982         throw RuntimeException();
 983     }
 984     return m_xResultSetOrigin->first();
 985 }
 986
 987 //virtual
 988 sal_Bool SAL_CALL ContentResultSetWrapper
 989     ::last()
 990     throw( SQLException,
 991            RuntimeException )
 992 {
 993     impl_EnsureNotDisposed();
 994
 995     if( !m_xResultSetOrigin.is() )
 996     {
 997         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
 998         throw RuntimeException();
 999     }
1000     return m_xResultSetOrigin->last();
1001 }
1002
1003 //virtual
1004 void SAL_CALL ContentResultSetWrapper
1005     ::beforeFirst()
1006     throw( SQLException,
1007            RuntimeException )
1008 {
1009     impl_EnsureNotDisposed();
1010
1011     if( !m_xResultSetOrigin.is() )
1012     {
1013         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1014         throw RuntimeException();
1015     }
1016     m_xResultSetOrigin->beforeFirst();
1017 }
1018
1019 //virtual
1020 void SAL_CALL ContentResultSetWrapper
1021     ::afterLast()
1022     throw( SQLException,
1023            RuntimeException )
1024 {
1025     impl_EnsureNotDisposed();
1026
1027     if( !m_xResultSetOrigin.is() )
1028     {
1029         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1030         throw RuntimeException();
1031     }
1032     m_xResultSetOrigin->afterLast();
1033 }
1034
1035 //virtual
1036 sal_Bool SAL_CALL ContentResultSetWrapper
1037     ::isAfterLast()
1038     throw( SQLException,
1039            RuntimeException )
1040 {
1041     impl_EnsureNotDisposed();
1042
1043     if( !m_xResultSetOrigin.is() )
1044     {
1045         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1046         throw RuntimeException();
1047     }
1048     return m_xResultSetOrigin->isAfterLast();
1049 }
1050
1051 //virtual
1052 sal_Bool SAL_CALL ContentResultSetWrapper
1053     ::isBeforeFirst()
1054     throw( SQLException,
1055            RuntimeException )
1056 {
1057     impl_EnsureNotDisposed();
1058
1059     if( !m_xResultSetOrigin.is() )
1060     {
1061         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1062         throw RuntimeException();
1063     }
1064     return m_xResultSetOrigin->isBeforeFirst();
1065 }
1066
1067 //virtual
1068 sal_Bool SAL_CALL ContentResultSetWrapper
1069     ::isFirst()
1070     throw( SQLException,
1071            RuntimeException )
1072 {
1073     impl_EnsureNotDisposed();
1074
1075     if( !m_xResultSetOrigin.is() )
1076     {
1077         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1078         throw RuntimeException();
1079     }
1080     return m_xResultSetOrigin->isFirst();
1081 }
1082
1083 //virtual
1084 sal_Bool SAL_CALL ContentResultSetWrapper
1085     ::isLast()
1086     throw( SQLException,
1087            RuntimeException )
1088 {
1089     impl_EnsureNotDisposed();
1090
1091     if( !m_xResultSetOrigin.is() )
1092     {
1093         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1094         throw RuntimeException();
1095     }
1096     return m_xResultSetOrigin->isLast();
1097 }
1098
1099
1100 //virtual
1101 sal_Int32 SAL_CALL ContentResultSetWrapper
1102     ::getRow()
1103     throw( SQLException,
1104            RuntimeException )
1105 {
1106     impl_EnsureNotDisposed();
1107
1108     if( !m_xResultSetOrigin.is() )
1109     {
1110         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1111         throw RuntimeException();
1112     }
1113     return m_xResultSetOrigin->getRow();
1114 }
1115
1116 //virtual
1117 void SAL_CALL ContentResultSetWrapper
1118     ::refreshRow()
1119     throw( SQLException,
1120            RuntimeException )
1121 {
1122     impl_EnsureNotDisposed();
1123
1124     if( !m_xResultSetOrigin.is() )
1125     {
1126         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1127         throw RuntimeException();
1128     }
1129     m_xResultSetOrigin->refreshRow();
1130 }
1131
1132 //virtual
1133 sal_Bool SAL_CALL ContentResultSetWrapper
1134     ::rowUpdated()
1135     throw( SQLException,
1136            RuntimeException )
1137 {
1138     impl_EnsureNotDisposed();
1139
1140     if( !m_xResultSetOrigin.is() )
1141     {
1142         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1143         throw RuntimeException();
1144     }
1145     return m_xResultSetOrigin->rowUpdated();
1146 }
1147 //virtual
1148 sal_Bool SAL_CALL ContentResultSetWrapper
1149     ::rowInserted()
1150     throw( SQLException,
1151            RuntimeException )
1152 {
1153     impl_EnsureNotDisposed();
1154
1155     if( !m_xResultSetOrigin.is() )
1156     {
1157         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1158         throw RuntimeException();
1159     }
1160     return m_xResultSetOrigin->rowInserted();
1161 }
1162
1163 //virtual
1164 sal_Bool SAL_CALL ContentResultSetWrapper
1165     ::rowDeleted()
1166     throw( SQLException,
1167            RuntimeException )
1168 {
1169     impl_EnsureNotDisposed();
1170
1171     if( !m_xResultSetOrigin.is() )
1172     {
1173         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1174         throw RuntimeException();
1175     }
1176     return m_xResultSetOrigin->rowDeleted();
1177 }
1178
1179 //virtual
1180 Reference< XInterface > SAL_CALL ContentResultSetWrapper
1181     ::getStatement()
1182     throw( SQLException,
1183            RuntimeException )
1184 {
1185     impl_EnsureNotDisposed();
1186     //@todo ?return anything
1187     return Reference< XInterface >();
1188 }
1189
1190 //-----------------------------------------------------------------
1191 // XRow methods.
1192 //-----------------------------------------------------------------
1193
1194 #define XROW_GETXXX( getXXX )                                                                   \
1195 impl_EnsureNotDisposed();                                                                               \
1196 impl_init_xRowOrigin();                                                                                 \
1197 if( !m_xRowOrigin.is() )                                                                                \
1198 {                                                                                                                               \
1199     OSL_ENSURE( sal_False, "broadcaster was disposed already" );\
1200     throw RuntimeException();                                                                   \
1201 }                                                                                                                               \
1202 return m_xRowOrigin->getXXX( columnIndex );
1203
1204 //virtual
1205 sal_Bool SAL_CALL ContentResultSetWrapper
1206     ::wasNull()
1207     throw( SQLException,
1208            RuntimeException )
1209 {
1210     impl_EnsureNotDisposed();
1211     impl_init_xRowOrigin();
1212     if( !m_xRowOrigin.is() )
1213     {
1214         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1215         throw RuntimeException();
1216     }
1217     return m_xRowOrigin->wasNull();
1218 }
1219
1220 //virtual
1221 rtl::OUString SAL_CALL ContentResultSetWrapper
1222     ::getString( sal_Int32 columnIndex )
1223     throw( SQLException,
1224            RuntimeException )
1225 {
1226     XROW_GETXXX( getString );
1227 }
1228
1229 //virtual
1230 sal_Bool SAL_CALL ContentResultSetWrapper
1231     ::getBoolean( sal_Int32 columnIndex )
1232     throw( SQLException,
1233            RuntimeException )
1234 {
1235     XROW_GETXXX( getBoolean );
1236 }
1237
1238 //virtual
1239 sal_Int8 SAL_CALL ContentResultSetWrapper
1240     ::getByte( sal_Int32 columnIndex )
1241     throw( SQLException,
1242            RuntimeException )
1243 {
1244     XROW_GETXXX( getByte );
1245 }
1246
1247 //virtual
1248 sal_Int16 SAL_CALL ContentResultSetWrapper
1249     ::getShort( sal_Int32 columnIndex )
1250     throw( SQLException,
1251            RuntimeException )
1252 {
1253     XROW_GETXXX( getShort );
1254 }
1255
1256 //virtual
1257 sal_Int32 SAL_CALL ContentResultSetWrapper
1258     ::getInt( sal_Int32 columnIndex )
1259     throw( SQLException,
1260            RuntimeException )
1261 {
1262     XROW_GETXXX( getInt );
1263 }
1264
1265 //virtual
1266 sal_Int64 SAL_CALL ContentResultSetWrapper
1267     ::getLong( sal_Int32 columnIndex )
1268     throw( SQLException,
1269            RuntimeException )
1270 {
1271     XROW_GETXXX( getLong );
1272 }
1273
1274 //virtual
1275 float SAL_CALL ContentResultSetWrapper
1276     ::getFloat( sal_Int32 columnIndex )
1277     throw( SQLException,
1278            RuntimeException )
1279 {
1280     XROW_GETXXX( getFloat );
1281 }
1282
1283 //virtual
1284 double SAL_CALL ContentResultSetWrapper
1285     ::getDouble( sal_Int32 columnIndex )
1286     throw( SQLException,
1287            RuntimeException )
1288 {
1289     XROW_GETXXX( getDouble );
1290 }
1291
1292 //virtual
1293 Sequence< sal_Int8 > SAL_CALL ContentResultSetWrapper
1294     ::getBytes( sal_Int32 columnIndex )
1295     throw( SQLException,
1296            RuntimeException )
1297 {
1298     XROW_GETXXX( getBytes );
1299 }
1300
1301 //virtual
1302 Date SAL_CALL ContentResultSetWrapper
1303     ::getDate( sal_Int32 columnIndex )
1304     throw( SQLException,
1305            RuntimeException )
1306 {
1307     XROW_GETXXX( getDate );
1308 }
1309
1310 //virtual
1311 Time SAL_CALL ContentResultSetWrapper
1312     ::getTime( sal_Int32 columnIndex )
1313     throw( SQLException,
1314            RuntimeException )
1315 {
1316     XROW_GETXXX( getTime );
1317 }
1318
1319 //virtual
1320 DateTime SAL_CALL ContentResultSetWrapper
1321     ::getTimestamp( sal_Int32 columnIndex )
1322     throw( SQLException,
1323            RuntimeException )
1324 {
1325     XROW_GETXXX( getTimestamp );
1326 }
1327
1328 //virtual
1329 Reference< com::sun::star::io::XInputStream >
1330     SAL_CALL ContentResultSetWrapper
1331     ::getBinaryStream( sal_Int32 columnIndex )
1332     throw( SQLException,
1333            RuntimeException )
1334 {
1335     XROW_GETXXX( getBinaryStream );
1336 }
1337
1338 //virtual
1339 Reference< com::sun::star::io::XInputStream >
1340     SAL_CALL ContentResultSetWrapper
1341     ::getCharacterStream( sal_Int32 columnIndex )
1342     throw( SQLException,
1343            RuntimeException )
1344 {
1345     XROW_GETXXX( getCharacterStream );
1346 }
1347
1348 //virtual
1349 Any SAL_CALL ContentResultSetWrapper
1350     ::getObject( sal_Int32 columnIndex,
1351            const Reference<
1352             com::sun::star::container::XNameAccess >& typeMap )
1353     throw( SQLException,
1354            RuntimeException )
1355 {
1356     //if you change this macro please pay attention to
1357     //define XROW_GETXXX, where this is similar implemented
1358
1359     impl_EnsureNotDisposed();
1360     impl_init_xRowOrigin();
1361     if( !m_xRowOrigin.is() )
1362     {
1363         OSL_ENSURE( sal_False, "broadcaster was disposed already" );
1364         throw RuntimeException();
1365     }
1366     return m_xRowOrigin->getObject( columnIndex, typeMap );
1367 }
1368
1369 //virtual
1370 Reference< XRef > SAL_CALL ContentResultSetWrapper
1371     ::getRef( sal_Int32 columnIndex )
1372     throw( SQLException,
1373            RuntimeException )
1374 {
1375     XROW_GETXXX( getRef );
1376 }
1377
1378 //virtual
1379 Reference< XBlob > SAL_CALL ContentResultSetWrapper
1380     ::getBlob( sal_Int32 columnIndex )
1381     throw( SQLException,
1382            RuntimeException )
1383 {
1384     XROW_GETXXX( getBlob );
1385 }
1386
1387 //virtual
1388 Reference< XClob > SAL_CALL ContentResultSetWrapper
1389     ::getClob( sal_Int32 columnIndex )
1390     throw( SQLException,
1391            RuntimeException )
1392 {
1393     XROW_GETXXX( getClob );
1394 }
1395
1396 //virtual
1397 Reference< XArray > SAL_CALL ContentResultSetWrapper
1398     ::getArray( sal_Int32 columnIndex )
1399     throw( SQLException,
1400            RuntimeException )
1401 {
1402     XROW_GETXXX( getArray );
1403 }
1404
1405 //--------------------------------------------------------------------------
1406 //--------------------------------------------------------------------------
1407 // class ContentResultSetWrapperListener
1408 //--------------------------------------------------------------------------
1409 //--------------------------------------------------------------------------
1410
1411 ContentResultSetWrapperListener::ContentResultSetWrapperListener(
1412     ContentResultSetWrapper* pOwner )
1413     : m_pOwner( pOwner )
1414 {
1415 }
1416
1417 ContentResultSetWrapperListener::~ContentResultSetWrapperListener()
1418 {
1419 }
1420
1421 //--------------------------------------------------------------------------
1422 // XInterface methods.
1423 //--------------------------------------------------------------------------
1424 //list all interfaces inclusive baseclasses of interfaces
1425 XINTERFACE_COMMON_IMPL( ContentResultSetWrapperListener )
1426 QUERYINTERFACE_IMPL_START( ContentResultSetWrapperListener )
1427
1428     static_cast< XEventListener * >(
1429                      static_cast< XPropertyChangeListener * >(this))
1430     , SAL_STATIC_CAST( XPropertyChangeListener*, this )
1431     , SAL_STATIC_CAST( XVetoableChangeListener*, this )
1432
1433 QUERYINTERFACE_IMPL_END
1434
1435
1436 //--------------------------------------------------------------------------
1437 //XEventListener methods.
1438 //--------------------------------------------------------------------------
1439
1440 //virtual
1441 void SAL_CALL ContentResultSetWrapperListener
1442     ::disposing( const EventObject& rEventObject )
1443     throw( RuntimeException )
1444 {
1445     if( m_pOwner )
1446         m_pOwner->impl_disposing( rEventObject );
1447 }
1448
1449 //--------------------------------------------------------------------------
1450 //XPropertyChangeListener methods.
1451 //--------------------------------------------------------------------------
1452
1453 //virtual
1454 void SAL_CALL ContentResultSetWrapperListener
1455     ::propertyChange( const PropertyChangeEvent& rEvt )
1456     throw( RuntimeException )
1457 {
1458     if( m_pOwner )
1459         m_pOwner->impl_propertyChange( rEvt );
1460 }
1461
1462 //--------------------------------------------------------------------------
1463 //XVetoableChangeListener methods.
1464 //--------------------------------------------------------------------------
1465 //virtual
1466 void SAL_CALL ContentResultSetWrapperListener
1467     ::vetoableChange( const PropertyChangeEvent& rEvt )
1468     throw( PropertyVetoException,
1469            RuntimeException )
1470 {
1471     if( m_pOwner )
1472         m_pOwner->impl_vetoableChange( rEvt );
1473 }
1474
1475 void SAL_CALL ContentResultSetWrapperListener
1476     ::impl_OwnerDies()
1477 {
1478     m_pOwner = NULL;
1479 }
1480