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