ucb/source/sorter/sortdynres.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sortdynres.hxx"
  21 #include <cppuhelper/supportsservice.hxx>
  22 #include <cppuhelper/weak.hxx>
  23 #include <com/sun/star/ucb/ContentResultSetCapability.hpp>
  24 #include <com/sun/star/ucb/ListActionType.hpp>
  25 #include <com/sun/star/ucb/ListenerAlreadySetException.hpp>
  26 #include <com/sun/star/ucb/ServiceNotFoundException.hpp>
  27 #include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp>
  28 #include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp>
  29 #include <com/sun/star/ucb/XSourceInitialization.hpp>
  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 comphelper;
  37
  38
  39 // SortedDynamicResultSet
  40
  41 SortedDynamicResultSet::SortedDynamicResultSet(
  42                         const Reference < XDynamicResultSet > &xOriginal,
  43                         const Sequence < NumberedSortingInfo > &aOptions,
  44                         const Reference < XAnyCompareFactory > &xCompFac,
  45                         const Reference < XComponentContext > &rxContext )
  46 {
  47     mxOwnListener           = new SortedDynamicResultSetListener( this );
  48
  49     mxOriginal  = xOriginal;
  50     maOptions   = aOptions;
  51     mxCompFac   = xCompFac;
  52     m_xContext  = rxContext;
  53
  54     mbGotWelcome    = false;
  55     mbUseOne        = true;
  56     mbStatic        = false;
  57 }
  58
  59
  60 SortedDynamicResultSet::~SortedDynamicResultSet()
  61 {
  62     mxOwnListener->impl_OwnerDies();
  63     mxOwnListener.clear();
  64
  65     {
  66         std::unique_lock aGuard(maMutex);
  67         maDisposeEventListeners.clear(aGuard);
  68     }
  69
  70     mxOne.clear();
  71     mxTwo.clear();
  72     mxOriginal.clear();
  73 }
  74
  75 // XServiceInfo methods.
  76
  77 OUString SAL_CALL SortedDynamicResultSet::getImplementationName()
  78 {
  79     return "com.sun.star.comp.ucb.SortedDynamicResultSet";
  80 }
  81
  82 sal_Bool SAL_CALL SortedDynamicResultSet::supportsService( const OUString& ServiceName )
  83 {
  84     return cppu::supportsService( this, ServiceName );
  85 }
  86
  87 css::uno::Sequence< OUString > SAL_CALL SortedDynamicResultSet::getSupportedServiceNames()
  88 {
  89     return { "com.sun.star.ucb.SortedDynamicResultSet" };
  90 }
  91
  92 // XComponent methods.
  93
  94 void SAL_CALL SortedDynamicResultSet::dispose()
  95 {
  96     std::unique_lock aGuard( maMutex );
  97
  98     if ( maDisposeEventListeners.getLength(aGuard) )
  99     {
 100         EventObject aEvt;
 101         aEvt.Source = static_cast< XComponent * >( this );
 102         maDisposeEventListeners.disposeAndClear( aGuard, aEvt );
 103     }
 104
 105     mxOne.clear();
 106     mxTwo.clear();
 107     mxOriginal.clear();
 108
 109     mbUseOne = true;
 110 }
 111
 112 void SAL_CALL SortedDynamicResultSet::addEventListener(
 113                             const Reference< XEventListener >& Listener )
 114 {
 115     std::unique_lock aGuard( maMutex );
 116
 117     maDisposeEventListeners.addInterface( aGuard, Listener );
 118 }
 119
 120 void SAL_CALL SortedDynamicResultSet::removeEventListener(
 121                             const Reference< XEventListener >& Listener )
 122 {
 123     std::unique_lock aGuard( maMutex );
 124
 125     maDisposeEventListeners.removeInterface( aGuard, Listener );
 126 }
 127
 128
 129 // XDynamicResultSet methods.
 130
 131 Reference< XResultSet > SAL_CALL
 132 SortedDynamicResultSet::getStaticResultSet()
 133 {
 134     std::unique_lock aGuard( maMutex );
 135
 136     if ( mxListener.is() )
 137         throw ListenerAlreadySetException();
 138
 139     mbStatic = true;
 140
 141     if ( mxOriginal.is() )
 142     {
 143         mxOne = new SortedResultSet( mxOriginal->getStaticResultSet() );
 144         mxOne->Initialize( maOptions, mxCompFac );
 145     }
 146
 147     return mxOne;
 148 }
 149
 150
 151 void SAL_CALL
 152 SortedDynamicResultSet::setListener( const Reference< XDynamicResultSetListener >& Listener )
 153 {
 154     std::unique_lock aGuard( maMutex );
 155
 156     if ( mxListener.is() )
 157         throw ListenerAlreadySetException();
 158
 159     maDisposeEventListeners.addInterface( aGuard, Listener );
 160
 161     mxListener = Listener;
 162
 163     if ( mxOriginal.is() )
 164         mxOriginal->setListener( mxOwnListener );
 165 }
 166
 167
 168 void SAL_CALL
 169 SortedDynamicResultSet::connectToCache( const Reference< XDynamicResultSet > & xCache )
 170 {
 171     if( mxListener.is() )
 172         throw ListenerAlreadySetException();
 173
 174     if( mbStatic )
 175         throw ListenerAlreadySetException();
 176
 177     Reference< XSourceInitialization > xTarget( xCache, UNO_QUERY );
 178     if( xTarget.is() && m_xContext.is() )
 179     {
 180         Reference< XCachedDynamicResultSetStubFactory > xStubFactory;
 181         try
 182         {
 183             xStubFactory = CachedDynamicResultSetStubFactory::create( m_xContext );
 184         }
 185         catch ( Exception const & )
 186         {
 187         }
 188
 189         if( xStubFactory.is() )
 190         {
 191             xStubFactory->connectToCache(
 192                   this, xCache, Sequence< NumberedSortingInfo > (), nullptr );
 193             return;
 194         }
 195     }
 196     throw ServiceNotFoundException();
 197 }
 198
 199
 200 sal_Int16 SAL_CALL SortedDynamicResultSet::getCapabilities()
 201 {
 202     std::unique_lock aGuard( maMutex );
 203
 204     sal_Int16 nCaps = 0;
 205
 206     if ( mxOriginal.is() )
 207         nCaps = mxOriginal->getCapabilities();
 208
 209     nCaps |= ContentResultSetCapability::SORTED;
 210
 211     return nCaps;
 212 }
 213
 214
 215 // XDynamicResultSetListener methods.
 216
 217
 218 /** In the first notify-call the listener gets the two
 219  <type>XResultSet</type>s and has to hold them. The <type>XResultSet</type>s
 220  are implementations of the service <type>ContentResultSet</type>.
 221
 222  <p>The notified new <type>XResultSet</type> will stay valid after returning
 223  notification. The old one will become invalid after returning notification.
 224
 225  <p>While in notify-call the listener is allowed to read old and new version,
 226  except in the first call, where only the new Resultset is valid.
 227
 228  <p>The Listener is allowed to blockade this call, until he really want to go
 229  to the new version. The only situation, where the listener has to return the
 230  update call at once is, while he disposes his broadcaster or while he is
 231  removing himself as listener (otherwise you deadlock)!!!
 232 */
 233 void SortedDynamicResultSet::impl_notify( const ListEvent& Changes )
 234 {
 235     std::unique_lock aGuard( maMutex );
 236
 237     bool bHasNew = false;
 238     bool bHasModified = false;
 239
 240     SortedResultSet *pCurSet = nullptr;
 241
 242     // exchange mxNew and mxOld and immediately afterwards copy the tables
 243     // from Old to New
 244     if ( mbGotWelcome )
 245     {
 246         if ( mbUseOne )
 247         {
 248             mbUseOne = false;
 249             mxTwo->CopyData( mxOne.get() );
 250             pCurSet = mxTwo.get();
 251         }
 252         else
 253         {
 254             mbUseOne = true;
 255             mxOne->CopyData( mxTwo.get() );
 256             pCurSet = mxOne.get();
 257         }
 258     }
 259
 260     if (!pCurSet)
 261         return;
 262
 263     Any  aRet;
 264
 265     try {
 266         aRet = pCurSet->getPropertyValue("IsRowCountFinal");
 267     }
 268     catch (const UnknownPropertyException&) {}
 269     catch (const WrappedTargetException&) {}
 270
 271     sal_Int32 nOldCount = pCurSet->GetCount();
 272     bool bWasFinal = false;
 273
 274     aRet >>= bWasFinal;
 275
 276     // handle the actions in the list
 277     for ( const ListAction& aAction : Changes.Changes )
 278     {
 279         switch ( aAction.ListActionType )
 280         {
 281             case ListActionType::WELCOME:
 282                 {
 283                     WelcomeDynamicResultSetStruct aWelcome;
 284                     if ( aAction.ActionInfo >>= aWelcome )
 285                     {
 286                         mxTwo = new SortedResultSet( aWelcome.Old );
 287                         mxOne = new SortedResultSet( aWelcome.New );
 288                         mxOne->Initialize( maOptions, mxCompFac );
 289                         mbGotWelcome = true;
 290                         mbUseOne = true;
 291                         pCurSet = mxOne.get();
 292
 293                         aWelcome.Old = mxTwo.get();
 294                         aWelcome.New = mxOne.get();
 295
 296                         ListAction aWelcomeAction;
 297                         aWelcomeAction.ActionInfo <<= aWelcome;
 298                         aWelcomeAction.Position = 0;
 299                         aWelcomeAction.Count = 0;
 300                         aWelcomeAction.ListActionType = ListActionType::WELCOME;
 301
 302                         maActions.Insert( aWelcomeAction );
 303                     }
 304                     else
 305                     {
 306                         // throw RuntimeException();
 307                     }
 308                     break;
 309                 }
 310             case ListActionType::INSERTED:
 311                 {
 312                     pCurSet->InsertNew( aAction.Position, aAction.Count );
 313                     bHasNew = true;
 314                     break;
 315                 }
 316             case ListActionType::REMOVED:
 317                 {
 318                     pCurSet->Remove( aAction.Position,
 319                                      aAction.Count,
 320                                      &maActions );
 321                     break;
 322                 }
 323             case ListActionType::MOVED:
 324                 {
 325                     sal_Int32 nOffset = 0;
 326                     if ( aAction.ActionInfo >>= nOffset )
 327                     {
 328                         pCurSet->Move( aAction.Position,
 329                                        aAction.Count,
 330                                        nOffset );
 331                     }
 332                     break;
 333                 }
 334             case ListActionType::PROPERTIES_CHANGED:
 335                 {
 336                     pCurSet->SetChanged( aAction.Position, aAction.Count );
 337                     bHasModified = true;
 338                     break;
 339                 }
 340             default: break;
 341         }
 342     }
 343
 344     if ( bHasModified )
 345         pCurSet->ResortModified( &maActions );
 346
 347     if ( bHasNew )
 348         pCurSet->ResortNew( &maActions );
 349
 350     // send the new actions with a notify to the listeners
 351     SendNotify();
 352
 353     // check for propertyChangeEvents
 354     pCurSet->CheckProperties( nOldCount, bWasFinal );
 355 }
 356
 357 // XEventListener
 358
 359 void SortedDynamicResultSet::impl_disposing()
 360 {
 361     mxListener.clear();
 362     mxOriginal.clear();
 363 }
 364
 365 // private methods
 366
 367 void SortedDynamicResultSet::SendNotify()
 368 {
 369     sal_Int32 nCount = maActions.Count();
 370
 371     if ( nCount && mxListener.is() )
 372     {
 373         Sequence< ListAction > aActionList( maActions.Count() );
 374         ListAction *pActionList = aActionList.getArray();
 375
 376         for ( sal_Int32 i=0; i<nCount; i++ )
 377         {
 378             pActionList[ i ] = maActions.GetAction( i );
 379         }
 380
 381         ListEvent aNewEvent;
 382         aNewEvent.Changes = aActionList;
 383
 384         mxListener->notify( aNewEvent );
 385     }
 386
 387     // clean up
 388     maActions.Clear();
 389 }
 390
 391 // SortedDynamicResultSetFactory
 392
 393 SortedDynamicResultSetFactory::SortedDynamicResultSetFactory(
 394                         const Reference< XComponentContext > & rxContext )
 395 {
 396     m_xContext = rxContext;
 397 }
 398
 399
 400 SortedDynamicResultSetFactory::~SortedDynamicResultSetFactory()
 401 {
 402 }
 403
 404
 405 // XServiceInfo methods.
 406
 407 OUString SAL_CALL SortedDynamicResultSetFactory::getImplementationName()
 408 {
 409     return "com.sun.star.comp.ucb.SortedDynamicResultSetFactory";
 410 }
 411
 412 sal_Bool SAL_CALL SortedDynamicResultSetFactory::supportsService( const OUString& ServiceName )
 413 {
 414     return cppu::supportsService( this, ServiceName );
 415 }
 416
 417 css::uno::Sequence< OUString > SAL_CALL SortedDynamicResultSetFactory::getSupportedServiceNames()
 418 {
 419     return { "com.sun.star.ucb.SortedDynamicResultSetFactory" };
 420 }
 421
 422
 423 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 424 ucb_SortedDynamicResultSetFactory_get_implementation(
 425     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 426 {
 427     return cppu::acquire(new SortedDynamicResultSetFactory(context));
 428 }
 429
 430 // SortedDynamicResultSetFactory methods.
 431
 432 Reference< XDynamicResultSet > SAL_CALL
 433 SortedDynamicResultSetFactory::createSortedDynamicResultSet(
 434                 const Reference< XDynamicResultSet > & Source,
 435                 const Sequence< NumberedSortingInfo > & Info,
 436                 const Reference< XAnyCompareFactory > & CompareFactory )
 437 {
 438     Reference< XDynamicResultSet > xRet = new SortedDynamicResultSet( Source, Info, CompareFactory, m_xContext );
 439     return xRet;
 440 }
 441
 442 // EventList
 443
 444 void EventList::Clear()
 445 {
 446     maData.clear();
 447 }
 448
 449 void EventList::AddEvent( sal_IntPtr nType, sal_Int32 nPos )
 450 {
 451     ListAction aAction;
 452     aAction.Position = nPos;
 453     aAction.Count = 1;
 454     aAction.ListActionType = nType;
 455
 456     Insert( aAction );
 457 }
 458
 459 // SortedDynamicResultSetListener
 460
 461 SortedDynamicResultSetListener::SortedDynamicResultSetListener(
 462                                 SortedDynamicResultSet *mOwner )
 463 {
 464     mpOwner = mOwner;
 465 }
 466
 467
 468 SortedDynamicResultSetListener::~SortedDynamicResultSetListener()
 469 {
 470 }
 471
 472 // XEventListener ( base of XDynamicResultSetListener )
 473
 474 void SAL_CALL
 475 SortedDynamicResultSetListener::disposing( const EventObject& /*Source*/ )
 476 {
 477     std::unique_lock aGuard( maMutex );
 478
 479     if ( mpOwner )
 480         mpOwner->impl_disposing();
 481 }
 482
 483
 484 // XDynamicResultSetListener
 485
 486 void SAL_CALL
 487 SortedDynamicResultSetListener::notify( const ListEvent& Changes )
 488 {
 489     std::unique_lock aGuard( maMutex );
 490
 491     if ( mpOwner )
 492         mpOwner->impl_notify( Changes );
 493 }
 494
 495 // own methods:
 496
 497 void
 498 SortedDynamicResultSetListener::impl_OwnerDies()
 499 {
 500     std::unique_lock aGuard( maMutex );
 501     mpOwner = nullptr;
 502 }
 503
 504 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */