Branch data 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 : : #include <comphelper/types.hxx>
21 : : #include <comphelper/extract.hxx>
22 : : #include <com/sun/star/util/Date.hpp>
23 : : #include <com/sun/star/util/Time.hpp>
24 : : #include <com/sun/star/util/DateTime.hpp>
25 : : #include <com/sun/star/awt/FontUnderline.hpp>
26 : : #include <com/sun/star/awt/FontStrikeout.hpp>
27 : : #include <com/sun/star/awt/FontDescriptor.hpp>
28 : : #include <osl/diagnose.h>
29 : : #include <typelib/typedescription.hxx>
30 : :
31 : : #include <memory.h>
32 : :
33 : :
34 : : //.........................................................................
35 : : namespace comphelper
36 : : {
37 : : //.........................................................................
38 : :
39 : : using namespace ::com::sun::star::uno;
40 : : using namespace ::com::sun::star::awt;
41 : : using namespace ::com::sun::star::util;
42 : : using namespace ::com::sun::star::lang;
43 : :
44 : : //-------------------------------------------------------------------------
45 : 0 : sal_Bool operator ==(const DateTime& _rLeft, const DateTime& _rRight)
46 : : {
47 : : return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) &&
48 : : ( _rLeft.Seconds == _rRight.Seconds) &&
49 : : ( _rLeft.Minutes == _rRight.Minutes) &&
50 : : ( _rLeft.Hours == _rRight.Hours) &&
51 : : ( _rLeft.Day == _rRight.Day) &&
52 : : ( _rLeft.Month == _rRight.Month) &&
53 [ # # ][ # # ]: 0 : ( _rLeft.Year == _rRight.Year) ;
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
54 : : }
55 : :
56 : : //-------------------------------------------------------------------------
57 : 0 : sal_Bool operator ==(const Date& _rLeft, const Date& _rRight)
58 : : {
59 : : return ( _rLeft.Day == _rRight.Day) &&
60 : : ( _rLeft.Month == _rRight.Month) &&
61 [ # # ][ # # ]: 0 : ( _rLeft.Year == _rRight.Year) ;
[ # # ]
62 : : }
63 : :
64 : : //-------------------------------------------------------------------------
65 : 0 : sal_Bool operator ==(const Time& _rLeft, const Time& _rRight)
66 : : {
67 : : return ( _rLeft.HundredthSeconds == _rRight.HundredthSeconds) &&
68 : : ( _rLeft.Seconds == _rRight.Seconds) &&
69 : : ( _rLeft.Minutes == _rRight.Minutes) &&
70 [ # # ][ # # ]: 0 : ( _rLeft.Hours == _rRight.Hours) ;
[ # # ][ # # ]
71 : : }
72 : :
73 : : //------------------------------------------------------------------------------
74 : 0 : sal_Int64 getINT64(const Any& _rAny)
75 : : {
76 : 0 : sal_Int64 nReturn = 0;
77 : 0 : OSL_VERIFY( _rAny >>= nReturn );
78 : 0 : return nReturn;
79 : : }
80 : :
81 : : //------------------------------------------------------------------------------
82 : 17339 : sal_Int32 getINT32(const Any& _rAny)
83 : : {
84 : 17339 : sal_Int32 nReturn = 0;
85 : 17339 : OSL_VERIFY( _rAny >>= nReturn );
86 : 17339 : return nReturn;
87 : : }
88 : :
89 : : //------------------------------------------------------------------------------
90 : 2516 : sal_Int16 getINT16(const Any& _rAny)
91 : : {
92 : 2516 : sal_Int16 nReturn = 0;
93 : 2516 : OSL_VERIFY( _rAny >>= nReturn );
94 : 2516 : return nReturn;
95 : : }
96 : :
97 : : //------------------------------------------------------------------------------
98 : 0 : double getDouble(const Any& _rAny)
99 : : {
100 : 0 : double nReturn = 0.0;
101 : 0 : OSL_VERIFY( _rAny >>= nReturn );
102 : 0 : return nReturn;
103 : : }
104 : :
105 : : //------------------------------------------------------------------------------
106 : 0 : float getFloat(const Any& _rAny)
107 : : {
108 : 0 : float nReturn = 0.0;
109 : 0 : OSL_VERIFY( _rAny >>= nReturn );
110 : 0 : return nReturn;
111 : : }
112 : :
113 : : //------------------------------------------------------------------------------
114 : 77204 : ::rtl::OUString getString(const Any& _rAny)
115 : : {
116 : 77204 : ::rtl::OUString nReturn;
117 : 77204 : OSL_VERIFY( _rAny >>= nReturn );
118 : 77204 : return nReturn;
119 : : }
120 : :
121 : : //------------------------------------------------------------------------------
122 : 11891 : sal_Bool getBOOL(const Any& _rAny)
123 : : {
124 : 11891 : sal_Bool nReturn = sal_False;
125 [ + - ]: 11891 : if (_rAny.getValueType() == ::getCppuBooleanType())
126 : 11891 : nReturn = *(sal_Bool*)_rAny.getValue();
127 : : else
128 : : OSL_FAIL("comphelper::getBOOL : invalid argument !");
129 : 11891 : return nReturn;
130 : : }
131 : :
132 : : //------------------------------------------------------------------------------
133 : 3133 : sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException)
134 : : {
135 : 3133 : sal_Int32 nReturn = 0;
136 [ - + ]: 3133 : if (! ::cppu::enum2int(nReturn,_rAny) )
137 [ # # ]: 0 : throw IllegalArgumentException();
138 : 3133 : return nReturn;
139 : : }
140 : :
141 : : //------------------------------------------------------------------------------
142 : 218 : FontDescriptor getDefaultFont()
143 : : {
144 : 218 : FontDescriptor aReturn;
145 : 218 : aReturn.Slant = FontSlant_DONTKNOW;
146 : 218 : aReturn.Underline = FontUnderline::DONTKNOW;
147 : 218 : aReturn.Strikeout = FontStrikeout::DONTKNOW;
148 : 218 : return aReturn;
149 : : }
150 : :
151 : : //------------------------------------------------------------------------------
152 : 10306 : sal_Bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
153 : : {
154 : : // getthe type lib descriptions
155 : 10306 : typelib_TypeDescription* pAssignable = NULL;
156 : 10306 : _rAssignable.getDescription(&pAssignable);
157 : :
158 : 10306 : typelib_TypeDescription* pFrom = NULL;
159 : 10306 : _rFrom.getDescription(&pFrom);
160 : :
161 : : // and ask the type lib
162 : 10306 : return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
163 : : }
164 : :
165 : : //------------------------------------------------------------------
166 : : template<class TYPE>
167 : 56322 : sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, TYPE& _rOut)
168 : : {
169 : 56322 : sal_Bool bSuccess = _rValue >>= _rOut;
170 [ # # ][ # # ]: 56322 : _bIdentical = bSuccess && (_rOut == *reinterpret_cast<const TYPE*>(_pData));
[ # # ][ # # ]
[ # # ][ + - ]
[ + + ][ # # ]
[ # # ][ + - ]
[ + + ][ + - ]
[ + + ][ # # ]
[ # # ][ + - ]
[ + + ][ # # ]
[ # # ][ + - ]
[ + + ][ + - ]
[ + + ][ # # ]
171 : 56322 : return bSuccess;
172 : : }
173 : :
174 : : //------------------------------------------------------------------
175 : 0 : sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, sal_Unicode& _rOut)
176 : : {
177 : 0 : sal_Bool bSuccess = ( _rValue.getValueTypeClass() == TypeClass_CHAR );
178 [ # # ]: 0 : if ( bSuccess )
179 : 0 : _rOut = *static_cast< const sal_Unicode* >( _rValue.getValue() );
180 [ # # ][ # # ]: 0 : _bIdentical = bSuccess && ( _rOut == *static_cast< const sal_Unicode* >( _pData ) );
181 : 0 : return bSuccess;
182 : : }
183 : :
184 : : //------------------------------------------------------------------
185 : 63124 : sal_Bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue)
186 : : {
187 : 63124 : sal_Bool bRes = sal_True;
188 : :
189 [ - + ]: 63124 : if (_rType.getTypeClass() == TypeClass_ANY)
190 : : {
191 : : // beides AnyWerte
192 [ # # ]: 0 : if (_rValue.getValueType().getTypeClass() == TypeClass_ANY)
193 : : bRes = compare_impl(
194 : 0 : reinterpret_cast<const Any*>(pData)->getValueType(),
195 : : reinterpret_cast<const Any*>(pData)->getValue(),
196 [ # # ]: 0 : *reinterpret_cast<const Any*>(_rValue.getValue()));
197 : : else
198 : : bRes = compare_impl(
199 : 0 : reinterpret_cast<const Any*>(pData)->getValueType(),
200 : : reinterpret_cast<const Any*>(pData)->getValue(),
201 [ # # ]: 0 : _rValue);
202 : : }
203 [ + + + + ]: 125681 : else if ( (_rType.getTypeClass() == TypeClass_VOID)
[ + + ]
204 : 62557 : || (_rValue.getValueType().getTypeClass() == TypeClass_VOID)
205 : : )
206 : : {
207 : 773 : bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass();
208 : : }
209 : : else
210 : : {
211 : 62351 : sal_Bool bConversionSuccess = sal_False;
212 [ - + - + : 62351 : switch (_rType.getTypeClass())
- + - + +
+ - - + +
+ - ]
213 : : {
214 : : case TypeClass_VOID:
215 : 0 : bConversionSuccess = sal_True;
216 : 0 : bRes = _rValue.getValueType().getTypeClass() == TypeClass_VOID;
217 : 0 : break;
218 : : case TypeClass_BOOLEAN:
219 : : {
220 : : sal_Bool aDummy;
221 : 20559 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
222 : : break;
223 : : }
224 : : case TypeClass_CHAR:
225 : : {
226 : 0 : sal_Unicode aDummy(0);
227 : 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
228 : : break;
229 : : }
230 : : case TypeClass_STRING:
231 : : {
232 : 13495 : ::rtl::OUString aDummy;
233 : 13495 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
234 : 13495 : break;
235 : : }
236 : : case TypeClass_FLOAT:
237 : : {
238 : : float aDummy;
239 : 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
240 : : break;
241 : : }
242 : : case TypeClass_DOUBLE:
243 : : {
244 : : double aDummy;
245 : 1703 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
246 : : break;
247 : : }
248 : : case TypeClass_BYTE:
249 : : {
250 : : sal_Int8 aDummy;
251 : 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
252 : : break;
253 : : }
254 : : case TypeClass_SHORT:
255 : : {
256 : : sal_Int16 aDummy;
257 : 16373 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
258 : : break;
259 : : }
260 : : case TypeClass_ENUM:
261 : : {
262 : 10 : sal_Int32 nAsInt32 = 0;
263 : 10 : bConversionSuccess = ::cppu::enum2int(nAsInt32, _rValue);
264 [ + + ][ + - ]: 10 : bRes = bConversionSuccess && (nAsInt32== *reinterpret_cast<const sal_Int32*>(pData));
265 : : break;
266 : : }
267 : : case TypeClass_LONG:
268 : : {
269 : : sal_Int32 aDummy;
270 : 3329 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
271 : : break;
272 : : }
273 : : case TypeClass_UNSIGNED_SHORT:
274 : : {
275 : : sal_uInt16 aDummy;
276 : 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
277 : : break;
278 : : }
279 : : case TypeClass_UNSIGNED_LONG:
280 : : {
281 : : sal_uInt32 aDummy;
282 : 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
283 : : break;
284 : : }
285 : : case TypeClass_INTERFACE:
286 : : {
287 : 863 : InterfaceRef aDummy;
288 [ + - ]: 863 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
289 : 863 : break;
290 : : }
291 : : case TypeClass_STRUCT:
292 [ + - ][ + - ]: 5239 : if (isA(_rType, static_cast<FontDescriptor*>(NULL)))
293 : : {
294 : 5239 : FontDescriptor aTemp;
295 [ + - ]: 5239 : bConversionSuccess = _rValue >>= aTemp;
296 [ + - ]: 5239 : if (bConversionSuccess)
297 : : {
298 [ + - ]: 5239 : bRes = *(FontDescriptor*)pData == aTemp;
299 : : }
300 : : else
301 : 0 : bRes = sal_False;
302 : 5239 : break;
303 : : }
304 [ # # ][ # # ]: 0 : if (isA(_rType, static_cast<Date*>(NULL)))
305 : : {
306 : 0 : Date aDummy;
307 [ # # ]: 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
308 : : break;
309 : : }
310 [ # # ][ # # ]: 0 : if (isA(_rType, static_cast<Time*>(NULL)))
311 : : {
312 : 0 : Time aDummy;
313 [ # # ]: 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
314 : : break;
315 : : }
316 [ # # ][ # # ]: 0 : if (isA(_rType, static_cast<DateTime*>(NULL)))
317 : : {
318 : 0 : DateTime aDummy;
319 [ # # ]: 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
320 : : break;
321 : : }
322 : 0 : break;
323 : : case TypeClass_SEQUENCE:
324 [ + - ][ - + ]: 780 : if (isA(_rType, static_cast< Sequence<sal_Int8>* >(NULL)))
325 : : {
326 [ # # ]: 0 : Sequence<sal_Int8> aTemp;
327 [ # # ]: 0 : bConversionSuccess = _rValue >>= aTemp;
328 [ # # ]: 0 : if (bConversionSuccess)
329 : : {
330 : 0 : const Sequence<sal_Int8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int8>*>(pData);
331 : 0 : const Sequence<sal_Int8>& rRightSeq = aTemp;
332 : 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
333 [ # # ][ # # ]: 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
334 [ # # ]: 0 : }
335 : : }
336 [ + - ][ - + ]: 780 : else if (isA(_rType, static_cast< Sequence<sal_uInt8>* >(NULL)))
337 : : {
338 [ # # ]: 0 : Sequence<sal_uInt8> aTemp;
339 [ # # ]: 0 : bConversionSuccess = _rValue >>= aTemp;
340 [ # # ]: 0 : if (bConversionSuccess)
341 : : {
342 : 0 : const Sequence<sal_uInt8>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt8>*>(pData);
343 : 0 : const Sequence<sal_uInt8>& rRightSeq = aTemp;
344 : 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
345 [ # # ][ # # ]: 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()) == 0;
346 [ # # ]: 0 : }
347 : : }
348 [ + - ][ + + ]: 780 : else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL)))
349 : : {
350 [ + - ]: 536 : Sequence<sal_Int16> aTemp;
351 [ + - ]: 536 : bConversionSuccess = _rValue >>= aTemp;
352 [ + - ]: 536 : if (bConversionSuccess)
353 : : {
354 : 536 : const Sequence<sal_Int16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int16>*>(pData);
355 : 536 : const Sequence<sal_Int16>& rRightSeq = aTemp;
356 : 536 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
357 [ + - ][ + + ]: 536 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0;
358 [ + - ]: 536 : }
359 : : }
360 [ + - ][ - + ]: 244 : else if (isA(_rType, static_cast< Sequence<sal_uInt16>* >(NULL)))
361 : : {
362 [ # # ]: 0 : Sequence<sal_uInt16> aTemp;
363 [ # # ]: 0 : bConversionSuccess = _rValue >>= aTemp;
364 [ # # ]: 0 : if (bConversionSuccess)
365 : : {
366 : 0 : const Sequence<sal_uInt16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt16>*>(pData);
367 : 0 : const Sequence<sal_uInt16>& rRightSeq = aTemp;
368 : 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
369 [ # # ][ # # ]: 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt16)) == 0;
370 [ # # ]: 0 : }
371 : : }
372 [ + - ][ - + ]: 244 : else if (isA(_rType, static_cast< Sequence<sal_Int32>* >(NULL)))
373 : : {
374 [ # # ]: 0 : Sequence<sal_Int32> aTemp;
375 [ # # ]: 0 : bConversionSuccess = _rValue >>= aTemp;
376 [ # # ]: 0 : if (bConversionSuccess)
377 : : {
378 : 0 : const Sequence<sal_Int32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int32>*>(pData);
379 : 0 : const Sequence<sal_Int32>& rRightSeq = aTemp;
380 : 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
381 [ # # ][ # # ]: 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int32)) == 0;
382 [ # # ]: 0 : }
383 : : }
384 [ + - ][ - + ]: 244 : else if (isA(_rType, static_cast< Sequence<sal_uInt32>* >(NULL)))
385 : : {
386 [ # # ]: 0 : Sequence<sal_uInt32> aTemp;
387 [ # # ]: 0 : bConversionSuccess = _rValue >>= aTemp;
388 [ # # ]: 0 : if (bConversionSuccess)
389 : : {
390 : 0 : const Sequence<sal_uInt32>& rLeftSeq = *reinterpret_cast<const Sequence<sal_uInt32>*>(pData);
391 : 0 : const Sequence<sal_uInt32>& rRightSeq = aTemp;
392 : 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
393 [ # # ][ # # ]: 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_uInt32)) == 0;
394 [ # # ]: 0 : }
395 : : }
396 [ + - ][ + - ]: 244 : else if (isA(_rType, static_cast< Sequence< ::rtl::OUString >* >(NULL)))
397 : : {
398 [ + - ]: 244 : Sequence< ::rtl::OUString > aTemp;
399 [ + - ]: 244 : bConversionSuccess = _rValue >>= aTemp;
400 [ + - ]: 244 : if (bConversionSuccess)
401 : : {
402 : 244 : const Sequence< ::rtl::OUString >& rLeftSeq = *reinterpret_cast<const Sequence< ::rtl::OUString>*>(pData);
403 : 244 : const Sequence< ::rtl::OUString >& rRightSeq = aTemp;
404 : 244 : sal_Int32 nSeqLen = rLeftSeq.getLength();
405 : 244 : bRes = ( nSeqLen == rRightSeq.getLength() );
406 [ + + ][ + + ]: 526 : for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ )
[ + + ]
407 : : {
408 : 282 : const ::rtl::OUString& rS1 = rLeftSeq.getConstArray()[n];
409 : 282 : const ::rtl::OUString& rS2 = rRightSeq.getConstArray()[n];
410 : 282 : bRes = ( rS1 == rS2 );
411 : : }
412 [ + - ]: 244 : }
413 : : }
414 : 780 : break;
415 : : default:
416 : 0 : bRes = sal_False;
417 : : }
418 : :
419 [ + + ][ + - ]: 62351 : bRes = bRes && bConversionSuccess;
420 : : }
421 : 63124 : return bRes;
422 : : }
423 : :
424 : : //------------------------------------------------------------------------------
425 : 63124 : sal_Bool compare(const Any& rLeft, const Any& rRight)
426 : : {
427 : 63124 : return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight);
428 : : }
429 : :
430 : : //-------------------------------------------------------------------------
431 : 5333 : sal_Bool operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight)
432 : : {
433 : 5333 : return ( _rLeft.Name.equals( _rRight.Name ) ) &&
434 : : ( _rLeft.Height == _rRight.Height ) &&
435 : : ( _rLeft.Width == _rRight.Width ) &&
436 : 4622 : ( _rLeft.StyleName.equals( _rRight.StyleName ) ) &&
437 : : ( _rLeft.Family == _rRight.Family ) &&
438 : : ( _rLeft.CharSet == _rRight.CharSet ) &&
439 : : ( _rLeft.Pitch == _rRight.Pitch ) &&
440 : : ( _rLeft.CharacterWidth == _rRight.CharacterWidth ) &&
441 : : ( _rLeft.Weight == _rRight.Weight ) &&
442 : : ( _rLeft.Slant == _rRight.Slant ) &&
443 : : ( _rLeft.Underline == _rRight.Underline ) &&
444 : : ( _rLeft.Strikeout == _rRight.Strikeout ) &&
445 : : ( _rLeft.Orientation == _rRight.Orientation ) &&
446 : : ( _rLeft.Kerning == _rRight.Kerning ) &&
447 : : ( _rLeft.WordLineMode == _rRight.WordLineMode ) &&
448 [ + + ]: 9955 : ( _rLeft.Type == _rRight.Type ) ;
[ + + + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ]
449 : : }
450 : :
451 : : //-------------------------------------------------------------------------
452 : 4 : Type getSequenceElementType(const Type& _rSequenceType)
453 : : {
454 : : OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE,
455 : : "getSequenceElementType: must be called with a sequence type!");
456 : :
457 [ - + ]: 4 : if (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE))
458 : 0 : return Type();
459 : :
460 : 4 : TypeDescription aTD(_rSequenceType);
461 : : typelib_IndirectTypeDescription* pSequenceTD =
462 : 4 : reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get());
463 : :
464 : : OSL_ASSERT(pSequenceTD);
465 : : OSL_ASSERT(pSequenceTD->pType);
466 : :
467 [ + - ][ + - ]: 4 : if (pSequenceTD && pSequenceTD->pType)
468 : 4 : return Type(pSequenceTD->pType);
469 : :
470 : 4 : return Type();
471 : : }
472 : : //.........................................................................
473 : : } // namespace comphelper
474 : : //.........................................................................
475 : :
476 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
