cppu/source/uno/cascade_mapping.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: cascade_mapping.cxx,v $
  10  * $Revision: 1.4 $
  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 <iostream>
  32
  33 #include "osl/interlck.h"
  34 #include "rtl/ustring.hxx"
  35 #include "uno/environment.hxx"
  36 #include "uno/mapping.hxx"
  37 #include "uno/dispatcher.h"
  38
  39 //#include "cascade_mappping.hxx"
  40 #include "cppu/EnvDcp.hxx"
  41
  42
  43 //#define LOG_CALLING_named_purpose_getMapping
  44
  45 //#define LOG_LIFECYLE_MediatorMapping
  46 #ifdef LOG_LIFECYLE_MediatorMapping
  47 #  define LOG_LIFECYLE_MediatorMapping_emit(x) x
  48
  49 #else
  50 #  define LOG_LIFECYLE_MediatorMapping_emit(x)
  51
  52 #endif
  53
  54
  55 using namespace com::sun::star;
  56
  57 class MediatorMapping : public uno_Mapping
  58 {
  59     oslInterlockedCount m_refCount;
  60
  61     uno::Mapping        m_from2uno;
  62     uno::Mapping        m_uno2to;
  63
  64     uno::Environment    m_from;
  65     uno::Environment    m_interm;
  66     uno::Environment    m_to;
  67
  68 public:
  69     void acquire(void);
  70     void release(void);
  71
  72     void mapInterface(void                            ** ppOut,
  73                       void                             * pInterface,
  74                       typelib_InterfaceTypeDescription * pInterfaceTypeDescr);
  75     MediatorMapping(uno_Environment * pFrom,
  76                     uno_Environment * pInterm,
  77                     uno_Environment * pTo);
  78     ~MediatorMapping();
  79 };
  80
  81 extern "C" {
  82 static void SAL_CALL s_acquire(uno_Mapping * mapping)
  83 {
  84     MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
  85     pMediatorMapping->acquire();
  86 }
  87
  88 static void SAL_CALL s_release(uno_Mapping * mapping)
  89 {
  90     MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
  91     pMediatorMapping->release();
  92 }
  93
  94 static void SAL_CALL s_mapInterface(
  95     uno_Mapping                      * mapping,
  96     void                            ** ppOut,
  97     void                             * pInterface,
  98     typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
  99 {
 100     MediatorMapping   * pMediatorMapping  = static_cast<MediatorMapping *>(mapping);
 101     pMediatorMapping->mapInterface(ppOut, pInterface, pInterfaceTypeDescr);
 102 }
 103 }
 104
 105 MediatorMapping::MediatorMapping(uno_Environment * pFrom,
 106                                  uno_Environment * pInterm,
 107                                  uno_Environment * pTo)
 108     : m_refCount(0),
 109       m_from2uno(pFrom, pInterm),
 110       m_uno2to  (pInterm, pTo),
 111       m_from    (pFrom),
 112       m_interm  (pInterm),
 113       m_to      (pTo)
 114 {
 115     LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
 116
 117     if (!m_from2uno.get() || !m_uno2to.get())
 118         abort();
 119
 120     uno_Mapping::acquire      = s_acquire;
 121     uno_Mapping::release      = s_release;
 122     uno_Mapping::mapInterface = s_mapInterface;
 123 }
 124
 125 MediatorMapping::~MediatorMapping()
 126 {
 127     LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
 128 }
 129
 130 void MediatorMapping::acquire(void)
 131 {
 132     LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
 133
 134     osl_incrementInterlockedCount(&m_refCount);
 135 }
 136
 137 void MediatorMapping::release(void)
 138 {
 139     LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl);
 140
 141     if (osl_decrementInterlockedCount(&m_refCount) == 0)
 142     {
 143         ::uno_revokeMapping(this);
 144     }
 145 }
 146
 147 extern "C" { static void s_mapInterface_v(va_list * pParam)
 148 {
 149     void                            ** ppOut               = va_arg(*pParam, void **);
 150     void                             * pInterface          = va_arg(*pParam, void *);
 151     typelib_InterfaceTypeDescription * pInterfaceTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
 152     uno_Mapping                      * pMapping            = va_arg(*pParam, uno_Mapping *);
 153
 154     pMapping->mapInterface(pMapping, ppOut, pInterface, pInterfaceTypeDescr);
 155 }}
 156
 157 void MediatorMapping::mapInterface(
 158     void                            ** ppOut,
 159     void                             * pInterface,
 160     typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
 161 {
 162     if (*ppOut != 0)
 163     {
 164         uno_ExtEnvironment * env = m_to.get()->pExtEnv;
 165         OSL_ASSERT( env != 0 );
 166         env->releaseInterface( env, *ppOut );
 167         *ppOut = NULL;
 168     }
 169
 170     void * ret = 0;
 171     uno_Interface * pUnoI = 0;
 172
 173     m_from.invoke(s_mapInterface_v, &pUnoI, pInterface, pInterfaceTypeDescr, m_from2uno.get());
 174
 175     m_uno2to.mapInterface(&ret, pUnoI, pInterfaceTypeDescr);
 176
 177     if (pUnoI)
 178         m_interm.get()->pExtEnv->releaseInterface(m_interm.get()->pExtEnv, pUnoI);
 179
 180     *ppOut = ret;
 181 }
 182
 183 extern "C" { static void SAL_CALL s_MediatorMapping_free(uno_Mapping * pMapping)
 184     SAL_THROW_EXTERN_C()
 185 {
 186     delete static_cast<MediatorMapping *>(pMapping);
 187 }}
 188
 189
 190
 191 static rtl::OUString getPrefix(rtl::OUString const & str1, rtl::OUString const & str2)
 192 {
 193     sal_Int32 nIndex1 = 0;
 194     sal_Int32 nIndex2 = 0;
 195     sal_Int32 sim = 0;
 196
 197     rtl::OUString token1;
 198     rtl::OUString token2;
 199
 200     do
 201     {
 202         token1 = str1.getToken(0, ':', nIndex1);
 203         token2 = str2.getToken(0, ':', nIndex2);
 204
 205         if (token1.equals(token2))
 206             sim += token1.getLength() + 1;
 207     }
 208     while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1.equals(token2));
 209
 210     rtl::OUString result;
 211
 212     if (sim)
 213         result = str1.copy(0, sim - 1);
 214
 215     return result;
 216 }
 217
 218 //      rtl::OUString str1(RTL_CONSTASCII_USTRINGPARAM("abc:def:ghi"));
 219 //      rtl::OUString str2(RTL_CONSTASCII_USTRINGPARAM("abc:def"));
 220 //      rtl::OUString str3(RTL_CONSTASCII_USTRINGPARAM("abc"));
 221 //      rtl::OUString str4(RTL_CONSTASCII_USTRINGPARAM(""));
 222
 223 //      rtl::OUString pref;
 224
 225 //      pref = getPrefix(str1, str1);
 226 //      pref = getPrefix(str1, str2);
 227 //      pref = getPrefix(str1, str3);
 228 //      pref = getPrefix(str1, str4);
 229
 230 //      pref = getPrefix(str2, str1);
 231 //      pref = getPrefix(str3, str1);
 232 //      pref = getPrefix(str4, str1);
 233
 234
 235 void getCascadeMapping(uno_Mapping     ** ppMapping,
 236                        uno_Environment  * pFrom,
 237                        uno_Environment  * pTo,
 238                        rtl_uString      * pAddPurpose)
 239 {
 240     if (pAddPurpose && pAddPurpose->length)
 241         return;
 242
 243     rtl::OUString uno_envType(RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO));
 244
 245     rtl::OUString from_envType    = cppu::EnvDcp::getTypeName(pFrom->pTypeName);
 246     rtl::OUString to_envType      = cppu::EnvDcp::getTypeName(pTo->pTypeName);
 247     rtl::OUString from_envPurpose = cppu::EnvDcp::getPurpose(pFrom->pTypeName);
 248     rtl::OUString to_envPurpose   = cppu::EnvDcp::getPurpose(pTo->pTypeName);
 249
 250 #ifdef LOG_CALLING_named_purpose_getMapping
 251     rtl::OString s_from_name = rtl::OUStringToOString(pFrom->pTypeName, RTL_TEXTENCODING_ASCII_US);
 252     rtl::OString s_to_name   = rtl::OUStringToOString(pTo->pTypeName,   RTL_TEXTENCODING_ASCII_US);
 253
 254     std::cerr << __FUNCTION__ << " - creating mediation ";
 255     std::cerr << "pFrom: " << s_from_name.getStr();
 256     std::cerr <<" pTo: "   << s_to_name.getStr() << std::endl;
 257 #endif
 258
 259     if (from_envPurpose == to_envPurpose) // gcc:bla => uno:bla
 260         return;
 261
 262     // reaching this point means, we need a mediated mapping!!!
 263     // we generall mediate via uno[:free]
 264     uno_Environment * pInterm = NULL;
 265
 266     // chained uno -> uno
 267     if (from_envType == uno_envType && to_envType == uno_envType)
 268     {
 269         rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
 270
 271         rtl::OUString uno_envDcp = uno_envType;
 272         uno_envDcp += purpose;
 273
 274         // direct mapping possible?
 275         // uno:bla-->uno:bla:blubb
 276         if (from_envPurpose.equals(purpose))
 277         {
 278             rtl::OUString rest = to_envPurpose.copy(purpose.getLength());
 279
 280             sal_Int32 index = rest.indexOf(':', 1);
 281             if (index == -1)
 282             {
 283                 uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
 284                 return;
 285             }
 286
 287             uno_envDcp += rest.copy(0, index);
 288         }
 289         else if (to_envPurpose.equals(purpose))
 290         {
 291             rtl::OUString rest = from_envPurpose.copy(purpose.getLength());
 292
 293             sal_Int32 index = rest.indexOf(':', 1);
 294             if (index == -1)
 295             {
 296                 uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
 297                 return;
 298             }
 299
 300             uno_envDcp += rest.copy(0, index);
 301         }
 302
 303         uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL);
 304     }
 305     else if (from_envType != uno_envType && to_envType == uno_envType) // <ANY> -> UNO ?
 306         // mediate via uno:purpose(fromEnv)
 307     {
 308         rtl::OUString     envDcp = uno_envType;
 309
 310         envDcp += from_envPurpose;
 311          uno_getEnvironment(&pInterm, envDcp.pData, NULL);
 312     }
 313     else if (from_envType == uno_envType && to_envType != uno_envType) // UNO -> <ANY>?
 314         // mediate via uno(context)
 315     {
 316         rtl::OUString     envDcp = uno_envType;
 317
 318          envDcp += to_envPurpose;
 319         uno_getEnvironment(&pInterm, envDcp.pData, NULL);
 320     }
 321     else // everything else
 322         // mediate via uno:purpose
 323     {
 324         rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
 325
 326         rtl::OUString uno_envDcp = uno_envType;
 327         uno_envDcp += purpose;
 328
 329         uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL);
 330     }
 331
 332     uno_Mapping * pMapping = new MediatorMapping(pFrom, pInterm, pTo);
 333     pInterm->release(pInterm);
 334
 335
 336     pMapping->acquire(pMapping);
 337
 338     ::uno_registerMapping(&pMapping, s_MediatorMapping_free, pFrom, pTo, pAddPurpose);
 339
 340     if (*ppMapping)
 341         (*ppMapping)->release(*ppMapping);
 342
 343     *ppMapping = pMapping;
 344 }