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 12 : sal_Int32 getINT32(const Any& _rAny)
83 : {
84 12 : sal_Int32 nReturn = 0;
85 12 : OSL_VERIFY( _rAny >>= nReturn );
86 12 : return nReturn;
87 : }
88 :
89 : //------------------------------------------------------------------------------
90 18 : sal_Int16 getINT16(const Any& _rAny)
91 : {
92 18 : sal_Int16 nReturn = 0;
93 18 : OSL_VERIFY( _rAny >>= nReturn );
94 18 : 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 24 : ::rtl::OUString getString(const Any& _rAny)
115 : {
116 24 : ::rtl::OUString nReturn;
117 24 : OSL_VERIFY( _rAny >>= nReturn );
118 24 : return nReturn;
119 : }
120 :
121 : //------------------------------------------------------------------------------
122 18 : sal_Bool getBOOL(const Any& _rAny)
123 : {
124 18 : sal_Bool nReturn = sal_False;
125 18 : if (_rAny.getValueType() == ::getCppuBooleanType())
126 18 : nReturn = *(sal_Bool*)_rAny.getValue();
127 : else
128 : OSL_FAIL("comphelper::getBOOL : invalid argument !");
129 18 : return nReturn;
130 : }
131 :
132 : //------------------------------------------------------------------------------
133 782 : sal_Int32 getEnumAsINT32(const Any& _rAny) throw(IllegalArgumentException)
134 : {
135 782 : sal_Int32 nReturn = 0;
136 782 : if (! ::cppu::enum2int(nReturn,_rAny) )
137 0 : throw IllegalArgumentException();
138 782 : return nReturn;
139 : }
140 :
141 : //------------------------------------------------------------------------------
142 0 : FontDescriptor getDefaultFont()
143 : {
144 0 : FontDescriptor aReturn;
145 0 : aReturn.Slant = FontSlant_DONTKNOW;
146 0 : aReturn.Underline = FontUnderline::DONTKNOW;
147 0 : aReturn.Strikeout = FontStrikeout::DONTKNOW;
148 0 : return aReturn;
149 : }
150 :
151 : //------------------------------------------------------------------------------
152 0 : sal_Bool isAssignableFrom(const Type& _rAssignable, const Type& _rFrom)
153 : {
154 : // getthe type lib descriptions
155 0 : typelib_TypeDescription* pAssignable = NULL;
156 0 : _rAssignable.getDescription(&pAssignable);
157 :
158 0 : typelib_TypeDescription* pFrom = NULL;
159 0 : _rFrom.getDescription(&pFrom);
160 :
161 : // and ask the type lib
162 0 : return typelib_typedescription_isAssignableFrom(pAssignable, pFrom);
163 : }
164 :
165 : //------------------------------------------------------------------
166 : template<class TYPE>
167 81 : sal_Bool tryCompare(const void* _pData, const Any& _rValue, sal_Bool& _bIdentical, TYPE& _rOut)
168 : {
169 81 : sal_Bool bSuccess = _rValue >>= _rOut;
170 81 : _bIdentical = bSuccess && (_rOut == *reinterpret_cast<const TYPE*>(_pData));
171 81 : 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 110 : sal_Bool compare_impl(const Type& _rType, const void* pData, const Any& _rValue)
186 : {
187 110 : sal_Bool bRes = sal_True;
188 :
189 110 : 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 220 : else if ( (_rType.getTypeClass() == TypeClass_VOID)
204 110 : || (_rValue.getValueType().getTypeClass() == TypeClass_VOID)
205 : )
206 : {
207 20 : bRes = _rType.getTypeClass() == _rValue.getValueType().getTypeClass();
208 : }
209 : else
210 : {
211 90 : sal_Bool bConversionSuccess = sal_False;
212 90 : 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 33 : 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 22 : ::rtl::OUString aDummy;
233 22 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
234 22 : 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 0 : 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 26 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
258 : break;
259 : }
260 : case TypeClass_ENUM:
261 : {
262 0 : sal_Int32 nAsInt32 = 0;
263 0 : bConversionSuccess = ::cppu::enum2int(nAsInt32, _rValue);
264 0 : bRes = bConversionSuccess && (nAsInt32== *reinterpret_cast<const sal_Int32*>(pData));
265 : break;
266 : }
267 : case TypeClass_LONG:
268 : {
269 : sal_Int32 aDummy;
270 0 : 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 0 : InterfaceRef aDummy;
288 0 : bConversionSuccess = tryCompare(pData, _rValue, bRes, aDummy);
289 0 : break;
290 : }
291 : case TypeClass_STRUCT:
292 9 : if (isA(_rType, static_cast<FontDescriptor*>(NULL)))
293 : {
294 9 : FontDescriptor aTemp;
295 9 : bConversionSuccess = _rValue >>= aTemp;
296 9 : if (bConversionSuccess)
297 : {
298 9 : bRes = *(FontDescriptor*)pData == aTemp;
299 : }
300 : else
301 0 : bRes = sal_False;
302 9 : 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 0 : 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 0 : 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 0 : else if (isA(_rType, static_cast< Sequence<sal_Int16>* >(NULL)))
349 : {
350 0 : Sequence<sal_Int16> aTemp;
351 0 : bConversionSuccess = _rValue >>= aTemp;
352 0 : if (bConversionSuccess)
353 : {
354 0 : const Sequence<sal_Int16>& rLeftSeq = *reinterpret_cast<const Sequence<sal_Int16>*>(pData);
355 0 : const Sequence<sal_Int16>& rRightSeq = aTemp;
356 0 : bRes = rLeftSeq.getLength() == rRightSeq.getLength() &&
357 0 : memcmp(rLeftSeq.getConstArray(), rRightSeq.getConstArray(), rLeftSeq.getLength()*sizeof(sal_Int16)) == 0;
358 0 : }
359 : }
360 0 : 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 0 : 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 0 : 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 0 : else if (isA(_rType, static_cast< Sequence< ::rtl::OUString >* >(NULL)))
397 : {
398 0 : Sequence< ::rtl::OUString > aTemp;
399 0 : bConversionSuccess = _rValue >>= aTemp;
400 0 : if (bConversionSuccess)
401 : {
402 0 : const Sequence< ::rtl::OUString >& rLeftSeq = *reinterpret_cast<const Sequence< ::rtl::OUString>*>(pData);
403 0 : const Sequence< ::rtl::OUString >& rRightSeq = aTemp;
404 0 : sal_Int32 nSeqLen = rLeftSeq.getLength();
405 0 : bRes = ( nSeqLen == rRightSeq.getLength() );
406 0 : for ( sal_Int32 n = 0; bRes && ( n < nSeqLen ); n++ )
407 : {
408 0 : const ::rtl::OUString& rS1 = rLeftSeq.getConstArray()[n];
409 0 : const ::rtl::OUString& rS2 = rRightSeq.getConstArray()[n];
410 0 : bRes = ( rS1 == rS2 );
411 : }
412 0 : }
413 : }
414 0 : break;
415 : default:
416 0 : bRes = sal_False;
417 : }
418 :
419 90 : bRes = bRes && bConversionSuccess;
420 : }
421 110 : return bRes;
422 : }
423 :
424 : //------------------------------------------------------------------------------
425 110 : sal_Bool compare(const Any& rLeft, const Any& rRight)
426 : {
427 110 : return compare_impl(rLeft.getValueType(), rLeft.getValue(), rRight);
428 : }
429 :
430 : //-------------------------------------------------------------------------
431 9 : sal_Bool operator ==(const FontDescriptor& _rLeft, const FontDescriptor& _rRight)
432 : {
433 9 : return ( _rLeft.Name.equals( _rRight.Name ) ) &&
434 : ( _rLeft.Height == _rRight.Height ) &&
435 : ( _rLeft.Width == _rRight.Width ) &&
436 0 : ( _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 9 : ( _rLeft.Type == _rRight.Type ) ;
449 : }
450 :
451 : //-------------------------------------------------------------------------
452 0 : Type getSequenceElementType(const Type& _rSequenceType)
453 : {
454 : OSL_ENSURE(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE,
455 : "getSequenceElementType: must be called with a sequence type!");
456 :
457 0 : if (!(_rSequenceType.getTypeClass() == TypeClass_SEQUENCE))
458 0 : return Type();
459 :
460 0 : TypeDescription aTD(_rSequenceType);
461 : typelib_IndirectTypeDescription* pSequenceTD =
462 0 : reinterpret_cast< typelib_IndirectTypeDescription* >(aTD.get());
463 :
464 : OSL_ASSERT(pSequenceTD);
465 : OSL_ASSERT(pSequenceTD->pType);
466 :
467 0 : if (pSequenceTD && pSequenceTD->pType)
468 0 : return Type(pSequenceTD->pType);
469 :
470 0 : return Type();
471 : }
472 : //.........................................................................
473 : } // namespace comphelper
474 : //.........................................................................
475 :
476 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
