?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fix baseline build (old cairo) - 'cairo_rectangle_int_t' does not name a type
[LibreOffice.git] / ucbhelper / source / provider / propertyvalueset.cxx
blob1732e70855642648cddfe039868143ae07302b9a
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
27 #include <vector>
28 #include <com/sun/star/beans/Property.hpp>
29 #include <com/sun/star/beans/XPropertyAccess.hpp>
30 #include <com/sun/star/beans/XPropertySet.hpp>
31 #include <com/sun/star/beans/XPropertySetInfo.hpp>
32 #include <com/sun/star/script/Converter.hpp>
33
34 #include "osl/diagnose.h"
35 #include "osl/mutex.hxx"
36 #include <ucbhelper/propertyvalueset.hxx>
37
38 using namespace com::sun::star::beans;
39 using namespace com::sun::star::container;
40 using namespace com::sun::star::io;
41 using namespace com::sun::star::lang;
42 using namespace com::sun::star::script;
43 using namespace com::sun::star::sdbc;
44 using namespace com::sun::star::uno;
45 using namespace com::sun::star::util;
46
47 namespace ucbhelper_impl
48 {
49
50
51
52 // PropertyValue.
53
54
55
56 const sal_uInt32 NO_VALUE_SET = 0x00000000;
57 const sal_uInt32 STRING_VALUE_SET = 0x00000001;
58 const sal_uInt32 BOOLEAN_VALUE_SET = 0x00000002;
59 const sal_uInt32 BYTE_VALUE_SET = 0x00000004;
60 const sal_uInt32 SHORT_VALUE_SET = 0x00000008;
61 const sal_uInt32 INT_VALUE_SET = 0x00000010;
62 const sal_uInt32 LONG_VALUE_SET = 0x00000020;
63 const sal_uInt32 FLOAT_VALUE_SET = 0x00000040;
64 const sal_uInt32 DOUBLE_VALUE_SET = 0x00000080;
65 const sal_uInt32 BYTES_VALUE_SET = 0x00000100;
66 const sal_uInt32 DATE_VALUE_SET = 0x00000200;
67 const sal_uInt32 TIME_VALUE_SET = 0x00000400;
68 const sal_uInt32 TIMESTAMP_VALUE_SET = 0x00000800;
69 const sal_uInt32 BINARYSTREAM_VALUE_SET = 0x00001000;
70 const sal_uInt32 CHARACTERSTREAM_VALUE_SET = 0x00002000;
71 const sal_uInt32 REF_VALUE_SET = 0x00004000;
72 const sal_uInt32 BLOB_VALUE_SET = 0x00008000;
73 const sal_uInt32 CLOB_VALUE_SET = 0x00010000;
74 const sal_uInt32 ARRAY_VALUE_SET = 0x00020000;
75 const sal_uInt32 OBJECT_VALUE_SET = 0x00040000;
76
77 struct PropertyValue
78 {
79 OUString
80 sPropertyName;
81
82 sal_uInt32 nPropsSet;
83 sal_uInt32 nOrigValue;
84
85 OUString aString; // getString
86 bool bBoolean; // getBoolean
87 sal_Int8 nByte; // getByte
88 sal_Int16 nShort; // getShort
89 sal_Int32 nInt; // getInt
90 sal_Int64 nLong; // getLong
91 float nFloat; // getFloat
92 double nDouble; // getDouble
93
94 Sequence< sal_Int8 > aBytes; // getBytes
95 Date aDate; // getDate
96 Time aTime; // getTime
97 DateTime aTimestamp; // getTimestamp
98 Reference< XInputStream > xBinaryStream; // getBinaryStream
99 Reference< XInputStream > xCharacterStream; // getCharacterStream
100 Reference< XRef > xRef; // getRef
101 Reference< XBlob > xBlob; // getBlob
102 Reference< XClob > xClob; // getClob
103 Reference< XArray > xArray; // getArray
104 Any aObject; // getObject
105
106 inline PropertyValue()
107 : nPropsSet( NO_VALUE_SET ), nOrigValue( NO_VALUE_SET ),
108 bBoolean(false),
109 nByte(0),
110 nShort(0),
111 nInt(0),
112 nLong(0),
113 nFloat(0.0),
114 nDouble(0.0)
115 {}
116 };
117 } // namespace ucbhelper_impl
118
119 using namespace ucbhelper_impl;
120
121 namespace ucbhelper
122 {
123
124
125
126 // class PropertyValues.
127
128
129
130 typedef std::vector< ucbhelper_impl::PropertyValue > PropertyValuesVector;
131
132 class PropertyValues : public PropertyValuesVector {};
133
134 } // namespace ucbhelper
135
136
137
138 // Welcome to the macro hell...
139
140
141
142 #define GETVALUE_IMPL_TYPE( _type_, _type_name_, _member_name_, _cppu_type_ ) \
143 \
144 osl::MutexGuard aGuard( m_aMutex ); \
145 \
146 _type_ aValue = _type_(); /* default ctor */ \
147 \
148 m_bWasNull = true; \
149 \
150 if ( ( columnIndex < 1 ) \
151 || ( columnIndex > sal_Int32( m_pValues->size() ) ) ) \
152 { \
153 OSL_FAIL( "PropertyValueSet - index out of range!" ); \
154 } \
155 else \
156 { \
157 ucbhelper_impl::PropertyValue& rValue \
158 = (*m_pValues)[ columnIndex - 1 ]; \
159 \
160 if ( rValue.nOrigValue != NO_VALUE_SET ) \
161 { \
162 if ( rValue.nPropsSet & _type_name_ ) \
163 { \
164 /* Values is present natively... */ \
165 aValue = rValue._member_name_; \
166 m_bWasNull = false; \
167 } \
168 else \
169 { \
170 if ( !(rValue.nPropsSet & OBJECT_VALUE_SET) ) \
171 { \
172 /* Value is not (yet) available as Any. Create it. */ \
173 getObject( columnIndex, Reference< XNameAccess >() ); \
174 } \
175 \
176 if ( rValue.nPropsSet & OBJECT_VALUE_SET ) \
177 { \
178 /* Value is available as Any. */ \
179 \
180 if ( rValue.aObject.hasValue() ) \
181 { \
182 /* Try to convert into native value. */ \
183 if ( rValue.aObject >>= aValue ) \
184 { \
185 rValue._member_name_ = aValue; \
186 rValue.nPropsSet |= _type_name_; \
187 m_bWasNull = false; \
188 } \
189 else \
190 { \
191 /* Last chance. Try type converter service... */ \
192 \
193 Reference< XTypeConverter > xConverter \
194 = getTypeConverter(); \
195 if ( xConverter.is() ) \
196 { \
197 try \
198 { \
199 Any aConvAny = xConverter->convertTo( \
200 rValue.aObject, \
201 _cppu_type_ ); \
202 \
203 if ( aConvAny >>= aValue ) \
204 { \
205 rValue._member_name_ = aValue; \
206 rValue.nPropsSet |= _type_name_; \
207 m_bWasNull = false; \
208 } \
209 } \
210 catch (const IllegalArgumentException&) \
211 { \
212 } \
213 catch (const CannotConvertException&) \
214 { \
215 } \
216 } \
217 } \
218 } \
219 } \
220 } \
221 } \
222 } \
223 return aValue;
224
225 #define GETVALUE_IMPL( _type_, _type_name_, _member_name_ ) \
226 GETVALUE_IMPL_TYPE( _type_, \
227 _type_name_, \
228 _member_name_, \
229 cppu::UnoType<_type_>::get() )
230
231 #define SETVALUE_IMPL( _prop_name_, _type_name_, _member_name_, _value_ ) \
232 \
233 osl::MutexGuard aGuard( m_aMutex ); \
234 \
235 ucbhelper_impl::PropertyValue aNewValue; \
236 aNewValue.sPropertyName = _prop_name_; \
237 aNewValue.nPropsSet = _type_name_; \
238 aNewValue.nOrigValue = _type_name_; \
239 aNewValue._member_name_ = _value_; \
240 \
241 m_pValues->push_back( aNewValue );
242
243 namespace ucbhelper {
244
245
246
247
248 // PropertyValueSet Implementation.
249
250
251
252
253
254 PropertyValueSet::PropertyValueSet(
255 const Reference< XComponentContext >& rxContext )
256 : m_xContext( rxContext ),
257 m_pValues( new PropertyValues ),
258 m_bWasNull( false ),
259 m_bTriedToGetTypeConverter( false )
260
261 {
262 }
263
264
265 // virtual
266 PropertyValueSet::~PropertyValueSet()
267 {
268 delete m_pValues;
269 }
270
271
272
273 // XInterface methods.
274 void SAL_CALL PropertyValueSet::acquire()
275 throw()
276 {
277 OWeakObject::acquire();
278 }
279
280 void SAL_CALL PropertyValueSet::release()
281 throw()
282 {
283 OWeakObject::release();
284 }
285
286 css::uno::Any SAL_CALL PropertyValueSet::queryInterface( const css::uno::Type & rType )
287 throw( css::uno::RuntimeException, std::exception )
288 {
289 css::uno::Any aRet = cppu::queryInterface( rType,
290 (static_cast< XTypeProvider* >(this)),
291 (static_cast< XRow* >(this)),
292 (static_cast< XColumnLocate* >(this))
293 );
294 return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
295 }
296
297 // XTypeProvider methods.
298
299
300
301 XTYPEPROVIDER_IMPL_3( PropertyValueSet,
302 XTypeProvider,
303 XRow,
304 XColumnLocate );
305
306
307
308 // XRow methods.
309
310
311
312 // virtual
313 sal_Bool SAL_CALL PropertyValueSet::wasNull()
314 throw( SQLException, RuntimeException, std::exception )
315 {
316 // This method can not be implemented correctly!!! Imagine different
317 // threads doing a getXYZ - wasNull calling sequence on the same
318 // implementation object...
319 return m_bWasNull;
320 }
321
322
323 // virtual
324 OUString SAL_CALL PropertyValueSet::getString( sal_Int32 columnIndex )
325 throw( SQLException, RuntimeException, std::exception )
326 {
327 GETVALUE_IMPL( OUString, STRING_VALUE_SET, aString );
328 }
329
330
331 // virtual
332 sal_Bool SAL_CALL PropertyValueSet::getBoolean( sal_Int32 columnIndex )
333 throw( SQLException, RuntimeException, std::exception )
334 {
335 GETVALUE_IMPL_TYPE(
336 bool, BOOLEAN_VALUE_SET, bBoolean, cppu::UnoType<bool>::get() );
337 }
338
339
340 // virtual
341 sal_Int8 SAL_CALL PropertyValueSet::getByte( sal_Int32 columnIndex )
342 throw( SQLException, RuntimeException, std::exception )
343 {
344 GETVALUE_IMPL( sal_Int8, BYTE_VALUE_SET, nByte );
345 }
346
347
348 // virtual
349 sal_Int16 SAL_CALL PropertyValueSet::getShort( sal_Int32 columnIndex )
350 throw( SQLException, RuntimeException, std::exception )
351 {
352 GETVALUE_IMPL( sal_Int16, SHORT_VALUE_SET, nShort );
353 }
354
355
356 // virtual
357 sal_Int32 SAL_CALL PropertyValueSet::getInt( sal_Int32 columnIndex )
358 throw( SQLException, RuntimeException, std::exception )
359 {
360 GETVALUE_IMPL( sal_Int32, INT_VALUE_SET, nInt );
361 }
362
363
364 // virtual
365 sal_Int64 SAL_CALL PropertyValueSet::getLong( sal_Int32 columnIndex )
366 throw( SQLException, RuntimeException, std::exception )
367 {
368 GETVALUE_IMPL( sal_Int64, LONG_VALUE_SET, nLong );
369 }
370
371
372 // virtual
373 float SAL_CALL PropertyValueSet::getFloat( sal_Int32 columnIndex )
374 throw( SQLException, RuntimeException, std::exception )
375 {
376 GETVALUE_IMPL( float, FLOAT_VALUE_SET, nFloat );
377 }
378
379
380 // virtual
381 double SAL_CALL PropertyValueSet::getDouble( sal_Int32 columnIndex )
382 throw( SQLException, RuntimeException, std::exception )
383 {
384 GETVALUE_IMPL( double, DOUBLE_VALUE_SET, nDouble );
385 }
386
387
388 // virtual
389 Sequence< sal_Int8 > SAL_CALL
390 PropertyValueSet::getBytes( sal_Int32 columnIndex )
391 throw( SQLException, RuntimeException, std::exception )
392 {
393 GETVALUE_IMPL( Sequence< sal_Int8 >, BYTES_VALUE_SET, aBytes );
394 }
395
396
397 // virtual
398 Date SAL_CALL PropertyValueSet::getDate( sal_Int32 columnIndex )
399 throw( SQLException, RuntimeException, std::exception )
400 {
401 GETVALUE_IMPL( Date, DATE_VALUE_SET, aDate );
402 }
403
404
405 // virtual
406 Time SAL_CALL PropertyValueSet::getTime( sal_Int32 columnIndex )
407 throw( SQLException, RuntimeException, std::exception )
408 {
409 GETVALUE_IMPL( Time, TIME_VALUE_SET, aTime );
410 }
411
412
413 // virtual
414 DateTime SAL_CALL PropertyValueSet::getTimestamp( sal_Int32 columnIndex )
415 throw( SQLException, RuntimeException, std::exception )
416 {
417 GETVALUE_IMPL( DateTime, TIMESTAMP_VALUE_SET, aTimestamp );
418 }
419
420
421 // virtual
422 Reference< XInputStream > SAL_CALL
423 PropertyValueSet::getBinaryStream( sal_Int32 columnIndex )
424 throw( SQLException, RuntimeException, std::exception )
425 {
426 GETVALUE_IMPL(
427 Reference< XInputStream >, BINARYSTREAM_VALUE_SET, xBinaryStream );
428 }
429
430
431 // virtual
432 Reference< XInputStream > SAL_CALL
433 PropertyValueSet::getCharacterStream( sal_Int32 columnIndex )
434 throw( SQLException, RuntimeException, std::exception )
435 {
436 GETVALUE_IMPL(
437 Reference< XInputStream >, CHARACTERSTREAM_VALUE_SET, xCharacterStream );
438 }
439
440
441 // virtual
442 Any SAL_CALL PropertyValueSet::getObject(
443 sal_Int32 columnIndex,
444 const Reference< XNameAccess >& )
445 throw( SQLException, RuntimeException, std::exception )
446 {
447 osl::MutexGuard aGuard( m_aMutex );
448
449 Any aValue;
450
451 m_bWasNull = true;
452
453 if ( ( columnIndex < 1 )
454 || ( columnIndex > sal_Int32( m_pValues->size() ) ) )
455 {
456 OSL_FAIL( "PropertyValueSet - index out of range!" );
457 }
458 else
459 {
460 ucbhelper_impl::PropertyValue& rValue
461 = (*m_pValues)[ columnIndex - 1 ];
462
463 if ( rValue.nPropsSet & OBJECT_VALUE_SET )
464 {
465 // Values is present natively...
466 aValue = rValue.aObject;
467 m_bWasNull = false;
468 }
469 else
470 {
471 // Make Any from original value.
472
473 switch ( rValue.nOrigValue )
474 {
475 case NO_VALUE_SET:
476 break;
477
478 case STRING_VALUE_SET:
479 aValue <<= rValue.aString;
480 break;
481
482 case BOOLEAN_VALUE_SET:
483 aValue <<= rValue.bBoolean;
484 break;
485
486 case BYTE_VALUE_SET:
487 aValue <<= rValue.nByte;
488 break;
489
490 case SHORT_VALUE_SET:
491 aValue <<= rValue.nShort;
492 break;
493
494 case INT_VALUE_SET:
495 aValue <<= rValue.nInt;
496 break;
497
498 case LONG_VALUE_SET:
499 aValue <<= rValue.nLong;
500 break;
501
502 case FLOAT_VALUE_SET:
503 aValue <<= rValue.nFloat;
504 break;
505
506 case DOUBLE_VALUE_SET:
507 aValue <<= rValue.nDouble;
508 break;
509
510 case BYTES_VALUE_SET:
511 aValue <<= rValue.aBytes;
512 break;
513
514 case DATE_VALUE_SET:
515 aValue <<= rValue.aDate;
516 break;
517
518 case TIME_VALUE_SET:
519 aValue <<= rValue.aTime;
520 break;
521
522 case TIMESTAMP_VALUE_SET:
523 aValue <<= rValue.aTimestamp;
524 break;
525
526 case BINARYSTREAM_VALUE_SET:
527 aValue <<= rValue.xBinaryStream;
528 break;
529
530 case CHARACTERSTREAM_VALUE_SET:
531 aValue <<= rValue.xCharacterStream;
532 break;
533
534 case REF_VALUE_SET:
535 aValue <<= rValue.xRef;
536 break;
537
538 case BLOB_VALUE_SET:
539 aValue <<= rValue.xBlob;
540 break;
541
542 case CLOB_VALUE_SET:
543 aValue <<= rValue.xClob;
544 break;
545
546 case ARRAY_VALUE_SET:
547 aValue <<= rValue.xArray;
548 break;
549
550 case OBJECT_VALUE_SET:
551 // Fall-through is intended!
552 default:
553 OSL_FAIL( "PropertyValueSet::getObject - "
554 "Wrong original type" );
555 break;
556 }
557
558 if ( aValue.hasValue() )
559 {
560 rValue.aObject = aValue;
561 rValue.nPropsSet |= OBJECT_VALUE_SET;
562 m_bWasNull = false;
563 }
564 }
565 }
566
567 return aValue;
568 }
569
570
571 // virtual
572 Reference< XRef > SAL_CALL PropertyValueSet::getRef( sal_Int32 columnIndex )
573 throw( SQLException, RuntimeException, std::exception )
574 {
575 GETVALUE_IMPL( Reference< XRef >, REF_VALUE_SET, xRef );
576 }
577
578
579 // virtual
580 Reference< XBlob > SAL_CALL PropertyValueSet::getBlob( sal_Int32 columnIndex )
581 throw( SQLException, RuntimeException, std::exception )
582 {
583 GETVALUE_IMPL( Reference< XBlob >, BLOB_VALUE_SET, xBlob );
584 }
585
586
587 // virtual
588 Reference< XClob > SAL_CALL PropertyValueSet::getClob( sal_Int32 columnIndex )
589 throw( SQLException, RuntimeException, std::exception )
590 {
591 GETVALUE_IMPL( Reference< XClob >, CLOB_VALUE_SET, xClob );
592 }
593
594
595 // virtual
596 Reference< XArray > SAL_CALL PropertyValueSet::getArray( sal_Int32 columnIndex )
597 throw( SQLException, RuntimeException, std::exception )
598 {
599 GETVALUE_IMPL( Reference< XArray >, ARRAY_VALUE_SET, xArray );
600 }
601
602
603
604 // XColumnLocate methods.
605
606
607
608 // virtual
609 sal_Int32 SAL_CALL PropertyValueSet::findColumn( const OUString& columnName )
610 throw( SQLException, RuntimeException, std::exception )
611 {
612 osl::MutexGuard aGuard( m_aMutex );
613
614 if ( !columnName.isEmpty() )
615 {
616 sal_Int32 nCount = m_pValues->size();
617 for ( sal_Int32 n = 0; n < nCount; ++n )
618 {
619 if ( (*m_pValues)[ n ].sPropertyName.equals( columnName ) )
620 return sal_Int32( n + 1 ); // Index is 1-based.
621 }
622 }
623 return 0;
624 }
625
626
627
628 // Non-interface methods.
629
630
631
632 const Reference< XTypeConverter >& PropertyValueSet::getTypeConverter()
633 {
634 osl::MutexGuard aGuard( m_aMutex );
635
636 if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() )
637 {
638 m_bTriedToGetTypeConverter = true;
639 m_xTypeConverter = Converter::create(m_xContext);
640
641 OSL_ENSURE( m_xTypeConverter.is(),
642 "PropertyValueSet::getTypeConverter() - "
643 "Service 'com.sun.star.script.Converter' n/a!" );
644 }
645 return m_xTypeConverter;
646 }
647
648
649 void PropertyValueSet::appendString( const OUString& rPropName,
650 const OUString& rValue )
651 {
652 SETVALUE_IMPL( rPropName, STRING_VALUE_SET, aString, rValue );
653 }
654
655
656 void PropertyValueSet::appendBoolean( const OUString& rPropName,
657 bool bValue )
658 {
659 SETVALUE_IMPL( rPropName, BOOLEAN_VALUE_SET, bBoolean, bValue );
660 }
661
662
663 void PropertyValueSet::appendLong( const OUString& rPropName,
664 sal_Int64 nValue )
665 {
666 SETVALUE_IMPL( rPropName, LONG_VALUE_SET, nLong, nValue );
667 }
668
669
670 void PropertyValueSet::appendTimestamp( const OUString& rPropName,
671 const DateTime& rValue )
672 {
673 SETVALUE_IMPL( rPropName, TIMESTAMP_VALUE_SET, aTimestamp, rValue );
674 }
675
676
677 void PropertyValueSet::appendObject( const OUString& rPropName,
678 const Any& rValue )
679 {
680 SETVALUE_IMPL( rPropName, OBJECT_VALUE_SET, aObject, rValue );
681 }
682
683
684 void PropertyValueSet::appendVoid( const OUString& rPropName )
685 {
686 SETVALUE_IMPL( rPropName, NO_VALUE_SET, aObject, Any() );
687 }
688
689
690 void PropertyValueSet::appendPropertySet(
691 const Reference< XPropertySet >& rxSet )
692 {
693 if ( rxSet.is() )
694 {
695 Reference< XPropertySetInfo > xInfo = rxSet->getPropertySetInfo();
696 if ( xInfo.is() )
697 {
698 Sequence< Property > aProps = xInfo->getProperties();
699 const Property* pProps = aProps.getConstArray();
700 sal_Int32 nPropsCount = aProps.getLength();
701
702 Reference< XPropertyAccess > xPropertyAccess( rxSet, UNO_QUERY );
703 if ( xPropertyAccess.is() )
704 {
705 // Efficient: Get all prop values with one ( remote) call.
706
707 Sequence< ::com::sun::star::beans::PropertyValue > aPropValues
708 = xPropertyAccess->getPropertyValues();
709
710 const ::com::sun::star::beans::PropertyValue* pPropValues
711 = aPropValues.getConstArray();
712
713 sal_Int32 nValuesCount = aPropValues.getLength();
714 for ( sal_Int32 n = 0; n < nValuesCount; ++n )
715 {
716 const ::com::sun::star::beans::PropertyValue& rPropValue
717 = pPropValues[ n ];
718
719 // Find info for current property value.
720 for ( sal_Int32 m = 0; m < nPropsCount; ++m )
721 {
722 const Property& rProp = pProps[ m ];
723 if ( rProp.Name == rPropValue.Name )
724 {
725 // Found!
726 appendObject( rProp, rPropValue.Value );
727 break;
728 }
729 }
730 }
731 }
732 else
733 {
734 // Get every single prop value with one ( remote) call.
735
736 for ( sal_Int32 n = 0; n < nPropsCount; ++n )
737 {
738 const Property& rProp = pProps[ n ];
739
740 try
741 {
742 Any aValue = rxSet->getPropertyValue( rProp.Name );
743
744 if ( aValue.hasValue() )
745 appendObject( rProp, aValue );
746 }
747 catch (const UnknownPropertyException&)
748 {
749 }
750 catch (const WrappedTargetException&)
751 {
752 }
753 }
754 }
755 }
756 }
757 }
758
759
760 bool PropertyValueSet::appendPropertySetValue(
761 const Reference< XPropertySet >& rxSet,
762 const Property& rProperty )
763 {
764 if ( rxSet.is() )
765 {
766 try
767 {
768 Any aValue = rxSet->getPropertyValue( rProperty.Name );
769 if ( aValue.hasValue() )
770 {
771 appendObject( rProperty, aValue );
772 return true;
773 }
774 }
775 catch (const UnknownPropertyException&)
776 {
777 }
778 catch (const WrappedTargetException&)
779 {
780 }
781 }
782
783 // Error.
784 return false;
785 }
786
787 } // namespace ucbhelper
788
789 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE