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 : bool operator ==(const DateTime& _rLeft, const DateTime& _rRight)
46 : {
47 0 : return ( _rLeft.NanoSeconds == _rRight.NanoSeconds) &&
48 0 : ( _rLeft.Seconds == _rRight.Seconds) &&
49 0 : ( _rLeft.Minutes == _rRight.Minutes) &&
50 0 : ( _rLeft.Hours == _rRight.Hours) &&
51 0 : ( _rLeft.Day == _rRight.Day) &&
52 0 : ( _rLeft.Month == _rRight.Month) &&
53 0 : ( _rLeft.Year == _rRight.Year) ;
54 : }
55 :
56 :
57 554 : bool operator ==(const Date& _rLeft, const Date& _rRight)
58 : {
59 1006 : return ( _rLeft.Day == _rRight.Day) &&
60 1002 : ( _rLeft.Month == _rRight.Month) &&
61 1002 : ( _rLeft.Year == _rRight.Year) ;
62 : }
63 :
64 :
65 458 : bool operator ==(const Time& _rLeft, const Time& _rRight)
66 : {
67 912 : return ( _rLeft.NanoSeconds == _rRight.NanoSeconds) &&
68 904 : ( _rLeft.Seconds == _rRight.Seconds) &&
69 1334 : ( _rLeft.Minutes == _rRight.Minutes) &&
70 884 : ( _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 21158 : sal_Int32 getINT32(const Any& _rAny)
83 : {
84 21158 : sal_Int32 nReturn = 0;
85 21158 : OSL_VERIFY( _rAny >>= nReturn );
86 21158 : return nReturn;
87 : }
88 :
89 :
90 16755 : sal_Int16 getINT16(const Any& _rAny)
91 : {
92 16755 : sal_Int16 nReturn = 0;
93 16755 : OSL_VERIFY( _rAny >>= nReturn );
94 16755 : 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 117076 : OUString getString(const Any& _rAny)
115 : {
116 117076 : OUString nReturn;
117 117076 : OSL_VERIFY( _rAny >>= nReturn );
118 117076 : return nReturn;
119 : }
120 :
121 :
122 19791 : bool getBOOL(const Any& _rAny)
123 : {
124 19791 : bool nReturn = false;
125 19791 : if (_rAny.getValueType() == ::getCppuBooleanType())
126 19791 : nReturn = *(sal_Bool*)_rAny.getValue();
127 : else
128 : OSL_FAIL("comphelper::getBOOL : invalid argument !");
129 19791 : return nReturn;
130 : }
131 :
132 :
133 69028 : sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException)
134 : {
135 69028 : sal_Int32 nReturn = 0;
136 69028 : if (! ::cppu::enum2int(nReturn,_rAny) )
137 0 : throw IllegalArgumentException();
138 69028 : return nReturn;
139 : }
140 :
141 :
142 337 : FontDescriptor getDefaultFont()
143 : {
144 337 : FontDescriptor aReturn;
145 337 : aReturn.Slant = FontSlant_DONTKNOW;
146 337 : aReturn.Underline = FontUnderline::DONTKNOW;
147 337 : aReturn.Strikeout = FontStrikeout::DONTKNOW;
148 337 : return aReturn;
149 : }
150 :
151 :
152 10721 : bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
153 : {
154 : // getthe type lib descriptions
155 10721 : typelib_TypeDescription* pAssignable = NULL;
156 10721 : _rAssignable.getDescription(&pAssignable);
157 :
158 10721 : typelib_TypeDescription* pFrom = NULL;
159 10721 : _rFrom.getDescription(&pFrom);
160 :
161 : // and ask the type lib
162 10721 : return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
163 : }
164 :
165 :
166 : template<class TYPE>
167 59965 : bool tryCompare(const void* _pData, const Any& _rValue, bool& _bIdentical, TYPE& _rOut)
168 : {
169 59965 : bool bSuccess = _rValue >>= _rOut;
170 59965 : _bIdentical = bSuccess && (_rOut == *reinterpret_cast<const TYPE*>(_pData));
171 59965 : return bSuccess;
172 : }
173 :
174 :
175 0 : bool tryCompare(const void* _pData, const Any& _rValue, bool& _bIdentical, sal_Unicode& _rOut)
176 : {
177 0 : 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 67373 : bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue)
186 : {
187 67373 : bool bRes = true;
188 :
189 67373 : 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 134746 : else if ( (_rType.getTypeClass() == TypeClass_VOID)
204 67373 : || (_rValue.getValueType().getTypeClass() == TypeClass_VOID)
205 : )
206 : {
207 1164 : bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass();
208 : }
209 : else
210 : {
211 66209 : bool bConversionSuccess = false;
212 66209 : switch (_rType.getTypeClass())
213 : {
214 : case TypeClass_VOID:
215 0 : bConversionSuccess = true;
216 0 : bRes = _rValue.getValueType().getTypeClass() == TypeClass_VOID;
217 0 : break;
218 : case TypeClass_BOOLEAN:
219 : {
220 : bool aDummy;
221 21778 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
222 21778 : break;
223 : }
224 : case TypeClass_CHAR:
225 : {
226 0 : sal_Unicode aDummy(0);
227 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
228 0 : break;
229 : }
230 : case TypeClass_STRING:
231 : {
232 14270 : OUString aDummy;
233 14270 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
234 14270 : break;
235 : }
236 : case TypeClass_FLOAT:
237 : {
238 : float aDummy;
239 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
240 0 : break;
241 : }
242 : case TypeClass_DOUBLE:
243 : {
244 : double aDummy;
245 1726 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
246 1726 : break;
247 : }
248 : case TypeClass_BYTE:
249 : {
250 : sal_Int8 aDummy;
251 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
252 0 : break;
253 : }
254 : case TypeClass_SHORT:
255 : {
256 : sal_Int16 aDummy;
257 17304 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
258 17304 : 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 10 : break;
266 : }
267 : case TypeClass_LONG:
268 : {
269 : sal_Int32 aDummy;
270 2938 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
271 2938 : break;
272 : }
273 : case TypeClass_UNSIGNED_SHORT:
274 : {
275 : sal_uInt16 aDummy;
276 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
277 0 : break;
278 : }
279 : case TypeClass_UNSIGNED_LONG:
280 : {
281 : sal_uInt32 aDummy;
282 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
283 0 : break;
284 : }
285 : case TypeClass_INTERFACE:
286 : {
287 937 : InterfaceRef aDummy;
288 937 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
289 937 : break;
290 : }
291 : case TypeClass_STRUCT:
292 6467 : if (isA(_rType, static_cast<FontDescriptor*>(NULL)))
293 : {
294 5455 : FontDescriptor aTemp;
295 5455 : bConversionSuccess = _rValue >>= aTemp;
296 5455 : if (bConversionSuccess)
297 : {
298 5455 : bRes = *(FontDescriptor*)pData == aTemp;
299 : }
300 : else
301 0 : bRes = false;
302 5455 : break;
303 : }
304 1012 : if (isA(_rType, static_cast<Date*>(NULL)))
305 : {
306 554 : Date aDummy;
307 554 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
308 554 : break;
309 : }
310 458 : if (isA(_rType, static_cast<Time*>(NULL)))
311 : {
312 458 : Time aDummy;
313 458 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
314 458 : 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 0 : break;
321 : }
322 0 : break;
323 : case TypeClass_SEQUENCE:
324 779 : 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 779 : 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 779 : else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL)))
349 : {
350 491 : Sequence<sal_Int16> aTemp;
351 491 : bConversionSuccess = _rValue >>= aTemp;
352 491 : if (bConversionSuccess)
353 : {
354 491 : const Sequence<sal_Int16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int16>*>(pData);
355 491 : const Sequence<sal_Int16>& rRightSeq = aTemp;
356 861 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
357 861 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0;
358 491 : }
359 : }
360 288 : 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 288 : 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 288 : 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 288 : else if (isA(_rType, static_cast< Sequence< OUString >* >(NULL)))
397 : {
398 288 : Sequence< OUString > aTemp;
399 288 : bConversionSuccess = _rValue >>= aTemp;
400 288 : if (bConversionSuccess)
401 : {
402 288 : const Sequence< OUString >& rLeftSeq = *reinterpret_cast<const Sequence< OUString>*>(pData);
403 288 : const Sequence< OUString >& rRightSeq = aTemp;
404 288 : sal_Int32 nSeqLen = rLeftSeq.getLength();
405 288 : bRes = ( nSeqLen == rRightSeq.getLength() );
406 570 : for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ )
407 : {
408 282 : const OUString& rS1 = rLeftSeq.getConstArray()[n];
409 282 : const OUString& rS2 = rRightSeq.getConstArray()[n];
410 282 : bRes = ( rS1 == rS2 );
411 : }
412 288 : }
413 : }
414 779 : break;
415 : default:
416 0 : bRes = false;
417 : }
418 :
419 66209 : bRes = bRes && bConversionSuccess;
420 : }
421 67373 : return bRes;
422 : }
423 :
424 :
425 67373 : bool compare(const Any& rLeft, const Any& rRight)
426 : {
427 67373 : return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight);
428 : }
429 :
430 :
431 5548 : bool operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight)
432 : {
433 10535 : return ( _rLeft.Name.equals( _rRight.Name ) ) &&
434 9838 : ( _rLeft.Height == _rRight.Height ) &&
435 9608 : ( _rLeft.Width == _rRight.Width ) &&
436 9419 : ( _rLeft.StyleName.equals( _rRight.StyleName ) ) &&
437 9230 : ( _rLeft.Family == _rRight.Family ) &&
438 9038 : ( _rLeft.CharSet == _rRight.CharSet ) &&
439 8846 : ( _rLeft.Pitch == _rRight.Pitch ) &&
440 8657 : ( _rLeft.CharacterWidth == _rRight.CharacterWidth ) &&
441 8466 : ( _rLeft.Weight == _rRight.Weight ) &&
442 6186 : ( _rLeft.Slant == _rRight.Slant ) &&
443 3936 : ( _rLeft.Underline == _rRight.Underline ) &&
444 3804 : ( _rLeft.Strikeout == _rRight.Strikeout ) &&
445 3674 : ( _rLeft.Orientation == _rRight.Orientation ) &&
446 3546 : ( _rLeft.Kerning == _rRight.Kerning ) &&
447 8965 : ( _rLeft.WordLineMode == _rRight.WordLineMode ) &&
448 7224 : ( _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 0 : return Type();
471 : }
472 :
473 : } // namespace comphelper
474 :
475 :
476 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
