1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 #ifndef ASSIGN_HXX 24 #define ASSIGN_HXX 25 26 #include "prim.hxx" 27 #include "destr.hxx" 28 #include "constr.hxx" 29 #include "copy.hxx" 30 31 32 namespace cppu 33 { 34 35 //################################################################################################## 36 //#### assignment ################################################################################## 37 //################################################################################################## 38 39 40 //-------------------------------------------------------------------------------------------------- 41 inline void _assignInterface( 42 void ** ppDest, void * pSource, 43 uno_AcquireFunc acquire, uno_ReleaseFunc release ) 44 SAL_THROW( () ) 45 { 46 _acquire( pSource, acquire ); 47 void * const pToBeReleased = *ppDest; 48 *ppDest = pSource; 49 _release( pToBeReleased, release ); 50 } 51 //-------------------------------------------------------------------------------------------------- 52 inline void * _queryInterface( 53 void * pSource, 54 typelib_TypeDescriptionReference * pDestType, 55 uno_QueryInterfaceFunc queryInterface ) 56 SAL_THROW( () ) 57 { 58 if (pSource) 59 { 60 if (0 == queryInterface) 61 queryInterface = binuno_queryInterface; 62 pSource = (*queryInterface)( pSource, pDestType ); 63 } 64 return pSource; 65 } 66 //================================================================================================== 67 sal_Bool assignStruct( 68 void * pDest, void * pSource, 69 typelib_CompoundTypeDescription * pTypeDescr, 70 uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release ) 71 SAL_THROW( () ); 72 //-------------------------------------------------------------------------------------------------- 73 inline sal_Bool _assignStruct( 74 void * pDest, void * pSource, 75 typelib_CompoundTypeDescription * pTypeDescr, 76 uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release ) 77 SAL_THROW( () ) 78 { 79 if (pTypeDescr->pBaseTypeDescription) 80 { 81 // copy base value 82 if (! assignStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, 83 queryInterface, acquire, release )) 84 { 85 return sal_False; 86 } 87 } 88 // then copy members 89 typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs; 90 sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets; 91 sal_Int32 nDescr = pTypeDescr->nMembers; 92 while (nDescr--) 93 { 94 if (! ::uno_type_assignData( (char *)pDest + pMemberOffsets[nDescr], 95 ppTypeRefs[nDescr], 96 (char *)pSource + pMemberOffsets[nDescr], 97 ppTypeRefs[nDescr], 98 queryInterface, acquire, release )) 99 { 100 return sal_False; 101 } 102 } 103 return sal_True; 104 } 105 //-------------------------------------------------------------------------------------------------- 106 inline sal_Bool _assignArray( 107 void * pDest, void * pSource, 108 typelib_ArrayTypeDescription * pTypeDescr, 109 uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release ) 110 { 111 typelib_TypeDescriptionReference * pElementTypeRef = 112 ((typelib_IndirectTypeDescription *)pTypeDescr)->pType; 113 typelib_TypeDescription * pElementTypeDescr = NULL; 114 TYPELIB_DANGER_GET( &pElementTypeDescr, pElementTypeRef ); 115 sal_Int32 nTotalElements = pTypeDescr->nTotalElements; 116 sal_Int32 nElementSize = pElementTypeDescr->nSize; 117 sal_Int32 i; 118 sal_Bool bRet = sal_False; 119 120 switch ( pElementTypeRef->eTypeClass ) 121 { 122 case typelib_TypeClass_CHAR: 123 case typelib_TypeClass_BOOLEAN: 124 case typelib_TypeClass_BYTE: 125 case typelib_TypeClass_SHORT: 126 case typelib_TypeClass_UNSIGNED_SHORT: 127 case typelib_TypeClass_LONG: 128 case typelib_TypeClass_UNSIGNED_LONG: 129 case typelib_TypeClass_HYPER: 130 case typelib_TypeClass_UNSIGNED_HYPER: 131 case typelib_TypeClass_FLOAT: 132 case typelib_TypeClass_DOUBLE: 133 for (i=0; i < nTotalElements; i++) 134 { 135 ::rtl_copyMemory((sal_Char *)pDest + i * nElementSize, 136 (sal_Char *)pSource + i * nElementSize, 137 nElementSize); 138 } 139 bRet = sal_True; 140 break; 141 case typelib_TypeClass_STRING: 142 for (i=0; i < nTotalElements; i++) 143 { 144 ::rtl_uString_assign( (rtl_uString **)pDest + i, 145 ((rtl_uString **)pSource)[i] ); 146 } 147 bRet = sal_True; 148 break; 149 case typelib_TypeClass_TYPE: 150 for (i=0; i < nTotalElements; i++) 151 { 152 typelib_TypeDescriptionReference ** pp = (typelib_TypeDescriptionReference **)pDest + i; 153 ::typelib_typedescriptionreference_release( *pp ); 154 *pp = *((typelib_TypeDescriptionReference **)pSource + i); 155 TYPE_ACQUIRE( *pp ); 156 } 157 bRet = sal_True; 158 break; 159 case typelib_TypeClass_ANY: 160 for (i=0; i < nTotalElements; i++) 161 { 162 _destructAny( (uno_Any *)pDest + i, release ); 163 _copyConstructAny( (uno_Any *)pDest + i, (uno_Any *)pSource + i, 164 pElementTypeRef, pElementTypeDescr, acquire, 0 ); 165 } 166 bRet = sal_True; 167 break; 168 case typelib_TypeClass_ENUM: 169 for (i=0; i < nTotalElements; i++) 170 { 171 *((sal_Int32 *)pDest + i) = *((sal_Int32 *)pSource + i); 172 } 173 bRet = sal_True; 174 break; 175 case typelib_TypeClass_STRUCT: 176 case typelib_TypeClass_EXCEPTION: 177 for (i=0; i < nTotalElements; i++) 178 { 179 bRet = _assignStruct( (sal_Char *)pDest + i * nElementSize, 180 (sal_Char *)pSource + i * nElementSize, 181 (typelib_CompoundTypeDescription *)pElementTypeDescr, 182 queryInterface, acquire, release ); 183 if (! bRet) 184 break; 185 } 186 bRet = sal_True; 187 break; 188 case typelib_TypeClass_UNION: 189 for (i=0; i < nTotalElements; i++) 190 { 191 _destructUnion( (sal_Char*)pDest + i * nElementSize, pElementTypeDescr, release ); 192 _copyConstructUnion( (sal_Char*)pDest + i * nElementSize, 193 (sal_Char*)pSource + i * nElementSize, 194 pElementTypeDescr, acquire, 0 ); 195 } 196 bRet = sal_True; 197 break; 198 case typelib_TypeClass_SEQUENCE: 199 for (i=0; i < nTotalElements; i++) 200 { 201 ::osl_incrementInterlockedCount( 202 &(*((uno_Sequence **)pSource + i))->nRefCount ); 203 idestructSequence( 204 *((uno_Sequence **)pDest + i), 205 pElementTypeRef, pElementTypeDescr, release ); 206 *((uno_Sequence **)pDest + i) = *((uno_Sequence **)pSource + i); 207 } 208 bRet = sal_True; 209 break; 210 case typelib_TypeClass_INTERFACE: 211 for (i=0; i < nTotalElements; i++) 212 { 213 _assignInterface( 214 (void **)((sal_Char*)pDest + i * nElementSize), 215 *(void **)((sal_Char*)pSource + i * nElementSize), 216 acquire, release ); 217 } 218 bRet = sal_True; 219 break; 220 default: 221 OSL_ASSERT(false); 222 break; 223 } 224 225 TYPELIB_DANGER_RELEASE( pElementTypeDescr ); 226 return bRet; 227 } 228 //-------------------------------------------------------------------------------------------------- 229 inline sal_Bool _assignData( 230 void * pDest, 231 typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr, 232 void * pSource, 233 typelib_TypeDescriptionReference * pSourceType, typelib_TypeDescription * pSourceTypeDescr, 234 uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release ) 235 SAL_THROW( () ) 236 { 237 if (pDest == pSource) 238 return _type_equals( pDestType, pSourceType ); 239 240 if (! pSource) 241 { 242 _destructData( pDest, pDestType, pDestTypeDescr, release ); 243 _defaultConstructData( pDest, pDestType, pDestTypeDescr ); 244 return sal_True; 245 } 246 while (typelib_TypeClass_ANY == pSourceType->eTypeClass) 247 { 248 pSourceTypeDescr = 0; 249 pSourceType = ((uno_Any *)pSource)->pType; 250 pSource = ((uno_Any *)pSource)->pData; 251 if (pDest == pSource) 252 return sal_True; 253 } 254 255 switch (pDestType->eTypeClass) 256 { 257 case typelib_TypeClass_VOID: 258 return pSourceType->eTypeClass == typelib_TypeClass_VOID; 259 case typelib_TypeClass_CHAR: 260 switch (pSourceType->eTypeClass) 261 { 262 case typelib_TypeClass_CHAR: 263 *(sal_Unicode *)pDest = *(sal_Unicode *)pSource; 264 return sal_True; 265 default: 266 return sal_False; 267 } 268 case typelib_TypeClass_BOOLEAN: 269 switch (pSourceType->eTypeClass) 270 { 271 case typelib_TypeClass_BOOLEAN: 272 *(sal_Bool *)pDest = (*(sal_Bool *)pSource != sal_False); 273 return sal_True; 274 default: 275 return sal_False; 276 } 277 case typelib_TypeClass_BYTE: 278 switch (pSourceType->eTypeClass) 279 { 280 case typelib_TypeClass_BYTE: 281 *(sal_Int8 *)pDest = *(sal_Int8 *)pSource; 282 return sal_True; 283 default: 284 return sal_False; 285 } 286 case typelib_TypeClass_SHORT: 287 switch (pSourceType->eTypeClass) 288 { 289 case typelib_TypeClass_BYTE: 290 *(sal_Int16 *)pDest = *(sal_Int8 *)pSource; 291 return sal_True; 292 case typelib_TypeClass_SHORT: 293 case typelib_TypeClass_UNSIGNED_SHORT: 294 *(sal_Int16 *)pDest = *(sal_Int16 *)pSource; 295 return sal_True; 296 default: 297 return sal_False; 298 } 299 case typelib_TypeClass_UNSIGNED_SHORT: 300 switch (pSourceType->eTypeClass) 301 { 302 case typelib_TypeClass_BYTE: 303 *(sal_uInt16 *)pDest = *(sal_Int8 *)pSource; 304 return sal_True; 305 case typelib_TypeClass_SHORT: 306 case typelib_TypeClass_UNSIGNED_SHORT: 307 *(sal_uInt16 *)pDest = *(sal_uInt16 *)pSource; 308 return sal_True; 309 default: 310 return sal_False; 311 } 312 case typelib_TypeClass_LONG: 313 switch (pSourceType->eTypeClass) 314 { 315 case typelib_TypeClass_BYTE: 316 *(sal_Int32 *)pDest = *(sal_Int8 *)pSource; 317 return sal_True; 318 case typelib_TypeClass_SHORT: 319 *(sal_Int32 *)pDest = *(sal_Int16 *)pSource; 320 return sal_True; 321 case typelib_TypeClass_UNSIGNED_SHORT: 322 *(sal_Int32 *)pDest = *(sal_uInt16 *)pSource; 323 return sal_True; 324 case typelib_TypeClass_LONG: 325 case typelib_TypeClass_UNSIGNED_LONG: 326 *(sal_Int32 *)pDest = *(sal_Int32 *)pSource; 327 return sal_True; 328 default: 329 return sal_False; 330 } 331 case typelib_TypeClass_UNSIGNED_LONG: 332 switch (pSourceType->eTypeClass) 333 { 334 case typelib_TypeClass_BYTE: 335 *(sal_uInt32 *)pDest = *(sal_Int8 *)pSource; 336 return sal_True; 337 case typelib_TypeClass_SHORT: 338 *(sal_uInt32 *)pDest = *(sal_Int16 *)pSource; 339 return sal_True; 340 case typelib_TypeClass_UNSIGNED_SHORT: 341 *(sal_uInt32 *)pDest = *(sal_uInt16 *)pSource; 342 return sal_True; 343 case typelib_TypeClass_LONG: 344 case typelib_TypeClass_UNSIGNED_LONG: 345 *(sal_uInt32 *)pDest = *(sal_uInt32 *)pSource; 346 return sal_True; 347 default: 348 return sal_False; 349 } 350 case typelib_TypeClass_HYPER: 351 switch (pSourceType->eTypeClass) 352 { 353 case typelib_TypeClass_BYTE: 354 *(sal_Int64 *)pDest = *(sal_Int8 *)pSource; 355 return sal_True; 356 case typelib_TypeClass_SHORT: 357 *(sal_Int64 *)pDest = *(sal_Int16 *)pSource; 358 return sal_True; 359 case typelib_TypeClass_UNSIGNED_SHORT: 360 *(sal_Int64 *)pDest = *(sal_uInt16 *)pSource; 361 return sal_True; 362 case typelib_TypeClass_LONG: 363 *(sal_Int64 *)pDest = *(sal_Int32 *)pSource; 364 return sal_True; 365 case typelib_TypeClass_UNSIGNED_LONG: 366 *(sal_Int64 *)pDest = *(sal_uInt32 *)pSource; 367 return sal_True; 368 case typelib_TypeClass_HYPER: 369 case typelib_TypeClass_UNSIGNED_HYPER: 370 *(sal_Int64 *)pDest = *(sal_Int64 *)pSource; 371 return sal_True; 372 default: 373 return sal_False; 374 } 375 case typelib_TypeClass_UNSIGNED_HYPER: 376 switch (pSourceType->eTypeClass) 377 { 378 case typelib_TypeClass_BYTE: 379 *(sal_uInt64 *)pDest = *(sal_Int8 *)pSource; 380 return sal_True; 381 case typelib_TypeClass_SHORT: 382 *(sal_uInt64 *)pDest = *(sal_Int16 *)pSource; 383 return sal_True; 384 case typelib_TypeClass_UNSIGNED_SHORT: 385 *(sal_uInt64 *)pDest = *(sal_uInt16 *)pSource; 386 return sal_True; 387 case typelib_TypeClass_LONG: 388 *(sal_uInt64 *)pDest = *(sal_Int32 *)pSource; 389 return sal_True; 390 case typelib_TypeClass_UNSIGNED_LONG: 391 *(sal_uInt64 *)pDest = *(sal_uInt32 *)pSource; 392 return sal_True; 393 case typelib_TypeClass_HYPER: 394 case typelib_TypeClass_UNSIGNED_HYPER: 395 *(sal_uInt64 *)pDest = *(sal_uInt64 *)pSource; 396 return sal_True; 397 default: 398 return sal_False; 399 } 400 case typelib_TypeClass_FLOAT: 401 switch (pSourceType->eTypeClass) 402 { 403 case typelib_TypeClass_BYTE: 404 *(float *)pDest = *(sal_Int8 *)pSource; 405 return sal_True; 406 case typelib_TypeClass_SHORT: 407 *(float *)pDest = *(sal_Int16 *)pSource; 408 return sal_True; 409 case typelib_TypeClass_UNSIGNED_SHORT: 410 *(float *)pDest = *(sal_uInt16 *)pSource; 411 return sal_True; 412 case typelib_TypeClass_FLOAT: 413 *(float *)pDest = *(float *)pSource; 414 return sal_True; 415 default: 416 return sal_False; 417 } 418 case typelib_TypeClass_DOUBLE: 419 switch (pSourceType->eTypeClass) 420 { 421 case typelib_TypeClass_BYTE: 422 *(double *)pDest = *(sal_Int8 *)pSource; 423 return sal_True; 424 case typelib_TypeClass_SHORT: 425 *(double *)pDest = *(sal_Int16 *)pSource; 426 return sal_True; 427 case typelib_TypeClass_UNSIGNED_SHORT: 428 *(double *)pDest = *(sal_uInt16 *)pSource; 429 return sal_True; 430 case typelib_TypeClass_LONG: 431 *(double *)pDest = *(sal_Int32 *)pSource; 432 return sal_True; 433 case typelib_TypeClass_UNSIGNED_LONG: 434 *(double *)pDest = *(sal_uInt32 *)pSource; 435 return sal_True; 436 case typelib_TypeClass_FLOAT: 437 *(double *)pDest = *(float *)pSource; 438 return sal_True; 439 case typelib_TypeClass_DOUBLE: 440 *(double *)pDest = *(double *)pSource; 441 return sal_True; 442 default: 443 return sal_False; 444 } 445 case typelib_TypeClass_STRING: 446 switch (pSourceType->eTypeClass) 447 { 448 case typelib_TypeClass_STRING: 449 ::rtl_uString_assign( (rtl_uString **)pDest, *(rtl_uString **)pSource ); 450 return sal_True; 451 default: 452 return sal_False; 453 } 454 case typelib_TypeClass_TYPE: 455 switch (pSourceType->eTypeClass) 456 { 457 case typelib_TypeClass_TYPE: 458 { 459 typelib_TypeDescriptionReference ** pp = (typelib_TypeDescriptionReference **)pDest; 460 ::typelib_typedescriptionreference_release( *pp ); 461 *pp = *(typelib_TypeDescriptionReference **)pSource; 462 TYPE_ACQUIRE( *pp ); 463 return sal_True; 464 } 465 default: 466 return sal_False; 467 } 468 case typelib_TypeClass_ANY: 469 _destructAny( (uno_Any *)pDest, release ); 470 _copyConstructAny( (uno_Any *)pDest, pSource, pSourceType, pSourceTypeDescr, acquire, 0 ); 471 return sal_True; 472 case typelib_TypeClass_ENUM: 473 if (_type_equals( pDestType, pSourceType )) 474 { 475 *(sal_Int32 *)pDest = *(sal_Int32 *)pSource; 476 return sal_True; 477 } 478 return sal_False; 479 case typelib_TypeClass_STRUCT: 480 case typelib_TypeClass_EXCEPTION: 481 if (typelib_TypeClass_STRUCT == pSourceType->eTypeClass || 482 typelib_TypeClass_EXCEPTION == pSourceType->eTypeClass) 483 { 484 sal_Bool bRet = sal_False; 485 if (pSourceTypeDescr) 486 { 487 typelib_CompoundTypeDescription * pTypeDescr = 488 (typelib_CompoundTypeDescription *)pSourceTypeDescr; 489 while (pTypeDescr && 490 !_type_equals( 491 ((typelib_TypeDescription *)pTypeDescr)->pWeakRef, pDestType )) 492 { 493 pTypeDescr = pTypeDescr->pBaseTypeDescription; 494 } 495 if (pTypeDescr) 496 { 497 bRet = _assignStruct( 498 pDest, pSource, pTypeDescr, queryInterface, acquire, release ); 499 } 500 } 501 else 502 { 503 TYPELIB_DANGER_GET( &pSourceTypeDescr, pSourceType ); 504 typelib_CompoundTypeDescription * pTypeDescr = 505 (typelib_CompoundTypeDescription *)pSourceTypeDescr; 506 while (pTypeDescr && 507 !_type_equals( 508 ((typelib_TypeDescription *)pTypeDescr)->pWeakRef, pDestType )) 509 { 510 pTypeDescr = pTypeDescr->pBaseTypeDescription; 511 } 512 if (pTypeDescr) 513 { 514 bRet = _assignStruct( 515 pDest, pSource, pTypeDescr, queryInterface, acquire, release ); 516 } 517 TYPELIB_DANGER_RELEASE( pSourceTypeDescr ); 518 } 519 return bRet; 520 } 521 return sal_False; 522 case typelib_TypeClass_ARRAY: 523 { 524 sal_Bool bRet = sal_False; 525 if (pSourceTypeDescr) 526 { 527 typelib_ArrayTypeDescription * pTypeDescr = 528 (typelib_ArrayTypeDescription *)pSourceTypeDescr; 529 bRet = _assignArray( pDest, pSource, pTypeDescr, queryInterface, acquire, release ); 530 } 531 else 532 { 533 TYPELIB_DANGER_GET( &pSourceTypeDescr, pSourceType ); 534 typelib_ArrayTypeDescription * pTypeDescr = 535 (typelib_ArrayTypeDescription *)pSourceTypeDescr; 536 if ( pTypeDescr ) 537 { 538 bRet = _assignArray( 539 pDest, pSource, pTypeDescr, queryInterface, acquire, release ); 540 } 541 TYPELIB_DANGER_RELEASE( pSourceTypeDescr ); 542 } 543 return bRet; 544 } 545 case typelib_TypeClass_UNION: 546 if (_type_equals( pDestType, pSourceType )) 547 { 548 if (pDestTypeDescr) 549 { 550 _destructUnion( pDest, pDestTypeDescr, release ); 551 _copyConstructUnion( pDest, pSource, pDestTypeDescr, acquire, 0 ); 552 } 553 else 554 { 555 TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType ); 556 _destructUnion( pDest, pDestTypeDescr, release ); 557 _copyConstructUnion( pDest, pSource, pDestTypeDescr, acquire, 0 ); 558 TYPELIB_DANGER_RELEASE( pDestTypeDescr ); 559 } 560 return sal_True; 561 } 562 return sal_False; 563 case typelib_TypeClass_SEQUENCE: 564 if (typelib_TypeClass_SEQUENCE != pSourceType->eTypeClass) 565 return sal_False; 566 // self assignment: 567 if (*(uno_Sequence **)pSource == *(uno_Sequence **)pDest) 568 return sal_True; 569 if (_type_equals( pDestType, pSourceType )) 570 { 571 ::osl_incrementInterlockedCount( 572 &(*(uno_Sequence **)pSource)->nRefCount ); 573 idestructSequence( 574 *(uno_Sequence **)pDest, pDestType, pDestTypeDescr, release ); 575 *(uno_Sequence **)pDest = *(uno_Sequence **)pSource; 576 return sal_True; 577 } 578 return sal_False; 579 case typelib_TypeClass_INTERFACE: 580 if (typelib_TypeClass_INTERFACE != pSourceType->eTypeClass) 581 return sal_False; 582 if (_type_equals( pDestType, pSourceType )) 583 { 584 _assignInterface( (void **)pDest, *(void **)pSource, acquire, release ); 585 return sal_True; 586 } 587 else if (*static_cast< void ** >(pSource) == 0) 588 { 589 // A null reference of any interface type can be converted to a null 590 // reference of any other interface type: 591 void * const pToBeReleased = *static_cast< void ** >(pDest); 592 *static_cast< void ** >(pDest) = 0; 593 _release( pToBeReleased, release ); 594 return true; 595 } 596 else 597 { 598 if (pSourceTypeDescr) 599 { 600 typelib_TypeDescription * pTD = pSourceTypeDescr; 601 while (pTD && !_type_equals( pTD->pWeakRef, pDestType )) 602 { 603 pTD = (typelib_TypeDescription *) 604 ((typelib_InterfaceTypeDescription *)pTD)->pBaseTypeDescription; 605 } 606 if (pTD) // is base of dest 607 { 608 _assignInterface( (void **)pDest, *(void **)pSource, acquire, release ); 609 return true; 610 } 611 } 612 613 // query for interface: 614 void * pQueried = _queryInterface( *static_cast<void **>(pSource), 615 pDestType, queryInterface ); 616 if (pQueried != 0) { 617 void * const pToBeReleased = *static_cast<void **>(pDest); 618 *static_cast<void **>(pDest) = pQueried; 619 _release( pToBeReleased, release ); 620 } 621 return (pQueried != 0); 622 } 623 default: 624 OSL_ASSERT(false); 625 return sal_False; 626 } 627 } 628 629 } 630 631 #endif 632