1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 #ifndef EQ_HXX 28 #define EQ_HXX 29 30 #include <math.h> 31 #include <rtl/memory.h> 32 33 #include "prim.hxx" 34 #include "destr.hxx" 35 36 37 namespace cppu 38 { 39 40 //################################################################################################## 41 //#### equality #################################################################################### 42 //################################################################################################## 43 44 //-------------------------------------------------------------------------------------------------- 45 inline sal_Bool _equalObject( 46 void * pI1, void * pI2, 47 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 48 SAL_THROW( () ) 49 { 50 if (pI1 == pI2) 51 return sal_True; 52 if ((0 == pI1) || (0 == pI2)) 53 return sal_False; 54 sal_Bool bRet = sal_False; 55 56 typelib_TypeDescriptionReference * type_XInterface = 57 * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE ); 58 if (0 == queryInterface) 59 queryInterface = binuno_queryInterface; 60 pI1 = (*queryInterface)( pI1, type_XInterface ); 61 if (0 != pI1) 62 { 63 pI2 = (*queryInterface)( pI2, type_XInterface ); 64 if (0 != pI2) 65 { 66 bRet = (pI1 == pI2); 67 _release( pI2, release ); 68 } 69 _release( pI1, release ); 70 } 71 return bRet; 72 } 73 74 //================================================================================================== 75 sal_Bool equalStruct( 76 void * pDest, void *pSource, 77 typelib_CompoundTypeDescription * pTypeDescr, 78 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 79 SAL_THROW( () ); 80 //-------------------------------------------------------------------------------------------------- 81 inline sal_Bool _equalStruct( 82 void * pDest, void *pSource, 83 typelib_CompoundTypeDescription * pTypeDescr, 84 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 85 SAL_THROW( () ) 86 { 87 if (pTypeDescr->pBaseTypeDescription && 88 !equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release )) 89 { 90 return sal_False; 91 } 92 93 typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs; 94 sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets; 95 sal_Int32 nDescr = pTypeDescr->nMembers; 96 97 while (nDescr--) 98 { 99 sal_Int32 nOffset = pMemberOffsets[nDescr]; 100 if (! ::uno_type_equalData( (char *)pDest + nOffset, 101 ppTypeRefs[nDescr], 102 (char *)pSource + nOffset, 103 ppTypeRefs[nDescr], 104 queryInterface, release )) 105 { 106 return sal_False; 107 } 108 } 109 return sal_True; 110 } 111 //================================================================================================== 112 sal_Bool equalSequence( 113 uno_Sequence * pDest, uno_Sequence * pSource, 114 typelib_TypeDescriptionReference * pElementType, 115 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 116 SAL_THROW( () ); 117 //-------------------------------------------------------------------------------------------------- 118 inline sal_Bool _equalSequence( 119 uno_Sequence * pDest, uno_Sequence * pSource, 120 typelib_TypeDescriptionReference * pElementType, 121 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 122 SAL_THROW( () ) 123 { 124 if (pDest == pSource) 125 return sal_True; 126 sal_Int32 nElements = pDest->nElements; 127 if (nElements != pSource->nElements) 128 return sal_False; 129 if (! nElements) 130 return sal_True; 131 132 void * pDestElements = pDest->elements; 133 void * pSourceElements = pSource->elements; 134 135 switch (pElementType->eTypeClass) 136 { 137 case typelib_TypeClass_CHAR: 138 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Unicode) * nElements )); 139 case typelib_TypeClass_BOOLEAN: 140 { 141 for ( sal_Int32 nPos = nElements; nPos--; ) 142 { 143 if ((((sal_Bool *)pDestElements)[nPos] != sal_False) != 144 (((sal_Bool *)pSourceElements)[nPos] != sal_False)) 145 { 146 return sal_False; 147 } 148 } 149 return sal_True; 150 } 151 case typelib_TypeClass_BYTE: 152 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int8) * nElements )); 153 case typelib_TypeClass_SHORT: 154 case typelib_TypeClass_UNSIGNED_SHORT: 155 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int16) * nElements )); 156 case typelib_TypeClass_LONG: 157 case typelib_TypeClass_UNSIGNED_LONG: 158 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements )); 159 case typelib_TypeClass_HYPER: 160 case typelib_TypeClass_UNSIGNED_HYPER: 161 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int64) * nElements )); 162 case typelib_TypeClass_FLOAT: 163 { 164 for ( sal_Int32 nPos = nElements; nPos--; ) 165 { 166 if (((float *)pDestElements)[nPos] != ((float *)pSourceElements)[nPos]) 167 return sal_False; 168 } 169 return sal_True; 170 } 171 case typelib_TypeClass_DOUBLE: 172 { 173 for ( sal_Int32 nPos = nElements; nPos--; ) 174 { 175 if (((double *)pDestElements)[nPos] != ((double *)pSourceElements)[nPos]) 176 return sal_False; 177 } 178 return sal_True; 179 } 180 case typelib_TypeClass_STRING: 181 { 182 for ( sal_Int32 nPos = nElements; nPos--; ) 183 { 184 if (! ((::rtl::OUString *)pDestElements +nPos)->equals( ((const ::rtl::OUString *)pSourceElements)[nPos] )) 185 return sal_False; 186 } 187 return sal_True; 188 } 189 case typelib_TypeClass_TYPE: 190 { 191 for ( sal_Int32 nPos = nElements; nPos--; ) 192 { 193 if (! _type_equals( ((typelib_TypeDescriptionReference **)pDestElements)[nPos], 194 ((typelib_TypeDescriptionReference **)pSourceElements)[nPos] )) 195 { 196 return sal_False; 197 } 198 } 199 return sal_True; 200 } 201 case typelib_TypeClass_ANY: 202 { 203 for ( sal_Int32 nPos = nElements; nPos--; ) 204 { 205 uno_Any * pDest2 = (uno_Any *)pDestElements + nPos; 206 uno_Any * pSource2 = (uno_Any *)pSourceElements + nPos; 207 if (! ::uno_type_equalData( pDest2->pData, pDest2->pType, 208 pSource2->pData, pSource2->pType, 209 queryInterface, release )) 210 { 211 return sal_False; 212 } 213 } 214 return sal_True; 215 } 216 case typelib_TypeClass_ENUM: 217 return (0 == ::rtl_compareMemory( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements )); 218 case typelib_TypeClass_STRUCT: 219 case typelib_TypeClass_EXCEPTION: 220 { 221 typelib_TypeDescription * pElementTypeDescr = 0; 222 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType ); 223 sal_Int32 nElementSize = pElementTypeDescr->nSize; 224 for ( sal_Int32 nPos = nElements; nPos--; ) 225 { 226 if (! _equalStruct( (char *)pDestElements + (nPos * nElementSize), 227 (char *)pSourceElements + (nPos * nElementSize), 228 (typelib_CompoundTypeDescription *)pElementTypeDescr, 229 queryInterface, release )) 230 { 231 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 232 return sal_False; 233 } 234 } 235 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 236 return sal_True; 237 } 238 case typelib_TypeClass_UNION: 239 { 240 typelib_TypeDescription * pElementTypeDescr = 0; 241 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType ); 242 sal_Int32 nElementSize = pElementTypeDescr->nSize; 243 sal_Int32 nValueOffset = ((typelib_UnionTypeDescription *)pElementTypeDescr)->nValueOffset; 244 for ( sal_Int32 nPos = nElements; nPos--; ) 245 { 246 char * pDest2 = (char *)pDestElements + (nPos * nElementSize); 247 char * pSource2 = (char *)pSourceElements + (nPos * nElementSize); 248 typelib_TypeDescriptionReference * pSetType = _unionGetSetType( 249 pDest2, pElementTypeDescr ); 250 sal_Bool bRet = ::uno_type_equalData( 251 pDest2 + nValueOffset, pSetType, 252 pSource2 + nValueOffset, pSetType, 253 queryInterface, release ); 254 ::typelib_typedescriptionreference_release( pSetType ); 255 if (! bRet) 256 { 257 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 258 return sal_False; 259 } 260 } 261 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 262 return sal_True; 263 } 264 case typelib_TypeClass_SEQUENCE: // sequence of sequence 265 { 266 typelib_TypeDescription * pElementTypeDescr = 0; 267 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType ); 268 typelib_TypeDescriptionReference * pSeqElementType = 269 ((typelib_IndirectTypeDescription *)pElementTypeDescr)->pType; 270 for ( sal_Int32 nPos = nElements; nPos--; ) 271 { 272 if (! equalSequence( ((uno_Sequence **)pDestElements)[nPos], 273 ((uno_Sequence **)pSourceElements)[nPos], 274 pSeqElementType, queryInterface, release )) 275 { 276 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 277 return sal_False; 278 } 279 } 280 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 281 return sal_True; 282 } 283 case typelib_TypeClass_INTERFACE: 284 { 285 for ( sal_Int32 nPos = nElements; nPos--; ) 286 { 287 if (! _equalObject( ((void **)pDestElements)[nPos], ((void **)pSourceElements)[nPos], 288 queryInterface, release )) 289 { 290 return sal_False; 291 } 292 } 293 return sal_True; 294 } 295 default: 296 OSL_ASSERT(false); 297 return sal_False; 298 } 299 } 300 //-------------------------------------------------------------------------------------------------- 301 inline sal_Bool _equalData( 302 void * pDest, 303 typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr, 304 void * pSource, 305 typelib_TypeDescriptionReference * pSourceType, typelib_TypeDescription * pSourceTypeDescr, 306 uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release ) 307 SAL_THROW( () ) 308 { 309 typelib_TypeClass eSourceTypeClass, eDestTypeClass; 310 while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass)) 311 { 312 pDestTypeDescr = 0; 313 pDestType = ((uno_Any *)pDest)->pType; 314 pDest = ((uno_Any *)pDest)->pData; 315 } 316 while (typelib_TypeClass_ANY == (eSourceTypeClass = pSourceType->eTypeClass)) 317 { 318 pSourceTypeDescr = 0; 319 pSourceType = ((uno_Any *)pSource)->pType; 320 pSource = ((uno_Any *)pSource)->pData; 321 } 322 323 switch (eDestTypeClass) 324 { 325 case typelib_TypeClass_VOID: 326 return eSourceTypeClass == typelib_TypeClass_VOID; 327 case typelib_TypeClass_CHAR: 328 return eSourceTypeClass == typelib_TypeClass_CHAR 329 && *(sal_Unicode *)pDest == *(sal_Unicode *)pSource; 330 case typelib_TypeClass_BOOLEAN: 331 return eSourceTypeClass == typelib_TypeClass_BOOLEAN 332 && ((*(sal_Bool *)pDest != sal_False) 333 == (*(sal_Bool *)pSource != sal_False)); 334 case typelib_TypeClass_BYTE: 335 switch (eSourceTypeClass) 336 { 337 case typelib_TypeClass_BYTE: 338 return (*(sal_Int8 *)pDest == *(sal_Int8 *)pSource); 339 case typelib_TypeClass_SHORT: 340 return ((sal_Int16)*(sal_Int8 *)pDest == *(sal_Int16 *)pSource); 341 case typelib_TypeClass_UNSIGNED_SHORT: 342 return ((sal_Int32)*(sal_Int8 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource); 343 case typelib_TypeClass_LONG: 344 return ((sal_Int32)*(sal_Int8 *)pDest == *(sal_Int32 *)pSource); 345 case typelib_TypeClass_UNSIGNED_LONG: 346 return ((sal_Int64)*(sal_Int8 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource); 347 case typelib_TypeClass_HYPER: 348 return ((sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource); 349 case typelib_TypeClass_UNSIGNED_HYPER: 350 return (*(sal_Int8 *)pDest >= 0 && 351 (sal_Int64)*(sal_Int8 *)pDest == *(sal_Int64 *)pSource); // same size 352 case typelib_TypeClass_FLOAT: 353 return ((float)*(sal_Int8 *)pDest == *(float *)pSource); 354 case typelib_TypeClass_DOUBLE: 355 return ((double)*(sal_Int8 *)pDest == *(double *)pSource); 356 default: 357 return sal_False; 358 } 359 case typelib_TypeClass_SHORT: 360 switch (eSourceTypeClass) 361 { 362 case typelib_TypeClass_BYTE: 363 return (*(sal_Int16 *)pDest == (sal_Int16)*(sal_Int8 *)pSource); 364 case typelib_TypeClass_SHORT: 365 return (*(sal_Int16 *)pDest == *(sal_Int16 *)pSource); 366 case typelib_TypeClass_UNSIGNED_SHORT: 367 return ((sal_Int32)*(sal_Int16 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource); 368 case typelib_TypeClass_LONG: 369 return ((sal_Int32)*(sal_Int16 *)pDest == *(sal_Int32 *)pSource); 370 case typelib_TypeClass_UNSIGNED_LONG: 371 return ((sal_Int64)*(sal_Int16 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource); 372 case typelib_TypeClass_HYPER: 373 return ((sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource); 374 case typelib_TypeClass_UNSIGNED_HYPER: 375 return (*(sal_Int16 *)pDest >= 0 && 376 (sal_Int64)*(sal_Int16 *)pDest == *(sal_Int64 *)pSource); // same size 377 case typelib_TypeClass_FLOAT: 378 return ((float)*(sal_Int16 *)pDest == *(float *)pSource); 379 case typelib_TypeClass_DOUBLE: 380 return ((double)*(sal_Int16 *)pDest == *(double *)pSource); 381 default: 382 return sal_False; 383 } 384 case typelib_TypeClass_UNSIGNED_SHORT: 385 switch (eSourceTypeClass) 386 { 387 case typelib_TypeClass_BYTE: 388 return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int8 *)pSource); 389 case typelib_TypeClass_SHORT: 390 return ((sal_Int32)*(sal_uInt16 *)pDest == (sal_Int32)*(sal_Int16 *)pSource); 391 case typelib_TypeClass_UNSIGNED_SHORT: 392 return (*(sal_uInt16 *)pDest == *(sal_uInt16 *)pSource); 393 case typelib_TypeClass_LONG: 394 return ((sal_Int32)*(sal_uInt16 *)pDest == *(sal_Int32 *)pSource); 395 case typelib_TypeClass_UNSIGNED_LONG: 396 return ((sal_uInt32)*(sal_uInt16 *)pDest == *(sal_uInt32 *)pSource); 397 case typelib_TypeClass_HYPER: 398 return ((sal_Int64)*(sal_uInt16 *)pDest == *(sal_Int64 *)pSource); 399 case typelib_TypeClass_UNSIGNED_HYPER: 400 return ((sal_uInt64)*(sal_uInt16 *)pDest == *(sal_uInt64 *)pSource); 401 case typelib_TypeClass_FLOAT: 402 return ((float)*(sal_uInt16 *)pDest == *(float *)pSource); 403 case typelib_TypeClass_DOUBLE: 404 return ((double)*(sal_uInt16 *)pDest == *(double *)pSource); 405 default: 406 return sal_False; 407 } 408 case typelib_TypeClass_LONG: 409 switch (eSourceTypeClass) 410 { 411 case typelib_TypeClass_BYTE: 412 return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int8 *)pSource); 413 case typelib_TypeClass_SHORT: 414 return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_Int16 *)pSource); 415 case typelib_TypeClass_UNSIGNED_SHORT: 416 return (*(sal_Int32 *)pDest == (sal_Int32)*(sal_uInt16 *)pSource); 417 case typelib_TypeClass_LONG: 418 return (*(sal_Int32 *)pDest == *(sal_Int32 *)pSource); 419 case typelib_TypeClass_UNSIGNED_LONG: 420 return ((sal_Int64)*(sal_Int32 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource); 421 case typelib_TypeClass_HYPER: 422 return ((sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource); 423 case typelib_TypeClass_UNSIGNED_HYPER: 424 return (*(sal_Int32 *)pDest >= 0 && 425 (sal_Int64)*(sal_Int32 *)pDest == *(sal_Int64 *)pSource); // same size 426 case typelib_TypeClass_FLOAT: 427 return ((float)*(sal_Int32 *)pDest == *(float *)pSource); 428 case typelib_TypeClass_DOUBLE: 429 return ((double)*(sal_Int32 *)pDest == *(double *)pSource); 430 default: 431 return sal_False; 432 } 433 case typelib_TypeClass_UNSIGNED_LONG: 434 switch (eSourceTypeClass) 435 { 436 case typelib_TypeClass_BYTE: 437 return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int8 *)pSource); 438 case typelib_TypeClass_SHORT: 439 return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int16 *)pSource); 440 case typelib_TypeClass_UNSIGNED_SHORT: 441 return (*(sal_uInt32 *)pDest == (sal_uInt32)*(sal_uInt16 *)pSource); 442 case typelib_TypeClass_LONG: 443 return ((sal_Int64)*(sal_uInt32 *)pDest == (sal_Int64)*(sal_Int32 *)pSource); 444 case typelib_TypeClass_UNSIGNED_LONG: 445 return (*(sal_uInt32 *)pDest == *(sal_uInt32 *)pSource); 446 case typelib_TypeClass_HYPER: 447 return ((sal_Int64)*(sal_uInt32 *)pDest == *(sal_Int64 *)pSource); 448 case typelib_TypeClass_UNSIGNED_HYPER: 449 return ((sal_uInt64)*(sal_uInt32 *)pDest == *(sal_uInt64 *)pSource); 450 case typelib_TypeClass_FLOAT: 451 return ((float)*(sal_uInt32 *)pDest == *(float *)pSource); 452 case typelib_TypeClass_DOUBLE: 453 return ((double)*(sal_uInt32 *)pDest == *(double *)pSource); 454 default: 455 return sal_False; 456 } 457 case typelib_TypeClass_HYPER: 458 switch (eSourceTypeClass) 459 { 460 case typelib_TypeClass_BYTE: 461 return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int8 *)pSource); 462 case typelib_TypeClass_SHORT: 463 return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int16 *)pSource); 464 case typelib_TypeClass_UNSIGNED_SHORT: 465 return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt16 *)pSource); 466 case typelib_TypeClass_LONG: 467 return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_Int32 *)pSource); 468 case typelib_TypeClass_UNSIGNED_LONG: 469 return (*(sal_Int64 *)pDest == (sal_Int64)*(sal_uInt32 *)pSource); 470 case typelib_TypeClass_HYPER: 471 return (*(sal_Int64 *)pDest == *(sal_Int64 *)pSource); 472 case typelib_TypeClass_UNSIGNED_HYPER: 473 return (*(sal_Int64 *)pDest >= 0 && 474 *(sal_Int64 *)pDest == *(sal_Int64 *)pSource); // same size 475 case typelib_TypeClass_FLOAT: 476 return ((float)*(sal_Int64 *)pDest == *(float *)pSource); 477 case typelib_TypeClass_DOUBLE: 478 return ((double)*(sal_Int64 *)pDest == *(double *)pSource); 479 default: 480 return sal_False; 481 } 482 case typelib_TypeClass_UNSIGNED_HYPER: 483 switch (eSourceTypeClass) 484 { 485 case typelib_TypeClass_BYTE: 486 return (*(sal_Int8 *)pSource >= 0 && 487 *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int8 *)pSource); 488 case typelib_TypeClass_SHORT: 489 return (*(sal_Int16 *)pSource >= 0 && 490 *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int16 *)pSource); 491 case typelib_TypeClass_UNSIGNED_SHORT: 492 return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt16 *)pSource); 493 case typelib_TypeClass_LONG: 494 return (*(sal_Int32 *)pSource >= 0 && 495 *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int32 *)pSource); 496 case typelib_TypeClass_UNSIGNED_LONG: 497 return (*(sal_uInt64 *)pDest == (sal_uInt64)*(sal_uInt32 *)pSource); 498 case typelib_TypeClass_HYPER: 499 return (*(sal_Int64 *)pSource >= 0 && 500 *(sal_uInt64 *)pDest == (sal_uInt64)*(sal_Int64 *)pSource); 501 case typelib_TypeClass_UNSIGNED_HYPER: 502 return (*(sal_uInt64 *)pDest == *(sal_uInt64 *)pSource); 503 case typelib_TypeClass_FLOAT: 504 if (::floor( *(float *)pSource ) != *(float *)pSource || *(float *)pSource < 0) 505 return sal_False; 506 return (*(sal_uInt64 *)pDest == (sal_uInt64)*(float *)pSource); 507 case typelib_TypeClass_DOUBLE: 508 if (::floor( *(double *)pSource ) != *(double *)pSource || *(double *)pSource < 0) 509 return sal_False; 510 return (*(sal_uInt64 *)pDest == (sal_uInt64)*(double *)pSource); 511 default: 512 return sal_False; 513 } 514 case typelib_TypeClass_FLOAT: 515 switch (eSourceTypeClass) 516 { 517 case typelib_TypeClass_BYTE: 518 return (*(float *)pDest == (float)*(sal_Int8 *)pSource); 519 case typelib_TypeClass_SHORT: 520 return (*(float *)pDest == (float)*(sal_Int16 *)pSource); 521 case typelib_TypeClass_UNSIGNED_SHORT: 522 return (*(float *)pDest == (float)*(sal_uInt16 *)pSource); 523 case typelib_TypeClass_LONG: 524 return (*(float *)pDest == (float)*(sal_Int32 *)pSource); 525 case typelib_TypeClass_UNSIGNED_LONG: 526 return (*(float *)pDest == (float)*(sal_uInt32 *)pSource); 527 case typelib_TypeClass_HYPER: 528 return (*(float *)pDest == (float)*(sal_Int64 *)pSource); 529 case typelib_TypeClass_UNSIGNED_HYPER: 530 if (::floor( *(float *)pDest ) != *(float *)pDest || *(float *)pDest < 0) 531 return sal_False; 532 return ((sal_uInt64)*(float *)pDest == *(sal_uInt64 *)pSource); 533 case typelib_TypeClass_FLOAT: 534 return (*(float *)pDest == *(float *)pSource); 535 case typelib_TypeClass_DOUBLE: 536 return ((double)*(float *)pDest == *(double *)pSource); 537 default: 538 return sal_False; 539 } 540 case typelib_TypeClass_DOUBLE: 541 switch (eSourceTypeClass) 542 { 543 case typelib_TypeClass_BYTE: 544 return (*(double *)pDest == (double)*(sal_Int8 *)pSource); 545 case typelib_TypeClass_SHORT: 546 return (*(double *)pDest == (double)*(sal_Int16 *)pSource); 547 case typelib_TypeClass_UNSIGNED_SHORT: 548 return (*(double *)pDest == (double)*(sal_uInt16 *)pSource); 549 case typelib_TypeClass_LONG: 550 return (*(double *)pDest == (double)*(sal_Int32 *)pSource); 551 case typelib_TypeClass_UNSIGNED_LONG: 552 return (*(double *)pDest == (double)*(sal_uInt32 *)pSource); 553 case typelib_TypeClass_HYPER: 554 return (*(double *)pDest == (double)*(sal_Int64 *)pSource); 555 case typelib_TypeClass_UNSIGNED_HYPER: 556 if (::floor( *(double *)pDest ) != *(double *)pDest || *(double *)pDest < 0) 557 return sal_False; 558 return ((sal_uInt64)*(double *)pDest == *(sal_uInt64 *)pSource); 559 case typelib_TypeClass_FLOAT: 560 return (*(double *)pDest == (double)*(float *)pSource); 561 case typelib_TypeClass_DOUBLE: 562 return (*(double *)pDest == *(double *)pSource); 563 default: 564 return sal_False; 565 } 566 case typelib_TypeClass_STRING: 567 return eSourceTypeClass == typelib_TypeClass_STRING 568 && ((::rtl::OUString *)pDest)->equals( 569 *(::rtl::OUString const *)pSource ); 570 case typelib_TypeClass_TYPE: 571 return eSourceTypeClass == typelib_TypeClass_TYPE 572 && _type_equals( 573 *(typelib_TypeDescriptionReference **)pDest, 574 *(typelib_TypeDescriptionReference **)pSource ); 575 case typelib_TypeClass_ENUM: 576 return (_type_equals( pDestType, pSourceType ) && 577 *(sal_Int32 *)pDest == *(sal_Int32 *)pSource); 578 case typelib_TypeClass_STRUCT: 579 case typelib_TypeClass_EXCEPTION: 580 if (! _type_equals( pDestType, pSourceType )) 581 return sal_False; 582 if (pDestTypeDescr) 583 { 584 return _equalStruct( 585 pDest, pSource, 586 (typelib_CompoundTypeDescription *)pDestTypeDescr, 587 queryInterface, release ); 588 } 589 else 590 { 591 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType ); 592 sal_Bool bRet = _equalStruct( 593 pDest, pSource, 594 (typelib_CompoundTypeDescription *)pDestTypeDescr, 595 queryInterface, release ); 596 TYPELIB_DANGER_RELEASE( pDestTypeDescr ); 597 return bRet; 598 } 599 case typelib_TypeClass_UNION: 600 if (_type_equals( pDestType, pSourceType ) && 601 *(sal_Int64 *)pDest == *(sal_Int64 *)pSource) // same discriminant 602 { 603 sal_Bool bRet; 604 if (pDestTypeDescr) 605 { 606 typelib_TypeDescriptionReference * pSetType = _unionGetSetType( 607 pDest, pDestTypeDescr ); 608 bRet = ::uno_type_equalData( 609 (char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset, 610 pSetType, 611 (char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset, 612 pSetType, 613 queryInterface, release ); 614 typelib_typedescriptionreference_release( pSetType ); 615 } 616 else 617 { 618 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType ); 619 typelib_TypeDescriptionReference * pSetType = _unionGetSetType( 620 pDest, pDestTypeDescr ); 621 bRet = ::uno_type_equalData( 622 (char *)pDest + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset, 623 pSetType, 624 (char *)pSource + ((typelib_UnionTypeDescription *)pDestTypeDescr)->nValueOffset, 625 pSetType, 626 queryInterface, release ); 627 typelib_typedescriptionreference_release( pSetType ); 628 TYPELIB_DANGER_RELEASE( pDestTypeDescr ); 629 } 630 return bRet; 631 } 632 return sal_False; 633 case typelib_TypeClass_SEQUENCE: 634 if (_type_equals( pDestType, pSourceType )) 635 { 636 if (pDestTypeDescr) 637 { 638 return _equalSequence( 639 *(uno_Sequence **)pDest, *(uno_Sequence **)pSource, 640 ((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType, 641 queryInterface, release ); 642 } 643 else 644 { 645 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType ); 646 sal_Bool bRet = _equalSequence( 647 *(uno_Sequence **)pDest, *(uno_Sequence **)pSource, 648 ((typelib_IndirectTypeDescription *)pDestTypeDescr)->pType, 649 queryInterface, release ); 650 TYPELIB_DANGER_RELEASE( pDestTypeDescr ); 651 return bRet; 652 } 653 } 654 return sal_False; 655 case typelib_TypeClass_INTERFACE: 656 if (typelib_TypeClass_INTERFACE == eSourceTypeClass) 657 return _equalObject( *(void **)pDest, *(void **)pSource, queryInterface, release ); 658 break; 659 default: 660 OSL_ASSERT(false); 661 break; 662 } 663 return sal_False; 664 } 665 666 } 667 668 #endif 669