LCOV - code coverage report
Current view: top level - libreoffice/cppu/source/uno - EnvStack.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 74 176 42.0 %
Date: 2012-12-27 Functions: 8 18 44.4 %
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             : #include "uno/environment.hxx"
      21             : 
      22             : #include "cppu/EnvDcp.hxx"
      23             : #include "cppu/Enterable.hxx"
      24             : 
      25             : #include "rtl/instance.hxx"
      26             : 
      27             : #include "osl/thread.h"
      28             : #include "osl/mutex.hxx"
      29             : 
      30             : #include <boost/unordered_map.hpp>
      31             : 
      32             : 
      33             : using namespace com::sun::star;
      34             : 
      35             : 
      36             : struct SAL_DLLPRIVATE oslThreadIdentifier_equal
      37             : {
      38             :     bool operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const;
      39             : };
      40             : 
      41           0 : bool oslThreadIdentifier_equal::operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const
      42             : {
      43           0 :     bool result = s1 == s2;
      44             : 
      45           0 :     return result;
      46             : }
      47             : 
      48             : 
      49             : struct SAL_DLLPRIVATE oslThreadIdentifier_hash
      50             : {
      51             :     size_t operator()(oslThreadIdentifier s1) const;
      52             : };
      53             : 
      54           0 : size_t oslThreadIdentifier_hash::operator()(oslThreadIdentifier s1) const
      55             : {
      56           0 :     return s1;
      57             : }
      58             : 
      59             : typedef ::boost::unordered_map<oslThreadIdentifier,
      60             :                         uno_Environment *,
      61             :                         oslThreadIdentifier_hash,
      62             :                         oslThreadIdentifier_equal>  ThreadMap;
      63             : 
      64             : namespace
      65             : {
      66             :     struct s_threadMap_mutex : public rtl::Static< osl::Mutex, s_threadMap_mutex > {};
      67             :     struct s_threadMap : public rtl::Static< ThreadMap, s_threadMap > {};
      68             : }
      69             : 
      70       78530 : static void s_setCurrent(uno_Environment * pEnv)
      71             : {
      72       78530 :     oslThreadIdentifier threadId = osl_getThreadIdentifier(NULL);
      73             : 
      74       78530 :     osl::MutexGuard guard(s_threadMap_mutex::get());
      75       78530 :     ThreadMap &rThreadMap = s_threadMap::get();
      76       78530 :     if (pEnv)
      77           0 :         rThreadMap[threadId] = pEnv;
      78             : 
      79             :     else
      80       78530 :         rThreadMap.erase(threadId);
      81       78530 : }
      82             : 
      83       85825 : static uno_Environment * s_getCurrent(void)
      84             : {
      85       85825 :     uno_Environment * pEnv = NULL;
      86             : 
      87       85825 :     oslThreadIdentifier threadId = osl_getThreadIdentifier(NULL);
      88             : 
      89       85825 :     osl::MutexGuard guard(s_threadMap_mutex::get());
      90       85825 :     ThreadMap &rThreadMap = s_threadMap::get();
      91       85825 :     ThreadMap::iterator iEnv = rThreadMap.find(threadId);
      92       85825 :     if(iEnv != rThreadMap.end())
      93           0 :         pEnv = iEnv->second;
      94             : 
      95       85825 :     return pEnv;
      96             : }
      97             : 
      98             : 
      99        7295 : extern "C" CPPU_DLLPUBLIC void SAL_CALL uno_getCurrentEnvironment(uno_Environment ** ppEnv, rtl_uString * pTypeName)
     100             :     SAL_THROW_EXTERN_C()
     101             : {
     102        7295 :     if (*ppEnv)
     103             :     {
     104           0 :         (*ppEnv)->release(*ppEnv);
     105           0 :         *ppEnv = NULL;
     106             :     }
     107             : 
     108        7295 :     rtl::OUString currPurpose;
     109             : 
     110        7295 :     uno_Environment * pCurrEnv = s_getCurrent();
     111        7295 :     if (pCurrEnv) // no environment means no purpose
     112           0 :         currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
     113             : 
     114        7295 :     if (pTypeName && rtl_uString_getLength(pTypeName))
     115             :     {
     116        7295 :         rtl::OUString envDcp(pTypeName);
     117        7295 :         envDcp += currPurpose;
     118             : 
     119        7295 :         uno_getEnvironment(ppEnv, envDcp.pData, NULL);
     120             :     }
     121             :     else
     122             :     {
     123           0 :         if (pCurrEnv)
     124             :         {
     125           0 :             *ppEnv = pCurrEnv;
     126           0 :             (*ppEnv)->acquire(*ppEnv);
     127             :         }
     128             :         else
     129             :         {
     130           0 :             rtl::OUString uno_envDcp(UNO_LB_UNO);
     131           0 :             uno_getEnvironment(ppEnv, uno_envDcp.pData, NULL);
     132             :         }
     133        7295 :     }
     134        7295 : }
     135             : 
     136       39265 : static rtl::OUString s_getPrefix(rtl::OUString const & str1, rtl::OUString const & str2)
     137             : {
     138       39265 :     sal_Int32 nIndex1 = 0;
     139       39265 :     sal_Int32 nIndex2 = 0;
     140       39265 :     sal_Int32 sim = 0;
     141             : 
     142       39265 :     rtl::OUString token1;
     143       39265 :     rtl::OUString token2;
     144             : 
     145       39265 :     do
     146             :     {
     147       39265 :         token1 = str1.getToken(0, ':', nIndex1);
     148       39265 :         token2 = str2.getToken(0, ':', nIndex2);
     149             : 
     150       39265 :         if (token1.equals(token2))
     151       39265 :             sim += token1.getLength() + 1;
     152             :     }
     153           0 :     while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1.equals(token2));
     154             : 
     155       39265 :     rtl::OUString result;
     156             : 
     157       39265 :     if (sim)
     158       39265 :         result = str1.copy(0, sim - 1);
     159             : 
     160       39265 :     return result;
     161             : }
     162             : 
     163       39265 : static int s_getNextEnv(uno_Environment ** ppEnv, uno_Environment * pCurrEnv, uno_Environment * pTargetEnv)
     164             : {
     165       39265 :     int res = 0;
     166             : 
     167       39265 :     rtl::OUString nextPurpose;
     168             : 
     169       39265 :     rtl::OUString currPurpose;
     170       39265 :     if (pCurrEnv)
     171           0 :         currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
     172             : 
     173       39265 :     rtl::OUString targetPurpose;
     174       39265 :     if (pTargetEnv)
     175       39265 :         targetPurpose = cppu::EnvDcp::getPurpose(pTargetEnv->pTypeName);
     176             : 
     177       39265 :     rtl::OUString intermPurpose(s_getPrefix(currPurpose, targetPurpose));
     178       39265 :     if (currPurpose.getLength() > intermPurpose.getLength())
     179             :     {
     180           0 :         sal_Int32 idx = currPurpose.lastIndexOf(':');
     181           0 :         nextPurpose = currPurpose.copy(0, idx);
     182             : 
     183           0 :         res = -1;
     184             :     }
     185       39265 :     else if (intermPurpose.getLength() < targetPurpose.getLength())
     186             :     {
     187           0 :         sal_Int32 idx = targetPurpose.indexOf(':', intermPurpose.getLength() + 1);
     188           0 :         if (idx == -1)
     189           0 :             nextPurpose = targetPurpose;
     190             : 
     191             :         else
     192           0 :             nextPurpose = targetPurpose.copy(0, idx);
     193             : 
     194           0 :         res = 1;
     195             :     }
     196             : 
     197       39265 :     if (!nextPurpose.isEmpty())
     198             :     {
     199           0 :         rtl::OUString next_envDcp(UNO_LB_UNO);
     200           0 :         next_envDcp += nextPurpose;
     201             : 
     202           0 :         uno_getEnvironment(ppEnv, next_envDcp.pData, NULL);
     203             :     }
     204             :     else
     205             :     {
     206       39265 :         if (*ppEnv)
     207           0 :             (*ppEnv)->release(*ppEnv);
     208             : 
     209       39265 :         *ppEnv = NULL;
     210             :     }
     211             : 
     212       39265 :     return res;
     213             : }
     214             : 
     215           0 : extern "C" { static void s_pull(va_list * pParam)
     216             : {
     217           0 :     uno_EnvCallee * pCallee = va_arg(*pParam, uno_EnvCallee *);
     218           0 :     va_list       * pXparam = va_arg(*pParam, va_list *);
     219             : 
     220           0 :     pCallee(pXparam);
     221           0 : }}
     222             : 
     223           0 : static void s_callInto_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
     224             : {
     225           0 :     cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
     226           0 :     if (pEnterable)
     227           0 :         pEnterable->callInto(s_pull, pCallee, pParam);
     228             : 
     229             :     else
     230           0 :         pCallee(pParam);
     231           0 : }
     232             : 
     233           0 : static void s_callInto(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
     234             : {
     235             :     va_list param;
     236             : 
     237           0 :     va_start(param, pCallee);
     238           0 :     s_callInto_v(pEnv, pCallee, &param);
     239           0 :     va_end(param);
     240           0 : }
     241             : 
     242           0 : static void s_callOut_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
     243             : {
     244           0 :     cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
     245           0 :     if (pEnterable)
     246           0 :         pEnterable->callOut_v(pCallee, pParam);
     247             : 
     248             :     else
     249           0 :         pCallee(pParam);
     250           0 : }
     251             : 
     252           0 : static void s_callOut(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
     253             : {
     254             :     va_list param;
     255             : 
     256           0 :     va_start(param, pCallee);
     257           0 :     s_callOut_v(pEnv, pCallee, &param);
     258           0 :     va_end(param);
     259           0 : }
     260             : 
     261             : static void s_environment_invoke_v(uno_Environment *, uno_Environment *, uno_EnvCallee *, va_list *);
     262             : 
     263           0 : extern "C" { static void s_environment_invoke_vv(va_list * pParam)
     264             : {
     265           0 :     uno_Environment * pCurrEnv    = va_arg(*pParam, uno_Environment *);
     266           0 :     uno_Environment * pTargetEnv  = va_arg(*pParam, uno_Environment *);
     267           0 :     uno_EnvCallee   * pCallee     = va_arg(*pParam, uno_EnvCallee *);
     268           0 :     va_list         * pXparam     = va_arg(*pParam, va_list *);
     269             : 
     270           0 :     s_environment_invoke_v(pCurrEnv, pTargetEnv, pCallee, pXparam);
     271           0 : }}
     272             : 
     273       39265 : static void s_environment_invoke_v(uno_Environment * pCurrEnv, uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
     274             : {
     275       39265 :     uno_Environment * pNextEnv = NULL;
     276       39265 :     switch(s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv))
     277             :     {
     278             :     case -1:
     279           0 :         s_setCurrent(pNextEnv);
     280           0 :         s_callOut(pCurrEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
     281           0 :         s_setCurrent(pCurrEnv);
     282           0 :         break;
     283             : 
     284             :     case 0: {
     285       39265 :         uno_Environment * hld = s_getCurrent();
     286       39265 :         s_setCurrent(pCurrEnv);
     287       39265 :         pCallee(pParam);
     288       39265 :         s_setCurrent(hld);
     289             :     }
     290       39265 :         break;
     291             : 
     292             :     case 1:
     293           0 :         s_setCurrent(pNextEnv);
     294           0 :         s_callInto(pNextEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
     295           0 :         s_setCurrent(pCurrEnv);
     296           0 :         break;
     297             :     }
     298             : 
     299       39265 :     if (pNextEnv)
     300           0 :         pNextEnv->release(pNextEnv);
     301       39265 : }
     302             : 
     303       39265 : extern "C" CPPU_DLLPUBLIC void SAL_CALL uno_Environment_invoke_v(uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
     304             :     SAL_THROW_EXTERN_C()
     305             : {
     306       39265 :     s_environment_invoke_v(s_getCurrent(), pTargetEnv, pCallee, pParam);
     307       39265 : }
     308             : 
     309       34302 : extern "C" CPPU_DLLPUBLIC void SAL_CALL uno_Environment_invoke(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
     310             :     SAL_THROW_EXTERN_C()
     311             : {
     312             :     va_list param;
     313             : 
     314       34302 :     va_start(param, pCallee);
     315       34302 :     uno_Environment_invoke_v(pEnv, pCallee, &param);
     316       34302 :     va_end(param);
     317       34302 : }
     318             : 
     319           0 : extern "C" CPPU_DLLPUBLIC void SAL_CALL uno_Environment_enter(uno_Environment * pTargetEnv)
     320             :     SAL_THROW_EXTERN_C()
     321             : {
     322           0 :     uno_Environment * pNextEnv = NULL;
     323           0 :     uno_Environment * pCurrEnv = s_getCurrent();
     324             : 
     325             :     int res;
     326           0 :     while ( (res = s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv)) != 0)
     327             :     {
     328             :         cppu::Enterable * pEnterable;
     329             : 
     330           0 :         switch(res)
     331             :         {
     332             :         case -1:
     333           0 :             pEnterable = reinterpret_cast<cppu::Enterable *>(pCurrEnv->pReserved);
     334           0 :             if (pEnterable)
     335           0 :                 pEnterable->leave();
     336           0 :             pCurrEnv->release(pCurrEnv);
     337           0 :             break;
     338             : 
     339             :         case 1:
     340           0 :             pNextEnv->acquire(pNextEnv);
     341           0 :             pEnterable = reinterpret_cast<cppu::Enterable *>(pNextEnv->pReserved);
     342           0 :             if (pEnterable)
     343           0 :                 pEnterable->enter();
     344           0 :             break;
     345             :         }
     346             : 
     347           0 :         s_setCurrent(pNextEnv);
     348           0 :         pCurrEnv = pNextEnv;
     349             :     }
     350           0 : }
     351             : 
     352           0 : CPPU_DLLPUBLIC int SAL_CALL uno_Environment_isValid(uno_Environment * pEnv, rtl_uString ** pReason)
     353             :     SAL_THROW_EXTERN_C()
     354             : {
     355           0 :     int result = 1;
     356             : 
     357           0 :     rtl::OUString typeName(cppu::EnvDcp::getTypeName(pEnv->pTypeName));
     358           0 :     if (typeName == UNO_LB_UNO)
     359             :     {
     360           0 :         cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
     361           0 :         if (pEnterable)
     362           0 :             result = pEnterable->isValid((rtl::OUString *)pReason);
     363             :     }
     364             :     else
     365             :     {
     366           0 :         rtl::OUString envDcp(UNO_LB_UNO);
     367           0 :         envDcp += cppu::EnvDcp::getPurpose(pEnv->pTypeName);
     368             : 
     369           0 :         uno::Environment env(envDcp);
     370             : 
     371           0 :         result = env.isValid((rtl::OUString *)pReason);
     372             :     }
     373             : 
     374           0 :     return result;
     375             : }
     376             : 
     377             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10