cppu/source/uno/assign.hxx

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