ucb/source/cacher/contentresultsetwrapper.cxx

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