LCOV - code coverage report
Current view: top level - libreoffice/cppu/source/uno - lbmap.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 155 271 57.2 %
Date: 2012-12-27 Functions: 21 33 63.6 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "IdentityMapping.hxx"
      22             : 
      23             : #include <boost/unordered_map.hpp>
      24             : #include <set>
      25             : #include <algorithm>
      26             : 
      27             : #include "rtl/unload.h"
      28             : #include "rtl/ustring.hxx"
      29             : #include "rtl/ustrbuf.hxx"
      30             : #include "osl/module.h"
      31             : #include "osl/diagnose.h"
      32             : #include "osl/mutex.hxx"
      33             : #include "osl/interlck.h"
      34             : 
      35             : #include "uno/dispatcher.h"
      36             : #include "uno/mapping.h"
      37             : #include "uno/lbnames.h"
      38             : #include "uno/environment.hxx"
      39             : 
      40             : #include "typelib/typedescription.h"
      41             : 
      42             : #include "cppu/EnvDcp.hxx"
      43             : #include "cascade_mapping.hxx"
      44             : #include "IdentityMapping.hxx"
      45             : #include "loadmodule.hxx"
      46             : 
      47             : using namespace std;
      48             : using namespace osl;
      49             : using namespace com::sun::star::uno;
      50             : using ::rtl::OUString;
      51             : using ::rtl::OUStringBuffer;
      52             : using ::rtl::OUStringToOString;
      53             : using ::rtl::OString;
      54             : 
      55             : namespace cppu
      56             : {
      57             : 
      58             : class Mapping
      59             : {
      60             :     uno_Mapping * _pMapping;
      61             : 
      62             : public:
      63             :     inline explicit Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW(());
      64             :     inline Mapping( const Mapping & rMapping ) SAL_THROW(());
      65             :     inline ~Mapping() SAL_THROW(());
      66             :     inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW(());
      67        1838 :     inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW(())
      68        1838 :         { return operator = ( rMapping._pMapping ); }
      69       36858 :     inline uno_Mapping * SAL_CALL get() const SAL_THROW(())
      70       36858 :         { return _pMapping; }
      71       65106 :     inline sal_Bool SAL_CALL is() const SAL_THROW(())
      72       65106 :         { return (_pMapping != 0); }
      73             : };
      74             : //__________________________________________________________________________________________________
      75       14124 : inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW(())
      76       14124 :     : _pMapping( pMapping )
      77             : {
      78       14124 :     if (_pMapping)
      79           0 :         (*_pMapping->acquire)( _pMapping );
      80       14124 : }
      81             : //__________________________________________________________________________________________________
      82        1838 : inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW(())
      83        1838 :     : _pMapping( rMapping._pMapping )
      84             : {
      85        1838 :     if (_pMapping)
      86        1838 :         (*_pMapping->acquire)( _pMapping );
      87        1838 : }
      88             : //__________________________________________________________________________________________________
      89       15962 : inline Mapping::~Mapping() SAL_THROW(())
      90             : {
      91       15962 :     if (_pMapping)
      92       15962 :         (*_pMapping->release)( _pMapping );
      93       15962 : }
      94             : //__________________________________________________________________________________________________
      95       12286 : inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW(())
      96             : {
      97       12286 :     if (pMapping)
      98       12286 :         (*pMapping->acquire)( pMapping );
      99       12286 :     if (_pMapping)
     100           0 :         (*_pMapping->release)( _pMapping );
     101       12286 :     _pMapping = pMapping;
     102       12286 :     return *this;
     103             : }
     104             : 
     105             : //==================================================================================================
     106        7321 : struct MappingEntry
     107             : {
     108             :     sal_Int32           nRef;
     109             :     uno_Mapping *       pMapping;
     110             :     uno_freeMappingFunc freeMapping;
     111             :     OUString            aMappingName;
     112             : 
     113        7321 :     MappingEntry(
     114             :         uno_Mapping * pMapping_, uno_freeMappingFunc freeMapping_,
     115             :         const OUString & rMappingName_ )
     116             :         SAL_THROW(())
     117             :         : nRef( 1 )
     118             :         , pMapping( pMapping_ )
     119             :         , freeMapping( freeMapping_ )
     120        7321 :         , aMappingName( rMappingName_ )
     121        7321 :         {}
     122             : };
     123             : //--------------------------------------------------------------------------------------------------
     124             : struct FctOUStringHash : public std::unary_function< const OUString &, size_t >
     125             : {
     126       19704 :     size_t operator()( const OUString & rKey ) const SAL_THROW(())
     127       19704 :         { return (size_t)rKey.hashCode(); }
     128             : };
     129             : //--------------------------------------------------------------------------------------------------
     130             : struct FctPtrHash : public std::unary_function< uno_Mapping *, size_t >
     131             : {
     132       22060 :     size_t operator()( uno_Mapping * pKey ) const SAL_THROW(())
     133       22060 :         { return (size_t)pKey; }
     134             : };
     135             : 
     136             : typedef boost::unordered_map<
     137             :     OUString, MappingEntry *, FctOUStringHash, equal_to< OUString > > t_OUString2Entry;
     138             : typedef boost::unordered_map<
     139             :     uno_Mapping *, MappingEntry *, FctPtrHash, equal_to< uno_Mapping * > > t_Mapping2Entry;
     140             : 
     141             : typedef set< uno_getMappingFunc > t_CallbackSet;
     142             : typedef set< OUString > t_OUStringSet;
     143             : 
     144             : //==================================================================================================
     145         257 : struct MappingsData
     146             : {
     147             :     Mutex               aMappingsMutex;
     148             :     t_OUString2Entry    aName2Entry;
     149             :     t_Mapping2Entry     aMapping2Entry;
     150             : 
     151             :     Mutex               aCallbacksMutex;
     152             :     t_CallbackSet       aCallbacks;
     153             : 
     154             :     Mutex               aNegativeLibsMutex;
     155             :     t_OUStringSet       aNegativeLibs;
     156             : };
     157             : //--------------------------------------------------------------------------------------------------
     158       28766 : static MappingsData & getMappingsData() SAL_THROW(())
     159             : {
     160             :     static MappingsData * s_p = 0;
     161       28766 :     if (! s_p)
     162             :     {
     163         257 :         MutexGuard aGuard( Mutex::getGlobalMutex() );
     164         257 :         if (! s_p)
     165             :         {
     166             :             //TODO  This memory is leaked; see #i63473# for when this should be
     167             :             // changed again:
     168         257 :             s_p = new MappingsData;
     169         257 :         }
     170             :     }
     171       28766 :     return *s_p;
     172             : }
     173             : 
     174             : /**
     175             :  * This class mediates two different mapping via uno, e.g. form any language to uno,
     176             :  * then from uno to any other language.
     177             :  */
     178           0 : struct uno_Mediate_Mapping : public uno_Mapping
     179             : {
     180             :     sal_Int32   nRef;
     181             : 
     182             :     Environment aFrom;
     183             :     Environment aTo;
     184             : 
     185             :     Mapping     aFrom2Uno;
     186             :     Mapping     aUno2To;
     187             : 
     188             :     OUString    aAddPurpose;
     189             : 
     190             :     uno_Mediate_Mapping(
     191             :         const Environment & rFrom_, const Environment & rTo_,
     192             :         const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
     193             :         const OUString & rAddPurpose )
     194             :         SAL_THROW(());
     195             : };
     196             : extern "C"
     197             : {
     198             : //--------------------------------------------------------------------------------------------------
     199           0 : static void SAL_CALL mediate_free( uno_Mapping * pMapping )
     200             :     SAL_THROW(())
     201             : {
     202           0 :     delete static_cast< uno_Mediate_Mapping * >( pMapping );
     203           0 : }
     204             : //--------------------------------------------------------------------------------------------------
     205           0 : static void SAL_CALL mediate_acquire( uno_Mapping * pMapping )
     206             :     SAL_THROW(())
     207             : {
     208           0 :     if (1 == ::osl_atomic_increment(
     209             :         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
     210             :     {
     211             :         uno_registerMapping(
     212             :             &pMapping, mediate_free,
     213             :             static_cast< uno_Mediate_Mapping * >( pMapping )->aFrom.get(),
     214             :             static_cast< uno_Mediate_Mapping * >( pMapping )->aTo.get(),
     215           0 :             static_cast< uno_Mediate_Mapping * >( pMapping )->aAddPurpose.pData );
     216             :     }
     217           0 : }
     218             : //--------------------------------------------------------------------------------------------------
     219           0 : static void SAL_CALL mediate_release( uno_Mapping * pMapping )
     220             :     SAL_THROW(())
     221             : {
     222           0 :     if (! ::osl_atomic_decrement(
     223             :         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
     224             :     {
     225           0 :         uno_revokeMapping( pMapping );
     226             :     }
     227           0 : }
     228             : //--------------------------------------------------------------------------------------------------
     229           0 : static void SAL_CALL mediate_mapInterface(
     230             :     uno_Mapping * pMapping,
     231             :     void ** ppOut, void * pInterface,
     232             :     typelib_InterfaceTypeDescription * pInterfaceTypeDescr )
     233             :     SAL_THROW(())
     234             : {
     235             :     OSL_ENSURE( pMapping && ppOut, "### null ptr!" );
     236           0 :     if (pMapping && ppOut)
     237             :     {
     238           0 :         uno_Mediate_Mapping * that = static_cast< uno_Mediate_Mapping * >( pMapping );
     239           0 :         uno_Mapping * pFrom2Uno = that->aFrom2Uno.get();
     240             : 
     241           0 :         uno_Interface * pUnoI = 0;
     242           0 :         (*pFrom2Uno->mapInterface)( pFrom2Uno, (void **) &pUnoI, pInterface, pInterfaceTypeDescr );
     243           0 :         if (0 == pUnoI)
     244             :         {
     245           0 :             void * pOut = *ppOut;
     246           0 :             if (0 != pOut)
     247             :             {
     248           0 :                 uno_ExtEnvironment * pTo = that->aTo.get()->pExtEnv;
     249             :                 OSL_ENSURE( 0 != pTo, "### cannot release out interface: leaking!" );
     250           0 :                 if (0 != pTo)
     251           0 :                     (*pTo->releaseInterface)( pTo, pOut );
     252           0 :                 *ppOut = 0; // set to 0 anyway, because mapping was not successfull!
     253             :             }
     254             :         }
     255             :         else
     256             :         {
     257           0 :             uno_Mapping * pUno2To = that->aUno2To.get();
     258           0 :             (*pUno2To->mapInterface)( pUno2To, ppOut, pUnoI, pInterfaceTypeDescr );
     259           0 :             (*pUnoI->release)( pUnoI );
     260             :         }
     261             :     }
     262           0 : }
     263             : }
     264             : //__________________________________________________________________________________________________
     265           0 : uno_Mediate_Mapping::uno_Mediate_Mapping(
     266             :     const Environment & rFrom_, const Environment & rTo_,
     267             :     const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
     268             :     const OUString & rAddPurpose_ )
     269             :     SAL_THROW(())
     270             :     : nRef( 1 )
     271             :     , aFrom( rFrom_ )
     272             :     , aTo( rTo_ )
     273             :     , aFrom2Uno( rFrom2Uno_ )
     274             :     , aUno2To( rUno2To_ )
     275           0 :     , aAddPurpose( rAddPurpose_ )
     276             : {
     277           0 :     uno_Mapping::acquire        = mediate_acquire;
     278           0 :     uno_Mapping::release        = mediate_release;
     279           0 :     uno_Mapping::mapInterface   = mediate_mapInterface;
     280           0 : }
     281             : 
     282             : //==================================================================================================
     283       19607 : static inline OUString getMappingName(
     284             :     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
     285             :     SAL_THROW(())
     286             : {
     287       19607 :     OUStringBuffer aKey( 64 );
     288       19607 :     aKey.append( rAddPurpose );
     289       19607 :     aKey.append( (sal_Unicode)';' );
     290       19607 :     aKey.append( rFrom.getTypeName() );
     291       19607 :     aKey.append( (sal_Unicode)'[' );
     292       19607 :     aKey.append( reinterpret_cast< sal_IntPtr >(rFrom.get()), 16 );
     293       19607 :     aKey.appendAscii( RTL_CONSTASCII_STRINGPARAM("];") );
     294       19607 :     aKey.append( rTo.getTypeName() );
     295       19607 :     aKey.append( (sal_Unicode)'[' );
     296       19607 :     aKey.append( reinterpret_cast< sal_IntPtr >(rTo.get()), 16 );
     297       19607 :     aKey.append( (sal_Unicode)']' );
     298       19607 :     return aKey.makeStringAndClear();
     299             : }
     300             : //==================================================================================================
     301        1838 : static inline OUString getBridgeName(
     302             :     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
     303             :     SAL_THROW(())
     304             : {
     305        1838 :     OUStringBuffer aBridgeName( 16 );
     306        1838 :     if (!rAddPurpose.isEmpty())
     307             :     {
     308           0 :         aBridgeName.append( rAddPurpose );
     309           0 :         aBridgeName.append( (sal_Unicode)'_' );
     310             :     }
     311        1838 :     aBridgeName.append( EnvDcp::getTypeName(rFrom.getTypeName()) );
     312        1838 :     aBridgeName.append( (sal_Unicode)'_' );
     313        1838 :     aBridgeName.append( EnvDcp::getTypeName(rTo.getTypeName()) );
     314        1838 :     return aBridgeName.makeStringAndClear();
     315             : }
     316             : //==================================================================================================
     317           0 : static inline void setNegativeBridge( const OUString & rBridgeName )
     318             :     SAL_THROW(())
     319             : {
     320           0 :     MappingsData & rData = getMappingsData();
     321           0 :     MutexGuard aGuard( rData.aNegativeLibsMutex );
     322           0 :     rData.aNegativeLibs.insert( rBridgeName );
     323           0 : }
     324             : 
     325             : #ifdef DISABLE_DYNLOADING
     326             : 
     327             : static uno_ext_getMappingFunc selectMapFunc( const OUString & rBridgeName )
     328             :     SAL_THROW(())
     329             : {
     330             :     if (rBridgeName.equalsAscii( CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" ))
     331             :         return CPPU_ENV_uno_ext_getMapping;
     332             : #ifdef SOLAR_JAVA
     333             :     if (rBridgeName.equalsAscii( "java" "_uno" ))
     334             :         return java_uno_ext_getMapping;
     335             : #endif
     336             : 
     337             : #if 0
     338             :     // I don't think the affine or log bridges will be needed on any
     339             :     // DISABLE_DYNLOADING platform (iOS at least, possibly Android), but if
     340             :     // somebody wants to experiment, need to find out then whether these are
     341             :     // needed.
     342             :     if (rBridgeName.equalsAscii( "affine_uno_uno" ))
     343             :         return affine_uno_uno_ext_getMapping;
     344             :     if (rBridgeName.equalsAscii( "log_uno_uno" ))
     345             :         return log_uno_uno_ext_getMapping;
     346             : #endif
     347             :     return 0;
     348             : }
     349             : 
     350             : #else
     351             : 
     352        1838 : static inline oslModule loadModule( const OUString & rBridgeName )
     353             :     SAL_THROW(())
     354             : {
     355             :     sal_Bool bNeg;
     356             :     {
     357        1838 :     MappingsData & rData = getMappingsData();
     358        1838 :     MutexGuard aGuard( rData.aNegativeLibsMutex );
     359        1838 :     const t_OUStringSet::const_iterator iFind( rData.aNegativeLibs.find( rBridgeName ) );
     360        1838 :     bNeg = (iFind != rData.aNegativeLibs.end());
     361             :     }
     362             : 
     363        1838 :     if (! bNeg)
     364             :     {
     365        1838 :         oslModule hModule = cppu::detail::loadModule( rBridgeName );
     366             : 
     367        1838 :         if (hModule)
     368        1838 :             return hModule;
     369             : 
     370           0 :         setNegativeBridge( rBridgeName ); // no load again
     371             :     }
     372           0 :     return 0;
     373             : }
     374             : 
     375             : #endif
     376             : 
     377             : //==================================================================================================
     378        1838 : static Mapping loadExternalMapping(
     379             :     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
     380             :     SAL_THROW(())
     381             : {
     382             :     OSL_ASSERT( rFrom.is() && rTo.is() );
     383        1838 :     if (rFrom.is() && rTo.is())
     384             :     {
     385             : #ifdef DISABLE_DYNLOADING
     386             :         OUString aName;
     387             :         uno_ext_getMappingFunc fpGetMapFunc = 0;
     388             : 
     389             :         if (EnvDcp::getTypeName(rFrom.getTypeName()).equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_LB_UNO) ))
     390             :         {
     391             :             aName = getBridgeName( rTo, rFrom, rAddPurpose );
     392             :             fpGetMapFunc = selectMapFunc( aName );
     393             :         }
     394             :         if (! fpGetMapFunc)
     395             :         {
     396             :             aName = getBridgeName( rFrom, rTo, rAddPurpose );
     397             :             fpGetMapFunc = selectMapFunc( aName );
     398             :         }
     399             :         if (! fpGetMapFunc)
     400             :         {
     401             :             aName = getBridgeName( rTo, rFrom, rAddPurpose );
     402             :             fpGetMapFunc = selectMapFunc( aName );
     403             :         }
     404             : 
     405             :         if (! fpGetMapFunc)
     406             :         {
     407             : #if OSL_DEBUG_LEVEL > 1
     408             :             OSL_TRACE( "Could not find mapfunc for %s", OUStringToOString( aName, RTL_TEXTENCODING_ASCII_US ).getStr());
     409             : #endif
     410             :             return Mapping();
     411             :         }
     412             : 
     413             :         if (fpGetMapFunc)
     414             :         {
     415             :             Mapping aExt;
     416             :             (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
     417             :             OSL_ASSERT( aExt.is() );
     418             :             if (aExt.is())
     419             :                 return aExt;
     420             :         }
     421             : #else
     422             :         // find proper lib
     423        1838 :         oslModule hModule = 0;
     424        1838 :         OUString aName;
     425             : 
     426        1838 :         if ( EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO )
     427        1750 :             hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
     428        1838 :         if (! hModule)
     429          88 :             hModule = loadModule( aName = getBridgeName( rFrom, rTo, rAddPurpose ) );
     430        1838 :         if (! hModule)
     431           0 :             hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
     432             : 
     433        1838 :         if (hModule)
     434             :         {
     435        1838 :             OUString aSymbolName( RTL_CONSTASCII_USTRINGPARAM(UNO_EXT_GETMAPPING) );
     436             :             uno_ext_getMappingFunc fpGetMapFunc =
     437             :                 (uno_ext_getMappingFunc)::osl_getFunctionSymbol(
     438        1838 :                     hModule, aSymbolName.pData );
     439             : 
     440        1838 :             if (fpGetMapFunc)
     441             :             {
     442        1838 :                 Mapping aExt;
     443        1838 :                 (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
     444             :                 OSL_ASSERT( aExt.is() );
     445        1838 :                 if (aExt.is())
     446             :                 {
     447        1838 :                     ::rtl_registerModuleForUnloading( hModule );
     448        1838 :                     return aExt;
     449        1838 :                 }
     450             :             }
     451           0 :             ::osl_unloadModule( hModule );
     452           0 :             setNegativeBridge( aName );
     453        1838 :         }
     454             : #endif
     455             :     }
     456           0 :     return Mapping();
     457             : }
     458             : 
     459             : //==================================================================================================
     460           0 : static Mapping getDirectMapping(
     461             :     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
     462             :     SAL_THROW(())
     463             : {
     464             :     OSL_ASSERT( rFrom.is() && rTo.is() );
     465           0 :     if (rFrom.is() && rTo.is())
     466             :     {
     467           0 :         MappingsData & rData = getMappingsData();
     468           0 :         ClearableMutexGuard aGuard( rData.aMappingsMutex );
     469             : 
     470             :         // try to find registered mapping
     471             :         const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
     472           0 :             getMappingName( rFrom, rTo, rAddPurpose ) ) );
     473             : 
     474           0 :         if (iFind == rData.aName2Entry.end())
     475             :         {
     476           0 :             aGuard.clear();
     477           0 :             return loadExternalMapping( rFrom, rTo, rAddPurpose );
     478             :         }
     479             :         else
     480             :         {
     481           0 :             return Mapping( (*iFind).second->pMapping );
     482           0 :         }
     483             :     }
     484           0 :     return Mapping();
     485             : }
     486             : 
     487             : //--------------------------------------------------------------------------------------------------
     488           0 : static inline Mapping createMediateMapping(
     489             :     const Environment & rFrom, const Environment & rTo,
     490             :     const Mapping & rFrom2Uno, const Mapping & rUno2To,
     491             :     const OUString & rAddPurpose )
     492             :     SAL_THROW(())
     493             : {
     494             :     uno_Mapping * pRet = new uno_Mediate_Mapping(
     495           0 :         rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
     496             :     uno_registerMapping(
     497           0 :         &pRet, mediate_free, rFrom.get(), rTo.get(), rAddPurpose.pData );
     498           0 :     Mapping aRet( pRet );
     499           0 :     (*pRet->release)( pRet );
     500           0 :     return aRet;
     501             : }
     502             : //==================================================================================================
     503           0 : static Mapping getMediateMapping(
     504             :     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
     505             :     SAL_THROW(())
     506             : {
     507           0 :     Environment aUno;
     508           0 :     Mapping aUno2To;
     509             : 
     510             :     // backwards: from dest to source of mapping chain
     511             : 
     512             :     // connect to uno
     513           0 :     OUString aUnoEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO) );
     514           0 :     if (rTo.getTypeName() == aUnoEnvTypeName) // to is uno
     515             :     {
     516           0 :         aUno = rTo;
     517             :         // no Uno2To mapping necessary
     518             :     }
     519             :     else
     520             :     {
     521             :         // get registered uno env
     522           0 :         ::uno_getEnvironment( (uno_Environment **)&aUno, aUnoEnvTypeName.pData, 0 );
     523             : 
     524           0 :         aUno2To = getDirectMapping( aUno, rTo );
     525             :         // : uno <-> to
     526           0 :         if (! aUno2To.is())
     527           0 :             return Mapping();
     528             :     }
     529             : 
     530             :     // connect to uno
     531           0 :     if (!rAddPurpose.isEmpty()) // insert purpose mapping between new ano_uno <-> uno
     532             :     {
     533             :         // create anonymous uno env
     534           0 :         Environment aAnUno;
     535           0 :         ::uno_createEnvironment( (uno_Environment **)&aAnUno, aUnoEnvTypeName.pData, 0 );
     536             : 
     537           0 :         Mapping aAnUno2Uno( getDirectMapping( aAnUno, aUno, rAddPurpose ) );
     538           0 :         if (! aAnUno2Uno.is())
     539           0 :             return Mapping();
     540             : 
     541           0 :         if (aUno2To.is()) // to is not uno
     542             :         {
     543             :             // create another purposed mediate mapping
     544           0 :             aUno2To = createMediateMapping( aAnUno, rTo, aAnUno2Uno, aUno2To, rAddPurpose );
     545             :             // : ano_uno <-> uno <-> to
     546             :         }
     547             :         else
     548             :         {
     549           0 :             aUno2To = aAnUno2Uno;
     550             :             // : ano_uno <-> to (i.e., uno)
     551             :         }
     552           0 :         aUno = aAnUno;
     553             :     }
     554             : 
     555           0 :     Mapping aFrom2Uno( getDirectMapping( rFrom, aUno ) );
     556           0 :     if (aFrom2Uno.is() && aUno2To.is())
     557             :     {
     558           0 :         return createMediateMapping( rFrom, rTo, aFrom2Uno, aUno2To, rAddPurpose );
     559             :         // : from <-> some uno ...
     560             :     }
     561             : 
     562           0 :     return Mapping();
     563             : }
     564             : }
     565             : 
     566             : using namespace ::cppu;
     567             : 
     568             : extern "C"
     569             : {
     570             : //##################################################################################################
     571       12286 : void SAL_CALL uno_getMapping(
     572             :     uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo,
     573             :     rtl_uString * pAddPurpose )
     574             :     SAL_THROW_EXTERN_C()
     575             : {
     576             :     OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
     577       12286 :     if (*ppMapping)
     578             :     {
     579           0 :         (*(*ppMapping)->release)( *ppMapping );
     580           0 :         *ppMapping = 0;
     581             :     }
     582             : 
     583       12286 :     Mapping aRet;
     584       12286 :     Environment aFrom( pFrom ), aTo( pTo );
     585             : 
     586       12286 :     OUString aAddPurpose;
     587       12286 :     if (pAddPurpose)
     588       12276 :         aAddPurpose = pAddPurpose;
     589             : 
     590       12286 :     MappingsData & rData = getMappingsData();
     591             : 
     592             :     // try registered mapping
     593             :     {
     594       12286 :     MutexGuard aGuard( rData.aMappingsMutex );
     595             :     const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
     596       12286 :         getMappingName( aFrom, aTo, aAddPurpose ) ) );
     597       12286 :     if (iFind != rData.aName2Entry.end())
     598        4965 :         aRet = (*iFind).second->pMapping;
     599             :     }
     600             : 
     601             :     // See if an identity mapping does fit.
     602       12286 :     if (!aRet.is() && pFrom == pTo && aAddPurpose.isEmpty())
     603        5483 :         aRet = createIdentityMapping(pFrom);
     604             : 
     605       12286 :     if (!aRet.is())
     606             :     {
     607        1838 :         getCascadeMapping(ppMapping, pFrom, pTo, pAddPurpose);
     608             : 
     609        1838 :         if (*ppMapping)
     610             :             return;
     611             :     }
     612             : 
     613       12286 :     if (! aRet.is()) // try callback chain
     614             :     {
     615        1838 :         MutexGuard aGuard( rData.aCallbacksMutex );
     616        5514 :         for ( t_CallbackSet::const_iterator iPos( rData.aCallbacks.begin() );
     617        3676 :               iPos != rData.aCallbacks.end(); ++iPos )
     618             :         {
     619           0 :             (**iPos)( ppMapping, pFrom, pTo, aAddPurpose.pData );
     620           0 :             if (*ppMapping)
     621             :                 return;
     622        1838 :         }
     623             :     }
     624             : 
     625       12286 :     if (! aRet.is())
     626             :     {
     627        1838 :         aRet = loadExternalMapping( aFrom, aTo, aAddPurpose ); // direct try
     628        1838 :         if (! aRet.is())
     629           0 :             aRet = getMediateMapping( aFrom, aTo, aAddPurpose ); // try via uno
     630             :     }
     631             : 
     632       12286 :     if (aRet.is())
     633             :     {
     634       12286 :         (*aRet.get()->acquire)( aRet.get() );
     635       12286 :         *ppMapping = aRet.get();
     636       12286 :     }
     637             : }
     638             : //##################################################################################################
     639          12 : void SAL_CALL uno_getMappingByName(
     640             :     uno_Mapping ** ppMapping, rtl_uString * pFrom, rtl_uString * pTo,
     641             :     rtl_uString * pAddPurpose )
     642             :     SAL_THROW_EXTERN_C()
     643             : {
     644             :     OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
     645          12 :     if (*ppMapping)
     646             :     {
     647           0 :         (*(*ppMapping)->release)( *ppMapping );
     648           0 :         *ppMapping = 0;
     649             :     }
     650             : 
     651          12 :     uno_Environment * pEFrom = 0;
     652          12 :     uno_getEnvironment( &pEFrom, pFrom, 0 );
     653             :     OSL_ENSURE( pEFrom, "### cannot get source environment!" );
     654          12 :     if (pEFrom)
     655             :     {
     656          12 :         uno_Environment * pETo = 0;
     657          12 :         uno_getEnvironment( &pETo, pTo, 0 );
     658             :         OSL_ENSURE( pETo, "### cannot get target environment!" );
     659          12 :         if (pETo)
     660             :         {
     661          12 :             ::uno_getMapping( ppMapping, pEFrom, pETo, pAddPurpose );
     662          12 :             (*pETo->release)( pETo );
     663             :         }
     664          12 :         (*pEFrom->release)( pEFrom );
     665             :     }
     666          12 : }
     667             : 
     668             : //##################################################################################################
     669        7321 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMapping(
     670             :     uno_Mapping ** ppMapping, uno_freeMappingFunc freeMapping,
     671             :     uno_Environment * pFrom, uno_Environment * pTo, rtl_uString * pAddPurpose )
     672             :     SAL_THROW_EXTERN_C()
     673             : {
     674        7321 :     MappingsData & rData = getMappingsData();
     675        7321 :     ClearableMutexGuard aGuard( rData.aMappingsMutex );
     676             : 
     677        7321 :     const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( *ppMapping ) );
     678        7321 :     if (iFind == rData.aMapping2Entry.end())
     679             :     {
     680             :         OUString aMappingName(
     681        7321 :             getMappingName( pFrom, pTo, pAddPurpose ? OUString(pAddPurpose) : OUString() ) );
     682             : #if OSL_DEBUG_LEVEL > 2
     683             :         OString cstr( OUStringToOString( aMappingName, RTL_TEXTENCODING_ASCII_US ) );
     684             :         OSL_TRACE( "> inserting new mapping: %s", cstr.getStr() );
     685             : #endif
     686             :         // count initially 1
     687        7321 :         MappingEntry * pEntry = new MappingEntry( *ppMapping, freeMapping, aMappingName );
     688        7321 :         rData.aName2Entry[ aMappingName ] = pEntry;
     689        7321 :         rData.aMapping2Entry[ *ppMapping ] = pEntry;
     690             :     }
     691             :     else
     692             :     {
     693           0 :         MappingEntry * pEntry = (*iFind).second;
     694           0 :         ++pEntry->nRef;
     695             : 
     696           0 :         if (pEntry->pMapping != *ppMapping) // exchange mapping to be registered
     697             :         {
     698           0 :             (*pEntry->pMapping->acquire)( pEntry->pMapping );
     699           0 :             --pEntry->nRef; // correct count; kill mapping to be registered
     700           0 :             aGuard.clear();
     701           0 :             (*freeMapping)( *ppMapping );
     702           0 :             *ppMapping = pEntry->pMapping;
     703             :         }
     704        7321 :     }
     705        7321 : }
     706             : //##################################################################################################
     707        7321 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMapping(
     708             :     uno_Mapping * pMapping )
     709             :     SAL_THROW_EXTERN_C()
     710             : {
     711        7321 :     MappingsData & rData = getMappingsData();
     712        7321 :     ClearableMutexGuard aGuard( rData.aMappingsMutex );
     713             : 
     714        7321 :     const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( pMapping ) );
     715             :     OSL_ASSERT( iFind != rData.aMapping2Entry.end() );
     716        7321 :     MappingEntry * pEntry = (*iFind).second;
     717        7321 :     if (! --pEntry->nRef)
     718             :     {
     719        7321 :         rData.aMapping2Entry.erase( pEntry->pMapping );
     720        7321 :         rData.aName2Entry.erase( pEntry->aMappingName );
     721        7321 :         aGuard.clear();
     722             : #if OSL_DEBUG_LEVEL > 2
     723             :         OString cstr( OUStringToOString( pEntry->aMappingName, RTL_TEXTENCODING_ASCII_US  ) );
     724             :         OSL_TRACE( "> revoking mapping %s", cstr.getStr() );
     725             : #endif
     726        7321 :         (*pEntry->freeMapping)( pEntry->pMapping );
     727        7321 :         delete pEntry;
     728        7321 :     }
     729        7321 : }
     730             : 
     731             : //##################################################################################################
     732           0 : CPPU_DLLPUBLIC void SAL_CALL uno_registerMappingCallback(
     733             :     uno_getMappingFunc pCallback )
     734             :     SAL_THROW_EXTERN_C()
     735             : {
     736             :     OSL_ENSURE( pCallback, "### null ptr!" );
     737           0 :     MappingsData & rData = getMappingsData();
     738           0 :     MutexGuard aGuard( rData.aCallbacksMutex );
     739           0 :     rData.aCallbacks.insert( pCallback );
     740           0 : }
     741             : //##################################################################################################
     742           0 : CPPU_DLLPUBLIC void SAL_CALL uno_revokeMappingCallback(
     743             :     uno_getMappingFunc pCallback )
     744             :     SAL_THROW_EXTERN_C()
     745             : {
     746             :     OSL_ENSURE( pCallback, "### null ptr!" );
     747           0 :     MappingsData & rData = getMappingsData();
     748           0 :     MutexGuard aGuard( rData.aCallbacksMutex );
     749           0 :     rData.aCallbacks.erase( pCallback );
     750           0 : }
     751             : } // extern "C"
     752             : 
     753             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10