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