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 #pragma once
20
21 #include <cmath>
22 #include <string.h>
23
24 #include <osl/diagnose.h>
25 #include <rtl/ustring.hxx>
26
27 #include "prim.hxx"
28
29
30 namespace cppu
31 {
32
33
34 //#### equality ####################################################################################
35
36
_equalObject(void * pI1,void * pI2,uno_QueryInterfaceFunc queryInterface,uno_ReleaseFunc release)37 inline bool _equalObject(
38 void * pI1, void * pI2,
39 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
40 {
41 if (pI1 == pI2)
42 return true;
43 if ((nullptr == pI1) || (nullptr == pI2))
44 return false;
45 bool bRet = false;
46
47 typelib_TypeDescriptionReference * type_XInterface =
48 * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
49 if (nullptr == queryInterface)
50 queryInterface = binuno_queryInterface;
51 pI1 = (*queryInterface)( pI1, type_XInterface );
52 if (nullptr != pI1)
53 {
54 pI2 = (*queryInterface)( pI2, type_XInterface );
55 if (nullptr != pI2)
56 {
57 bRet = (pI1 == pI2);
58 _release( pI2, release );
59 }
60 _release( pI1, release );
61 }
62 return bRet;
63 }
64
65
66 bool equalStruct(
67 void * pDest, void *pSource,
68 typelib_CompoundTypeDescription * pTypeDescr,
69 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release );
70
_equalStruct(void * pDest,void * pSource,typelib_CompoundTypeDescription * pTypeDescr,uno_QueryInterfaceFunc queryInterface,uno_ReleaseFunc release)71 inline bool _equalStruct(
72 void * pDest, void *pSource,
73 typelib_CompoundTypeDescription * pTypeDescr,
74 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
75 {
76 if (pTypeDescr->pBaseTypeDescription &&
77 !equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release ))
78 {
79 return false;
80 }
81
82 typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
83 sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
84 sal_Int32 nDescr = pTypeDescr->nMembers;
85
86 while (nDescr--)
87 {
88 sal_Int32 nOffset = pMemberOffsets[nDescr];
89 if (! ::uno_type_equalData( static_cast<char *>(pDest) + nOffset,
90 ppTypeRefs[nDescr],
91 static_cast<char *>(pSource) + nOffset,
92 ppTypeRefs[nDescr],
93 queryInterface, release ))
94 {
95 return false;
96 }
97 }
98 return true;
99 }
100
101 bool equalSequence(
102 uno_Sequence * pDest, uno_Sequence * pSource,
103 typelib_TypeDescriptionReference * pElementType,
104 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release );
105
_equalSequence(uno_Sequence * pDest,uno_Sequence * pSource,typelib_TypeDescriptionReference * pElementType,uno_QueryInterfaceFunc queryInterface,uno_ReleaseFunc release)106 inline bool _equalSequence(
107 uno_Sequence * pDest, uno_Sequence * pSource,
108 typelib_TypeDescriptionReference * pElementType,
109 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
110 {
111 if (pDest == pSource)
112 return true;
113 sal_Int32 nElements = pDest->nElements;
114 if (nElements != pSource->nElements)
115 return false;
116 if (! nElements)
117 return true;
118
119 void * pDestElements = pDest->elements;
120 void * pSourceElements = pSource->elements;
121
122 switch (pElementType->eTypeClass)
123 {
124 case typelib_TypeClass_CHAR:
125 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Unicode) * nElements ));
126 case typelib_TypeClass_BOOLEAN:
127 {
128 for ( sal_Int32 nPos = nElements; nPos--; )
129 {
130 if (bool(static_cast<sal_Bool *>(pDestElements)[nPos]) !=
131 bool(static_cast<sal_Bool *>(pSourceElements)[nPos]))
132 {
133 return false;
134 }
135 }
136 return true;
137 }
138 case typelib_TypeClass_BYTE:
139 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int8) * nElements ));
140 case typelib_TypeClass_SHORT:
141 case typelib_TypeClass_UNSIGNED_SHORT:
142 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int16) * nElements ));
143 case typelib_TypeClass_LONG:
144 case typelib_TypeClass_UNSIGNED_LONG:
145 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
146 case typelib_TypeClass_HYPER:
147 case typelib_TypeClass_UNSIGNED_HYPER:
148 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int64) * nElements ));
149 case typelib_TypeClass_FLOAT:
150 {
151 for ( sal_Int32 nPos = nElements; nPos--; )
152 {
153 if (static_cast<float *>(pDestElements)[nPos] != static_cast<float *>(pSourceElements)[nPos])
154 return false;
155 }
156 return true;
157 }
158 case typelib_TypeClass_DOUBLE:
159 {
160 for ( sal_Int32 nPos = nElements; nPos--; )
161 {
162 if (static_cast<double *>(pDestElements)[nPos] != static_cast<double *>(pSourceElements)[nPos])
163 return false;
164 }
165 return true;
166 }
167 case typelib_TypeClass_STRING:
168 {
169 for ( sal_Int32 nPos = nElements; nPos--; )
170 {
171 if ( static_cast<OUString *>(pDestElements)[nPos] != static_cast<const OUString *>(pSourceElements)[nPos] )
172 return false;
173 }
174 return true;
175 }
176 case typelib_TypeClass_TYPE:
177 {
178 for ( sal_Int32 nPos = nElements; nPos--; )
179 {
180 if (! _type_equals( static_cast<typelib_TypeDescriptionReference **>(pDestElements)[nPos],
181 static_cast<typelib_TypeDescriptionReference **>(pSourceElements)[nPos] ))
182 {
183 return false;
184 }
185 }
186 return true;
187 }
188 case typelib_TypeClass_ANY:
189 {
190 for ( sal_Int32 nPos = nElements; nPos--; )
191 {
192 uno_Any * pDest2 = static_cast<uno_Any *>(pDestElements) + nPos;
193 uno_Any * pSource2 = static_cast<uno_Any *>(pSourceElements) + nPos;
194 if (! ::uno_type_equalData( pDest2->pData, pDest2->pType,
195 pSource2->pData, pSource2->pType,
196 queryInterface, release ))
197 {
198 return false;
199 }
200 }
201 return true;
202 }
203 case typelib_TypeClass_ENUM:
204 return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
205 case typelib_TypeClass_STRUCT:
206 case typelib_TypeClass_EXCEPTION:
207 {
208 typelib_TypeDescription * pElementTypeDescr = nullptr;
209 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
210 sal_Int32 nElementSize = pElementTypeDescr->nSize;
211 for ( sal_Int32 nPos = nElements; nPos--; )
212 {
213 if (! _equalStruct( static_cast<char *>(pDestElements) + (nPos * nElementSize),
214 static_cast<char *>(pSourceElements) + (nPos * nElementSize),
215 reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr),
216 queryInterface, release ))
217 {
218 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
219 return false;
220 }
221 }
222 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
223 return true;
224 }
225 case typelib_TypeClass_SEQUENCE: // sequence of sequence
226 {
227 typelib_TypeDescription * pElementTypeDescr = nullptr;
228 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
229 typelib_TypeDescriptionReference * pSeqElementType =
230 reinterpret_cast<typelib_IndirectTypeDescription *>(pElementTypeDescr)->pType;
231 for ( sal_Int32 nPos = nElements; nPos--; )
232 {
233 if (! equalSequence( static_cast<uno_Sequence **>(pDestElements)[nPos],
234 static_cast<uno_Sequence **>(pSourceElements)[nPos],
235 pSeqElementType, queryInterface, release ))
236 {
237 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
238 return false;
239 }
240 }
241 TYPELIB_DANGER_RELEASE( pElementTypeDescr );
242 return true;
243 }
244 case typelib_TypeClass_INTERFACE:
245 {
246 for ( sal_Int32 nPos = nElements; nPos--; )
247 {
248 if (! _equalObject( static_cast<void **>(pDestElements)[nPos], static_cast<void **>(pSourceElements)[nPos],
249 queryInterface, release ))
250 {
251 return false;
252 }
253 }
254 return true;
255 }
256 default:
257 OSL_ASSERT(false);
258 return false;
259 }
260 }
261
_equalData(void * pDest,typelib_TypeDescriptionReference * pDestType,typelib_TypeDescription * pDestTypeDescr,void * pSource,typelib_TypeDescriptionReference * pSourceType,uno_QueryInterfaceFunc queryInterface,uno_ReleaseFunc release)262 inline bool _equalData(
263 void * pDest,
264 typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr,
265 void * pSource,
266 typelib_TypeDescriptionReference * pSourceType,
267 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
268 {
269 typelib_TypeClass eSourceTypeClass, eDestTypeClass;
270 while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass))
271 {
272 pDestTypeDescr = nullptr;
273 pDestType = static_cast<uno_Any *>(pDest)->pType;
274 pDest = static_cast<uno_Any *>(pDest)->pData;
275 }
276 while (typelib_TypeClass_ANY == (eSourceTypeClass = pSourceType->eTypeClass))
277 {
278 pSourceType = static_cast<uno_Any *>(pSource)->pType;
279 pSource = static_cast<uno_Any *>(pSource)->pData;
280 }
281
282 switch (eDestTypeClass)
283 {
284 case typelib_TypeClass_VOID:
285 return eSourceTypeClass == typelib_TypeClass_VOID;
286 case typelib_TypeClass_CHAR:
287 return eSourceTypeClass == typelib_TypeClass_CHAR
288 && *static_cast<sal_Unicode *>(pDest) == *static_cast<sal_Unicode *>(pSource);
289 case typelib_TypeClass_BOOLEAN:
290 return eSourceTypeClass == typelib_TypeClass_BOOLEAN
291 && (bool(*static_cast<sal_Bool *>(pDest))
292 == bool(*static_cast<sal_Bool *>(pSource)));
293 case typelib_TypeClass_BYTE:
294 switch (eSourceTypeClass)
295 {
296 case typelib_TypeClass_BYTE:
297 return (*static_cast<sal_Int8 *>(pDest) == *static_cast<sal_Int8 *>(pSource));
298 case typelib_TypeClass_SHORT:
299 return (static_cast<sal_Int16>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int16 *>(pSource));
300 case typelib_TypeClass_UNSIGNED_SHORT:
301 return (static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
302 case typelib_TypeClass_LONG:
303 return (static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
304 case typelib_TypeClass_UNSIGNED_LONG:
305 return (static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
306 case typelib_TypeClass_HYPER:
307 return (static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
308 case typelib_TypeClass_UNSIGNED_HYPER:
309 return (*static_cast<sal_Int8 *>(pDest) >= 0 &&
310 static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
311 case typelib_TypeClass_FLOAT:
312 return (static_cast<float>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<float *>(pSource));
313 case typelib_TypeClass_DOUBLE:
314 return (static_cast<double>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<double *>(pSource));
315 default:
316 return false;
317 }
318 case typelib_TypeClass_SHORT:
319 switch (eSourceTypeClass)
320 {
321 case typelib_TypeClass_BYTE:
322 return (*static_cast<sal_Int16 *>(pDest) == static_cast<sal_Int16>(*static_cast<sal_Int8 *>(pSource)));
323 case typelib_TypeClass_SHORT:
324 return (*static_cast<sal_Int16 *>(pDest) == *static_cast<sal_Int16 *>(pSource));
325 case typelib_TypeClass_UNSIGNED_SHORT:
326 return (static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
327 case typelib_TypeClass_LONG:
328 return (static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
329 case typelib_TypeClass_UNSIGNED_LONG:
330 return (static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
331 case typelib_TypeClass_HYPER:
332 return (static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
333 case typelib_TypeClass_UNSIGNED_HYPER:
334 return (*static_cast<sal_Int16 *>(pDest) >= 0 &&
335 static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
336 case typelib_TypeClass_FLOAT:
337 return (static_cast<float>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<float *>(pSource));
338 case typelib_TypeClass_DOUBLE:
339 return (static_cast<double>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<double *>(pSource));
340 default:
341 return false;
342 }
343 case typelib_TypeClass_UNSIGNED_SHORT:
344 switch (eSourceTypeClass)
345 {
346 case typelib_TypeClass_BYTE:
347 return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pSource)));
348 case typelib_TypeClass_SHORT:
349 return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pSource)));
350 case typelib_TypeClass_UNSIGNED_SHORT:
351 return (*static_cast<sal_uInt16 *>(pDest) == *static_cast<sal_uInt16 *>(pSource));
352 case typelib_TypeClass_LONG:
353 return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
354 case typelib_TypeClass_UNSIGNED_LONG:
355 return (static_cast<sal_uInt32>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_uInt32 *>(pSource));
356 case typelib_TypeClass_HYPER:
357 return (static_cast<sal_Int64>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
358 case typelib_TypeClass_UNSIGNED_HYPER:
359 return (static_cast<sal_uInt64>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
360 case typelib_TypeClass_FLOAT:
361 return (static_cast<float>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<float *>(pSource));
362 case typelib_TypeClass_DOUBLE:
363 return (static_cast<double>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<double *>(pSource));
364 default:
365 return false;
366 }
367 case typelib_TypeClass_LONG:
368 switch (eSourceTypeClass)
369 {
370 case typelib_TypeClass_BYTE:
371 return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pSource)));
372 case typelib_TypeClass_SHORT:
373 return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pSource)));
374 case typelib_TypeClass_UNSIGNED_SHORT:
375 return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
376 case typelib_TypeClass_LONG:
377 return (*static_cast<sal_Int32 *>(pDest) == *static_cast<sal_Int32 *>(pSource));
378 case typelib_TypeClass_UNSIGNED_LONG:
379 return (static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
380 case typelib_TypeClass_HYPER:
381 return (static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
382 case typelib_TypeClass_UNSIGNED_HYPER:
383 return (*static_cast<sal_Int32 *>(pDest) >= 0 &&
384 static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
385 case typelib_TypeClass_FLOAT:
386 return (static_cast<float>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<float *>(pSource));
387 case typelib_TypeClass_DOUBLE:
388 return (static_cast<double>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<double *>(pSource));
389 default:
390 return false;
391 }
392 case typelib_TypeClass_UNSIGNED_LONG:
393 switch (eSourceTypeClass)
394 {
395 case typelib_TypeClass_BYTE:
396 return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pSource)));
397 case typelib_TypeClass_SHORT:
398 return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pSource)));
399 case typelib_TypeClass_UNSIGNED_SHORT:
400 return (*static_cast<sal_uInt32 *>(pDest) == static_cast<sal_uInt32>(*static_cast<sal_uInt16 *>(pSource)));
401 case typelib_TypeClass_LONG:
402 return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pSource)));
403 case typelib_TypeClass_UNSIGNED_LONG:
404 return (*static_cast<sal_uInt32 *>(pDest) == *static_cast<sal_uInt32 *>(pSource));
405 case typelib_TypeClass_HYPER:
406 return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
407 case typelib_TypeClass_UNSIGNED_HYPER:
408 return (static_cast<sal_uInt64>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
409 case typelib_TypeClass_FLOAT:
410 return (static_cast<float>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<float *>(pSource));
411 case typelib_TypeClass_DOUBLE:
412 return (static_cast<double>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<double *>(pSource));
413 default:
414 return false;
415 }
416 case typelib_TypeClass_HYPER:
417 switch (eSourceTypeClass)
418 {
419 case typelib_TypeClass_BYTE:
420 return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pSource)));
421 case typelib_TypeClass_SHORT:
422 return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pSource)));
423 case typelib_TypeClass_UNSIGNED_SHORT:
424 return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_uInt16 *>(pSource)));
425 case typelib_TypeClass_LONG:
426 return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pSource)));
427 case typelib_TypeClass_UNSIGNED_LONG:
428 return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
429 case typelib_TypeClass_HYPER:
430 return (*static_cast<sal_Int64 *>(pDest) == *static_cast<sal_Int64 *>(pSource));
431 case typelib_TypeClass_UNSIGNED_HYPER:
432 return (*static_cast<sal_Int64 *>(pDest) >= 0 &&
433 *static_cast<sal_Int64 *>(pDest) == *static_cast<sal_Int64 *>(pSource)); // same size
434 case typelib_TypeClass_FLOAT:
435 return (static_cast<float>(*static_cast<sal_Int64 *>(pDest)) == *static_cast<float *>(pSource));
436 case typelib_TypeClass_DOUBLE:
437 return (static_cast<double>(*static_cast<sal_Int64 *>(pDest)) == *static_cast<double *>(pSource));
438 default:
439 return false;
440 }
441 case typelib_TypeClass_UNSIGNED_HYPER:
442 switch (eSourceTypeClass)
443 {
444 case typelib_TypeClass_BYTE:
445 return (*static_cast<sal_Int8 *>(pSource) >= 0 &&
446 *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int8 *>(pSource)));
447 case typelib_TypeClass_SHORT:
448 return (*static_cast<sal_Int16 *>(pSource) >= 0 &&
449 *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int16 *>(pSource)));
450 case typelib_TypeClass_UNSIGNED_SHORT:
451 return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_uInt16 *>(pSource)));
452 case typelib_TypeClass_LONG:
453 return (*static_cast<sal_Int32 *>(pSource) >= 0 &&
454 *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int32 *>(pSource)));
455 case typelib_TypeClass_UNSIGNED_LONG:
456 return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_uInt32 *>(pSource)));
457 case typelib_TypeClass_HYPER:
458 return (*static_cast<sal_Int64 *>(pSource) >= 0 &&
459 *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int64 *>(pSource)));
460 case typelib_TypeClass_UNSIGNED_HYPER:
461 return (*static_cast<sal_uInt64 *>(pDest) == *static_cast<sal_uInt64 *>(pSource));
462 case typelib_TypeClass_FLOAT:
463 if (::floor( *static_cast<float *>(pSource) ) != *static_cast<float *>(pSource) || *static_cast<float *>(pSource) < 0)
464 return false;
465 return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<float *>(pSource)));
466 case typelib_TypeClass_DOUBLE:
467 if (::floor( *static_cast<double *>(pSource) ) != *static_cast<double *>(pSource) || *static_cast<double *>(pSource) < 0)
468 return false;
469 return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<double *>(pSource)));
470 default:
471 return false;
472 }
473 case typelib_TypeClass_FLOAT:
474 switch (eSourceTypeClass)
475 {
476 case typelib_TypeClass_BYTE:
477 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int8 *>(pSource)));
478 case typelib_TypeClass_SHORT:
479 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int16 *>(pSource)));
480 case typelib_TypeClass_UNSIGNED_SHORT:
481 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_uInt16 *>(pSource)));
482 case typelib_TypeClass_LONG:
483 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int32 *>(pSource)));
484 case typelib_TypeClass_UNSIGNED_LONG:
485 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_uInt32 *>(pSource)));
486 case typelib_TypeClass_HYPER:
487 return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int64 *>(pSource)));
488 case typelib_TypeClass_UNSIGNED_HYPER:
489 if (::floor( *static_cast<float *>(pDest) ) != *static_cast<float *>(pDest) || *static_cast<float *>(pDest) < 0)
490 return false;
491 return (static_cast<sal_uInt64>(*static_cast<float *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
492 case typelib_TypeClass_FLOAT:
493 return (*static_cast<float *>(pDest) == *static_cast<float *>(pSource));
494 case typelib_TypeClass_DOUBLE:
495 return (static_cast<double>(*static_cast<float *>(pDest)) == *static_cast<double *>(pSource));
496 default:
497 return false;
498 }
499 case typelib_TypeClass_DOUBLE:
500 switch (eSourceTypeClass)
501 {
502 case typelib_TypeClass_BYTE:
503 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int8 *>(pSource)));
504 case typelib_TypeClass_SHORT:
505 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int16 *>(pSource)));
506 case typelib_TypeClass_UNSIGNED_SHORT:
507 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_uInt16 *>(pSource)));
508 case typelib_TypeClass_LONG:
509 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int32 *>(pSource)));
510 case typelib_TypeClass_UNSIGNED_LONG:
511 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_uInt32 *>(pSource)));
512 case typelib_TypeClass_HYPER:
513 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int64 *>(pSource)));
514 case typelib_TypeClass_UNSIGNED_HYPER:
515 if (::floor( *static_cast<double *>(pDest) ) != *static_cast<double *>(pDest) || *static_cast<double *>(pDest) < 0)
516 return false;
517 return (static_cast<sal_uInt64>(*static_cast<double *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
518 case typelib_TypeClass_FLOAT:
519 return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<float *>(pSource)));
520 case typelib_TypeClass_DOUBLE:
521 return (*static_cast<double *>(pDest) == *static_cast<double *>(pSource));
522 default:
523 return false;
524 }
525 case typelib_TypeClass_STRING:
526 return eSourceTypeClass == typelib_TypeClass_STRING
527 && *static_cast<OUString *>(pDest) ==
528 *static_cast<OUString const *>(pSource);
529 case typelib_TypeClass_TYPE:
530 return eSourceTypeClass == typelib_TypeClass_TYPE
531 && _type_equals(
532 *static_cast<typelib_TypeDescriptionReference **>(pDest),
533 *static_cast<typelib_TypeDescriptionReference **>(pSource) );
534 case typelib_TypeClass_ENUM:
535 return (_type_equals( pDestType, pSourceType ) &&
536 *static_cast<sal_Int32 *>(pDest) == *static_cast<sal_Int32 *>(pSource));
537 case typelib_TypeClass_STRUCT:
538 case typelib_TypeClass_EXCEPTION:
539 if (! _type_equals( pDestType, pSourceType ))
540 return false;
541 if (pDestTypeDescr)
542 {
543 return _equalStruct(
544 pDest, pSource,
545 reinterpret_cast<typelib_CompoundTypeDescription *>(pDestTypeDescr),
546 queryInterface, release );
547 }
548 else
549 {
550 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
551 bool bRet = _equalStruct(
552 pDest, pSource,
553 reinterpret_cast<typelib_CompoundTypeDescription *>(pDestTypeDescr),
554 queryInterface, release );
555 TYPELIB_DANGER_RELEASE( pDestTypeDescr );
556 return bRet;
557 }
558 case typelib_TypeClass_SEQUENCE:
559 if (_type_equals( pDestType, pSourceType ))
560 {
561 if (pDestTypeDescr)
562 {
563 return _equalSequence(
564 *static_cast<uno_Sequence **>(pDest), *static_cast<uno_Sequence **>(pSource),
565 reinterpret_cast<typelib_IndirectTypeDescription *>(pDestTypeDescr)->pType,
566 queryInterface, release );
567 }
568 else
569 {
570 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
571 bool bRet = _equalSequence(
572 *static_cast<uno_Sequence **>(pDest), *static_cast<uno_Sequence **>(pSource),
573 reinterpret_cast<typelib_IndirectTypeDescription *>(pDestTypeDescr)->pType,
574 queryInterface, release );
575 TYPELIB_DANGER_RELEASE( pDestTypeDescr );
576 return bRet;
577 }
578 }
579 return false;
580 case typelib_TypeClass_INTERFACE:
581 if (typelib_TypeClass_INTERFACE == eSourceTypeClass)
582 return _equalObject( *static_cast<void **>(pDest), *static_cast<void **>(pSource), queryInterface, release );
583 break;
584 default:
585 OSL_ASSERT(false);
586 break;
587 }
588 return false;
589 }
590
591 }
592
593 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
594