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