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