LCOV - code coverage report
Current view: top level - cppuhelper/source - component_context.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 136 249 54.6 %
Date: 2014-04-14 Functions: 16 28 57.1 %
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             : #ifdef DIAG
      22             : #define CONTEXT_DIAG
      23             : #endif
      24             : 
      25             : #if OSL_DEBUG_LEVEL > 0
      26             : #include <stdio.h>
      27             : #endif
      28             : 
      29             : #include <boost/unordered_map.hpp>
      30             : #ifdef CONTEXT_DIAG
      31             : #include <map>
      32             : #endif
      33             : 
      34             : #include <osl/diagnose.h>
      35             : #include <osl/mutex.hxx>
      36             : 
      37             : #include <rtl/ustrbuf.hxx>
      38             : 
      39             : #include <uno/lbnames.h>
      40             : #include <uno/mapping.hxx>
      41             : 
      42             : #include <cppuhelper/implbase1.hxx>
      43             : #include <cppuhelper/compbase2.hxx>
      44             : #include <cppuhelper/component_context.hxx>
      45             : #include <cppuhelper/exc_hlp.hxx>
      46             : 
      47             : #include <com/sun/star/container/XNameContainer.hpp>
      48             : #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
      49             : #include <com/sun/star/lang/XSingleServiceFactory.hpp>
      50             : #include <com/sun/star/lang/XSingleComponentFactory.hpp>
      51             : #include <com/sun/star/lang/XMultiComponentFactory.hpp>
      52             : #include <com/sun/star/lang/XComponent.hpp>
      53             : #include <com/sun/star/beans/XPropertySet.hpp>
      54             : #include "com/sun/star/uno/DeploymentException.hpp"
      55             : #include "com/sun/star/uno/RuntimeException.hpp"
      56             : 
      57             : #define SMGR_SINGLETON "/singletons/com.sun.star.lang.theServiceManager"
      58             : #define TDMGR_SINGLETON "/singletons/com.sun.star.reflection.theTypeDescriptionManager"
      59             : #define AC_SINGLETON "/singletons/com.sun.star.security.theAccessController"
      60             : 
      61             : using namespace ::osl;
      62             : using namespace ::com::sun::star::uno;
      63             : using namespace ::com::sun::star;
      64             : 
      65             : using rtl::OUString;
      66             : using rtl::OUStringBuffer;
      67             : using rtl::OUStringHash;
      68             : 
      69             : namespace cppu
      70             : {
      71             : 
      72             : #ifdef CONTEXT_DIAG
      73             : 
      74             : static OUString val2str( void const * pVal, typelib_TypeDescriptionReference * pTypeRef )
      75             : {
      76             :     OSL_ASSERT( pVal );
      77             :     if (pTypeRef->eTypeClass == typelib_TypeClass_VOID)
      78             :         return "void";
      79             : 
      80             :     OUStringBuffer buf( 64 );
      81             :     buf.append( "(" + pTypeRef->pTypeName + ")" );
      82             : 
      83             :     switch (pTypeRef->eTypeClass)
      84             :     {
      85             :     case typelib_TypeClass_INTERFACE:
      86             :         buf.append( "0x" );
      87             :         buf.append( (sal_Int64)*(void **)pVal, 16 );
      88             :         break;
      89             :     case typelib_TypeClass_STRUCT:
      90             :     case typelib_TypeClass_EXCEPTION:
      91             :     {
      92             :         buf.append( "{ " );
      93             :         typelib_TypeDescription * pTypeDescr = 0;
      94             :         ::typelib_typedescriptionreference_getDescription( &pTypeDescr, pTypeRef );
      95             :         OSL_ASSERT( pTypeDescr );
      96             :         if (! pTypeDescr->bComplete)
      97             :             ::typelib_typedescription_complete( &pTypeDescr );
      98             : 
      99             :         typelib_CompoundTypeDescription * pCompType = (typelib_CompoundTypeDescription *)pTypeDescr;
     100             :         sal_Int32 nDescr = pCompType->nMembers;
     101             : 
     102             :         if (pCompType->pBaseTypeDescription)
     103             :         {
     104             :             buf.append( val2str( pVal, ((typelib_TypeDescription *)pCompType->pBaseTypeDescription)->pWeakRef ) );
     105             :             if (nDescr)
     106             :                 buf.append( ", " );
     107             :         }
     108             : 
     109             :         typelib_TypeDescriptionReference ** ppTypeRefs = pCompType->ppTypeRefs;
     110             :         sal_Int32 * pMemberOffsets = pCompType->pMemberOffsets;
     111             :         rtl_uString ** ppMemberNames = pCompType->ppMemberNames;
     112             : 
     113             :         for ( sal_Int32 nPos = 0; nPos < nDescr; ++nPos )
     114             :         {
     115             :             buf.append( ppMemberNames[ nPos ] );
     116             :             buf.append( " = " );
     117             :             typelib_TypeDescription * pMemberType = 0;
     118             :             TYPELIB_DANGER_GET( &pMemberType, ppTypeRefs[ nPos ] );
     119             :             buf.append( val2str( (char *)pVal + pMemberOffsets[ nPos ], pMemberType->pWeakRef ) );
     120             :             TYPELIB_DANGER_RELEASE( pMemberType );
     121             :             if (nPos < (nDescr -1))
     122             :                 buf.append( ", " );
     123             :         }
     124             : 
     125             :         ::typelib_typedescription_release( pTypeDescr );
     126             : 
     127             :         buf.append( " }" );
     128             :         break;
     129             :     }
     130             :     case typelib_TypeClass_SEQUENCE:
     131             :     {
     132             :         typelib_TypeDescription * pTypeDescr = 0;
     133             :         TYPELIB_DANGER_GET( &pTypeDescr, pTypeRef );
     134             : 
     135             :         uno_Sequence * pSequence = *(uno_Sequence **)pVal;
     136             :         typelib_TypeDescription * pElementTypeDescr = 0;
     137             :         TYPELIB_DANGER_GET( &pElementTypeDescr, ((typelib_IndirectTypeDescription *)pTypeDescr)->pType );
     138             : 
     139             :         sal_Int32 nElementSize = pElementTypeDescr->nSize;
     140             :         sal_Int32 nElements    = pSequence->nElements;
     141             : 
     142             :         if (nElements)
     143             :         {
     144             :             buf.append( "{ " );
     145             :             char * pElements = pSequence->elements;
     146             :             for ( sal_Int32 nPos = 0; nPos < nElements; ++nPos )
     147             :             {
     148             :                 buf.append( val2str( pElements + (nElementSize * nPos), pElementTypeDescr->pWeakRef ) );
     149             :                 if (nPos < (nElements -1))
     150             :                     buf.append( ", " );
     151             :             }
     152             :             buf.append( " }" );
     153             :         }
     154             :         else
     155             :         {
     156             :             buf.append( "{}" );
     157             :         }
     158             :         TYPELIB_DANGER_RELEASE( pElementTypeDescr );
     159             :         TYPELIB_DANGER_RELEASE( pTypeDescr );
     160             :         break;
     161             :     }
     162             :     case typelib_TypeClass_ANY:
     163             :         buf.append( "{ " );
     164             :         buf.append( val2str( ((uno_Any *)pVal)->pData,
     165             :                              ((uno_Any *)pVal)->pType ) );
     166             :         buf.append( " }" );
     167             :         break;
     168             :     case typelib_TypeClass_TYPE:
     169             :         buf.append( (*(typelib_TypeDescriptionReference **)pVal)->pTypeName );
     170             :         break;
     171             :     case typelib_TypeClass_STRING:
     172             :         buf.append( '\"' );
     173             :         buf.append( *(rtl_uString **)pVal );
     174             :         buf.append( '\"' );
     175             :         break;
     176             :     case typelib_TypeClass_ENUM:
     177             :     {
     178             :         typelib_TypeDescription * pTypeDescr = 0;
     179             :         ::typelib_typedescriptionreference_getDescription( &pTypeDescr, pTypeRef );
     180             :         OSL_ASSERT( pTypeDescr );
     181             :         if (! pTypeDescr->bComplete)
     182             :             ::typelib_typedescription_complete( &pTypeDescr );
     183             : 
     184             :         sal_Int32 * pValues = ((typelib_EnumTypeDescription *)pTypeDescr)->pEnumValues;
     185             :         sal_Int32 nPos = ((typelib_EnumTypeDescription *)pTypeDescr)->nEnumValues;
     186             :         while (nPos--)
     187             :         {
     188             :             if (pValues[ nPos ] == *(sal_Int32 *)pVal)
     189             :                 break;
     190             :         }
     191             :         if (nPos >= 0)
     192             :             buf.append( ((typelib_EnumTypeDescription *)pTypeDescr)->ppEnumNames[ nPos ] );
     193             :         else
     194             :             buf.append( '?' );
     195             : 
     196             :         ::typelib_typedescription_release( pTypeDescr );
     197             :         break;
     198             :     }
     199             :     case typelib_TypeClass_BOOLEAN:
     200             :         if (*(sal_Bool *)pVal)
     201             :             buf.append( "true" );
     202             :         else
     203             :             buf.append( "false" );
     204             :         break;
     205             :     case typelib_TypeClass_CHAR:
     206             :         buf.append( '\'' );
     207             :         buf.append( *(sal_Unicode *)pVal );
     208             :         buf.append( '\'' );
     209             :         break;
     210             :     case typelib_TypeClass_FLOAT:
     211             :         buf.append( *(float *)pVal );
     212             :         break;
     213             :     case typelib_TypeClass_DOUBLE:
     214             :         buf.append( *(double *)pVal );
     215             :         break;
     216             :     case typelib_TypeClass_BYTE:
     217             :         buf.append( "0x" );
     218             :         buf.append( (sal_Int32)*(sal_Int8 *)pVal, 16 );
     219             :         break;
     220             :     case typelib_TypeClass_SHORT:
     221             :         buf.append( "0x" );
     222             :         buf.append( (sal_Int32)*(sal_Int16 *)pVal, 16 );
     223             :         break;
     224             :     case typelib_TypeClass_UNSIGNED_SHORT:
     225             :         buf.append( "0x" );
     226             :         buf.append( (sal_Int32)*(sal_uInt16 *)pVal, 16 );
     227             :         break;
     228             :     case typelib_TypeClass_LONG:
     229             :         buf.append( "0x" );
     230             :         buf.append( *(sal_Int32 *)pVal, 16 );
     231             :         break;
     232             :     case typelib_TypeClass_UNSIGNED_LONG:
     233             :         buf.append( "0x" );
     234             :         buf.append( (sal_Int64)*(sal_uInt32 *)pVal, 16 );
     235             :         break;
     236             :     case typelib_TypeClass_HYPER:
     237             :     case typelib_TypeClass_UNSIGNED_HYPER:
     238             :         buf.append( "0x" );
     239             : #if defined(__GNUC__) && defined(SPARC)
     240             : // I guess this really should check if there are strict alignment
     241             : // requirements, not just "GCC on SPARC".
     242             :         {
     243             :             sal_Int64 aVal;
     244             :             *(sal_Int32 *)&aVal = *(sal_Int32 *)pVal;
     245             :             *((sal_Int32 *)&aVal +1)= *((sal_Int32 *)pVal +1);
     246             :             buf.append( aVal, 16 );
     247             :         }
     248             : #else
     249             :         buf.append( *(sal_Int64 *)pVal, 16 );
     250             : #endif
     251             :         break;
     252             :     default:
     253             :         buf.append( '?' );
     254             :     }
     255             : 
     256             :     return buf.makeStringAndClear();
     257             : }
     258             : 
     259             : static void dumpEntry( OUString const & key, Any const & value )
     260             : {
     261             :     OUString val( val2str( value.getValue(), value.getValueTypeRef() ) );
     262             :     OString key_str( OUStringToOString( key, RTL_TEXTENCODING_ASCII_US ) );
     263             :     OString val_str( OUStringToOString( val, RTL_TEXTENCODING_ASCII_US ) );
     264             :     ::fprintf( stderr, "| %s = %s\n", key_str.getStr(), val_str.getStr() );
     265             : }
     266             : #endif
     267             : 
     268           1 : static inline void try_dispose( Reference< XInterface > const & xInstance )
     269             :     SAL_THROW( (RuntimeException) )
     270             : {
     271           1 :     Reference< lang::XComponent > xComp( xInstance, UNO_QUERY );
     272           1 :     if (xComp.is())
     273             :     {
     274           1 :         xComp->dispose();
     275           1 :     }
     276           1 : }
     277             : 
     278           2 : static inline void try_dispose( Reference< lang::XComponent > const & xComp )
     279             :     SAL_THROW( (RuntimeException) )
     280             : {
     281           2 :     if (xComp.is())
     282             :     {
     283           1 :         xComp->dispose();
     284             :     }
     285           2 : }
     286             : 
     287             : 
     288             : 
     289           0 : class DisposingForwarder
     290             :     : public WeakImplHelper1< lang::XEventListener >
     291             : {
     292             :     Reference< lang::XComponent > m_xTarget;
     293             : 
     294           0 :     inline DisposingForwarder( Reference< lang::XComponent > const & xTarget )
     295             :         SAL_THROW(())
     296           0 :         : m_xTarget( xTarget )
     297           0 :         { OSL_ASSERT( m_xTarget.is() ); }
     298             : public:
     299             :     // listens at source for disposing, then disposes target
     300             :     static inline void listen(
     301             :         Reference< lang::XComponent > const & xSource,
     302             :         Reference< lang::XComponent > const & xTarget )
     303             :         SAL_THROW( (RuntimeException) );
     304             : 
     305             :     virtual void SAL_CALL disposing( lang::EventObject const & rSource )
     306             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     307             : };
     308             : 
     309           1 : inline void DisposingForwarder::listen(
     310             :     Reference< lang::XComponent > const & xSource,
     311             :     Reference< lang::XComponent > const & xTarget )
     312             :     SAL_THROW( (RuntimeException) )
     313             : {
     314           1 :     if (xSource.is())
     315             :     {
     316           0 :         xSource->addEventListener( new DisposingForwarder( xTarget ) );
     317             :     }
     318           1 : }
     319             : 
     320           0 : void DisposingForwarder::disposing( lang::EventObject const & )
     321             :     throw (RuntimeException, std::exception)
     322             : {
     323           0 :     m_xTarget->dispose();
     324           0 :     m_xTarget.clear();
     325           0 : }
     326             : 
     327             : 
     328           2 : struct MutexHolder
     329             : {
     330             : protected:
     331             :     Mutex m_mutex;
     332             : };
     333             : 
     334             : 
     335             : class ComponentContext
     336             :     : private MutexHolder
     337             :     , public WeakComponentImplHelper2< XComponentContext,
     338             :                                        container::XNameContainer >
     339             : {
     340             : protected:
     341             :     Reference< XComponentContext > m_xDelegate;
     342             : 
     343          41 :     struct ContextEntry
     344             :     {
     345             :         Any value;
     346             :         bool lateInit;
     347             : 
     348          41 :         inline ContextEntry( Any const & value_, bool lateInit_ )
     349             :             : value( value_ )
     350          41 :             , lateInit( lateInit_ )
     351          41 :             {}
     352             :     };
     353             :     typedef ::boost::unordered_map< OUString, ContextEntry * , OUStringHash > t_map;
     354             :     t_map m_map;
     355             : 
     356             :     Reference< lang::XMultiComponentFactory > m_xSMgr;
     357             : 
     358             : protected:
     359             :     Any lookupMap( OUString const & rName )
     360             :         SAL_THROW( (RuntimeException) );
     361             : 
     362             :     virtual void SAL_CALL disposing() SAL_OVERRIDE;
     363             : public:
     364             :     ComponentContext(
     365             :         ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     366             :         Reference< XComponentContext > const & xDelegate );
     367             :     virtual ~ComponentContext()
     368             :         SAL_THROW(());
     369             : 
     370             :     // XComponentContext
     371             :     virtual Any SAL_CALL getValueByName( OUString const & rName )
     372             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     373             :     virtual Reference<lang::XMultiComponentFactory> SAL_CALL getServiceManager()
     374             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     375             : 
     376             :     // XNameContainer
     377             :     virtual void SAL_CALL insertByName(
     378             :         OUString const & name, Any const & element )
     379             :         throw (lang::IllegalArgumentException, container::ElementExistException,
     380             :                lang::WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
     381             :     virtual void SAL_CALL removeByName( OUString const & name )
     382             :         throw (container::NoSuchElementException,
     383             :                lang::WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
     384             :     // XNameReplace
     385             :     virtual void SAL_CALL replaceByName(
     386             :         OUString const & name, Any const & element )
     387             :         throw (lang::IllegalArgumentException,container::NoSuchElementException,
     388             :                lang::WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
     389             :     // XNameAccess
     390             :     virtual Any SAL_CALL getByName( OUString const & name )
     391             :         throw (container::NoSuchElementException,
     392             :                lang::WrappedTargetException, RuntimeException, std::exception) SAL_OVERRIDE;
     393             :     virtual Sequence<OUString> SAL_CALL getElementNames()
     394             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     395             :     virtual sal_Bool SAL_CALL hasByName( OUString const & name )
     396             :         throw (RuntimeException, std::exception) SAL_OVERRIDE;
     397             :     // XElementAccess
     398             :     virtual Type SAL_CALL getElementType() throw (RuntimeException, std::exception) SAL_OVERRIDE;
     399             :     virtual sal_Bool SAL_CALL hasElements() throw (RuntimeException, std::exception) SAL_OVERRIDE;
     400             : };
     401             : 
     402             : // XNameContainer
     403             : 
     404           0 : void ComponentContext::insertByName(
     405             :     OUString const & name, Any const & element )
     406             :     throw (lang::IllegalArgumentException, container::ElementExistException,
     407             :            lang::WrappedTargetException, RuntimeException, std::exception)
     408             : {
     409             :     t_map::mapped_type entry(
     410             :         new ContextEntry(
     411             :             element,
     412             :             /* lateInit_: */
     413           0 :             name.startsWith( "/singletons/" ) &&
     414           0 :             !element.hasValue() ) );
     415           0 :     MutexGuard guard( m_mutex );
     416             :     ::std::pair<t_map::iterator, bool> insertion( m_map.insert(
     417           0 :         t_map::value_type( name, entry ) ) );
     418           0 :     if (! insertion.second)
     419             :         throw container::ElementExistException(
     420           0 :             "element already exists: " + name,
     421           0 :             static_cast<OWeakObject *>(this) );
     422           0 : }
     423             : 
     424             : 
     425           0 : void ComponentContext::removeByName( OUString const & name )
     426             :         throw (container::NoSuchElementException,
     427             :                lang::WrappedTargetException, RuntimeException, std::exception)
     428             : {
     429           0 :     MutexGuard guard( m_mutex );
     430           0 :     t_map::iterator iFind( m_map.find( name ) );
     431           0 :     if (iFind == m_map.end())
     432             :         throw container::NoSuchElementException(
     433           0 :             "no such element: " + name,
     434           0 :             static_cast<OWeakObject *>(this) );
     435             : 
     436           0 :     delete iFind->second;
     437           0 :     m_map.erase(iFind);
     438           0 : }
     439             : 
     440             : // XNameReplace
     441             : 
     442           0 : void ComponentContext::replaceByName(
     443             :     OUString const & name, Any const & element )
     444             :     throw (lang::IllegalArgumentException,container::NoSuchElementException,
     445             :            lang::WrappedTargetException, RuntimeException, std::exception)
     446             : {
     447           0 :     MutexGuard guard( m_mutex );
     448           0 :     t_map::const_iterator const iFind( m_map.find( name ) );
     449           0 :     if (iFind == m_map.end())
     450             :         throw container::NoSuchElementException(
     451           0 :             "no such element: " + name,
     452           0 :             static_cast<OWeakObject *>(this) );
     453           0 :     if (name.startsWith( "/singletons/" ) &&
     454           0 :         !element.hasValue())
     455             :     {
     456           0 :         iFind->second->value.clear();
     457           0 :         iFind->second->lateInit = true;
     458             :     }
     459             :     else
     460             :     {
     461           0 :         iFind->second->value = element;
     462           0 :         iFind->second->lateInit = false;
     463           0 :     }
     464           0 : }
     465             : 
     466             : // XNameAccess
     467             : 
     468           0 : Any ComponentContext::getByName( OUString const & name )
     469             :     throw (container::NoSuchElementException,
     470             :            lang::WrappedTargetException, RuntimeException, std::exception)
     471             : {
     472           0 :     return getValueByName( name );
     473             : }
     474             : 
     475             : 
     476           0 : Sequence<OUString> ComponentContext::getElementNames()
     477             :     throw (RuntimeException, std::exception)
     478             : {
     479           0 :     MutexGuard guard( m_mutex );
     480           0 :     Sequence<OUString> ret( m_map.size() );
     481           0 :     OUString * pret = ret.getArray();
     482           0 :     sal_Int32 pos = 0;
     483           0 :     t_map::const_iterator iPos( m_map.begin() );
     484           0 :     t_map::const_iterator const iEnd( m_map.end() );
     485           0 :     for ( ; iPos != iEnd; ++iPos )
     486           0 :         pret[pos++] = iPos->first;
     487           0 :     return ret;
     488             : }
     489             : 
     490             : 
     491           0 : sal_Bool ComponentContext::hasByName( OUString const & name )
     492             :     throw (RuntimeException, std::exception)
     493             : {
     494           0 :     MutexGuard guard( m_mutex );
     495           0 :     return m_map.find( name ) != m_map.end();
     496             : }
     497             : 
     498             : // XElementAccess
     499             : 
     500           0 : Type ComponentContext::getElementType() throw (RuntimeException, std::exception)
     501             : {
     502           0 :     return ::getVoidCppuType();
     503             : }
     504             : 
     505             : 
     506           0 : sal_Bool ComponentContext::hasElements() throw (RuntimeException, std::exception)
     507             : {
     508           0 :     MutexGuard guard( m_mutex );
     509           0 :     return ! m_map.empty();
     510             : }
     511             : 
     512             : 
     513           6 : Any ComponentContext::lookupMap( OUString const & rName )
     514             :     SAL_THROW( (RuntimeException) )
     515             : {
     516             : #ifdef CONTEXT_DIAG
     517             :     if ( rName == "dump_maps" )
     518             :     {
     519             :         ::fprintf( stderr, ">>> dumping out ComponentContext %p m_map:\n", this );
     520             :         typedef ::std::map< OUString, ContextEntry * > t_sorted; // sorted map
     521             :         t_sorted sorted;
     522             :         for ( t_map::const_iterator iPos( m_map.begin() ); iPos != m_map.end(); ++iPos )
     523             :         {
     524             :             sorted[ iPos->first ] = iPos->second;
     525             :         }
     526             :         {
     527             :         for ( t_sorted::const_iterator iPos( sorted.begin() ); iPos != sorted.end(); ++iPos )
     528             :         {
     529             :             dumpEntry( iPos->first, iPos->second->value );
     530             :         }
     531             :         }
     532             :         return Any();
     533             :     }
     534             : #endif
     535             : 
     536           6 :     ResettableMutexGuard guard( m_mutex );
     537           6 :     t_map::const_iterator iFind( m_map.find( rName ) );
     538           6 :     if (iFind == m_map.end())
     539           1 :         return Any();
     540             : 
     541           5 :     t_map::mapped_type pEntry = iFind->second;
     542           5 :     if (! pEntry->lateInit)
     543           4 :         return pEntry->value;
     544             : 
     545             :     // late init singleton entry
     546           2 :     Reference< XInterface > xInstance;
     547           1 :     guard.clear();
     548             : 
     549             :     try
     550             :     {
     551           1 :         Any usesService( getValueByName( rName + "/service" ) );
     552           2 :         Any args_( getValueByName( rName + "/arguments" ) );
     553           2 :         Sequence<Any> args;
     554           1 :         if (args_.hasValue() && !(args_ >>= args))
     555             :         {
     556           0 :             args.realloc( 1 );
     557           0 :             args[ 0 ] = args_;
     558             :         }
     559             : 
     560           2 :         Reference< lang::XSingleComponentFactory > xFac;
     561           1 :         if (usesService >>= xFac) // try via factory
     562             :         {
     563           3 :             xInstance = args.getLength()
     564           0 :                 ? xFac->createInstanceWithArgumentsAndContext( args, this )
     565           3 :                 : xFac->createInstanceWithContext( this );
     566             :         }
     567             :         else
     568             :         {
     569           0 :             Reference< lang::XSingleServiceFactory > xFac2;
     570           0 :             if (usesService >>= xFac2)
     571             :             {
     572             :                 // try via old XSingleServiceFactory
     573             : #if OSL_DEBUG_LEVEL > 0
     574             :                 ::fprintf(
     575             :                     stderr,
     576             :                     "### omitting context for service instanciation!\n" );
     577             : #endif
     578           0 :                 xInstance = args.getLength()
     579           0 :                     ? xFac2->createInstanceWithArguments( args )
     580           0 :                     : xFac2->createInstance();
     581             :             }
     582           0 :             else if (m_xSMgr.is()) // optionally service name
     583             :             {
     584           0 :                 OUString serviceName;
     585           0 :                 if ((usesService >>= serviceName) &&
     586           0 :                     !serviceName.isEmpty())
     587             :                 {
     588           0 :                     xInstance = args.getLength()
     589           0 :                         ? m_xSMgr->createInstanceWithArgumentsAndContext(
     590           0 :                             serviceName, args, this )
     591           0 :                         : m_xSMgr->createInstanceWithContext(
     592           0 :                             serviceName, this );
     593           0 :                 }
     594           0 :             }
     595           1 :         }
     596             :     }
     597           0 :     catch (RuntimeException &)
     598             :     {
     599           0 :         throw;
     600             :     }
     601           0 :     catch (Exception & exc)
     602             :     {
     603             :         SAL_WARN(
     604             :             "cppuhelper",
     605             :             "exception occurred raising singleton \"" << rName << "\": "
     606             :             << exc.Message);
     607             :     }
     608             : 
     609             :     SAL_WARN_IF(!xInstance.is(),
     610             :             "cppuhelper", "no service object raising singleton " << rName);
     611             : 
     612           2 :     Any ret;
     613           1 :     guard.reset();
     614           1 :     iFind = m_map.find( rName );
     615           1 :     if (iFind != m_map.end())
     616             :     {
     617           1 :         pEntry = iFind->second;
     618           1 :         if (pEntry->lateInit)
     619             :         {
     620           1 :             pEntry->value <<= xInstance;
     621           1 :             pEntry->lateInit = false;
     622           1 :             return pEntry->value;
     623             :         }
     624             :         else
     625           0 :             ret = pEntry->value;
     626             :     }
     627           0 :     guard.clear();
     628           0 :     try_dispose( xInstance );
     629           6 :     return ret;
     630             : }
     631             : 
     632             : 
     633           6 : Any ComponentContext::getValueByName( OUString const & rName )
     634             :     throw (RuntimeException, std::exception)
     635             : {
     636             :     // to determine the root context:
     637           6 :     if ( rName == "_root" )
     638             :     {
     639           0 :         if (m_xDelegate.is())
     640           0 :             return m_xDelegate->getValueByName( rName );
     641             :         else
     642           0 :             return makeAny( Reference<XComponentContext>(this) );
     643             :     }
     644             : 
     645           6 :     Any ret( lookupMap( rName ) );
     646           6 :     if (!ret.hasValue() && m_xDelegate.is())
     647             :     {
     648           0 :         return m_xDelegate->getValueByName( rName );
     649             :     }
     650           6 :     return ret;
     651             : }
     652             : 
     653           5 : Reference< lang::XMultiComponentFactory > ComponentContext::getServiceManager()
     654             :     throw (RuntimeException, std::exception)
     655             : {
     656           5 :     if ( !m_xSMgr.is() )
     657             :     {
     658             :         throw DeploymentException(
     659             :             "null component context service manager",
     660           0 :             static_cast<OWeakObject *>(this) );
     661             :     }
     662           5 :     return m_xSMgr;
     663             : }
     664             : 
     665           3 : ComponentContext::~ComponentContext()
     666             :     SAL_THROW(())
     667             : {
     668             : #ifdef CONTEXT_DIAG
     669             :     ::fprintf( stderr, "> destructed context %p\n", this );
     670             : #endif
     671           1 :     t_map::const_iterator iPos( m_map.begin() );
     672           1 :     t_map::const_iterator const iEnd( m_map.end() );
     673           1 :     for ( ; iPos != iEnd; ++iPos )
     674           0 :         delete iPos->second;
     675           1 :     m_map.clear();
     676           2 : }
     677             : 
     678           1 : void ComponentContext::disposing()
     679             : {
     680             : #ifdef CONTEXT_DIAG
     681             :     ::fprintf( stderr, "> disposing context %p\n", this );
     682             : #endif
     683             : 
     684           2 :     Reference< lang::XComponent > xTDMgr, xAC; // to be disposed separately
     685             : 
     686             :     // dispose all context objects
     687           1 :     t_map::const_iterator iPos( m_map.begin() );
     688           1 :     t_map::const_iterator const iEnd( m_map.end() );
     689          42 :     for ( ; iPos != iEnd; ++iPos )
     690             :     {
     691          41 :         t_map::mapped_type pEntry = iPos->second;
     692             : 
     693             :         // service manager disposed separately
     694          82 :         if (!m_xSMgr.is() ||
     695          41 :             !iPos->first.startsWith( SMGR_SINGLETON ))
     696             :         {
     697          40 :             if (pEntry->lateInit)
     698             :             {
     699             :                 // late init
     700          18 :                 MutexGuard guard( m_mutex );
     701          18 :                 if (pEntry->lateInit)
     702             :                 {
     703          18 :                     pEntry->value.clear(); // release factory
     704          18 :                     pEntry->lateInit = false;
     705          18 :                     continue;
     706           0 :                 }
     707             :             }
     708             : 
     709          22 :             Reference< lang::XComponent > xComp;
     710          22 :             pEntry->value >>= xComp;
     711          22 :             if (xComp.is())
     712             :             {
     713           3 :                 if ( iPos->first == TDMGR_SINGLETON )
     714             :                 {
     715           1 :                     xTDMgr = xComp;
     716             :                 }
     717           2 :                 else if ( iPos->first == AC_SINGLETON )
     718             :                 {
     719           0 :                     xAC = xComp;
     720             :                 }
     721             :                 else // dispose immediately
     722             :                 {
     723           2 :                     xComp->dispose();
     724             :                 }
     725          22 :             }
     726             :         }
     727             :     }
     728             : 
     729             :     // dispose service manager
     730           1 :     try_dispose( m_xSMgr );
     731           1 :     m_xSMgr.clear();
     732             :     // dispose ac
     733           1 :     try_dispose( xAC );
     734             :     // dispose tdmgr; revokes callback from cppu runtime
     735           1 :     try_dispose( xTDMgr );
     736             : 
     737           1 :     iPos = m_map.begin();
     738          42 :     for ( ; iPos != iEnd; ++iPos )
     739          41 :         delete iPos->second;
     740           2 :     m_map.clear();
     741           1 : }
     742             : 
     743           1 : ComponentContext::ComponentContext(
     744             :     ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     745             :     Reference< XComponentContext > const & xDelegate )
     746             :     : WeakComponentImplHelper2< XComponentContext, container::XNameContainer >(
     747             :         m_mutex ),
     748           1 :       m_xDelegate( xDelegate )
     749             : {
     750          23 :     for ( sal_Int32 nPos = 0; nPos < nEntries; ++nPos )
     751             :     {
     752          22 :         ContextEntry_Init const & rEntry = pEntries[ nPos ];
     753             : 
     754          22 :         if ( rEntry.name == SMGR_SINGLETON )
     755             :         {
     756           1 :             rEntry.value >>= m_xSMgr;
     757             :         }
     758             : 
     759          22 :         if (rEntry.bLateInitService)
     760             :         {
     761             :             // singleton entry
     762          19 :             m_map[ rEntry.name ] = new ContextEntry( Any(), true );
     763             :             // /service
     764          19 :             m_map[ rEntry.name + "/service" ] = new ContextEntry( rEntry.value, false );
     765             :             // /initial-arguments are provided as optional context entry
     766             :         }
     767             :         else
     768             :         {
     769             :             // only value, no late init factory nor string
     770           3 :             m_map[ rEntry.name ] = new ContextEntry( rEntry.value, false );
     771             :         }
     772             :     }
     773             : 
     774           1 :     if (!m_xSMgr.is() && m_xDelegate.is())
     775             :     {
     776             :         // wrap delegate's smgr XPropertySet into new smgr
     777           0 :         Reference< lang::XMultiComponentFactory > xMgr( m_xDelegate->getServiceManager() );
     778           0 :         if (xMgr.is())
     779             :         {
     780           0 :             osl_atomic_increment( &m_refCount );
     781             :             try
     782             :             {
     783             :                 // create new smgr based on delegate's one
     784             :                 m_xSMgr.set(
     785           0 :                     xMgr->createInstanceWithContext(
     786           0 :                         "com.sun.star.comp.stoc.OServiceManagerWrapper", xDelegate ),
     787           0 :                     UNO_QUERY );
     788             :                 // patch DefaultContext property of new one
     789           0 :                 Reference< beans::XPropertySet > xProps( m_xSMgr, UNO_QUERY );
     790             :                 OSL_ASSERT( xProps.is() );
     791           0 :                 if (xProps.is())
     792             :                 {
     793           0 :                     Reference< XComponentContext > xThis( this );
     794           0 :                     xProps->setPropertyValue( "DefaultContext", makeAny( xThis ) );
     795           0 :                 }
     796             :             }
     797           0 :             catch (...)
     798             :             {
     799           0 :                 osl_atomic_decrement( &m_refCount );
     800           0 :                 throw;
     801             :             }
     802           0 :             osl_atomic_decrement( &m_refCount );
     803             :             OSL_ASSERT( m_xSMgr.is() );
     804           0 :         }
     805             :     }
     806           1 : }
     807             : 
     808             : 
     809             : 
     810           1 : extern "C" { static void s_createComponentContext_v(va_list * pParam)
     811             : {
     812           1 :     ContextEntry_Init const  * pEntries     = va_arg(*pParam, ContextEntry_Init const *);
     813           1 :     sal_Int32                  nEntries     = va_arg(*pParam, sal_Int32);
     814           1 :     XComponentContext        * pDelegatee   = va_arg(*pParam, XComponentContext *);
     815           1 :     void                    ** ppContext    = va_arg(*pParam, void **);
     816           1 :     uno::Mapping             * pTarget2curr = va_arg(*pParam, uno::Mapping *);
     817             : 
     818           1 :     Reference<XComponentContext> xDelegate(pDelegatee, SAL_NO_ACQUIRE);
     819           2 :     Reference<XComponentContext> xContext;
     820             : 
     821           1 :     if (nEntries > 0)
     822             :     {
     823             :         try
     824             :         {
     825           1 :             ComponentContext * p = new ComponentContext( pEntries, nEntries, xDelegate );
     826           1 :             xContext.set(p);
     827             :             // listen delegate for disposing, to dispose this (wrapping) context first.
     828           1 :             DisposingForwarder::listen( Reference< lang::XComponent >::query( xDelegate ), p );
     829             :         }
     830           0 :         catch (Exception & exc)
     831             :         {
     832             :             (void) exc; // avoid warning about unused variable
     833             :             OSL_FAIL( OUStringToOString(
     834             :                             exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() );
     835           0 :             xContext.clear();
     836             :         }
     837             :     }
     838             :     else
     839             :     {
     840           0 :         xContext = xDelegate;
     841             :     }
     842             : 
     843           2 :     *ppContext = pTarget2curr->mapInterface(xContext.get(), ::getCppuType(&xContext));
     844           1 : }}
     845             : 
     846           1 : Reference< XComponentContext > SAL_CALL createComponentContext(
     847             :     ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     848             :     Reference< XComponentContext > const & xDelegate )
     849             :     SAL_THROW(())
     850             : {
     851           1 :     uno::Environment curr_env(Environment::getCurrent());
     852           2 :     uno::Environment source_env(CPPU_CURRENT_LANGUAGE_BINDING_NAME);
     853             : 
     854           2 :     uno::Mapping curr2source(curr_env, source_env);
     855           2 :     uno::Mapping source2curr(source_env, curr_env);
     856             : 
     857           1 :     ContextEntry_Init * mapped_entries = new ContextEntry_Init[nEntries];
     858          23 :     for (sal_Int32 nPos = 0; nPos < nEntries; ++ nPos)
     859             :     {
     860          22 :         mapped_entries[nPos].bLateInitService = pEntries[nPos].bLateInitService;
     861          22 :         mapped_entries[nPos].name             = pEntries[nPos].name;
     862             : 
     863          22 :         uno_type_any_constructAndConvert(&mapped_entries[nPos].value,
     864          22 :                                          const_cast<void *>(pEntries[nPos].value.getValue()),
     865          22 :                                          pEntries[nPos].value.getValueTypeRef(),
     866          66 :                                          curr2source.get());
     867             :     }
     868             : 
     869           1 :     void * mapped_delegate = curr2source.mapInterface(xDelegate.get(), ::getCppuType(&xDelegate));
     870           1 :     XComponentContext * pXComponentContext = NULL;
     871           1 :     source_env.invoke(s_createComponentContext_v, mapped_entries, nEntries, mapped_delegate, &pXComponentContext, &source2curr);
     872           1 :     delete[] mapped_entries;
     873             : 
     874           2 :     return Reference<XComponentContext>(pXComponentContext, SAL_NO_ACQUIRE);
     875             : }
     876             : 
     877             : }
     878             : 
     879             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10