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