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 :
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 17888 : 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 5752 : 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 5752 : nDouble(0.0)
115 5752 : {}
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 11096 : 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 : getCppuType( static_cast< const _type_ * >( 0 ) ) )
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 5548 : PropertyValueSet::PropertyValueSet(
255 : const Reference< XComponentContext >& rxContext )
256 : : m_xContext( rxContext ),
257 5548 : m_pValues( new PropertyValues ),
258 : m_bWasNull( false ),
259 11096 : m_bTriedToGetTypeConverter( false )
260 :
261 : {
262 5548 : }
263 :
264 :
265 : // virtual
266 16644 : PropertyValueSet::~PropertyValueSet()
267 : {
268 5548 : delete m_pValues;
269 11096 : }
270 :
271 :
272 :
273 : // XInterface methods.
274 22504 : void SAL_CALL PropertyValueSet::acquire()
275 : throw()
276 : {
277 22504 : OWeakObject::acquire();
278 22504 : }
279 :
280 22504 : void SAL_CALL PropertyValueSet::release()
281 : throw()
282 : {
283 22504 : OWeakObject::release();
284 22504 : }
285 :
286 0 : 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 0 : );
294 0 : return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
295 : }
296 :
297 : // XTypeProvider methods.
298 :
299 :
300 :
301 0 : XTYPEPROVIDER_IMPL_3( PropertyValueSet,
302 : XTypeProvider,
303 : XRow,
304 : XColumnLocate );
305 :
306 :
307 :
308 : // XRow methods.
309 :
310 :
311 :
312 : // virtual
313 20 : 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 20 : return m_bWasNull;
320 : }
321 :
322 :
323 : // virtual
324 64 : OUString SAL_CALL PropertyValueSet::getString( sal_Int32 columnIndex )
325 : throw( SQLException, RuntimeException, std::exception )
326 : {
327 64 : GETVALUE_IMPL( OUString, STRING_VALUE_SET, aString );
328 : }
329 :
330 :
331 : // virtual
332 40 : sal_Bool SAL_CALL PropertyValueSet::getBoolean( sal_Int32 columnIndex )
333 : throw( SQLException, RuntimeException, std::exception )
334 : {
335 80 : GETVALUE_IMPL_TYPE(
336 40 : bool, BOOLEAN_VALUE_SET, bBoolean, getCppuBooleanType() );
337 : }
338 :
339 :
340 : // virtual
341 0 : sal_Int8 SAL_CALL PropertyValueSet::getByte( sal_Int32 columnIndex )
342 : throw( SQLException, RuntimeException, std::exception )
343 : {
344 0 : GETVALUE_IMPL( sal_Int8, BYTE_VALUE_SET, nByte );
345 : }
346 :
347 :
348 : // virtual
349 0 : sal_Int16 SAL_CALL PropertyValueSet::getShort( sal_Int32 columnIndex )
350 : throw( SQLException, RuntimeException, std::exception )
351 : {
352 0 : GETVALUE_IMPL( sal_Int16, SHORT_VALUE_SET, nShort );
353 : }
354 :
355 :
356 : // virtual
357 0 : sal_Int32 SAL_CALL PropertyValueSet::getInt( sal_Int32 columnIndex )
358 : throw( SQLException, RuntimeException, std::exception )
359 : {
360 0 : GETVALUE_IMPL( sal_Int32, INT_VALUE_SET, nInt );
361 : }
362 :
363 :
364 : // virtual
365 0 : sal_Int64 SAL_CALL PropertyValueSet::getLong( sal_Int32 columnIndex )
366 : throw( SQLException, RuntimeException, std::exception )
367 : {
368 0 : GETVALUE_IMPL( sal_Int64, LONG_VALUE_SET, nLong );
369 : }
370 :
371 :
372 : // virtual
373 0 : float SAL_CALL PropertyValueSet::getFloat( sal_Int32 columnIndex )
374 : throw( SQLException, RuntimeException, std::exception )
375 : {
376 0 : GETVALUE_IMPL( float, FLOAT_VALUE_SET, nFloat );
377 : }
378 :
379 :
380 : // virtual
381 0 : double SAL_CALL PropertyValueSet::getDouble( sal_Int32 columnIndex )
382 : throw( SQLException, RuntimeException, std::exception )
383 : {
384 0 : GETVALUE_IMPL( double, DOUBLE_VALUE_SET, nDouble );
385 : }
386 :
387 :
388 : // virtual
389 : Sequence< sal_Int8 > SAL_CALL
390 0 : PropertyValueSet::getBytes( sal_Int32 columnIndex )
391 : throw( SQLException, RuntimeException, std::exception )
392 : {
393 0 : GETVALUE_IMPL( Sequence< sal_Int8 >, BYTES_VALUE_SET, aBytes );
394 : }
395 :
396 :
397 : // virtual
398 0 : Date SAL_CALL PropertyValueSet::getDate( sal_Int32 columnIndex )
399 : throw( SQLException, RuntimeException, std::exception )
400 : {
401 0 : GETVALUE_IMPL( Date, DATE_VALUE_SET, aDate );
402 : }
403 :
404 :
405 : // virtual
406 0 : Time SAL_CALL PropertyValueSet::getTime( sal_Int32 columnIndex )
407 : throw( SQLException, RuntimeException, std::exception )
408 : {
409 0 : GETVALUE_IMPL( Time, TIME_VALUE_SET, aTime );
410 : }
411 :
412 :
413 : // virtual
414 0 : DateTime SAL_CALL PropertyValueSet::getTimestamp( sal_Int32 columnIndex )
415 : throw( SQLException, RuntimeException, std::exception )
416 : {
417 0 : GETVALUE_IMPL( DateTime, TIMESTAMP_VALUE_SET, aTimestamp );
418 : }
419 :
420 :
421 : // virtual
422 : Reference< XInputStream > SAL_CALL
423 0 : PropertyValueSet::getBinaryStream( sal_Int32 columnIndex )
424 : throw( SQLException, RuntimeException, std::exception )
425 : {
426 0 : GETVALUE_IMPL(
427 0 : Reference< XInputStream >, BINARYSTREAM_VALUE_SET, xBinaryStream );
428 : }
429 :
430 :
431 : // virtual
432 : Reference< XInputStream > SAL_CALL
433 0 : PropertyValueSet::getCharacterStream( sal_Int32 columnIndex )
434 : throw( SQLException, RuntimeException, std::exception )
435 : {
436 0 : GETVALUE_IMPL(
437 0 : Reference< XInputStream >, CHARACTERSTREAM_VALUE_SET, xCharacterStream );
438 : }
439 :
440 :
441 : // virtual
442 5728 : Any SAL_CALL PropertyValueSet::getObject(
443 : sal_Int32 columnIndex,
444 : const Reference< XNameAccess >& )
445 : throw( SQLException, RuntimeException, std::exception )
446 : {
447 5728 : osl::MutexGuard aGuard( m_aMutex );
448 :
449 5728 : Any aValue;
450 :
451 5728 : m_bWasNull = true;
452 :
453 5728 : if ( ( columnIndex < 1 )
454 5728 : || ( 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 5728 : = (*m_pValues)[ columnIndex - 1 ];
462 :
463 5728 : if ( rValue.nPropsSet & OBJECT_VALUE_SET )
464 : {
465 : // Values is present natively...
466 412 : aValue = rValue.aObject;
467 412 : m_bWasNull = false;
468 : }
469 : else
470 : {
471 : // Make Any from original value.
472 :
473 5316 : switch ( rValue.nOrigValue )
474 : {
475 : case NO_VALUE_SET:
476 4 : break;
477 :
478 : case STRING_VALUE_SET:
479 2320 : aValue <<= rValue.aString;
480 2320 : break;
481 :
482 : case BOOLEAN_VALUE_SET:
483 2980 : aValue <<= rValue.bBoolean;
484 2980 : break;
485 :
486 : case BYTE_VALUE_SET:
487 0 : aValue <<= rValue.nByte;
488 0 : break;
489 :
490 : case SHORT_VALUE_SET:
491 0 : aValue <<= rValue.nShort;
492 0 : break;
493 :
494 : case INT_VALUE_SET:
495 0 : aValue <<= rValue.nInt;
496 0 : break;
497 :
498 : case LONG_VALUE_SET:
499 12 : aValue <<= rValue.nLong;
500 12 : break;
501 :
502 : case FLOAT_VALUE_SET:
503 0 : aValue <<= rValue.nFloat;
504 0 : break;
505 :
506 : case DOUBLE_VALUE_SET:
507 0 : aValue <<= rValue.nDouble;
508 0 : break;
509 :
510 : case BYTES_VALUE_SET:
511 0 : aValue <<= rValue.aBytes;
512 0 : break;
513 :
514 : case DATE_VALUE_SET:
515 0 : aValue <<= rValue.aDate;
516 0 : break;
517 :
518 : case TIME_VALUE_SET:
519 0 : aValue <<= rValue.aTime;
520 0 : break;
521 :
522 : case TIMESTAMP_VALUE_SET:
523 0 : aValue <<= rValue.aTimestamp;
524 0 : break;
525 :
526 : case BINARYSTREAM_VALUE_SET:
527 0 : aValue <<= rValue.xBinaryStream;
528 0 : break;
529 :
530 : case CHARACTERSTREAM_VALUE_SET:
531 0 : aValue <<= rValue.xCharacterStream;
532 0 : break;
533 :
534 : case REF_VALUE_SET:
535 0 : aValue <<= rValue.xRef;
536 0 : break;
537 :
538 : case BLOB_VALUE_SET:
539 0 : aValue <<= rValue.xBlob;
540 0 : break;
541 :
542 : case CLOB_VALUE_SET:
543 0 : aValue <<= rValue.xClob;
544 0 : break;
545 :
546 : case ARRAY_VALUE_SET:
547 0 : aValue <<= rValue.xArray;
548 0 : break;
549 :
550 : case OBJECT_VALUE_SET:
551 : // Fall-through is intended!
552 : default:
553 : OSL_FAIL( "PropertyValueSet::getObject - "
554 : "Wrong original type" );
555 0 : break;
556 : }
557 :
558 5316 : if ( aValue.hasValue() )
559 : {
560 5312 : rValue.aObject = aValue;
561 5312 : rValue.nPropsSet |= OBJECT_VALUE_SET;
562 5312 : m_bWasNull = false;
563 : }
564 : }
565 : }
566 :
567 5728 : return aValue;
568 : }
569 :
570 :
571 : // virtual
572 0 : Reference< XRef > SAL_CALL PropertyValueSet::getRef( sal_Int32 columnIndex )
573 : throw( SQLException, RuntimeException, std::exception )
574 : {
575 0 : GETVALUE_IMPL( Reference< XRef >, REF_VALUE_SET, xRef );
576 : }
577 :
578 :
579 : // virtual
580 0 : Reference< XBlob > SAL_CALL PropertyValueSet::getBlob( sal_Int32 columnIndex )
581 : throw( SQLException, RuntimeException, std::exception )
582 : {
583 0 : GETVALUE_IMPL( Reference< XBlob >, BLOB_VALUE_SET, xBlob );
584 : }
585 :
586 :
587 : // virtual
588 0 : Reference< XClob > SAL_CALL PropertyValueSet::getClob( sal_Int32 columnIndex )
589 : throw( SQLException, RuntimeException, std::exception )
590 : {
591 0 : GETVALUE_IMPL( Reference< XClob >, CLOB_VALUE_SET, xClob );
592 : }
593 :
594 :
595 : // virtual
596 0 : Reference< XArray > SAL_CALL PropertyValueSet::getArray( sal_Int32 columnIndex )
597 : throw( SQLException, RuntimeException, std::exception )
598 : {
599 0 : GETVALUE_IMPL( Reference< XArray >, ARRAY_VALUE_SET, xArray );
600 : }
601 :
602 :
603 :
604 : // XColumnLocate methods.
605 :
606 :
607 :
608 : // virtual
609 0 : sal_Int32 SAL_CALL PropertyValueSet::findColumn( const OUString& columnName )
610 : throw( SQLException, RuntimeException, std::exception )
611 : {
612 0 : osl::MutexGuard aGuard( m_aMutex );
613 :
614 0 : if ( !columnName.isEmpty() )
615 : {
616 0 : sal_Int32 nCount = m_pValues->size();
617 0 : for ( sal_Int32 n = 0; n < nCount; ++n )
618 : {
619 0 : if ( (*m_pValues)[ n ].sPropertyName.equals( columnName ) )
620 0 : return sal_Int32( n + 1 ); // Index is 1-based.
621 : }
622 : }
623 0 : return 0;
624 : }
625 :
626 :
627 :
628 : // Non-interface methods.
629 :
630 :
631 :
632 0 : const Reference< XTypeConverter >& PropertyValueSet::getTypeConverter()
633 : {
634 0 : osl::MutexGuard aGuard( m_aMutex );
635 :
636 0 : if ( !m_bTriedToGetTypeConverter && !m_xTypeConverter.is() )
637 : {
638 0 : m_bTriedToGetTypeConverter = true;
639 0 : 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 0 : return m_xTypeConverter;
646 : }
647 :
648 :
649 2344 : void PropertyValueSet::appendString( const OUString& rPropName,
650 : const OUString& rValue )
651 : {
652 2344 : SETVALUE_IMPL( rPropName, STRING_VALUE_SET, aString, rValue );
653 2344 : }
654 :
655 :
656 3020 : void PropertyValueSet::appendBoolean( const OUString& rPropName,
657 : bool bValue )
658 : {
659 3020 : SETVALUE_IMPL( rPropName, BOOLEAN_VALUE_SET, bBoolean, bValue );
660 3020 : }
661 :
662 :
663 12 : void PropertyValueSet::appendLong( const OUString& rPropName,
664 : sal_Int64 nValue )
665 : {
666 12 : SETVALUE_IMPL( rPropName, LONG_VALUE_SET, nLong, nValue );
667 12 : }
668 :
669 :
670 0 : void PropertyValueSet::appendTimestamp( const OUString& rPropName,
671 : const DateTime& rValue )
672 : {
673 0 : SETVALUE_IMPL( rPropName, TIMESTAMP_VALUE_SET, aTimestamp, rValue );
674 0 : }
675 :
676 :
677 348 : void PropertyValueSet::appendObject( const OUString& rPropName,
678 : const Any& rValue )
679 : {
680 348 : SETVALUE_IMPL( rPropName, OBJECT_VALUE_SET, aObject, rValue );
681 348 : }
682 :
683 :
684 28 : void PropertyValueSet::appendVoid( const OUString& rPropName )
685 : {
686 28 : SETVALUE_IMPL( rPropName, NO_VALUE_SET, aObject, Any() );
687 28 : }
688 :
689 :
690 0 : void PropertyValueSet::appendPropertySet(
691 : const Reference< XPropertySet >& rxSet )
692 : {
693 0 : if ( rxSet.is() )
694 : {
695 0 : Reference< XPropertySetInfo > xInfo = rxSet->getPropertySetInfo();
696 0 : if ( xInfo.is() )
697 : {
698 0 : Sequence< Property > aProps = xInfo->getProperties();
699 0 : const Property* pProps = aProps.getConstArray();
700 0 : sal_Int32 nPropsCount = aProps.getLength();
701 :
702 0 : Reference< XPropertyAccess > xPropertyAccess( rxSet, UNO_QUERY );
703 0 : if ( xPropertyAccess.is() )
704 : {
705 : // Efficient: Get all prop values with one ( remote) call.
706 :
707 : Sequence< ::com::sun::star::beans::PropertyValue > aPropValues
708 0 : = xPropertyAccess->getPropertyValues();
709 :
710 : const ::com::sun::star::beans::PropertyValue* pPropValues
711 0 : = aPropValues.getConstArray();
712 :
713 0 : sal_Int32 nValuesCount = aPropValues.getLength();
714 0 : for ( sal_Int32 n = 0; n < nValuesCount; ++n )
715 : {
716 : const ::com::sun::star::beans::PropertyValue& rPropValue
717 0 : = pPropValues[ n ];
718 :
719 : // Find info for current property value.
720 0 : for ( sal_Int32 m = 0; m < nPropsCount; ++m )
721 : {
722 0 : const Property& rProp = pProps[ m ];
723 0 : if ( rProp.Name == rPropValue.Name )
724 : {
725 : // Found!
726 0 : appendObject( rProp, rPropValue.Value );
727 0 : break;
728 : }
729 : }
730 0 : }
731 : }
732 : else
733 : {
734 : // Get every single prop value with one ( remote) call.
735 :
736 0 : for ( sal_Int32 n = 0; n < nPropsCount; ++n )
737 : {
738 0 : const Property& rProp = pProps[ n ];
739 :
740 : try
741 : {
742 0 : Any aValue = rxSet->getPropertyValue( rProp.Name );
743 :
744 0 : if ( aValue.hasValue() )
745 0 : appendObject( rProp, aValue );
746 : }
747 0 : catch (const UnknownPropertyException&)
748 : {
749 : }
750 0 : catch (const WrappedTargetException&)
751 : {
752 : }
753 : }
754 0 : }
755 0 : }
756 : }
757 0 : }
758 :
759 :
760 0 : bool PropertyValueSet::appendPropertySetValue(
761 : const Reference< XPropertySet >& rxSet,
762 : const Property& rProperty )
763 : {
764 0 : if ( rxSet.is() )
765 : {
766 : try
767 : {
768 0 : Any aValue = rxSet->getPropertyValue( rProperty.Name );
769 0 : if ( aValue.hasValue() )
770 : {
771 0 : appendObject( rProperty, aValue );
772 0 : return true;
773 0 : }
774 : }
775 0 : catch (const UnknownPropertyException&)
776 : {
777 : }
778 0 : catch (const WrappedTargetException&)
779 : {
780 : }
781 : }
782 :
783 : // Error.
784 0 : return false;
785 : }
786 :
787 : } // namespace ucbhelper
788 :
789 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
