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