xref: /trunk/main/ucb/source/cacher/contentresultsetwrapper.cxx (revision 45c5a00162811bd03b87fcb4fe9996782f2b59ec) 
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 
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 
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 
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 
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 
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 
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 
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
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
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
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
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
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
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
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 
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
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
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
466     ::close()
467 {
468     impl_EnsureNotDisposed();
469     dispose();
470 }
471 
472 //--------------------------------------------------------------------------
473 //XResultSetMetaDataSupplier methods.
474 //--------------------------------------------------------------------------
475 //virtual
476 Reference< XResultSetMetaData > SAL_CALL ContentResultSetWrapper
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1141     ::getString( sal_Int32 columnIndex )
1142 {
1143     XROW_GETXXX( getString );
1144 }
1145 
1146 //virtual
1147 sal_Bool SAL_CALL ContentResultSetWrapper
1148     ::getBoolean( sal_Int32 columnIndex )
1149 {
1150     XROW_GETXXX( getBoolean );
1151 }
1152 
1153 //virtual
1154 sal_Int8 SAL_CALL ContentResultSetWrapper
1155     ::getByte( sal_Int32 columnIndex )
1156 {
1157     XROW_GETXXX( getByte );
1158 }
1159 
1160 //virtual
1161 sal_Int16 SAL_CALL ContentResultSetWrapper
1162     ::getShort( sal_Int32 columnIndex )
1163 {
1164     XROW_GETXXX( getShort );
1165 }
1166 
1167 //virtual
1168 sal_Int32 SAL_CALL ContentResultSetWrapper
1169     ::getInt( sal_Int32 columnIndex )
1170 {
1171     XROW_GETXXX( getInt );
1172 }
1173 
1174 //virtual
1175 sal_Int64 SAL_CALL ContentResultSetWrapper
1176     ::getLong( sal_Int32 columnIndex )
1177 {
1178     XROW_GETXXX( getLong );
1179 }
1180 
1181 //virtual
1182 float SAL_CALL ContentResultSetWrapper
1183     ::getFloat( sal_Int32 columnIndex )
1184 {
1185     XROW_GETXXX( getFloat );
1186 }
1187 
1188 //virtual
1189 double SAL_CALL ContentResultSetWrapper
1190     ::getDouble( sal_Int32 columnIndex )
1191 {
1192     XROW_GETXXX( getDouble );
1193 }
1194 
1195 //virtual
1196 Sequence< sal_Int8 > SAL_CALL ContentResultSetWrapper
1197     ::getBytes( sal_Int32 columnIndex )
1198 {
1199     XROW_GETXXX( getBytes );
1200 }
1201 
1202 //virtual
1203 Date SAL_CALL ContentResultSetWrapper
1204     ::getDate( sal_Int32 columnIndex )
1205 {
1206     XROW_GETXXX( getDate );
1207 }
1208 
1209 //virtual
1210 Time SAL_CALL ContentResultSetWrapper
1211     ::getTime( sal_Int32 columnIndex )
1212 {
1213     XROW_GETXXX( getTime );
1214 }
1215 
1216 //virtual
1217 DateTime SAL_CALL ContentResultSetWrapper
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
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
1234     ::getCharacterStream( sal_Int32 columnIndex )
1235 {
1236     XROW_GETXXX( getCharacterStream );
1237 }
1238 
1239 //virtual
1240 Any SAL_CALL ContentResultSetWrapper
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
1260     ::getRef( sal_Int32 columnIndex )
1261 {
1262     XROW_GETXXX( getRef );
1263 }
1264 
1265 //virtual
1266 Reference< XBlob > SAL_CALL ContentResultSetWrapper
1267     ::getBlob( sal_Int32 columnIndex )
1268 {
1269     XROW_GETXXX( getBlob );
1270 }
1271 
1272 //virtual
1273 Reference< XClob > SAL_CALL ContentResultSetWrapper
1274     ::getClob( sal_Int32 columnIndex )
1275 {
1276     XROW_GETXXX( getClob );
1277 }
1278 
1279 //virtual
1280 Reference< XArray > SAL_CALL ContentResultSetWrapper
1281     ::getArray( sal_Int32 columnIndex )
1282 {
1283     XROW_GETXXX( getArray );
1284 }
1285 
1286 //--------------------------------------------------------------------------
1287 //--------------------------------------------------------------------------
1288 // class ContentResultSetWrapperListener
1289 //--------------------------------------------------------------------------
1290 //--------------------------------------------------------------------------
1291 
1292 ContentResultSetWrapperListener::ContentResultSetWrapperListener(
1293     ContentResultSetWrapper* pOwner )
1294     : m_pOwner( pOwner )
1295 {
1296 }
1297 
1298 ContentResultSetWrapperListener::~ContentResultSetWrapperListener()
1299 {
1300 }
1301 
1302 //--------------------------------------------------------------------------
1303 // XInterface methods.
1304 //--------------------------------------------------------------------------
1305 //list all interfaces inclusive baseclasses of interfaces
1306 XINTERFACE_COMMON_IMPL( 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
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
1346     ::vetoableChange( const PropertyChangeEvent& rEvt )
1347 {
1348     if( m_pOwner )
1349         m_pOwner->impl_vetoableChange( rEvt );
1350 }
1351 
1352 void SAL_CALL ContentResultSetWrapperListener
1353     ::impl_OwnerDies()
1354 {
1355     m_pOwner = NULL;
1356 }
1357