cppuhelper/source/tdmgr.cxx

   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
  20
  21 #include <sal/config.h>
  22
  23 #include <vector>
  24
  25 #include <sal/alloca.h>
  26
  27 #include <osl/diagnose.h>
  28 #include <rtl/alloc.h>
  29 #include <rtl/ustring.hxx>
  30
  31 #include <uno/lbnames.h>
  32 #include <uno/mapping.hxx>
  33
  34 #include <cppuhelper/bootstrap.hxx>
  35 #include <cppuhelper/implbase1.hxx>
  36 #include <typelib/typedescription.h>
  37
  38 #include <com/sun/star/lang/XComponent.hpp>
  39 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  40 #include <com/sun/star/reflection/XTypeDescription.hpp>
  41 #include <com/sun/star/reflection/XEnumTypeDescription.hpp>
  42 #include <com/sun/star/reflection/XIndirectTypeDescription.hpp>
  43 #include <com/sun/star/reflection/XInterfaceMemberTypeDescription.hpp>
  44 #include <com/sun/star/reflection/XInterfaceAttributeTypeDescription2.hpp>
  45 #include <com/sun/star/reflection/XMethodParameter.hpp>
  46 #include <com/sun/star/reflection/XInterfaceMethodTypeDescription.hpp>
  47 #include <com/sun/star/reflection/XInterfaceTypeDescription2.hpp>
  48 #include <com/sun/star/reflection/XCompoundTypeDescription.hpp>
  49 #include <com/sun/star/reflection/XStructTypeDescription.hpp>
  50 #include <com/sun/star/uno/RuntimeException.hpp>
  51
  52 #include <boost/scoped_array.hpp>
  53
  54 using namespace ::com::sun::star;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::reflection;
  57
  58 using rtl::OUString;
  59
  60 namespace cppu
  61 {
  62
  63 static typelib_TypeDescription * createCTD(
  64     Reference< container::XHierarchicalNameAccess > const & access,
  65     const Reference< XTypeDescription > & xType );
  66
  67
  68 inline static typelib_TypeDescription * createCTD(
  69     const Reference< XCompoundTypeDescription > & xType )
  70 {
  71     typelib_TypeDescription * pRet = 0;
  72     if (xType.is())
  73     {
  74         typelib_TypeDescription * pBaseType = createCTD(
  75             Reference< XCompoundTypeDescription >::query( xType->getBaseType() ) );
  76         if (pBaseType)
  77             typelib_typedescription_register( &pBaseType );
  78
  79         // construct member init array
  80         const Sequence<Reference< XTypeDescription > > & rMemberTypes = xType->getMemberTypes();
  81         const Sequence< OUString > & rMemberNames                     = xType->getMemberNames();
  82
  83         const Reference< XTypeDescription > * pMemberTypes = rMemberTypes.getConstArray();
  84         const OUString * pMemberNames                      = rMemberNames.getConstArray();
  85
  86         sal_Int32 nMembers = rMemberTypes.getLength();
  87         OSL_ENSURE( nMembers == rMemberNames.getLength(), "### lens differ!" );
  88
  89         OUString aTypeName( xType->getName() );
  90
  91         typelib_CompoundMember_Init * pMemberInits = static_cast<typelib_CompoundMember_Init *>(alloca(
  92             sizeof(typelib_CompoundMember_Init) * nMembers ));
  93
  94         sal_Int32 nPos;
  95         for ( nPos = nMembers; nPos--; )
  96         {
  97             typelib_CompoundMember_Init & rInit = pMemberInits[nPos];
  98             rInit.eTypeClass = (typelib_TypeClass)pMemberTypes[nPos]->getTypeClass();
  99
 100             OUString aMemberTypeName( pMemberTypes[nPos]->getName() );
 101             rtl_uString_acquire( rInit.pTypeName = aMemberTypeName.pData );
 102
 103             // string is held by rMemberNames
 104             rInit.pMemberName = pMemberNames[nPos].pData;
 105         }
 106
 107         typelib_typedescription_new(
 108             &pRet,
 109             (typelib_TypeClass)xType->getTypeClass(),
 110             aTypeName.pData,
 111             (pBaseType ? pBaseType->pWeakRef : 0),
 112             nMembers, pMemberInits );
 113
 114         // cleanup
 115         for ( nPos = nMembers; nPos--; )
 116         {
 117             rtl_uString_release( pMemberInits[nPos].pTypeName );
 118         }
 119         if (pBaseType)
 120             typelib_typedescription_release( pBaseType );
 121     }
 122     return pRet;
 123 }
 124
 125 inline static typelib_TypeDescription * createCTD(
 126     Reference< container::XHierarchicalNameAccess > const & access,
 127     const Reference< XStructTypeDescription > & xType )
 128 {
 129     typelib_TypeDescription * pRet = 0;
 130     if (xType.is() && xType->getTypeParameters().getLength() == 0)
 131     {
 132         typelib_TypeDescription * pBaseType = createCTD(
 133             access, xType->getBaseType() );
 134         if (pBaseType)
 135             typelib_typedescription_register( &pBaseType );
 136
 137         // construct member init array
 138         const Sequence<Reference< XTypeDescription > > & rMemberTypes = xType->getMemberTypes();
 139         const Sequence< OUString > & rMemberNames                     = xType->getMemberNames();
 140
 141         const Reference< XTypeDescription > * pMemberTypes = rMemberTypes.getConstArray();
 142         const OUString * pMemberNames                      = rMemberNames.getConstArray();
 143
 144         sal_Int32 nMembers = rMemberTypes.getLength();
 145         OSL_ENSURE( nMembers == rMemberNames.getLength(), "### lens differ!" );
 146
 147         OUString aTypeName( xType->getName() );
 148
 149         typelib_StructMember_Init * pMemberInits = static_cast<typelib_StructMember_Init *>(alloca(
 150             sizeof(typelib_StructMember_Init) * nMembers ));
 151
 152         Sequence< Reference< XTypeDescription > > templateMemberTypes;
 153         sal_Int32 i = aTypeName.indexOf('<');
 154         if (i >= 0) {
 155             Reference< XStructTypeDescription > templateDesc(
 156                 access->getByHierarchicalName(aTypeName.copy(0, i)),
 157                 UNO_QUERY_THROW);
 158             OSL_ASSERT(
 159                 templateDesc->getTypeParameters().getLength()
 160                 == xType->getTypeArguments().getLength());
 161             templateMemberTypes = templateDesc->getMemberTypes();
 162             OSL_ASSERT(templateMemberTypes.getLength() == nMembers);
 163         }
 164
 165         sal_Int32 nPos;
 166         for ( nPos = nMembers; nPos--; )
 167         {
 168             typelib_StructMember_Init & rInit = pMemberInits[nPos];
 169             rInit.aBase.eTypeClass
 170                 = (typelib_TypeClass)pMemberTypes[nPos]->getTypeClass();
 171
 172             OUString aMemberTypeName( pMemberTypes[nPos]->getName() );
 173             rtl_uString_acquire(
 174                 rInit.aBase.pTypeName = aMemberTypeName.pData );
 175
 176             // string is held by rMemberNames
 177             rInit.aBase.pMemberName = pMemberNames[nPos].pData;
 178
 179             rInit.bParameterizedType = templateMemberTypes.getLength() != 0
 180                 && (templateMemberTypes[nPos]->getTypeClass()
 181                     == TypeClass_UNKNOWN);
 182         }
 183
 184         typelib_typedescription_newStruct(
 185             &pRet,
 186             aTypeName.pData,
 187             (pBaseType ? pBaseType->pWeakRef : 0),
 188             nMembers, pMemberInits );
 189
 190         // cleanup
 191         for ( nPos = nMembers; nPos--; )
 192         {
 193             rtl_uString_release( pMemberInits[nPos].aBase.pTypeName );
 194         }
 195         if (pBaseType)
 196             typelib_typedescription_release( pBaseType );
 197     }
 198     return pRet;
 199 }
 200
 201 inline static typelib_TypeDescription * createCTD(
 202     const Reference< XInterfaceAttributeTypeDescription2 > & xAttribute )
 203 {
 204     typelib_TypeDescription * pRet = 0;
 205     if (xAttribute.is())
 206     {
 207         OUString aMemberName( xAttribute->getName() );
 208         Reference< XTypeDescription > xType( xAttribute->getType() );
 209         OUString aMemberTypeName( xType->getName() );
 210         std::vector< rtl_uString * > getExc;
 211         Sequence< Reference< XCompoundTypeDescription > > getExcs(
 212             xAttribute->getGetExceptions() );
 213         for (sal_Int32 i = 0; i != getExcs.getLength(); ++i)
 214         {
 215             OSL_ASSERT( getExcs[i].is() );
 216             getExc.push_back( getExcs[i]->getName().pData );
 217         }
 218         std::vector< rtl_uString * > setExc;
 219         Sequence< Reference< XCompoundTypeDescription > > setExcs(
 220             xAttribute->getSetExceptions() );
 221         for (sal_Int32 i = 0; i != setExcs.getLength(); ++i)
 222         {
 223             OSL_ASSERT( setExcs[i].is() );
 224             setExc.push_back( setExcs[i]->getName().pData );
 225         }
 226         typelib_typedescription_newExtendedInterfaceAttribute(
 227             reinterpret_cast<typelib_InterfaceAttributeTypeDescription **>(&pRet),
 228             xAttribute->getPosition(),
 229             aMemberName.pData, // name
 230             (typelib_TypeClass)xType->getTypeClass(),
 231             aMemberTypeName.pData, // type name
 232             xAttribute->isReadOnly(),
 233             getExc.size(), getExc.data(),
 234             setExc.size(), setExc.data() );
 235     }
 236     return pRet;
 237 }
 238
 239 static typelib_TypeDescription * createCTD(
 240     const Reference< XInterfaceMethodTypeDescription > & xMethod )
 241 {
 242     typelib_TypeDescription * pRet = 0;
 243     if (xMethod.is())
 244     {
 245         Reference< XTypeDescription > xReturnType( xMethod->getReturnType() );
 246
 247         // init all params
 248         const Sequence<Reference< XMethodParameter > > & rParams = xMethod->getParameters();
 249         const Reference< XMethodParameter > * pParams            = rParams.getConstArray();
 250         sal_Int32 nParams = rParams.getLength();
 251
 252         typelib_Parameter_Init * pParamInit = static_cast<typelib_Parameter_Init *>(alloca(
 253             sizeof(typelib_Parameter_Init) * nParams ));
 254
 255         sal_Int32 nPos;
 256         for ( nPos = nParams; nPos--; )
 257         {
 258             const Reference< XMethodParameter > & xParam = pParams[nPos];
 259             const Reference< XTypeDescription > & xType  = xParam->getType();
 260             typelib_Parameter_Init & rInit = pParamInit[xParam->getPosition()];
 261
 262             rInit.eTypeClass = (typelib_TypeClass)xType->getTypeClass();
 263             OUString aParamTypeName( xType->getName() );
 264             rtl_uString_acquire( rInit.pTypeName = aParamTypeName.pData );
 265             OUString aParamName( xParam->getName() );
 266             rtl_uString_acquire( rInit.pParamName = aParamName.pData );
 267             rInit.bIn  = xParam->isIn();
 268             rInit.bOut = xParam->isOut();
 269         }
 270
 271         // init all exception strings
 272         const Sequence<Reference< XTypeDescription > > & rExceptions = xMethod->getExceptions();
 273         const Reference< XTypeDescription > * pExceptions = rExceptions.getConstArray();
 274         sal_Int32 nExceptions = rExceptions.getLength();
 275         rtl_uString ** ppExceptionNames = static_cast<rtl_uString **>(alloca(
 276             sizeof(rtl_uString *) * nExceptions ));
 277
 278         for ( nPos = nExceptions; nPos--; )
 279         {
 280             OUString aExceptionTypeName( pExceptions[nPos]->getName() );
 281             rtl_uString_acquire( ppExceptionNames[nPos] = aExceptionTypeName.pData );
 282         }
 283
 284         OUString aTypeName( xMethod->getName() );
 285         OUString aReturnTypeName( xReturnType->getName() );
 286
 287         typelib_typedescription_newInterfaceMethod(
 288             reinterpret_cast<typelib_InterfaceMethodTypeDescription **>(&pRet),
 289             xMethod->getPosition(),
 290             xMethod->isOneway(),
 291             aTypeName.pData,
 292             (typelib_TypeClass)xReturnType->getTypeClass(),
 293             aReturnTypeName.pData,
 294             nParams, pParamInit,
 295             nExceptions, ppExceptionNames );
 296
 297         for ( nPos = nParams; nPos--; )
 298         {
 299             rtl_uString_release( pParamInit[nPos].pTypeName );
 300             rtl_uString_release( pParamInit[nPos].pParamName );
 301         }
 302         for ( nPos = nExceptions; nPos--; )
 303         {
 304             rtl_uString_release( ppExceptionNames[nPos] );
 305         }
 306     }
 307     return pRet;
 308 }
 309
 310 inline static typelib_TypeDescription * createCTD(
 311     Reference< container::XHierarchicalNameAccess > const & access,
 312     const Reference< XInterfaceTypeDescription2 > & xType )
 313 {
 314     typelib_TypeDescription * pRet = 0;
 315     if (xType.is())
 316     {
 317         Sequence< Reference< XTypeDescription > > aBases(xType->getBaseTypes());
 318         sal_Int32 nBases = aBases.getLength();
 319         // Exploit the fact that a typelib_TypeDescription for an interface type
 320         // is also the typelib_TypeDescriptionReference for that type:
 321         boost::scoped_array< typelib_TypeDescription * > aBaseTypes(
 322             new typelib_TypeDescription *[nBases]);
 323         for (sal_Int32 i = 0; i < nBases; ++i) {
 324             typelib_TypeDescription * p = createCTD(access, aBases[i]);
 325             OSL_ASSERT(
 326                 !TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK(p->eTypeClass));
 327             typelib_typedescription_register(&p);
 328             aBaseTypes[i] = p;
 329         }
 330         typelib_TypeDescriptionReference ** pBaseTypeRefs
 331             = reinterpret_cast< typelib_TypeDescriptionReference ** >(
 332                 aBaseTypes.get());
 333
 334         // construct all member refs
 335         const Sequence<Reference< XInterfaceMemberTypeDescription > > & rMembers = xType->getMembers();
 336         sal_Int32 nMembers = rMembers.getLength();
 337
 338         typelib_TypeDescriptionReference ** ppMemberRefs = static_cast<typelib_TypeDescriptionReference **>(alloca(
 339             sizeof(typelib_TypeDescriptionReference *) * nMembers ));
 340
 341         const Reference< XInterfaceMemberTypeDescription > * pMembers = rMembers.getConstArray();
 342
 343         OUString aTypeName( xType->getName() );
 344
 345         sal_Int32 nPos;
 346         for ( nPos = nMembers; nPos--; )
 347         {
 348             OUString aMemberTypeName( pMembers[nPos]->getName() );
 349             ppMemberRefs[nPos] = 0;
 350             typelib_typedescriptionreference_new(
 351                 ppMemberRefs + nPos,
 352                 (typelib_TypeClass)pMembers[nPos]->getTypeClass(),
 353                 aMemberTypeName.pData );
 354         }
 355
 356         typelib_typedescription_newMIInterface(
 357             reinterpret_cast<typelib_InterfaceTypeDescription **>(&pRet),
 358             aTypeName.pData,
 359             0, 0, 0, 0, 0,
 360             nBases, pBaseTypeRefs,
 361             nMembers, ppMemberRefs );
 362
 363         // cleanup refs and base type
 364         for (int i = 0; i < nBases; ++i) {
 365             typelib_typedescription_release(aBaseTypes[i]);
 366         }
 367
 368         for ( nPos = nMembers; nPos--; )
 369         {
 370             typelib_typedescriptionreference_release( ppMemberRefs[nPos] );
 371         }
 372     }
 373     return pRet;
 374 }
 375
 376 inline static typelib_TypeDescription * createCTD( const Reference< XEnumTypeDescription > & xType )
 377 {
 378     typelib_TypeDescription * pRet = 0;
 379     if (xType.is())
 380     {
 381         OUString aTypeName( xType->getName() );
 382         Sequence< OUString > aNames( xType->getEnumNames() );
 383         OSL_ASSERT( sizeof(OUString) == sizeof(rtl_uString *) ); // !!!
 384         Sequence< sal_Int32 > aValues( xType->getEnumValues() );
 385
 386         typelib_typedescription_newEnum(
 387             &pRet, aTypeName.pData, xType->getDefaultEnumValue(),
 388             aNames.getLength(),
 389             const_cast<rtl_uString **>(reinterpret_cast<rtl_uString * const *>(aNames.getConstArray())),
 390             const_cast< sal_Int32 * >( aValues.getConstArray() ) );
 391     }
 392     return pRet;
 393 }
 394
 395 inline static typelib_TypeDescription * createCTD(
 396     Reference< container::XHierarchicalNameAccess > const & access,
 397     const Reference< XIndirectTypeDescription > & xType )
 398 {
 399     typelib_TypeDescription * pRet = 0;
 400     if (xType.is())
 401     {
 402         typelib_TypeDescription * pRefType = createCTD(
 403             access, xType->getReferencedType() );
 404         typelib_typedescription_register( &pRefType );
 405
 406         OUString aTypeName( xType->getName() );
 407
 408         typelib_typedescription_new(
 409             &pRet,
 410             (typelib_TypeClass)xType->getTypeClass(),
 411             aTypeName.pData,
 412             pRefType->pWeakRef,
 413             0, 0 );
 414
 415         // cleanup
 416         typelib_typedescription_release( pRefType );
 417     }
 418     return pRet;
 419 }
 420
 421
 422 static typelib_TypeDescription * createCTD(
 423     Reference< container::XHierarchicalNameAccess > const & access,
 424     const Reference< XTypeDescription > & xType )
 425 {
 426     typelib_TypeDescription * pRet = 0;
 427
 428     if (xType.is())
 429     {
 430         switch (xType->getTypeClass())
 431         {
 432             // built in types
 433         case TypeClass_VOID:
 434         {
 435             OUString aTypeName("void");
 436             typelib_typedescription_new( &pRet, typelib_TypeClass_VOID, aTypeName.pData, 0, 0, 0 );
 437             break;
 438         }
 439         case TypeClass_CHAR:
 440         {
 441             OUString aTypeName("char");
 442             typelib_typedescription_new( &pRet, typelib_TypeClass_CHAR, aTypeName.pData, 0, 0, 0 );
 443             break;
 444         }
 445         case TypeClass_BOOLEAN:
 446         {
 447             OUString aTypeName("boolean");
 448             typelib_typedescription_new( &pRet, typelib_TypeClass_BOOLEAN, aTypeName.pData, 0, 0, 0 );
 449             break;
 450         }
 451         case TypeClass_BYTE:
 452         {
 453             OUString aTypeName("byte");
 454             typelib_typedescription_new( &pRet, typelib_TypeClass_BYTE, aTypeName.pData, 0, 0, 0 );
 455             break;
 456         }
 457         case TypeClass_SHORT:
 458         {
 459             OUString aTypeName("short");
 460             typelib_typedescription_new( &pRet, typelib_TypeClass_SHORT, aTypeName.pData, 0, 0, 0 );
 461             break;
 462         }
 463         case TypeClass_UNSIGNED_SHORT:
 464         {
 465             OUString aTypeName("unsigned short");
 466             typelib_typedescription_new( &pRet, typelib_TypeClass_UNSIGNED_SHORT, aTypeName.pData, 0, 0, 0 );
 467             break;
 468         }
 469         case TypeClass_LONG:
 470         {
 471             OUString aTypeName("long");
 472             typelib_typedescription_new( &pRet, typelib_TypeClass_LONG, aTypeName.pData, 0, 0, 0 );
 473             break;
 474         }
 475         case TypeClass_UNSIGNED_LONG:
 476         {
 477             OUString aTypeName("unsigned long");
 478             typelib_typedescription_new( &pRet, typelib_TypeClass_UNSIGNED_LONG, aTypeName.pData, 0, 0, 0 );
 479             break;
 480         }
 481         case TypeClass_HYPER:
 482         {
 483             OUString aTypeName("hyper");
 484             typelib_typedescription_new( &pRet, typelib_TypeClass_HYPER, aTypeName.pData, 0, 0, 0 );
 485             break;
 486         }
 487         case TypeClass_UNSIGNED_HYPER:
 488         {
 489             OUString aTypeName("unsigned hyper");
 490             typelib_typedescription_new( &pRet, typelib_TypeClass_UNSIGNED_HYPER, aTypeName.pData, 0, 0, 0 );
 491             break;
 492         }
 493         case TypeClass_FLOAT:
 494         {
 495             OUString aTypeName("float");
 496             typelib_typedescription_new( &pRet, typelib_TypeClass_FLOAT, aTypeName.pData, 0, 0, 0 );
 497             break;
 498         }
 499         case TypeClass_DOUBLE:
 500         {
 501             OUString aTypeName("double");
 502             typelib_typedescription_new( &pRet, typelib_TypeClass_DOUBLE, aTypeName.pData, 0, 0, 0 );
 503             break;
 504         }
 505         case TypeClass_STRING:
 506         {
 507             OUString aTypeName("string");
 508             typelib_typedescription_new( &pRet, typelib_TypeClass_STRING, aTypeName.pData, 0, 0, 0 );
 509             break;
 510         }
 511         case TypeClass_TYPE:
 512         {
 513             OUString aTypeName("type");
 514             typelib_typedescription_new( &pRet, typelib_TypeClass_TYPE, aTypeName.pData, 0, 0, 0 );
 515             break;
 516         }
 517         case TypeClass_ANY:
 518         {
 519             OUString aTypeName("any");
 520             typelib_typedescription_new( &pRet, typelib_TypeClass_ANY, aTypeName.pData, 0, 0, 0 );
 521             break;
 522         }
 523
 524         case TypeClass_EXCEPTION:
 525             pRet = createCTD( Reference< XCompoundTypeDescription >::query( xType ) );
 526             break;
 527         case TypeClass_STRUCT:
 528             pRet = createCTD(
 529                 access, Reference< XStructTypeDescription >::query( xType ) );
 530             break;
 531         case TypeClass_ENUM:
 532             pRet = createCTD( Reference< XEnumTypeDescription >::query( xType ) );
 533             break;
 534         case TypeClass_TYPEDEF:
 535         {
 536             Reference< XIndirectTypeDescription > xTypedef( xType, UNO_QUERY );
 537             if (xTypedef.is())
 538                 pRet = createCTD( access, xTypedef->getReferencedType() );
 539             break;
 540         }
 541         case TypeClass_SEQUENCE:
 542             pRet = createCTD(
 543                 access, Reference< XIndirectTypeDescription >::query( xType ) );
 544             break;
 545         case TypeClass_INTERFACE:
 546             pRet = createCTD(
 547                 access,
 548                 Reference< XInterfaceTypeDescription2 >::query( xType ) );
 549             break;
 550         case TypeClass_INTERFACE_METHOD:
 551             pRet = createCTD( Reference< XInterfaceMethodTypeDescription >::query( xType ) );
 552             break;
 553         case TypeClass_INTERFACE_ATTRIBUTE:
 554             pRet = createCTD( Reference< XInterfaceAttributeTypeDescription2 >::query( xType ) );
 555             break;
 556         default:
 557             break;
 558         }
 559     }
 560
 561     return pRet;
 562 }
 563
 564
 565
 566 extern "C"
 567 {
 568 static void SAL_CALL typelib_callback(
 569     void * pContext, typelib_TypeDescription ** ppRet, rtl_uString * pTypeName )
 570 {
 571     OSL_ENSURE( pContext && ppRet && pTypeName, "### null ptr!" );
 572     if (ppRet)
 573     {
 574         if (*ppRet)
 575         {
 576             ::typelib_typedescription_release( *ppRet );
 577             *ppRet = 0;
 578         }
 579         if (pContext && pTypeName)
 580         {
 581             Reference< container::XHierarchicalNameAccess > access(
 582                 static_cast< container::XHierarchicalNameAccess * >(
 583                     pContext));
 584             try
 585             {
 586                 OUString const & rTypeName = OUString::unacquired( &pTypeName );
 587                 Reference< XTypeDescription > xTD;
 588                 if (access->getByHierarchicalName(rTypeName ) >>= xTD)
 589                 {
 590                     *ppRet = createCTD( access, xTD );
 591                 }
 592             }
 593             catch (container::NoSuchElementException & exc)
 594             {
 595                 (void) exc; // avoid warning about unused variable
 596                 OSL_TRACE(
 597                     "typelibrary type not available: %s",
 598                     OUStringToOString(
 599                         exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() );
 600             }
 601             catch (Exception & exc)
 602             {
 603                 (void) exc; // avoid warning about unused variable
 604                 OSL_TRACE(
 605                     "%s",
 606                     OUStringToOString(
 607                         exc.Message, RTL_TEXTENCODING_UTF8 ).getStr() );
 608             }
 609         }
 610     }
 611 }
 612 }
 613
 614
 615 class EventListenerImpl
 616     : public WeakImplHelper1< lang::XEventListener >
 617 {
 618     Reference< container::XHierarchicalNameAccess > m_xTDMgr;
 619
 620 public:
 621     inline EventListenerImpl(
 622         Reference< container::XHierarchicalNameAccess > const & xTDMgr )
 623         : m_xTDMgr( xTDMgr )
 624         {}
 625
 626     // XEventListener
 627     virtual void SAL_CALL disposing( lang::EventObject const & rEvt )
 628         throw (RuntimeException, std::exception) SAL_OVERRIDE;
 629 };
 630
 631 void EventListenerImpl::disposing( lang::EventObject const & rEvt )
 632     throw (RuntimeException, std::exception)
 633 {
 634     if (rEvt.Source != m_xTDMgr) {
 635         OSL_ASSERT(false);
 636     }
 637     // deregister of c typelib callback
 638     ::typelib_typedescription_revokeCallback( m_xTDMgr.get(), typelib_callback );
 639 }
 640
 641
 642 sal_Bool SAL_CALL installTypeDescriptionManager(
 643     Reference< container::XHierarchicalNameAccess > const & xTDMgr_c )
 644 {
 645     uno::Environment curr_env(Environment::getCurrent());
 646     uno::Environment target_env(CPPU_CURRENT_LANGUAGE_BINDING_NAME);
 647
 648     uno::Mapping curr2target(curr_env, target_env);
 649
 650
 651     Reference<container::XHierarchicalNameAccess> xTDMgr(
 652         static_cast<container::XHierarchicalNameAccess *>(
 653             curr2target.mapInterface(xTDMgr_c.get(), cppu::UnoType<decltype(xTDMgr_c)>::get())),
 654         SAL_NO_ACQUIRE);
 655
 656     Reference< lang::XComponent > xComp( xTDMgr, UNO_QUERY );
 657     if (xComp.is())
 658     {
 659         xComp->addEventListener( new EventListenerImpl( xTDMgr ) );
 660         // register c typelib callback
 661         ::typelib_typedescription_registerCallback( xTDMgr.get(), typelib_callback );
 662         return sal_True;
 663     }
 664     return sal_False;
 665 }
 666
 667 } // end namespace cppu
 668
 669 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */