ucb/source/cacher/dynamicresultsetwrapper.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 "dynamicresultsetwrapper.hxx"
  22 #include <cppuhelper/queryinterface.hxx>
  23 #include <osl/diagnose.h>
  24 #include <com/sun/star/ucb/AlreadyInitializedException.hpp>
  25 #include <com/sun/star/ucb/ListActionType.hpp>
  26 #include <com/sun/star/ucb/ListenerAlreadySetException.hpp>
  27 #include <com/sun/star/ucb/ServiceNotFoundException.hpp>
  28 #include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp>
  29 #include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp>
  30
  31 using namespace com::sun::star::lang;
  32 using namespace com::sun::star::sdbc;
  33 using namespace com::sun::star::ucb;
  34 using namespace com::sun::star::uno;
  35 using namespace comphelper;
  36
  37
  38
  39
  40 DynamicResultSetWrapper::DynamicResultSetWrapper(
  41                     Reference< XDynamicResultSet > const & xOrigin
  42                     , const Reference< XComponentContext > & rxContext )
  43
  44                 : m_bDisposed( false )
  45                 , m_bInDispose( false )
  46                 , m_xContext( rxContext )
  47                 , m_bStatic( false )
  48                 , m_bGotWelcome( false )
  49                 , m_xSource( xOrigin )
  50             //  , m_xSourceResultCurrent( NULL )
  51             //  , m_bUseOne( NULL )
  52 {
  53     m_xMyListenerImpl = new DynamicResultSetWrapperListener( this );
  54     //call impl_init() at the end of constructor of derived class
  55 };
  56
  57 void DynamicResultSetWrapper::impl_init()
  58 {
  59     //call this at the end of constructor of derived class
  60
  61
  62     Reference< XDynamicResultSet > xSource;
  63     {
  64         std::unique_lock aGuard( m_aMutex );
  65         xSource = m_xSource;
  66         m_xSource = nullptr;
  67     }
  68     if( xSource.is() )
  69         setSource( xSource );
  70 }
  71
  72 DynamicResultSetWrapper::~DynamicResultSetWrapper()
  73 {
  74     //call impl_deinit() at start of destructor of derived class
  75 };
  76
  77 void DynamicResultSetWrapper::impl_deinit()
  78 {
  79     //call this at start of destructor of derived class
  80
  81     m_xMyListenerImpl->impl_OwnerDies();
  82 }
  83
  84 void DynamicResultSetWrapper::impl_EnsureNotDisposed(std::unique_lock<std::mutex>& /*rGuard*/)
  85 {
  86     if( m_bDisposed )
  87         throw DisposedException();
  88 }
  89
  90 //virtual
  91 void DynamicResultSetWrapper::impl_InitResultSetOne( std::unique_lock<std::mutex>& /*rGuard*/, const Reference< XResultSet >& xResultSet )
  92 {
  93     OSL_ENSURE( !m_xSourceResultOne.is(), "Source ResultSet One is set already" );
  94     m_xSourceResultOne = xResultSet;
  95     m_xMyResultOne = xResultSet;
  96 }
  97
  98 //virtual
  99 void DynamicResultSetWrapper::impl_InitResultSetTwo( std::unique_lock<std::mutex>& /*rGuard*/, const Reference< XResultSet >& xResultSet )
 100 {
 101     OSL_ENSURE( !m_xSourceResultTwo.is(), "Source ResultSet Two is set already" );
 102     m_xSourceResultTwo = xResultSet;
 103     m_xMyResultTwo = xResultSet;
 104 }
 105
 106 // XInterface methods.
 107 css::uno::Any SAL_CALL DynamicResultSetWrapper::queryInterface( const css::uno::Type & rType )
 108 {
 109     //list all interfaces inclusive baseclasses of interfaces
 110     css::uno::Any aRet = cppu::queryInterface( rType,
 111                                                static_cast< XComponent* >(this), //base of XDynamicResultSet
 112                                                static_cast< XDynamicResultSet* >(this),
 113                                                static_cast< XSourceInitialization* >(this)
 114                                                );
 115     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 116 }
 117
 118 // XComponent methods.
 119
 120 // virtual
 121 void SAL_CALL DynamicResultSetWrapper::dispose()
 122 {
 123     std::unique_lock aGuard( m_aMutex );
 124     impl_EnsureNotDisposed(aGuard);
 125
 126     Reference< XComponent > xSourceComponent;
 127     if( m_bInDispose || m_bDisposed )
 128         return;
 129     m_bInDispose = true;
 130
 131     xSourceComponent = m_xSource;
 132
 133     if( m_aDisposeEventListeners.getLength(aGuard) )
 134     {
 135         EventObject aEvt;
 136         aEvt.Source = static_cast< XComponent * >( this );
 137         m_aDisposeEventListeners.disposeAndClear( aGuard, aEvt );
 138     }
 139
 140     /* //@todo ?? ( only if java collection needs to long )
 141     if( xSourceComponent.is() )
 142         xSourceComponent->dispose();
 143     */
 144
 145     m_bDisposed = true;
 146     m_bInDispose = false;
 147 }
 148
 149
 150 // virtual
 151 void SAL_CALL DynamicResultSetWrapper::addEventListener( const Reference< XEventListener >& Listener )
 152 {
 153     std::unique_lock aGuard( m_aMutex );
 154     impl_EnsureNotDisposed(aGuard);
 155
 156     m_aDisposeEventListeners.addInterface( aGuard, Listener );
 157 }
 158
 159
 160 // virtual
 161 void SAL_CALL DynamicResultSetWrapper::removeEventListener( const Reference< XEventListener >& Listener )
 162 {
 163     std::unique_lock aGuard( m_aMutex );
 164     impl_EnsureNotDisposed(aGuard);
 165
 166     m_aDisposeEventListeners.removeInterface( aGuard, Listener );
 167 }
 168
 169
 170 // own methods
 171
 172
 173 //virtual
 174 void DynamicResultSetWrapper::impl_disposing( const EventObject& )
 175 {
 176     std::unique_lock aGuard( m_aMutex );
 177
 178     impl_EnsureNotDisposed(aGuard);
 179
 180     if( !m_xSource.is() )
 181         return;
 182
 183     //release all references to the broadcaster:
 184     m_xSource.clear();
 185     m_xSourceResultOne.clear();//?? or only when not static??
 186     m_xSourceResultTwo.clear();//??
 187     //@todo m_xMyResultOne.clear(); ???
 188     //@todo m_xMyResultTwo.clear(); ???
 189 }
 190
 191 //virtual
 192 void DynamicResultSetWrapper::impl_notify( const ListEvent& Changes )
 193 {
 194     std::unique_lock aGuard( m_aMutex );
 195     impl_EnsureNotDisposed(aGuard);
 196     //@todo
 197     /*
 198     <p>The Listener is allowed to blockade this call, until he really want to go
 199     to the new version. The only situation, where the listener has to return the
 200     update call at once is, while he disposes his broadcaster or while he is
 201     removing himself as listener (otherwise you deadlock)!!!
 202     */
 203     // handle the actions in the list
 204
 205     ListEvent aNewEvent;
 206     aNewEvent.Source = static_cast< XDynamicResultSet * >( this );
 207     aNewEvent.Changes = Changes.Changes;
 208
 209     for( ListAction& rAction : asNonConstRange(aNewEvent.Changes) )
 210     {
 211         if (m_bGotWelcome)
 212             break;
 213
 214         switch( rAction.ListActionType )
 215         {
 216             case ListActionType::WELCOME:
 217             {
 218                 WelcomeDynamicResultSetStruct aWelcome;
 219                 if( rAction.ActionInfo >>= aWelcome )
 220                 {
 221                     impl_InitResultSetOne( aGuard, aWelcome.Old );
 222                     impl_InitResultSetTwo( aGuard, aWelcome.New );
 223                     m_bGotWelcome = true;
 224
 225                     aWelcome.Old = m_xMyResultOne;
 226                     aWelcome.New = m_xMyResultTwo;
 227
 228                     rAction.ActionInfo <<= aWelcome;
 229                 }
 230                 else
 231                 {
 232                     OSL_FAIL( "ListActionType was WELCOME but ActionInfo didn't contain a WelcomeDynamicResultSetStruct" );
 233                     //throw RuntimeException();
 234                 }
 235                 break;
 236             }
 237         }
 238     }
 239     OSL_ENSURE( m_bGotWelcome, "first notification was without WELCOME" );
 240
 241     aGuard.unlock();
 242
 243     if( !m_xListener.is() )
 244         m_aListenerSet.wait();
 245     m_xListener->notify( aNewEvent );
 246
 247     /*
 248     m_bUseOne = !m_bUseOne;
 249     if( m_bUseOne )
 250         m_xSourceResultCurrent = m_xSourceResultOne;
 251     else
 252         m_xSourceResultCurrent = m_xSourceResultTwo;
 253     */
 254 }
 255
 256
 257 // XSourceInitialization
 258
 259 //virtual
 260 void SAL_CALL DynamicResultSetWrapper::setSource( const Reference< XInterface > & Source )
 261 {
 262     std::unique_lock aGuard( m_aMutex );
 263     impl_EnsureNotDisposed(aGuard);
 264     if( m_xSource.is() )
 265         throw AlreadyInitializedException();
 266
 267     Reference< XDynamicResultSet > xSourceDynamic( Source, UNO_QUERY );
 268     OSL_ENSURE( xSourceDynamic.is(),
 269         "the given source is not of required type XDynamicResultSet" );
 270
 271     Reference< XDynamicResultSetListener > xListener;
 272     Reference< XDynamicResultSetListener > xMyListenerImpl;
 273
 274     bool bStatic = false;
 275     m_xSource = xSourceDynamic;
 276     xListener = m_xListener;
 277     bStatic = m_bStatic;
 278     xMyListenerImpl = m_xMyListenerImpl.get();
 279     if( xListener.is() )
 280         xSourceDynamic->setListener( m_xMyListenerImpl );
 281     else if( bStatic )
 282     {
 283         Reference< XComponent > xSourceComponent( Source, UNO_QUERY );
 284         xSourceComponent->addEventListener( xMyListenerImpl );
 285     }
 286     m_aSourceSet.set();
 287 }
 288
 289
 290 // XDynamicResultSet
 291
 292 //virtual
 293 Reference< XResultSet > SAL_CALL DynamicResultSetWrapper::getStaticResultSet()
 294 {
 295     std::unique_lock aGuard( m_aMutex );
 296     impl_EnsureNotDisposed(aGuard);
 297
 298     if( m_xListener.is() )
 299         throw ListenerAlreadySetException();
 300
 301     Reference< XDynamicResultSet > xSource = m_xSource;
 302     Reference< XEventListener > xMyListenerImpl = m_xMyListenerImpl;
 303     m_bStatic = true;
 304
 305     aGuard.unlock();
 306
 307     if( xSource.is() )
 308     {
 309         xSource->addEventListener( xMyListenerImpl );
 310     }
 311     if( !xSource.is() )
 312         m_aSourceSet.wait();
 313
 314     aGuard.lock();
 315
 316     Reference< XResultSet > xResultSet = xSource->getStaticResultSet();
 317     impl_InitResultSetOne( aGuard, xResultSet );
 318     return m_xMyResultOne;
 319 }
 320
 321 //virtual
 322 void SAL_CALL DynamicResultSetWrapper::setListener( const Reference< XDynamicResultSetListener > & Listener )
 323 {
 324     std::unique_lock aGuard( m_aMutex );
 325     impl_EnsureNotDisposed(aGuard);
 326
 327     if( m_xListener.is() )
 328         throw ListenerAlreadySetException();
 329     if( m_bStatic )
 330         throw ListenerAlreadySetException();
 331
 332     m_xListener = Listener;
 333     m_aDisposeEventListeners.addInterface( aGuard, Listener );
 334
 335     Reference< XDynamicResultSet > xSource = m_xSource;
 336     Reference< XDynamicResultSetListener > xMyListenerImpl = m_xMyListenerImpl;
 337
 338     aGuard.unlock();
 339
 340     if ( xSource.is() )
 341         xSource->setListener( xMyListenerImpl );
 342
 343     m_aListenerSet.set();
 344 }
 345
 346 //virtual
 347 void SAL_CALL DynamicResultSetWrapper::connectToCache( const Reference< XDynamicResultSet > & xCache )
 348 {
 349     std::unique_lock aGuard( m_aMutex );
 350     impl_EnsureNotDisposed(aGuard);
 351
 352     if( m_xListener.is() )
 353         throw ListenerAlreadySetException();
 354     if( m_bStatic )
 355         throw ListenerAlreadySetException();
 356     aGuard.unlock();
 357
 358     Reference< XSourceInitialization > xTarget( xCache, UNO_QUERY );
 359     OSL_ENSURE( xTarget.is(), "The given Target doesn't have the required interface 'XSourceInitialization'" );
 360     if( xTarget.is() && m_xContext.is() )
 361     {
 362         //@todo m_aSourceSet.wait();?
 363
 364         Reference< XCachedDynamicResultSetStubFactory > xStubFactory;
 365         try
 366         {
 367             xStubFactory = CachedDynamicResultSetStubFactory::create( m_xContext );
 368         }
 369         catch ( Exception const & )
 370         {
 371         }
 372
 373         if( xStubFactory.is() )
 374         {
 375             xStubFactory->connectToCache(
 376                   this, xCache, Sequence< NumberedSortingInfo > (), nullptr );
 377             return;
 378         }
 379     }
 380     OSL_FAIL( "could not connect to cache" );
 381     throw ServiceNotFoundException();
 382 }
 383
 384 //virtual
 385 sal_Int16 SAL_CALL DynamicResultSetWrapper::getCapabilities()
 386 {
 387     {
 388         std::unique_lock aGuard( m_aMutex );
 389         impl_EnsureNotDisposed(aGuard);
 390     }
 391     m_aSourceSet.wait();
 392     Reference< XDynamicResultSet > xSource;
 393     {
 394         std::unique_lock aGuard( m_aMutex );
 395         xSource = m_xSource;
 396     }
 397     return xSource->getCapabilities();
 398 }
 399
 400
 401
 402
 403 DynamicResultSetWrapperListener::DynamicResultSetWrapperListener(
 404         DynamicResultSetWrapper* pOwner )
 405         : m_pOwner( pOwner )
 406 {
 407
 408 }
 409
 410 DynamicResultSetWrapperListener::~DynamicResultSetWrapperListener()
 411 {
 412
 413 }
 414
 415
 416 // XInterface methods.
 417
 418 void SAL_CALL DynamicResultSetWrapperListener::acquire()
 419     noexcept
 420 {
 421     OWeakObject::acquire();
 422 }
 423
 424 void SAL_CALL DynamicResultSetWrapperListener::release()
 425     noexcept
 426 {
 427     OWeakObject::release();
 428 }
 429
 430 css::uno::Any SAL_CALL DynamicResultSetWrapperListener::queryInterface( const css::uno::Type & rType )
 431 {
 432     css::uno::Any aRet = cppu::queryInterface( rType,
 433                                                static_cast< XDynamicResultSetListener* >(this),
 434                                                static_cast< XEventListener* >(this)
 435                                                );
 436     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 437 }
 438
 439 // XDynamicResultSetListener methods:
 440
 441 //virtual
 442 void SAL_CALL DynamicResultSetWrapperListener::disposing( const EventObject& rEventObject )
 443 {
 444     std::unique_lock aGuard( m_aMutex );
 445
 446     if( m_pOwner )
 447         m_pOwner->impl_disposing( rEventObject );
 448 }
 449
 450 //virtual
 451 void SAL_CALL DynamicResultSetWrapperListener::notify( const ListEvent& Changes )
 452 {
 453     std::unique_lock aGuard( m_aMutex );
 454
 455     if( m_pOwner )
 456         m_pOwner->impl_notify( Changes );
 457 }
 458
 459
 460 // own methods:
 461
 462
 463 void DynamicResultSetWrapperListener::impl_OwnerDies()
 464 {
 465     std::unique_lock aGuard( m_aMutex );
 466
 467     m_pOwner = nullptr;
 468 }
 469
 470 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */