cppu/source/uno/EnvStack.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: EnvStack.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "uno/environment.hxx"
  32
  33 #include "cppu/EnvDcp.hxx"
  34 #include "cppu/Enterable.hxx"
  35
  36 #include "osl/thread.h"
  37 #include "osl/mutex.hxx"
  38
  39 #include <hash_map>
  40
  41
  42 using namespace com::sun::star;
  43
  44
  45 struct SAL_DLLPRIVATE oslThreadIdentifier_equal
  46 {
  47     bool operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const;
  48 };
  49
  50 bool oslThreadIdentifier_equal::operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const
  51 {
  52     bool result = s1 == s2;
  53
  54     return result;
  55 }
  56
  57
  58 struct SAL_DLLPRIVATE oslThreadIdentifier_hash
  59 {
  60     size_t operator()(oslThreadIdentifier s1) const;
  61 };
  62
  63 size_t oslThreadIdentifier_hash::operator()(oslThreadIdentifier s1) const
  64 {
  65     return s1;
  66 }
  67
  68 typedef ::std::hash_map<oslThreadIdentifier,
  69                         uno_Environment *,
  70                         oslThreadIdentifier_hash,
  71                         oslThreadIdentifier_equal>  ThreadMap;
  72
  73 static osl::Mutex s_threadMap_mutex;
  74 static ThreadMap  s_threadMap;
  75
  76
  77 static rtl::OUString s_uno_envDcp(RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO));
  78
  79 static void s_setCurrent(uno_Environment * pEnv)
  80 {
  81     oslThreadIdentifier threadId = osl_getThreadIdentifier(NULL);
  82
  83     osl::MutexGuard guard(s_threadMap_mutex);
  84     if (pEnv)
  85         s_threadMap[threadId] = pEnv;
  86
  87     else
  88     {
  89         ThreadMap::iterator iEnv = s_threadMap.find(threadId);
  90         s_threadMap.erase(iEnv);
  91     }
  92 }
  93
  94 static uno_Environment * s_getCurrent(void)
  95 {
  96     uno_Environment * pEnv = NULL;
  97
  98     oslThreadIdentifier threadId = osl_getThreadIdentifier(NULL);
  99
 100     osl::MutexGuard guard(s_threadMap_mutex);
 101     ThreadMap::iterator iEnv = s_threadMap.find(threadId);
 102     if(iEnv != s_threadMap.end())
 103         pEnv = iEnv->second;
 104
 105     return pEnv;
 106 }
 107
 108
 109 extern "C" void SAL_CALL uno_getCurrentEnvironment(uno_Environment ** ppEnv, rtl_uString * pTypeName)
 110     SAL_THROW_EXTERN_C()
 111 {
 112     if (*ppEnv)
 113     {
 114         (*ppEnv)->release(*ppEnv);
 115         *ppEnv = NULL;
 116     }
 117
 118     rtl::OUString currPurpose;
 119
 120     uno_Environment * pCurrEnv = s_getCurrent();
 121     if (pCurrEnv) // no environment means no purpose
 122         currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
 123
 124     if (pTypeName && rtl_uString_getLength(pTypeName))
 125     {
 126         rtl::OUString envDcp(pTypeName);
 127         envDcp += currPurpose;
 128
 129         uno_getEnvironment(ppEnv, envDcp.pData, NULL);
 130     }
 131     else
 132     {
 133         if (pCurrEnv)
 134         {
 135             *ppEnv = pCurrEnv;
 136             (*ppEnv)->acquire(*ppEnv);
 137         }
 138         else
 139             uno_getEnvironment(ppEnv, s_uno_envDcp.pData, NULL);
 140
 141     }
 142 }
 143
 144 static rtl::OUString s_getPrefix(rtl::OUString const & str1, rtl::OUString const & str2)
 145 {
 146     sal_Int32 nIndex1 = 0;
 147     sal_Int32 nIndex2 = 0;
 148     sal_Int32 sim = 0;
 149
 150     rtl::OUString token1;
 151     rtl::OUString token2;
 152
 153     do
 154     {
 155         token1 = str1.getToken(0, ':', nIndex1);
 156         token2 = str2.getToken(0, ':', nIndex2);
 157
 158         if (token1.equals(token2))
 159             sim += token1.getLength() + 1;
 160     }
 161     while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1.equals(token2));
 162
 163     rtl::OUString result;
 164
 165     if (sim)
 166         result = str1.copy(0, sim - 1);
 167
 168     return result;
 169 }
 170
 171 static int s_getNextEnv(uno_Environment ** ppEnv, uno_Environment * pCurrEnv, uno_Environment * pTargetEnv)
 172 {
 173     int res = 0;
 174
 175     rtl::OUString nextPurpose;
 176
 177     rtl::OUString currPurpose;
 178     if (pCurrEnv)
 179         currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
 180
 181     rtl::OUString targetPurpose;
 182     if (pTargetEnv)
 183         targetPurpose = cppu::EnvDcp::getPurpose(pTargetEnv->pTypeName);
 184
 185     rtl::OUString intermPurpose(s_getPrefix(currPurpose, targetPurpose));
 186     if (currPurpose.getLength() > intermPurpose.getLength())
 187     {
 188         sal_Int32 idx = currPurpose.lastIndexOf(':');
 189         nextPurpose = currPurpose.copy(0, idx);
 190
 191         res = -1;
 192     }
 193     else if (intermPurpose.getLength() < targetPurpose.getLength())
 194     {
 195         sal_Int32 idx = targetPurpose.indexOf(':', intermPurpose.getLength() + 1);
 196         if (idx == -1)
 197             nextPurpose = targetPurpose;
 198
 199         else
 200             nextPurpose = targetPurpose.copy(0, idx);
 201
 202         res = 1;
 203     }
 204
 205     if (nextPurpose.getLength())
 206     {
 207         rtl::OUString next_envDcp(s_uno_envDcp);
 208         next_envDcp += nextPurpose;
 209
 210         uno_getEnvironment(ppEnv, next_envDcp.pData, NULL);
 211     }
 212     else
 213     {
 214         if (*ppEnv)
 215             (*ppEnv)->release(*ppEnv);
 216
 217         *ppEnv = NULL;
 218     }
 219
 220     return res;
 221 }
 222
 223 extern "C" { static void s_pull(va_list * pParam)
 224 {
 225     uno_EnvCallee * pCallee = va_arg(*pParam, uno_EnvCallee *);
 226     va_list       * pXparam = va_arg(*pParam, va_list *);
 227
 228     pCallee(pXparam);
 229 }}
 230
 231 static void s_callInto_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
 232 {
 233     cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
 234     if (pEnterable)
 235         pEnterable->callInto(s_pull, pCallee, pParam);
 236
 237     else
 238         pCallee(pParam);
 239 }
 240
 241 static void s_callInto(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
 242 {
 243     va_list param;
 244
 245     va_start(param, pCallee);
 246     s_callInto_v(pEnv, pCallee, &param);
 247     va_end(param);
 248 }
 249
 250 static void s_callOut_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
 251 {
 252     cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
 253     if (pEnterable)
 254         pEnterable->callOut_v(pCallee, pParam);
 255
 256     else
 257         pCallee(pParam);
 258 }
 259
 260 static void s_callOut(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
 261 {
 262     va_list param;
 263
 264     va_start(param, pCallee);
 265     s_callOut_v(pEnv, pCallee, &param);
 266     va_end(param);
 267 }
 268
 269 static void s_environment_invoke_v(uno_Environment *, uno_Environment *, uno_EnvCallee *, va_list *);
 270
 271 extern "C" { static void s_environment_invoke_vv(va_list * pParam)
 272 {
 273     uno_Environment * pCurrEnv    = va_arg(*pParam, uno_Environment *);
 274     uno_Environment * pTargetEnv  = va_arg(*pParam, uno_Environment *);
 275     uno_EnvCallee   * pCallee     = va_arg(*pParam, uno_EnvCallee *);
 276     va_list         * pXparam     = va_arg(*pParam, va_list *);
 277
 278     s_environment_invoke_v(pCurrEnv, pTargetEnv, pCallee, pXparam);
 279 }}
 280
 281 static void s_environment_invoke_v(uno_Environment * pCurrEnv, uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
 282 {
 283     uno_Environment * pNextEnv = NULL;
 284     switch(s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv))
 285     {
 286     case -1:
 287         s_setCurrent(pNextEnv);
 288         s_callOut(pCurrEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
 289         s_setCurrent(pCurrEnv);
 290         break;
 291
 292     case 0: {
 293         uno_Environment * hld = s_getCurrent();
 294         s_setCurrent(pCurrEnv);
 295         pCallee(pParam);
 296         s_setCurrent(hld);
 297     }
 298         break;
 299
 300     case 1:
 301         s_setCurrent(pNextEnv);
 302         s_callInto(pNextEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
 303         s_setCurrent(pCurrEnv);
 304         break;
 305     }
 306
 307     if (pNextEnv)
 308         pNextEnv->release(pNextEnv);
 309 }
 310
 311 extern "C" void SAL_CALL uno_Environment_invoke_v(uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
 312     SAL_THROW_EXTERN_C()
 313 {
 314     s_environment_invoke_v(s_getCurrent(), pTargetEnv, pCallee, pParam);
 315 }
 316
 317 extern "C" void SAL_CALL uno_Environment_invoke(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
 318     SAL_THROW_EXTERN_C()
 319 {
 320     va_list param;
 321
 322     va_start(param, pCallee);
 323     uno_Environment_invoke_v(pEnv, pCallee, &param);
 324     va_end(param);
 325 }
 326
 327 extern "C" void SAL_CALL uno_Environment_enter(uno_Environment * pTargetEnv)
 328     SAL_THROW_EXTERN_C()
 329 {
 330     uno_Environment * pNextEnv = NULL;
 331     uno_Environment * pCurrEnv = s_getCurrent();
 332
 333     int res;
 334     while ( (res = s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv)) != 0)
 335     {
 336         cppu::Enterable * pEnterable;
 337
 338         switch(res)
 339         {
 340         case -1:
 341             pEnterable = reinterpret_cast<cppu::Enterable *>(pCurrEnv->pReserved);
 342             if (pEnterable)
 343                 pEnterable->leave();
 344             pCurrEnv->release(pCurrEnv);
 345             break;
 346
 347         case 1:
 348             pNextEnv->acquire(pNextEnv);
 349             pEnterable = reinterpret_cast<cppu::Enterable *>(pNextEnv->pReserved);
 350             if (pEnterable)
 351                 pEnterable->enter();
 352             break;
 353         }
 354
 355         s_setCurrent(pNextEnv);
 356         pCurrEnv = pNextEnv;
 357     }
 358 }
 359
 360 int SAL_CALL uno_Environment_isValid(uno_Environment * pEnv, rtl_uString ** pReason)
 361     SAL_THROW_EXTERN_C()
 362 {
 363     int result = 1;
 364
 365     rtl::OUString typeName(cppu::EnvDcp::getTypeName(pEnv->pTypeName));
 366     if (typeName.equals(s_uno_envDcp))
 367     {
 368         cppu::Enterable * pEnterable = reinterpret_cast<cppu::Enterable *>(pEnv->pReserved);
 369         if (pEnterable)
 370             result = pEnterable->isValid((rtl::OUString *)pReason);
 371     }
 372     else
 373     {
 374         rtl::OUString envDcp(s_uno_envDcp);
 375         envDcp += cppu::EnvDcp::getPurpose(pEnv->pTypeName);
 376
 377         uno::Environment env(envDcp);
 378
 379         result = env.isValid((rtl::OUString *)pReason);
 380     }
 381
 382     return result;
 383 }