Line data Source code
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 : /**************************************************************************
22 : TODO
23 : **************************************************************************
24 :
25 : *************************************************************************/
26 : #include <cppuhelper/interfacecontainer.hxx>
27 : #include <com/sun/star/beans/PropertyAttribute.hpp>
28 : #include <ucbhelper/getcomponentcontext.hxx>
29 : #include <ucbhelper/resultset.hxx>
30 : #include <ucbhelper/resultsetmetadata.hxx>
31 :
32 : using namespace com::sun::star;
33 :
34 :
35 :
36 : namespace ucbhelper_impl
37 : {
38 :
39 : struct PropertyInfo
40 : {
41 : const char* pName;
42 : sal_Int32 nHandle;
43 : sal_Int16 nAttributes;
44 : const uno::Type& (*pGetCppuType)();
45 : };
46 :
47 0 : static const uno::Type& sal_Int32_getCppuType()
48 : {
49 0 : return getCppuType( static_cast< const sal_Int32 * >( 0 ) );
50 : }
51 :
52 0 : static const uno::Type& sal_Bool_getCppuType()
53 : {
54 0 : return getCppuBooleanType();
55 : }
56 :
57 : static const PropertyInfo aPropertyTable[] =
58 : {
59 : { "IsRowCountFinal",
60 : 1000,
61 : beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY,
62 : &sal_Bool_getCppuType
63 : },
64 : { "RowCount",
65 : 1001,
66 : beans::PropertyAttribute::BOUND | beans::PropertyAttribute::READONLY,
67 : &sal_Int32_getCppuType
68 : },
69 : { 0,
70 : 0,
71 : 0,
72 : 0
73 : }
74 : };
75 :
76 : #define RESULTSET_PROPERTY_COUNT 2
77 :
78 :
79 :
80 : // class PropertySetInfo
81 :
82 :
83 :
84 : class PropertySetInfo :
85 : public cppu::OWeakObject,
86 : public lang::XTypeProvider,
87 : public beans::XPropertySetInfo
88 : {
89 : uno::Sequence< beans::Property >* m_pProps;
90 :
91 : private:
92 : bool queryProperty(
93 : const OUString& aName, beans::Property& rProp );
94 :
95 : public:
96 : PropertySetInfo(
97 : const PropertyInfo* pProps,
98 : sal_Int32 nProps );
99 : virtual ~PropertySetInfo();
100 :
101 : // XInterface
102 : virtual css::uno::Any SAL_CALL queryInterface( const css::uno::Type & rType )
103 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
104 : virtual void SAL_CALL acquire()
105 : throw() SAL_OVERRIDE;
106 : virtual void SAL_CALL release()
107 : throw() SAL_OVERRIDE;
108 :
109 : // XTypeProvider
110 : virtual css::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId()
111 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
112 : virtual css::uno::Sequence< css::uno::Type > SAL_CALL getTypes()
113 : throw( css::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
114 :
115 : // XPropertySetInfo
116 : virtual uno::Sequence< beans::Property > SAL_CALL getProperties()
117 : throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
118 : virtual beans::Property SAL_CALL getPropertyByName(
119 : const OUString& aName )
120 : throw( beans::UnknownPropertyException, uno::RuntimeException, std::exception ) SAL_OVERRIDE;
121 : virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& Name )
122 : throw( uno::RuntimeException, std::exception ) SAL_OVERRIDE;
123 : };
124 :
125 :
126 :
127 : // PropertyChangeListenerContainer.
128 :
129 :
130 :
131 : typedef cppu::OMultiTypeInterfaceContainerHelperVar
132 : <
133 : OUString,
134 : OUStringHash
135 : > PropertyChangeListenerContainer;
136 :
137 :
138 :
139 : // class PropertyChangeListeners.
140 :
141 :
142 :
143 0 : class PropertyChangeListeners : public PropertyChangeListenerContainer
144 : {
145 : public:
146 0 : PropertyChangeListeners( osl::Mutex& rMtx )
147 0 : : PropertyChangeListenerContainer( rMtx ) {}
148 : };
149 :
150 : } // namespace ucbhelper_impl
151 :
152 : using namespace ucbhelper_impl;
153 :
154 : namespace ucbhelper
155 : {
156 :
157 :
158 :
159 : // struct ResultSet_Impl.
160 :
161 :
162 :
163 : struct ResultSet_Impl
164 : {
165 : uno::Reference< uno::XComponentContext > m_xContext;
166 : uno::Reference< com::sun::star::ucb::XCommandEnvironment > m_xEnv;
167 : uno::Reference< beans::XPropertySetInfo > m_xPropSetInfo;
168 : uno::Reference< sdbc::XResultSetMetaData > m_xMetaData;
169 : uno::Sequence< beans::Property > m_aProperties;
170 : rtl::Reference< ResultSetDataSupplier > m_xDataSupplier;
171 : osl::Mutex m_aMutex;
172 : cppu::OInterfaceContainerHelper* m_pDisposeEventListeners;
173 : PropertyChangeListeners* m_pPropertyChangeListeners;
174 : sal_Int32 m_nPos;
175 : bool m_bWasNull;
176 : bool m_bAfterLast;
177 :
178 : inline ResultSet_Impl(
179 : const uno::Reference< uno::XComponentContext >& rxContext,
180 : const uno::Sequence< beans::Property >& rProperties,
181 : const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
182 : const uno::Reference< com::sun::star::ucb::XCommandEnvironment >&
183 : rxEnv );
184 : inline ~ResultSet_Impl();
185 : };
186 :
187 0 : inline ResultSet_Impl::ResultSet_Impl(
188 : const uno::Reference< uno::XComponentContext >& rxContext,
189 : const uno::Sequence< beans::Property >& rProperties,
190 : const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
191 : const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv )
192 : : m_xContext( rxContext ),
193 : m_xEnv( rxEnv ),
194 : m_aProperties( rProperties ),
195 : m_xDataSupplier( rDataSupplier ),
196 : m_pDisposeEventListeners( 0 ),
197 : m_pPropertyChangeListeners( 0 ),
198 : m_nPos( 0 ), // Position is one-based. Zero means: before first element.
199 : m_bWasNull( false ),
200 0 : m_bAfterLast( false )
201 : {
202 0 : }
203 :
204 :
205 0 : inline ResultSet_Impl::~ResultSet_Impl()
206 : {
207 0 : delete m_pDisposeEventListeners;
208 0 : delete m_pPropertyChangeListeners;
209 0 : }
210 :
211 :
212 :
213 :
214 : // ResultSet Implementation.
215 :
216 :
217 :
218 :
219 0 : ResultSet::ResultSet(
220 : const uno::Reference< uno::XComponentContext >& rxContext,
221 : const uno::Sequence< beans::Property >& rProperties,
222 : const rtl::Reference< ResultSetDataSupplier >& rDataSupplier )
223 : : m_pImpl( new ResultSet_Impl(
224 : rxContext,
225 : rProperties,
226 : rDataSupplier,
227 0 : uno::Reference< com::sun::star::ucb::XCommandEnvironment >() ) )
228 : {
229 0 : rDataSupplier->m_pResultSet = this;
230 0 : }
231 :
232 :
233 0 : ResultSet::ResultSet(
234 : const uno::Reference< uno::XComponentContext >& rxContext,
235 : const uno::Sequence< beans::Property >& rProperties,
236 : const rtl::Reference< ResultSetDataSupplier >& rDataSupplier,
237 : const uno::Reference< com::sun::star::ucb::XCommandEnvironment >& rxEnv )
238 0 : : m_pImpl( new ResultSet_Impl( rxContext, rProperties, rDataSupplier, rxEnv ) )
239 : {
240 0 : rDataSupplier->m_pResultSet = this;
241 0 : }
242 :
243 :
244 : // virtual
245 0 : ResultSet::~ResultSet()
246 : {
247 0 : delete m_pImpl;
248 0 : }
249 :
250 :
251 :
252 : // XInterface methods.
253 :
254 0 : void SAL_CALL ResultSet::acquire()
255 : throw()
256 : {
257 0 : OWeakObject::acquire();
258 0 : }
259 :
260 0 : void SAL_CALL ResultSet::release()
261 : throw()
262 : {
263 0 : OWeakObject::release();
264 0 : }
265 :
266 0 : css::uno::Any SAL_CALL ResultSet::queryInterface( const css::uno::Type & rType )
267 : throw( css::uno::RuntimeException, std::exception )
268 : {
269 : css::uno::Any aRet = cppu::queryInterface( rType,
270 : (static_cast< lang::XTypeProvider* >(this)),
271 : (static_cast< lang::XServiceInfo* >(this)),
272 : (static_cast< lang::XComponent* >(this)),
273 : (static_cast< css::ucb::XContentAccess* >(this)),
274 : (static_cast< sdbc::XResultSet* >(this)),
275 : (static_cast< sdbc::XResultSetMetaDataSupplier* >(this)),
276 : (static_cast< sdbc::XRow* >(this)),
277 : (static_cast< sdbc::XCloseable* >(this)),
278 : (static_cast< beans::XPropertySet* >(this))
279 0 : );
280 0 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
281 : }
282 :
283 : // XTypeProvider methods.
284 :
285 :
286 :
287 0 : XTYPEPROVIDER_IMPL_9( ResultSet,
288 : lang::XTypeProvider,
289 : lang::XServiceInfo,
290 : lang::XComponent,
291 : com::sun::star::ucb::XContentAccess,
292 : sdbc::XResultSet,
293 : sdbc::XResultSetMetaDataSupplier,
294 : sdbc::XRow,
295 : sdbc::XCloseable,
296 : beans::XPropertySet );
297 :
298 :
299 :
300 : // XServiceInfo methods.
301 :
302 :
303 :
304 0 : XSERVICEINFO_NOFACTORY_IMPL_1( ResultSet,
305 : OUString("ResultSet"),
306 : OUString(RESULTSET_SERVICE_NAME ) );
307 :
308 :
309 :
310 : // XComponent methods.
311 :
312 :
313 :
314 : // virtual
315 0 : void SAL_CALL ResultSet::dispose()
316 : throw( uno::RuntimeException, std::exception )
317 : {
318 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
319 :
320 0 : if ( m_pImpl->m_pDisposeEventListeners &&
321 0 : m_pImpl->m_pDisposeEventListeners->getLength() )
322 : {
323 0 : lang::EventObject aEvt;
324 0 : aEvt.Source = static_cast< lang::XComponent * >( this );
325 0 : m_pImpl->m_pDisposeEventListeners->disposeAndClear( aEvt );
326 : }
327 :
328 0 : if ( m_pImpl->m_pPropertyChangeListeners )
329 : {
330 0 : lang::EventObject aEvt;
331 0 : aEvt.Source = static_cast< beans::XPropertySet * >( this );
332 0 : m_pImpl->m_pPropertyChangeListeners->disposeAndClear( aEvt );
333 : }
334 :
335 0 : m_pImpl->m_xDataSupplier->close();
336 0 : }
337 :
338 :
339 : // virtual
340 0 : void SAL_CALL ResultSet::addEventListener(
341 : const uno::Reference< lang::XEventListener >& Listener )
342 : throw( uno::RuntimeException, std::exception )
343 : {
344 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
345 :
346 0 : if ( !m_pImpl->m_pDisposeEventListeners )
347 : m_pImpl->m_pDisposeEventListeners =
348 0 : new cppu::OInterfaceContainerHelper( m_pImpl->m_aMutex );
349 :
350 0 : m_pImpl->m_pDisposeEventListeners->addInterface( Listener );
351 0 : }
352 :
353 :
354 : // virtual
355 0 : void SAL_CALL ResultSet::removeEventListener(
356 : const uno::Reference< lang::XEventListener >& Listener )
357 : throw( uno::RuntimeException, std::exception )
358 : {
359 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
360 :
361 0 : if ( m_pImpl->m_pDisposeEventListeners )
362 0 : m_pImpl->m_pDisposeEventListeners->removeInterface( Listener );
363 0 : }
364 :
365 :
366 :
367 : // XResultSetMetaDataSupplier methods.
368 :
369 :
370 :
371 : // virtual
372 0 : uno::Reference< sdbc::XResultSetMetaData > SAL_CALL ResultSet::getMetaData()
373 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
374 : {
375 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
376 :
377 0 : if ( !m_pImpl->m_xMetaData.is() )
378 0 : m_pImpl->m_xMetaData = new ResultSetMetaData( m_pImpl->m_xContext,
379 0 : m_pImpl->m_aProperties );
380 :
381 0 : return m_pImpl->m_xMetaData;
382 : }
383 :
384 :
385 :
386 : // XResultSet methods.
387 :
388 :
389 :
390 : // virtual
391 0 : sal_Bool SAL_CALL ResultSet::next()
392 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
393 : {
394 : // Note: Cursor is initially positioned before the first row.
395 : // First call to 'next()' moves it to first row.
396 :
397 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
398 :
399 0 : if ( m_pImpl->m_bAfterLast )
400 : {
401 0 : m_pImpl->m_xDataSupplier->validate();
402 0 : return sal_False;
403 : }
404 :
405 : // getResult works zero-based!
406 0 : if ( !m_pImpl->m_xDataSupplier->getResult( m_pImpl->m_nPos ) )
407 : {
408 0 : m_pImpl->m_bAfterLast = true;
409 0 : m_pImpl->m_xDataSupplier->validate();
410 0 : return sal_False;
411 : }
412 :
413 0 : m_pImpl->m_nPos++;
414 0 : m_pImpl->m_xDataSupplier->validate();
415 0 : return sal_True;
416 : }
417 :
418 :
419 : // virtual
420 0 : sal_Bool SAL_CALL ResultSet::isBeforeFirst()
421 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
422 : {
423 0 : if ( m_pImpl->m_bAfterLast )
424 : {
425 0 : m_pImpl->m_xDataSupplier->validate();
426 0 : return sal_False;
427 : }
428 :
429 : // getResult works zero-based!
430 0 : if ( !m_pImpl->m_xDataSupplier->getResult( 0 ) )
431 : {
432 0 : m_pImpl->m_xDataSupplier->validate();
433 0 : return sal_False;
434 : }
435 :
436 0 : m_pImpl->m_xDataSupplier->validate();
437 0 : return ( m_pImpl->m_nPos == 0 );
438 : }
439 :
440 :
441 : // virtual
442 0 : sal_Bool SAL_CALL ResultSet::isAfterLast()
443 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
444 : {
445 0 : m_pImpl->m_xDataSupplier->validate();
446 0 : return m_pImpl->m_bAfterLast;
447 : }
448 :
449 :
450 : // virtual
451 0 : sal_Bool SAL_CALL ResultSet::isFirst()
452 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
453 : {
454 0 : if ( m_pImpl->m_bAfterLast )
455 : {
456 0 : m_pImpl->m_xDataSupplier->validate();
457 0 : return sal_False;
458 : }
459 :
460 0 : m_pImpl->m_xDataSupplier->validate();
461 0 : return ( m_pImpl->m_nPos == 1 );
462 : }
463 :
464 :
465 : // virtual
466 0 : sal_Bool SAL_CALL ResultSet::isLast()
467 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
468 : {
469 0 : if ( m_pImpl->m_bAfterLast )
470 : {
471 0 : m_pImpl->m_xDataSupplier->validate();
472 0 : return sal_False;
473 : }
474 :
475 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
476 0 : if ( !nCount )
477 : {
478 0 : m_pImpl->m_xDataSupplier->validate();
479 0 : return sal_False;
480 : }
481 :
482 0 : m_pImpl->m_xDataSupplier->validate();
483 0 : return ( m_pImpl->m_nPos == nCount );
484 : }
485 :
486 :
487 : // virtual
488 0 : void SAL_CALL ResultSet::beforeFirst()
489 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
490 : {
491 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
492 0 : m_pImpl->m_bAfterLast = false;
493 0 : m_pImpl->m_nPos = 0;
494 0 : m_pImpl->m_xDataSupplier->validate();
495 0 : }
496 :
497 :
498 : // virtual
499 0 : void SAL_CALL ResultSet::afterLast()
500 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
501 : {
502 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
503 0 : m_pImpl->m_bAfterLast = true;
504 0 : m_pImpl->m_xDataSupplier->validate();
505 0 : }
506 :
507 :
508 : // virtual
509 0 : sal_Bool SAL_CALL ResultSet::first()
510 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
511 : {
512 : // getResult works zero-based!
513 0 : if ( m_pImpl->m_xDataSupplier->getResult( 0 ) )
514 : {
515 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
516 0 : m_pImpl->m_bAfterLast = false;
517 0 : m_pImpl->m_nPos = 1;
518 0 : m_pImpl->m_xDataSupplier->validate();
519 0 : return sal_True;
520 : }
521 :
522 0 : m_pImpl->m_xDataSupplier->validate();
523 0 : return sal_False;
524 : }
525 :
526 :
527 : // virtual
528 0 : sal_Bool SAL_CALL ResultSet::last()
529 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
530 : {
531 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
532 0 : if ( nCount )
533 : {
534 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
535 0 : m_pImpl->m_bAfterLast = false;
536 0 : m_pImpl->m_nPos = nCount;
537 0 : m_pImpl->m_xDataSupplier->validate();
538 0 : return sal_True;
539 : }
540 :
541 0 : m_pImpl->m_xDataSupplier->validate();
542 0 : return sal_False;
543 : }
544 :
545 :
546 : // virtual
547 0 : sal_Int32 SAL_CALL ResultSet::getRow()
548 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
549 : {
550 0 : if ( m_pImpl->m_bAfterLast )
551 : {
552 0 : m_pImpl->m_xDataSupplier->validate();
553 0 : return 0;
554 : }
555 :
556 0 : m_pImpl->m_xDataSupplier->validate();
557 0 : return m_pImpl->m_nPos;
558 : }
559 :
560 :
561 : // virtual
562 0 : sal_Bool SAL_CALL ResultSet::absolute( sal_Int32 row )
563 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
564 : {
565 : /*
566 : If the row number is positive, the cursor moves to the given row number
567 : with respect to the beginning of the result set. The first row is row 1,
568 : the second is row 2, and so on.
569 :
570 : If the given row number is negative, the cursor moves to an absolute row
571 : position with respect to the end of the result set. For example, calling
572 : absolaute( -1 ) positions the cursor on the last row, absolaute( -2 )
573 : indicates the next-to-last row, and so on.
574 :
575 : An attempt to position the cursor beyond the first/last row in the result
576 : set leaves the cursor before/after the first/last row, respectively.
577 :
578 : Calling absolute( 1 ) is the same as calling first().
579 :
580 : Calling absolute( -1 ) is the same as calling last().
581 : */
582 0 : if ( row < 0 )
583 : {
584 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
585 :
586 0 : if ( ( row * -1 ) > nCount )
587 : {
588 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
589 0 : m_pImpl->m_bAfterLast = false;
590 0 : m_pImpl->m_nPos = 0;
591 0 : m_pImpl->m_xDataSupplier->validate();
592 0 : return sal_False;
593 : }
594 : else // |row| <= nCount
595 : {
596 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
597 0 : m_pImpl->m_bAfterLast = false;
598 0 : m_pImpl->m_nPos = ( nCount + row + 1 );
599 0 : m_pImpl->m_xDataSupplier->validate();
600 0 : return sal_True;
601 : }
602 : }
603 0 : else if ( row == 0 )
604 : {
605 : // @throws SQLException
606 : // ... if row is 0 ...
607 0 : throw sdbc::SQLException();
608 : }
609 : else // row > 0
610 : {
611 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
612 :
613 0 : if ( row <= nCount )
614 : {
615 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
616 0 : m_pImpl->m_bAfterLast = false;
617 0 : m_pImpl->m_nPos = row;
618 0 : m_pImpl->m_xDataSupplier->validate();
619 0 : return sal_True;
620 : }
621 : else // row > nCount
622 : {
623 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
624 0 : m_pImpl->m_bAfterLast = true;
625 0 : m_pImpl->m_xDataSupplier->validate();
626 0 : return sal_False;
627 : }
628 : }
629 :
630 : // unreachable...
631 : }
632 :
633 :
634 : // virtual
635 0 : sal_Bool SAL_CALL ResultSet::relative( sal_Int32 rows )
636 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
637 : {
638 : /*
639 : Attempting to move beyond the first/last row in the result set
640 : positions the cursor before/after the first/last row.
641 :
642 : Calling relative( 0 ) is valid, but does not change the cursor position.
643 :
644 : Calling relative( 1 ) is different from calling next() because it makes
645 : sense to call next() when there is no current row, for example, when
646 : the cursor is positioned before the first row or after the last row of
647 : the result set.
648 : */
649 0 : if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) )
650 : {
651 : // "No current row".
652 0 : throw sdbc::SQLException();
653 : }
654 :
655 0 : if ( rows < 0 )
656 : {
657 0 : if ( ( m_pImpl->m_nPos + rows ) > 0 )
658 : {
659 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
660 0 : m_pImpl->m_bAfterLast = false;
661 0 : m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows );
662 0 : m_pImpl->m_xDataSupplier->validate();
663 0 : return sal_True;
664 : }
665 : else
666 : {
667 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
668 0 : m_pImpl->m_bAfterLast = false;
669 0 : m_pImpl->m_nPos = 0;
670 0 : m_pImpl->m_xDataSupplier->validate();
671 0 : return sal_False;
672 : }
673 : }
674 0 : else if ( rows == 0 )
675 : {
676 : // nop.
677 0 : m_pImpl->m_xDataSupplier->validate();
678 0 : return sal_True;
679 : }
680 : else // rows > 0
681 : {
682 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
683 0 : if ( ( m_pImpl->m_nPos + rows ) <= nCount )
684 : {
685 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
686 0 : m_pImpl->m_bAfterLast = false;
687 0 : m_pImpl->m_nPos = ( m_pImpl->m_nPos + rows );
688 0 : m_pImpl->m_xDataSupplier->validate();
689 0 : return sal_True;
690 : }
691 : else
692 : {
693 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
694 0 : m_pImpl->m_bAfterLast = true;
695 0 : m_pImpl->m_xDataSupplier->validate();
696 0 : return sal_False;
697 : }
698 : }
699 :
700 : // unreachable...
701 : }
702 :
703 :
704 : // virtual
705 0 : sal_Bool SAL_CALL ResultSet::previous()
706 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
707 : {
708 : /*
709 : previous() is not the same as relative( -1 ) because it makes sense
710 : to call previous() when there is no current row.
711 : */
712 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
713 :
714 0 : if ( m_pImpl->m_bAfterLast )
715 : {
716 0 : m_pImpl->m_bAfterLast = false;
717 0 : sal_Int32 nCount = m_pImpl->m_xDataSupplier->totalCount();
718 0 : m_pImpl->m_nPos = nCount;
719 : }
720 0 : else if ( m_pImpl->m_nPos )
721 0 : m_pImpl->m_nPos--;
722 :
723 0 : if ( m_pImpl->m_nPos )
724 : {
725 0 : m_pImpl->m_xDataSupplier->validate();
726 0 : return sal_True;
727 : }
728 :
729 0 : m_pImpl->m_xDataSupplier->validate();
730 0 : return sal_False;
731 : }
732 :
733 :
734 : // virtual
735 0 : void SAL_CALL ResultSet::refreshRow()
736 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
737 : {
738 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
739 0 : if ( m_pImpl->m_bAfterLast || ( m_pImpl->m_nPos == 0 ) )
740 0 : return;
741 :
742 0 : m_pImpl->m_xDataSupplier->releasePropertyValues( m_pImpl->m_nPos );
743 0 : m_pImpl->m_xDataSupplier->validate();
744 : }
745 :
746 :
747 : // virtual
748 0 : sal_Bool SAL_CALL ResultSet::rowUpdated()
749 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
750 : {
751 0 : m_pImpl->m_xDataSupplier->validate();
752 0 : return sal_False;
753 : }
754 :
755 :
756 : // virtual
757 0 : sal_Bool SAL_CALL ResultSet::rowInserted()
758 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
759 : {
760 0 : m_pImpl->m_xDataSupplier->validate();
761 0 : return sal_False;
762 : }
763 :
764 :
765 : // virtual
766 0 : sal_Bool SAL_CALL ResultSet::rowDeleted()
767 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
768 : {
769 0 : m_pImpl->m_xDataSupplier->validate();
770 0 : return sal_False;
771 : }
772 :
773 :
774 : // virtual
775 0 : uno::Reference< uno::XInterface > SAL_CALL ResultSet::getStatement()
776 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
777 : {
778 : /*
779 : returns the Statement that produced this ResultSet object. If the
780 : result set was generated some other way, ... this method returns null.
781 : */
782 0 : m_pImpl->m_xDataSupplier->validate();
783 0 : return uno::Reference< uno::XInterface >();
784 : }
785 :
786 :
787 :
788 : // XRow methods.
789 :
790 :
791 :
792 : // virtual
793 0 : sal_Bool SAL_CALL ResultSet::wasNull()
794 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
795 : {
796 : // This method can not be implemented correctly!!! Imagine different
797 : // threads doing a getXYZ - wasNull calling sequence on the same
798 : // implementation object...
799 :
800 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
801 : {
802 : uno::Reference< sdbc::XRow > xValues
803 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
804 0 : m_pImpl->m_nPos - 1 );
805 0 : if ( xValues.is() )
806 : {
807 0 : m_pImpl->m_xDataSupplier->validate();
808 0 : return xValues->wasNull();
809 0 : }
810 : }
811 :
812 0 : m_pImpl->m_xDataSupplier->validate();
813 0 : return m_pImpl->m_bWasNull;
814 : }
815 :
816 :
817 : // virtual
818 0 : OUString SAL_CALL ResultSet::getString( sal_Int32 columnIndex )
819 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
820 : {
821 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
822 : {
823 : uno::Reference< sdbc::XRow > xValues
824 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
825 0 : m_pImpl->m_nPos - 1 );
826 0 : if ( xValues.is() )
827 : {
828 0 : m_pImpl->m_bWasNull = false;
829 0 : m_pImpl->m_xDataSupplier->validate();
830 0 : return xValues->getString( columnIndex );
831 0 : }
832 : }
833 :
834 0 : m_pImpl->m_bWasNull = true;
835 0 : m_pImpl->m_xDataSupplier->validate();
836 0 : return OUString();
837 : }
838 :
839 :
840 : // virtual
841 0 : sal_Bool SAL_CALL ResultSet::getBoolean( sal_Int32 columnIndex )
842 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
843 : {
844 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
845 : {
846 : uno::Reference< sdbc::XRow > xValues
847 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
848 0 : m_pImpl->m_nPos - 1 );
849 0 : if ( xValues.is() )
850 : {
851 0 : m_pImpl->m_bWasNull = false;
852 0 : m_pImpl->m_xDataSupplier->validate();
853 0 : return xValues->getBoolean( columnIndex );
854 0 : }
855 : }
856 :
857 0 : m_pImpl->m_bWasNull = true;
858 0 : m_pImpl->m_xDataSupplier->validate();
859 0 : return sal_False;
860 : }
861 :
862 :
863 : // virtual
864 0 : sal_Int8 SAL_CALL ResultSet::getByte( sal_Int32 columnIndex )
865 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
866 : {
867 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
868 : {
869 : uno::Reference< sdbc::XRow > xValues
870 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
871 0 : m_pImpl->m_nPos - 1 );
872 0 : if ( xValues.is() )
873 : {
874 0 : m_pImpl->m_bWasNull = false;
875 0 : m_pImpl->m_xDataSupplier->validate();
876 0 : return xValues->getByte( columnIndex );
877 0 : }
878 : }
879 :
880 0 : m_pImpl->m_bWasNull = true;
881 0 : m_pImpl->m_xDataSupplier->validate();
882 0 : return 0;
883 : }
884 :
885 :
886 : // virtual
887 0 : sal_Int16 SAL_CALL ResultSet::getShort( sal_Int32 columnIndex )
888 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
889 : {
890 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
891 : {
892 : uno::Reference< sdbc::XRow > xValues
893 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
894 0 : m_pImpl->m_nPos - 1 );
895 0 : if ( xValues.is() )
896 : {
897 0 : m_pImpl->m_bWasNull = false;
898 0 : m_pImpl->m_xDataSupplier->validate();
899 0 : return xValues->getShort( columnIndex );
900 0 : }
901 : }
902 :
903 0 : m_pImpl->m_bWasNull = true;
904 0 : m_pImpl->m_xDataSupplier->validate();
905 0 : return 0;
906 : }
907 :
908 :
909 : // virtual
910 0 : sal_Int32 SAL_CALL ResultSet::getInt( sal_Int32 columnIndex )
911 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
912 : {
913 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
914 : {
915 : uno::Reference< sdbc::XRow > xValues
916 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
917 0 : m_pImpl->m_nPos - 1 );
918 0 : if ( xValues.is() )
919 : {
920 0 : m_pImpl->m_bWasNull = false;
921 0 : m_pImpl->m_xDataSupplier->validate();
922 0 : return xValues->getInt( columnIndex );
923 0 : }
924 : }
925 :
926 0 : m_pImpl->m_bWasNull = true;
927 0 : m_pImpl->m_xDataSupplier->validate();
928 0 : return 0;
929 : }
930 :
931 :
932 : // virtual
933 0 : sal_Int64 SAL_CALL ResultSet::getLong( sal_Int32 columnIndex )
934 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
935 : {
936 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
937 : {
938 : uno::Reference< sdbc::XRow > xValues
939 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
940 0 : m_pImpl->m_nPos - 1 );
941 0 : if ( xValues.is() )
942 : {
943 0 : m_pImpl->m_bWasNull = false;
944 0 : m_pImpl->m_xDataSupplier->validate();
945 0 : return xValues->getLong( columnIndex );
946 0 : }
947 : }
948 :
949 0 : m_pImpl->m_bWasNull = true;
950 0 : m_pImpl->m_xDataSupplier->validate();
951 0 : return 0;
952 : }
953 :
954 :
955 : // virtual
956 0 : float SAL_CALL ResultSet::getFloat( sal_Int32 columnIndex )
957 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
958 : {
959 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
960 : {
961 : uno::Reference< sdbc::XRow > xValues
962 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
963 0 : m_pImpl->m_nPos - 1 );
964 0 : if ( xValues.is() )
965 : {
966 0 : m_pImpl->m_bWasNull = false;
967 0 : m_pImpl->m_xDataSupplier->validate();
968 0 : return xValues->getFloat( columnIndex );
969 0 : }
970 : }
971 :
972 0 : m_pImpl->m_bWasNull = true;
973 0 : m_pImpl->m_xDataSupplier->validate();
974 0 : return 0;
975 : }
976 :
977 :
978 : // virtual
979 0 : double SAL_CALL ResultSet::getDouble( sal_Int32 columnIndex )
980 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
981 : {
982 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
983 : {
984 : uno::Reference< sdbc::XRow > xValues
985 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
986 0 : m_pImpl->m_nPos - 1 );
987 0 : if ( xValues.is() )
988 : {
989 0 : m_pImpl->m_bWasNull = false;
990 0 : m_pImpl->m_xDataSupplier->validate();
991 0 : return xValues->getDouble( columnIndex );
992 0 : }
993 : }
994 :
995 0 : m_pImpl->m_bWasNull = true;
996 0 : m_pImpl->m_xDataSupplier->validate();
997 0 : return 0;
998 : }
999 :
1000 :
1001 : // virtual
1002 : uno::Sequence< sal_Int8 > SAL_CALL
1003 0 : ResultSet::getBytes( sal_Int32 columnIndex )
1004 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1005 : {
1006 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1007 : {
1008 : uno::Reference< sdbc::XRow > xValues
1009 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1010 0 : m_pImpl->m_nPos - 1 );
1011 0 : if ( xValues.is() )
1012 : {
1013 0 : m_pImpl->m_bWasNull = false;
1014 0 : m_pImpl->m_xDataSupplier->validate();
1015 0 : return xValues->getBytes( columnIndex );
1016 0 : }
1017 : }
1018 :
1019 0 : m_pImpl->m_bWasNull = true;
1020 0 : m_pImpl->m_xDataSupplier->validate();
1021 0 : return uno::Sequence< sal_Int8 >();
1022 : }
1023 :
1024 :
1025 : // virtual
1026 0 : util::Date SAL_CALL ResultSet::getDate( sal_Int32 columnIndex )
1027 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1028 : {
1029 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1030 : {
1031 : uno::Reference< sdbc::XRow > xValues
1032 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1033 0 : m_pImpl->m_nPos - 1 );
1034 0 : if ( xValues.is() )
1035 : {
1036 0 : m_pImpl->m_bWasNull = false;
1037 0 : m_pImpl->m_xDataSupplier->validate();
1038 0 : return xValues->getDate( columnIndex );
1039 0 : }
1040 : }
1041 :
1042 0 : m_pImpl->m_bWasNull = true;
1043 0 : m_pImpl->m_xDataSupplier->validate();
1044 0 : return util::Date();
1045 : }
1046 :
1047 :
1048 : // virtual
1049 0 : util::Time SAL_CALL ResultSet::getTime( sal_Int32 columnIndex )
1050 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1051 : {
1052 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1053 : {
1054 : uno::Reference< sdbc::XRow > xValues
1055 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1056 0 : m_pImpl->m_nPos - 1 );
1057 0 : if ( xValues.is() )
1058 : {
1059 0 : m_pImpl->m_bWasNull = false;
1060 0 : m_pImpl->m_xDataSupplier->validate();
1061 0 : return xValues->getTime( columnIndex );
1062 0 : }
1063 : }
1064 :
1065 0 : m_pImpl->m_bWasNull = true;
1066 0 : m_pImpl->m_xDataSupplier->validate();
1067 0 : return util::Time();
1068 : }
1069 :
1070 :
1071 : // virtual
1072 : util::DateTime SAL_CALL
1073 0 : ResultSet::getTimestamp( sal_Int32 columnIndex )
1074 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1075 : {
1076 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1077 : {
1078 : uno::Reference< sdbc::XRow > xValues
1079 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1080 0 : m_pImpl->m_nPos - 1 );
1081 0 : if ( xValues.is() )
1082 : {
1083 0 : m_pImpl->m_bWasNull = false;
1084 0 : m_pImpl->m_xDataSupplier->validate();
1085 0 : return xValues->getTimestamp( columnIndex );
1086 0 : }
1087 : }
1088 :
1089 0 : m_pImpl->m_bWasNull = true;
1090 0 : m_pImpl->m_xDataSupplier->validate();
1091 0 : return util::DateTime();
1092 : }
1093 :
1094 :
1095 : // virtual
1096 : uno::Reference< io::XInputStream > SAL_CALL
1097 0 : ResultSet::getBinaryStream( sal_Int32 columnIndex )
1098 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1099 : {
1100 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1101 : {
1102 : uno::Reference< sdbc::XRow > xValues
1103 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1104 0 : m_pImpl->m_nPos - 1 );
1105 0 : if ( xValues.is() )
1106 : {
1107 0 : m_pImpl->m_bWasNull = false;
1108 0 : m_pImpl->m_xDataSupplier->validate();
1109 0 : return xValues->getBinaryStream( columnIndex );
1110 0 : }
1111 : }
1112 :
1113 0 : m_pImpl->m_bWasNull = true;
1114 0 : m_pImpl->m_xDataSupplier->validate();
1115 0 : return uno::Reference< io::XInputStream >();
1116 : }
1117 :
1118 :
1119 : // virtual
1120 : uno::Reference< io::XInputStream > SAL_CALL
1121 0 : ResultSet::getCharacterStream( sal_Int32 columnIndex )
1122 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1123 : {
1124 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1125 : {
1126 : uno::Reference< sdbc::XRow > xValues
1127 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1128 0 : m_pImpl->m_nPos - 1 );
1129 0 : if ( xValues.is() )
1130 : {
1131 0 : m_pImpl->m_bWasNull = false;
1132 0 : m_pImpl->m_xDataSupplier->validate();
1133 0 : return xValues->getCharacterStream( columnIndex );
1134 0 : }
1135 : }
1136 :
1137 0 : m_pImpl->m_bWasNull = true;
1138 0 : m_pImpl->m_xDataSupplier->validate();
1139 0 : return uno::Reference< io::XInputStream >();
1140 : }
1141 :
1142 :
1143 : // virtual
1144 0 : uno::Any SAL_CALL ResultSet::getObject(
1145 : sal_Int32 columnIndex,
1146 : const uno::Reference< container::XNameAccess >& typeMap )
1147 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1148 : {
1149 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1150 : {
1151 : uno::Reference< sdbc::XRow > xValues
1152 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1153 0 : m_pImpl->m_nPos - 1 );
1154 0 : if ( xValues.is() )
1155 : {
1156 0 : m_pImpl->m_bWasNull = false;
1157 0 : m_pImpl->m_xDataSupplier->validate();
1158 0 : return xValues->getObject( columnIndex, typeMap );
1159 0 : }
1160 : }
1161 :
1162 0 : m_pImpl->m_bWasNull = true;
1163 0 : m_pImpl->m_xDataSupplier->validate();
1164 0 : return uno::Any();
1165 : }
1166 :
1167 :
1168 : // virtual
1169 : uno::Reference< sdbc::XRef > SAL_CALL
1170 0 : ResultSet::getRef( sal_Int32 columnIndex )
1171 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1172 : {
1173 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1174 : {
1175 : uno::Reference< sdbc::XRow > xValues
1176 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1177 0 : m_pImpl->m_nPos - 1 );
1178 0 : if ( xValues.is() )
1179 : {
1180 0 : m_pImpl->m_bWasNull = false;
1181 0 : m_pImpl->m_xDataSupplier->validate();
1182 0 : return xValues->getRef( columnIndex );
1183 0 : }
1184 : }
1185 :
1186 0 : m_pImpl->m_bWasNull = true;
1187 0 : m_pImpl->m_xDataSupplier->validate();
1188 0 : return uno::Reference< sdbc::XRef >();
1189 : }
1190 :
1191 :
1192 : // virtual
1193 : uno::Reference< sdbc::XBlob > SAL_CALL
1194 0 : ResultSet::getBlob( sal_Int32 columnIndex )
1195 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1196 : {
1197 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1198 : {
1199 : uno::Reference< sdbc::XRow > xValues
1200 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1201 0 : m_pImpl->m_nPos - 1 );
1202 0 : if ( xValues.is() )
1203 : {
1204 0 : m_pImpl->m_bWasNull = false;
1205 0 : m_pImpl->m_xDataSupplier->validate();
1206 0 : return xValues->getBlob( columnIndex );
1207 0 : }
1208 : }
1209 :
1210 0 : m_pImpl->m_bWasNull = true;
1211 0 : m_pImpl->m_xDataSupplier->validate();
1212 0 : return uno::Reference< sdbc::XBlob >();
1213 : }
1214 :
1215 :
1216 : // virtual
1217 : uno::Reference< sdbc::XClob > SAL_CALL
1218 0 : ResultSet::getClob( sal_Int32 columnIndex )
1219 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1220 : {
1221 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1222 : {
1223 : uno::Reference< sdbc::XRow > xValues
1224 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1225 0 : m_pImpl->m_nPos - 1 );
1226 0 : if ( xValues.is() )
1227 : {
1228 0 : m_pImpl->m_bWasNull = false;
1229 0 : m_pImpl->m_xDataSupplier->validate();
1230 0 : return xValues->getClob( columnIndex );
1231 0 : }
1232 : }
1233 :
1234 0 : m_pImpl->m_bWasNull = true;
1235 0 : m_pImpl->m_xDataSupplier->validate();
1236 0 : return uno::Reference< sdbc::XClob >();
1237 : }
1238 :
1239 :
1240 : // virtual
1241 : uno::Reference< sdbc::XArray > SAL_CALL
1242 0 : ResultSet::getArray( sal_Int32 columnIndex )
1243 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1244 : {
1245 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1246 : {
1247 : uno::Reference< sdbc::XRow > xValues
1248 0 : = m_pImpl->m_xDataSupplier->queryPropertyValues(
1249 0 : m_pImpl->m_nPos - 1 );
1250 0 : if ( xValues.is() )
1251 : {
1252 0 : m_pImpl->m_bWasNull = false;
1253 0 : m_pImpl->m_xDataSupplier->validate();
1254 0 : return xValues->getArray( columnIndex );
1255 0 : }
1256 : }
1257 :
1258 0 : m_pImpl->m_bWasNull = true;
1259 0 : m_pImpl->m_xDataSupplier->validate();
1260 0 : return uno::Reference< sdbc::XArray >();
1261 : }
1262 :
1263 :
1264 :
1265 : // XCloseable methods.
1266 :
1267 :
1268 :
1269 : // virtual
1270 0 : void SAL_CALL ResultSet::close()
1271 : throw( sdbc::SQLException, uno::RuntimeException, std::exception )
1272 : {
1273 0 : m_pImpl->m_xDataSupplier->close();
1274 0 : m_pImpl->m_xDataSupplier->validate();
1275 0 : }
1276 :
1277 :
1278 :
1279 : // XContentAccess methods.
1280 :
1281 :
1282 :
1283 : // virtual
1284 0 : OUString SAL_CALL ResultSet::queryContentIdentifierString()
1285 : throw( uno::RuntimeException, std::exception )
1286 : {
1287 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1288 0 : return m_pImpl->m_xDataSupplier->queryContentIdentifierString(
1289 0 : m_pImpl->m_nPos - 1 );
1290 :
1291 0 : return OUString();
1292 : }
1293 :
1294 :
1295 : // virtual
1296 : uno::Reference< com::sun::star::ucb::XContentIdentifier > SAL_CALL
1297 0 : ResultSet::queryContentIdentifier()
1298 : throw( uno::RuntimeException, std::exception )
1299 : {
1300 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1301 0 : return m_pImpl->m_xDataSupplier->queryContentIdentifier(
1302 0 : m_pImpl->m_nPos - 1 );
1303 :
1304 0 : return uno::Reference< com::sun::star::ucb::XContentIdentifier >();
1305 : }
1306 :
1307 :
1308 : // virtual
1309 : uno::Reference< com::sun::star::ucb::XContent > SAL_CALL
1310 0 : ResultSet::queryContent()
1311 : throw( uno::RuntimeException, std::exception )
1312 : {
1313 0 : if ( m_pImpl->m_nPos && !m_pImpl->m_bAfterLast )
1314 0 : return m_pImpl->m_xDataSupplier->queryContent( m_pImpl->m_nPos - 1 );
1315 :
1316 0 : return uno::Reference< com::sun::star::ucb::XContent >();
1317 : }
1318 :
1319 :
1320 :
1321 : // XPropertySet methods.
1322 :
1323 :
1324 :
1325 : // virtual
1326 : uno::Reference< beans::XPropertySetInfo > SAL_CALL
1327 0 : ResultSet::getPropertySetInfo()
1328 : throw( uno::RuntimeException, std::exception )
1329 : {
1330 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1331 :
1332 0 : if ( !m_pImpl->m_xPropSetInfo.is() )
1333 : m_pImpl->m_xPropSetInfo
1334 0 : = new PropertySetInfo( aPropertyTable,
1335 0 : RESULTSET_PROPERTY_COUNT );
1336 0 : return m_pImpl->m_xPropSetInfo;
1337 : }
1338 :
1339 :
1340 : // virtual
1341 0 : void SAL_CALL ResultSet::setPropertyValue( const OUString& aPropertyName,
1342 : const uno::Any& )
1343 : throw( beans::UnknownPropertyException,
1344 : beans::PropertyVetoException,
1345 : lang::IllegalArgumentException,
1346 : lang::WrappedTargetException,
1347 : uno::RuntimeException, std::exception )
1348 : {
1349 0 : if ( aPropertyName.isEmpty() )
1350 0 : throw beans::UnknownPropertyException();
1351 :
1352 0 : if ( aPropertyName.equals(
1353 0 : OUString("RowCount") ) )
1354 : {
1355 : // property is read-only.
1356 0 : throw lang::IllegalArgumentException();
1357 : }
1358 0 : else if ( aPropertyName.equals(
1359 0 : OUString("IsRowCountFinal") ) )
1360 : {
1361 : // property is read-only.
1362 0 : throw lang::IllegalArgumentException();
1363 : }
1364 : else
1365 : {
1366 0 : throw beans::UnknownPropertyException();
1367 : }
1368 : }
1369 :
1370 :
1371 : // virtual
1372 0 : uno::Any SAL_CALL ResultSet::getPropertyValue(
1373 : const OUString& PropertyName )
1374 : throw( beans::UnknownPropertyException,
1375 : lang::WrappedTargetException,
1376 : uno::RuntimeException, std::exception )
1377 : {
1378 0 : if ( PropertyName.isEmpty() )
1379 0 : throw beans::UnknownPropertyException();
1380 :
1381 0 : uno::Any aValue;
1382 :
1383 0 : if ( PropertyName.equals(
1384 0 : OUString("RowCount") ) )
1385 : {
1386 0 : aValue <<= m_pImpl->m_xDataSupplier->currentCount();
1387 : }
1388 0 : else if ( PropertyName.equals(
1389 0 : OUString("IsRowCountFinal") ) )
1390 : {
1391 0 : aValue <<= m_pImpl->m_xDataSupplier->isCountFinal();
1392 : }
1393 : else
1394 : {
1395 0 : throw beans::UnknownPropertyException();
1396 : }
1397 :
1398 0 : return aValue;
1399 : }
1400 :
1401 :
1402 : // virtual
1403 0 : void SAL_CALL ResultSet::addPropertyChangeListener(
1404 : const OUString& aPropertyName,
1405 : const uno::Reference< beans::XPropertyChangeListener >& xListener )
1406 : throw( beans::UnknownPropertyException,
1407 : lang::WrappedTargetException,
1408 : uno::RuntimeException, std::exception )
1409 : {
1410 : // Note: An empty property name means a listener for "all" properties.
1411 :
1412 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1413 :
1414 0 : if ( !aPropertyName.isEmpty() &&
1415 : !aPropertyName.equals(
1416 0 : OUString("RowCount") ) &&
1417 : !aPropertyName.equals(
1418 0 : OUString("IsRowCountFinal") ) )
1419 0 : throw beans::UnknownPropertyException();
1420 :
1421 0 : if ( !m_pImpl->m_pPropertyChangeListeners )
1422 : m_pImpl->m_pPropertyChangeListeners
1423 0 : = new PropertyChangeListeners( m_pImpl->m_aMutex );
1424 :
1425 : m_pImpl->m_pPropertyChangeListeners->addInterface(
1426 0 : aPropertyName, xListener );
1427 0 : }
1428 :
1429 :
1430 : // virtual
1431 0 : void SAL_CALL ResultSet::removePropertyChangeListener(
1432 : const OUString& aPropertyName,
1433 : const uno::Reference< beans::XPropertyChangeListener >& xListener )
1434 : throw( beans::UnknownPropertyException,
1435 : lang::WrappedTargetException,
1436 : uno::RuntimeException, std::exception )
1437 : {
1438 0 : osl::MutexGuard aGuard( m_pImpl->m_aMutex );
1439 :
1440 0 : if ( !aPropertyName.isEmpty() &&
1441 : !aPropertyName.equals(
1442 0 : OUString("RowCount") ) &&
1443 : !aPropertyName.equals(
1444 0 : OUString("IsRowCountFinal") ) )
1445 0 : throw beans::UnknownPropertyException();
1446 :
1447 0 : if ( m_pImpl->m_pPropertyChangeListeners )
1448 : m_pImpl->m_pPropertyChangeListeners->removeInterface(
1449 0 : aPropertyName, xListener );
1450 :
1451 0 : }
1452 :
1453 :
1454 : // virtual
1455 0 : void SAL_CALL ResultSet::addVetoableChangeListener(
1456 : const OUString&,
1457 : const uno::Reference< beans::XVetoableChangeListener >& )
1458 : throw( beans::UnknownPropertyException,
1459 : lang::WrappedTargetException,
1460 : uno::RuntimeException, std::exception )
1461 : {
1462 : // No constrained props, at the moment.
1463 0 : }
1464 :
1465 :
1466 : // virtual
1467 0 : void SAL_CALL ResultSet::removeVetoableChangeListener(
1468 : const OUString&,
1469 : const uno::Reference< beans::XVetoableChangeListener >& )
1470 : throw( beans::UnknownPropertyException,
1471 : lang::WrappedTargetException,
1472 : uno::RuntimeException, std::exception )
1473 : {
1474 : // No constrained props, at the moment.
1475 0 : }
1476 :
1477 :
1478 :
1479 : // Non-interface methods.
1480 :
1481 :
1482 :
1483 0 : void ResultSet::propertyChanged( const beans::PropertyChangeEvent& rEvt )
1484 : {
1485 0 : if ( !m_pImpl->m_pPropertyChangeListeners )
1486 0 : return;
1487 :
1488 : // Notify listeners interested especially in the changed property.
1489 : cppu::OInterfaceContainerHelper* pPropsContainer
1490 : = m_pImpl->m_pPropertyChangeListeners->getContainer(
1491 0 : rEvt.PropertyName );
1492 0 : if ( pPropsContainer )
1493 : {
1494 0 : cppu::OInterfaceIteratorHelper aIter( *pPropsContainer );
1495 0 : while ( aIter.hasMoreElements() )
1496 : {
1497 : uno::Reference< beans::XPropertyChangeListener > xListener(
1498 0 : aIter.next(), uno::UNO_QUERY );
1499 0 : if ( xListener.is() )
1500 0 : xListener->propertyChange( rEvt );
1501 0 : }
1502 : }
1503 :
1504 : // Notify listeners interested in all properties.
1505 : pPropsContainer
1506 0 : = m_pImpl->m_pPropertyChangeListeners->getContainer( OUString() );
1507 0 : if ( pPropsContainer )
1508 : {
1509 0 : cppu::OInterfaceIteratorHelper aIter( *pPropsContainer );
1510 0 : while ( aIter.hasMoreElements() )
1511 : {
1512 : uno::Reference< beans::XPropertyChangeListener > xListener(
1513 0 : aIter.next(), uno::UNO_QUERY );
1514 0 : if ( xListener.is() )
1515 0 : xListener->propertyChange( rEvt );
1516 0 : }
1517 : }
1518 : }
1519 :
1520 :
1521 0 : void ResultSet::rowCountChanged( sal_uInt32 nOld, sal_uInt32 nNew )
1522 : {
1523 : OSL_ENSURE( nOld < nNew, "ResultSet::rowCountChanged - nOld >= nNew!" );
1524 :
1525 0 : if ( !m_pImpl->m_pPropertyChangeListeners )
1526 0 : return;
1527 :
1528 : propertyChanged(
1529 : beans::PropertyChangeEvent(
1530 : static_cast< cppu::OWeakObject * >( this ),
1531 : OUString("RowCount"),
1532 : sal_False,
1533 : 1001,
1534 : uno::makeAny( nOld ), // old value
1535 0 : uno::makeAny( nNew ) ) ); // new value
1536 : }
1537 :
1538 :
1539 0 : void ResultSet::rowCountFinal()
1540 : {
1541 0 : if ( !m_pImpl->m_pPropertyChangeListeners )
1542 0 : return;
1543 :
1544 : propertyChanged(
1545 : beans::PropertyChangeEvent(
1546 : static_cast< cppu::OWeakObject * >( this ),
1547 : OUString("IsRowCountFinal"),
1548 : sal_False,
1549 : 1000,
1550 : uno:: makeAny( sal_False ), // old value
1551 0 : uno::makeAny( sal_True ) ) ); // new value
1552 : }
1553 :
1554 :
1555 0 : const uno::Sequence< beans::Property >& ResultSet::getProperties()
1556 : {
1557 0 : return m_pImpl->m_aProperties;
1558 : }
1559 :
1560 :
1561 : const uno::Reference< com::sun::star::ucb::XCommandEnvironment >&
1562 0 : ResultSet::getEnvironment()
1563 : {
1564 0 : return m_pImpl->m_xEnv;
1565 : }
1566 :
1567 : } // namespace ucbhelper
1568 :
1569 : namespace ucbhelper_impl {
1570 :
1571 :
1572 :
1573 :
1574 : // PropertySetInfo Implementation.
1575 :
1576 :
1577 :
1578 :
1579 0 : PropertySetInfo::PropertySetInfo(
1580 : const PropertyInfo* pProps,
1581 0 : sal_Int32 nProps )
1582 : {
1583 0 : m_pProps = new uno::Sequence< beans::Property >( nProps );
1584 :
1585 0 : if ( nProps )
1586 : {
1587 0 : const PropertyInfo* pEntry = pProps;
1588 0 : beans::Property* pProperties = m_pProps->getArray();
1589 :
1590 0 : for ( sal_Int32 n = 0; n < nProps; ++n )
1591 : {
1592 0 : beans::Property& rProp = pProperties[ n ];
1593 :
1594 0 : rProp.Name = OUString::createFromAscii( pEntry->pName );
1595 0 : rProp.Handle = pEntry->nHandle;
1596 0 : rProp.Type = pEntry->pGetCppuType();
1597 0 : rProp.Attributes = pEntry->nAttributes;
1598 :
1599 0 : pEntry++;
1600 : }
1601 : }
1602 0 : }
1603 :
1604 :
1605 : // virtual
1606 0 : PropertySetInfo::~PropertySetInfo()
1607 : {
1608 0 : delete m_pProps;
1609 0 : }
1610 :
1611 :
1612 :
1613 : // XInterface methods.
1614 0 : void SAL_CALL PropertySetInfo::acquire()
1615 : throw()
1616 : {
1617 0 : OWeakObject::acquire();
1618 0 : }
1619 :
1620 0 : void SAL_CALL PropertySetInfo::release()
1621 : throw()
1622 : {
1623 0 : OWeakObject::release();
1624 0 : }
1625 :
1626 0 : css::uno::Any SAL_CALL PropertySetInfo::queryInterface(
1627 : const css::uno::Type & rType )
1628 : throw( css::uno::RuntimeException, std::exception )
1629 : {
1630 : css::uno::Any aRet = cppu::queryInterface( rType,
1631 : (static_cast< lang::XTypeProvider* >(this)),
1632 : (static_cast< beans::XPropertySetInfo* >(this))
1633 0 : );
1634 0 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
1635 : }
1636 :
1637 : // XTypeProvider methods.
1638 :
1639 :
1640 :
1641 0 : XTYPEPROVIDER_IMPL_2( PropertySetInfo,
1642 : lang::XTypeProvider,
1643 : beans::XPropertySetInfo );
1644 :
1645 :
1646 :
1647 : // XPropertySetInfo methods.
1648 :
1649 :
1650 :
1651 : // virtual
1652 0 : uno::Sequence< beans::Property > SAL_CALL PropertySetInfo::getProperties()
1653 : throw( uno::RuntimeException, std::exception )
1654 : {
1655 0 : return uno::Sequence< beans::Property >( *m_pProps );
1656 : }
1657 :
1658 :
1659 : // virtual
1660 0 : beans::Property SAL_CALL PropertySetInfo::getPropertyByName(
1661 : const OUString& aName )
1662 : throw( beans::UnknownPropertyException, uno::RuntimeException, std::exception )
1663 : {
1664 0 : beans::Property aProp;
1665 0 : if ( queryProperty( aName, aProp ) )
1666 0 : return aProp;
1667 :
1668 0 : throw beans::UnknownPropertyException();
1669 : }
1670 :
1671 :
1672 : // virtual
1673 0 : sal_Bool SAL_CALL PropertySetInfo::hasPropertyByName(
1674 : const OUString& Name )
1675 : throw( uno::RuntimeException, std::exception )
1676 : {
1677 0 : beans::Property aProp;
1678 0 : return queryProperty( Name, aProp );
1679 : }
1680 :
1681 :
1682 0 : bool PropertySetInfo::queryProperty(
1683 : const OUString& aName, beans::Property& rProp )
1684 : {
1685 0 : sal_Int32 nCount = m_pProps->getLength();
1686 0 : const beans::Property* pProps = m_pProps->getConstArray();
1687 0 : for ( sal_Int32 n = 0; n < nCount; ++n )
1688 : {
1689 0 : const beans::Property& rCurr = pProps[ n ];
1690 0 : if ( rCurr.Name == aName )
1691 : {
1692 0 : rProp = rCurr;
1693 0 : return true;
1694 : }
1695 : }
1696 :
1697 0 : return false;
1698 : }
1699 :
1700 : } // namespace ucbhelper_impl
1701 :
1702 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
