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
  21 #include <vector>
  22 #include <sortdynres.hxx>
  23 #include <cppuhelper/interfacecontainer.hxx>
  24 #include <com/sun/star/ucb/ContentResultSetCapability.hpp>
  25 #include <com/sun/star/ucb/ListActionType.hpp>
  26 #include <com/sun/star/ucb/WelcomeDynamicResultSetStruct.hpp>
  27 #include <com/sun/star/ucb/CachedDynamicResultSetStubFactory.hpp>
  28 #include <com/sun/star/ucb/XSourceInitialization.hpp>
  29
  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 cppu;
  37
  38
  39 //=========================================================================
  40
  41 //  The mutex to synchronize access to containers.
  42 static osl::Mutex& getContainerMutex()
  43 {
  44     static osl::Mutex* pMutex = NULL;
  45     if( !pMutex )
  46     {
  47         osl::Guard< osl::Mutex > aGuard( osl::Mutex::getGlobalMutex() );
  48         if( !pMutex )
  49         {
  50             static osl::Mutex aMutex;
  51             pMutex = &aMutex;
  52         }
  53     }
  54
  55     return *pMutex;
  56 }
  57
  58 //=========================================================================
  59 //
  60 // SortedDynamicResultSet
  61 //
  62 //=========================================================================
  63
  64 SortedDynamicResultSet::SortedDynamicResultSet(
  65                         const Reference < XDynamicResultSet > &xOriginal,
  66                         const Sequence < NumberedSortingInfo > &aOptions,
  67                         const Reference < XAnyCompareFactory > &xCompFac,
  68                         const Reference < XComponentContext > &rxContext )
  69 {
  70     mpDisposeEventListeners = NULL;
  71     mpOwnListener           = new SortedDynamicResultSetListener( this );
  72
  73     mxOwnListener = Reference< XDynamicResultSetListener >( mpOwnListener );
  74
  75     mxOriginal  = xOriginal;
  76     maOptions   = aOptions;
  77     mxCompFac   = xCompFac;
  78     m_xContext  = rxContext;
  79
  80     mpOne = NULL;
  81     mpTwo = NULL;
  82
  83     mbGotWelcome    = sal_False;
  84     mbUseOne        = sal_True;
  85     mbStatic        = sal_False;
  86 }
  87
  88 //--------------------------------------------------------------------------
  89 SortedDynamicResultSet::~SortedDynamicResultSet()
  90 {
  91     mpOwnListener->impl_OwnerDies();
  92     mxOwnListener.clear();
  93
  94     delete mpDisposeEventListeners;
  95
  96     mxOne.clear();
  97     mxTwo.clear();
  98     mxOriginal.clear();
  99
 100     mpOne = NULL;
 101     mpTwo = NULL;
 102 }
 103
 104 //--------------------------------------------------------------------------
 105 // XInterface methods.
 106 //--------------------------------------------------------------------------
 107
 108 XINTERFACE_IMPL_4( SortedDynamicResultSet,
 109                    XTypeProvider,
 110                    XServiceInfo,
 111                    XComponent,      /* base class of XDynamicResultSet */
 112                    XDynamicResultSet );
 113
 114 //--------------------------------------------------------------------------
 115 // XTypeProvider methods.
 116 //--------------------------------------------------------------------------
 117
 118 XTYPEPROVIDER_IMPL_3( SortedDynamicResultSet,
 119                       XTypeProvider,
 120                          XServiceInfo,
 121                       XDynamicResultSet );
 122
 123 //--------------------------------------------------------------------------
 124 // XServiceInfo methods.
 125 //--------------------------------------------------------------------------
 126
 127 XSERVICEINFO_NOFACTORY_IMPL_1( SortedDynamicResultSet,
 128                                    OUString( "com.sun.star.comp.ucb.SortedDynamicResultSet" ),
 129                                    OUString( DYNAMIC_RESULTSET_SERVICE_NAME ) );
 130
 131 //--------------------------------------------------------------------------
 132 // XComponent methods.
 133 //--------------------------------------------------------------------------
 134 void SAL_CALL SortedDynamicResultSet::dispose()
 135     throw( RuntimeException )
 136 {
 137     osl::Guard< osl::Mutex > aGuard( maMutex );
 138
 139     if ( mpDisposeEventListeners && mpDisposeEventListeners->getLength() )
 140     {
 141         EventObject aEvt;
 142         aEvt.Source = static_cast< XComponent * >( this );
 143         mpDisposeEventListeners->disposeAndClear( aEvt );
 144     }
 145
 146     mxOne.clear();
 147     mxTwo.clear();
 148     mxOriginal.clear();
 149
 150     mpOne = NULL;
 151     mpTwo = NULL;
 152     mbUseOne = sal_True;
 153 }
 154
 155 //--------------------------------------------------------------------------
 156 void SAL_CALL SortedDynamicResultSet::addEventListener(
 157                             const Reference< XEventListener >& Listener )
 158     throw( RuntimeException )
 159 {
 160     osl::Guard< osl::Mutex > aGuard( maMutex );
 161
 162     if ( !mpDisposeEventListeners )
 163         mpDisposeEventListeners =
 164                     new OInterfaceContainerHelper( getContainerMutex() );
 165
 166     mpDisposeEventListeners->addInterface( Listener );
 167 }
 168
 169 //--------------------------------------------------------------------------
 170 void SAL_CALL SortedDynamicResultSet::removeEventListener(
 171                             const Reference< XEventListener >& Listener )
 172     throw( RuntimeException )
 173 {
 174     osl::Guard< osl::Mutex > aGuard( maMutex );
 175
 176     if ( mpDisposeEventListeners )
 177         mpDisposeEventListeners->removeInterface( Listener );
 178 }
 179
 180 //--------------------------------------------------------------------------
 181 // XDynamicResultSet methods.
 182 // ------------------------------------------------------------------------------
 183 Reference< XResultSet > SAL_CALL
 184 SortedDynamicResultSet::getStaticResultSet()
 185     throw( ListenerAlreadySetException, RuntimeException )
 186 {
 187     osl::Guard< osl::Mutex > aGuard( maMutex );
 188
 189     if ( mxListener.is() )
 190         throw ListenerAlreadySetException();
 191
 192     mbStatic = sal_True;
 193
 194     if ( mxOriginal.is() )
 195     {
 196         mpOne = new SortedResultSet( mxOriginal->getStaticResultSet() );
 197         mxOne = mpOne;
 198         mpOne->Initialize( maOptions, mxCompFac );
 199     }
 200
 201     return mxOne;
 202 }
 203
 204 // ------------------------------------------------------------------------------
 205 void SAL_CALL
 206 SortedDynamicResultSet::setListener( const Reference< XDynamicResultSetListener >& Listener )
 207     throw( ListenerAlreadySetException, RuntimeException )
 208 {
 209     osl::Guard< osl::Mutex > aGuard( maMutex );
 210
 211     if ( mxListener.is() )
 212         throw ListenerAlreadySetException();
 213
 214     addEventListener( Reference< XEventListener >::query( Listener ) );
 215
 216     mxListener = Listener;
 217
 218     if ( mxOriginal.is() )
 219         mxOriginal->setListener( mxOwnListener );
 220 }
 221
 222 // ------------------------------------------------------------------------------
 223 void SAL_CALL
 224 SortedDynamicResultSet::connectToCache(
 225         const Reference< XDynamicResultSet > & xCache )
 226         throw( ListenerAlreadySetException,
 227                AlreadyInitializedException,
 228                ServiceNotFoundException,
 229                RuntimeException )
 230 {
 231     if( mxListener.is() )
 232         throw ListenerAlreadySetException();
 233
 234     if( mbStatic )
 235         throw ListenerAlreadySetException();
 236
 237     Reference< XSourceInitialization > xTarget( xCache, UNO_QUERY );
 238     if( xTarget.is() && m_xContext.is() )
 239     {
 240         Reference< XCachedDynamicResultSetStubFactory > xStubFactory;
 241         try
 242         {
 243             xStubFactory = CachedDynamicResultSetStubFactory::create( m_xContext );
 244         }
 245         catch ( Exception const & )
 246         {
 247         }
 248
 249         if( xStubFactory.is() )
 250         {
 251             xStubFactory->connectToCache(
 252                   this, xCache, Sequence< NumberedSortingInfo > (), NULL );
 253             return;
 254         }
 255     }
 256     throw ServiceNotFoundException();
 257 }
 258
 259 // ------------------------------------------------------------------------------
 260 sal_Int16 SAL_CALL
 261 SortedDynamicResultSet::getCapabilities()
 262     throw( RuntimeException )
 263 {
 264     osl::Guard< osl::Mutex > aGuard( maMutex );
 265
 266     sal_Int16 nCaps = 0;
 267
 268     if ( mxOriginal.is() )
 269         nCaps = mxOriginal->getCapabilities();
 270
 271     nCaps |= ContentResultSetCapability::SORTED;
 272
 273     return nCaps;
 274 }
 275
 276 //--------------------------------------------------------------------------
 277 // XDynamicResultSetListener methods.
 278 // ------------------------------------------------------------------------------
 279
 280 /** In the first notify-call the listener gets the two
 281  <type>XResultSet</type>s and has to hold them. The <type>XResultSet</type>s
 282  are implementations of the service <type>ContentResultSet</type>.
 283
 284  <p>The notified new <type>XResultSet</type> will stay valid after returning
 285  notification. The old one will become invalid after returning notification.
 286
 287  <p>While in notify-call the listener is allowed to read old and new version,
 288  except in the first call, where only the new Resultset is valid.
 289
 290  <p>The Listener is allowed to blockade this call, until he really want to go
 291  to the new version. The only situation, where the listener has to return the
 292  update call at once is, while he disposes his broadcaster or while he is
 293  removing himsef as listener (otherwise you deadlock)!!!
 294 */
 295 void SAL_CALL
 296 SortedDynamicResultSet::impl_notify( const ListEvent& Changes )
 297     throw( RuntimeException )
 298 {
 299     osl::Guard< osl::Mutex > aGuard( maMutex );
 300
 301     sal_Bool bHasNew = sal_False;
 302     sal_Bool bHasModified = sal_False;
 303
 304     SortedResultSet *pCurSet = NULL;
 305
 306     // exchange mxNew and mxOld and immediately afterwards copy the tables
 307     // from Old to New
 308     if ( mbGotWelcome )
 309     {
 310         if ( mbUseOne )
 311         {
 312             mbUseOne = sal_False;
 313             mpTwo->CopyData( mpOne );
 314             pCurSet = mpTwo;
 315         }
 316         else
 317         {
 318             mbUseOne = sal_True;
 319             mpOne->CopyData( mpTwo );
 320             pCurSet = mpOne;
 321         }
 322     }
 323
 324     Any  aRet;
 325
 326     try {
 327         aRet = pCurSet->getPropertyValue( OUString("IsRowCountFinal") );
 328     }
 329     catch (const UnknownPropertyException&) {}
 330     catch (const WrappedTargetException&) {}
 331
 332     long nOldCount = pCurSet->GetCount();
 333     sal_Bool bWasFinal = false;
 334
 335     aRet >>= bWasFinal;
 336
 337     // handle the actions in the list
 338     for ( long i=0; i<Changes.Changes.getLength(); i++ )
 339     {
 340         const ListAction aAction = Changes.Changes[i];
 341         switch ( aAction.ListActionType )
 342         {
 343             case ListActionType::WELCOME:
 344                 {
 345                     WelcomeDynamicResultSetStruct aWelcome;
 346                     if ( aAction.ActionInfo >>= aWelcome )
 347                     {
 348                         mpTwo = new SortedResultSet( aWelcome.Old );
 349                         mxTwo = mpTwo;
 350                         mpOne = new SortedResultSet( aWelcome.New );
 351                         mxOne = mpOne;
 352                         mpOne->Initialize( maOptions, mxCompFac );
 353                         mbGotWelcome = sal_True;
 354                         mbUseOne = sal_True;
 355                         pCurSet = mpOne;
 356
 357                         aWelcome.Old = mxTwo;
 358                         aWelcome.New = mxOne;
 359
 360                         ListAction *pWelcomeAction = new ListAction;
 361                         pWelcomeAction->ActionInfo <<= aWelcome;
 362                         pWelcomeAction->Position = 0;
 363                         pWelcomeAction->Count = 0;
 364                         pWelcomeAction->ListActionType = ListActionType::WELCOME;
 365
 366                         maActions.Insert( pWelcomeAction );
 367                     }
 368                     else
 369                     {
 370                         // throw RuntimeException();
 371                     }
 372                     break;
 373                 }
 374             case ListActionType::INSERTED:
 375                 {
 376                     pCurSet->InsertNew( aAction.Position, aAction.Count );
 377                     bHasNew = sal_True;
 378                     break;
 379                 }
 380             case ListActionType::REMOVED:
 381                 {
 382                     pCurSet->Remove( aAction.Position,
 383                                      aAction.Count,
 384                                      &maActions );
 385                     break;
 386                 }
 387             case ListActionType::MOVED:
 388                 {
 389                     long nOffset = 0;
 390                     if ( aAction.ActionInfo >>= nOffset )
 391                     {
 392                         pCurSet->Move( aAction.Position,
 393                                        aAction.Count,
 394                                        nOffset );
 395                     }
 396                     break;
 397                 }
 398             case ListActionType::PROPERTIES_CHANGED:
 399                 {
 400                     pCurSet->SetChanged( aAction.Position, aAction.Count );
 401                     bHasModified = sal_True;
 402                     break;
 403                 }
 404             default: break;
 405         }
 406     }
 407
 408     if ( bHasModified )
 409         pCurSet->ResortModified( &maActions );
 410
 411     if ( bHasNew )
 412         pCurSet->ResortNew( &maActions );
 413
 414     // send the new actions with a notify to the listeners
 415     SendNotify();
 416
 417     // check for propertyChangeEvents
 418     pCurSet->CheckProperties( nOldCount, bWasFinal );
 419 }
 420
 421 //-----------------------------------------------------------------
 422 // XEventListener
 423 //-----------------------------------------------------------------
 424 void SAL_CALL
 425 SortedDynamicResultSet::impl_disposing( const EventObject& )
 426     throw( RuntimeException )
 427 {
 428     mxListener.clear();
 429     mxOriginal.clear();
 430 }
 431
 432 // ------------------------------------------------------------------------------
 433 // private methods
 434 // ------------------------------------------------------------------------------
 435 void SortedDynamicResultSet::SendNotify()
 436 {
 437     long nCount = maActions.Count();
 438
 439     if ( nCount && mxListener.is() )
 440     {
 441         Sequence< ListAction > aActionList( maActions.Count() );
 442         ListAction *pActionList = aActionList.getArray();
 443
 444         for ( long i=0; i<nCount; i++ )
 445         {
 446             pActionList[ i ] = *(maActions.GetAction( i ));
 447         }
 448
 449         ListEvent aNewEvent;
 450         aNewEvent.Changes = aActionList;
 451
 452         mxListener->notify( aNewEvent );
 453     }
 454
 455     // clean up
 456     maActions.Clear();
 457 }
 458
 459 //=========================================================================
 460 //
 461 // SortedDynamicResultSetFactory
 462 //
 463 //=========================================================================
 464 SortedDynamicResultSetFactory::SortedDynamicResultSetFactory(
 465                         const Reference< XComponentContext > & rxContext )
 466 {
 467     m_xContext = rxContext;
 468 }
 469
 470 //--------------------------------------------------------------------------
 471 SortedDynamicResultSetFactory::~SortedDynamicResultSetFactory()
 472 {
 473 }
 474
 475 //--------------------------------------------------------------------------
 476 // XInterface methods.
 477 //--------------------------------------------------------------------------
 478
 479 XINTERFACE_IMPL_3( SortedDynamicResultSetFactory,
 480                    XTypeProvider,
 481                    XServiceInfo,
 482                    XSortedDynamicResultSetFactory );
 483
 484 //--------------------------------------------------------------------------
 485 // XTypeProvider methods.
 486 //--------------------------------------------------------------------------
 487
 488 XTYPEPROVIDER_IMPL_3( SortedDynamicResultSetFactory,
 489                       XTypeProvider,
 490                          XServiceInfo,
 491                       XSortedDynamicResultSetFactory );
 492
 493 //--------------------------------------------------------------------------
 494 // XServiceInfo methods.
 495 //--------------------------------------------------------------------------
 496
 497 XSERVICEINFO_IMPL_1_CTX( SortedDynamicResultSetFactory,
 498                          OUString( "com.sun.star.comp.ucb.SortedDynamicResultSetFactory" ),
 499                          OUString( DYNAMIC_RESULTSET_FACTORY_NAME ) );
 500
 501 //--------------------------------------------------------------------------
 502 // Service factory implementation.
 503 //--------------------------------------------------------------------------
 504
 505 ONE_INSTANCE_SERVICE_FACTORY_IMPL( SortedDynamicResultSetFactory );
 506
 507 //--------------------------------------------------------------------------
 508 // SortedDynamicResultSetFactory methods.
 509 //--------------------------------------------------------------------------
 510 Reference< XDynamicResultSet > SAL_CALL
 511 SortedDynamicResultSetFactory::createSortedDynamicResultSet(
 512                 const Reference< XDynamicResultSet > & Source,
 513                 const Sequence< NumberedSortingInfo > & Info,
 514                 const Reference< XAnyCompareFactory > & CompareFactory )
 515     throw( RuntimeException )
 516 {
 517     Reference< XDynamicResultSet > xRet;
 518     xRet = new SortedDynamicResultSet( Source, Info, CompareFactory, m_xContext );
 519     return xRet;
 520 }
 521
 522 //=========================================================================
 523 //
 524 // EventList
 525 //
 526 //=========================================================================
 527
 528 void EventList::Clear()
 529 {
 530     for ( std::deque< ListAction* >::size_type i = 0;
 531           i < maData.size(); ++i )
 532     {
 533         delete maData[i];
 534     }
 535
 536     maData.clear();
 537 }
 538
 539 //--------------------------------------------------------------------------
 540 void EventList::AddEvent( long nType, long nPos, long nCount )
 541 {
 542     ListAction *pAction = new ListAction;
 543     pAction->Position = nPos;
 544     pAction->Count = nCount;
 545     pAction->ListActionType = nType;
 546
 547     Insert( pAction );
 548 }
 549
 550 //=================================================================
 551 //
 552 // SortedDynamicResultSetListener
 553 //
 554 //=================================================================
 555
 556 SortedDynamicResultSetListener::SortedDynamicResultSetListener(
 557                                 SortedDynamicResultSet *mOwner )
 558 {
 559     mpOwner = mOwner;
 560 }
 561
 562 //-----------------------------------------------------------------
 563 SortedDynamicResultSetListener::~SortedDynamicResultSetListener()
 564 {
 565 }
 566
 567 //-----------------------------------------------------------------
 568 // XInterface methods.
 569 //-----------------------------------------------------------------
 570
 571 XINTERFACE_IMPL_2( SortedDynamicResultSetListener,
 572                    XEventListener,  /* base class of XDynamicResultSetListener */
 573                    XDynamicResultSetListener );
 574
 575 //-----------------------------------------------------------------
 576 // XEventListener ( base of XDynamicResultSetListener )
 577 //-----------------------------------------------------------------
 578 void SAL_CALL
 579 SortedDynamicResultSetListener::disposing( const EventObject& Source )
 580     throw( RuntimeException )
 581 {
 582     osl::Guard< osl::Mutex > aGuard( maMutex );
 583
 584     if ( mpOwner )
 585         mpOwner->impl_disposing( Source );
 586 }
 587
 588 //-----------------------------------------------------------------
 589 // XDynamicResultSetListener
 590 //-----------------------------------------------------------------
 591 void SAL_CALL
 592 SortedDynamicResultSetListener::notify( const ListEvent& Changes )
 593     throw( RuntimeException )
 594 {
 595     osl::Guard< osl::Mutex > aGuard( maMutex );
 596
 597     if ( mpOwner )
 598         mpOwner->impl_notify( Changes );
 599 }
 600
 601 //-----------------------------------------------------------------
 602 // own methods:
 603 //-----------------------------------------------------------------
 604 void SAL_CALL
 605 SortedDynamicResultSetListener::impl_OwnerDies()
 606 {
 607     osl::Guard< osl::Mutex > aGuard( maMutex );
 608     mpOwner = NULL;
 609 }
 610
 611 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */