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