cppu/source/helper/purpenv/helper_purpenv_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: helper_purpenv_Mapping.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 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_cppu.hxx"
  33
  34 #include "cppu/helper/purpenv/Mapping.hxx"
  35
  36 #include "Proxy.hxx"
  37
  38 #include "osl/interlck.h"
  39 #include "uno/environment.hxx"
  40 #include "uno/dispatcher.h"
  41 #include "typelib/typedescription.h"
  42
  43
  44 #ifdef debug
  45 # define LOG_LIFECYCLE_cppu_helper_purpenv_Mapping
  46 #endif
  47
  48 #ifdef LOG_LIFECYCLE_cppu_helper_purpenv_Mapping
  49 #  include <iostream>
  50 #  define LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(x) x
  51
  52 #else
  53 #  define LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(x)
  54
  55 #endif
  56
  57
  58 using namespace com::sun::star;
  59
  60
  61 class Mapping : public uno_Mapping
  62 {
  63     uno::Environment   m_from;
  64     uno::Environment   m_to;
  65
  66     oslInterlockedCount m_nCount;
  67
  68     cppu::helper::purpenv::ProbeFun * m_probeFun;
  69     void                            * m_pContext;
  70
  71 public:
  72     explicit  Mapping(uno_Environment                 * pFrom,
  73                       uno_Environment                 * pTo,
  74                       cppu::helper::purpenv::ProbeFun * probeFun,
  75                       void                            * pProbeContext);
  76     virtual  ~Mapping(void);
  77
  78     void mapInterface(
  79         uno_Interface                    ** ppOut,
  80         uno_Interface                     * pUnoI,
  81         typelib_InterfaceTypeDescription  * pTypeDescr);
  82
  83     void acquire(void);
  84     void release(void);
  85 };
  86
  87 static void SAL_CALL s_mapInterface(
  88     uno_Mapping                       * puno_Mapping,
  89     uno_Interface                    ** ppOut,
  90     uno_Interface                     * pUnoI,
  91     typelib_InterfaceTypeDescription  * pTypeDescr )
  92     SAL_THROW_EXTERN_C()
  93 {
  94     Mapping * pMapping = static_cast<Mapping *>(puno_Mapping);
  95     pMapping->mapInterface(ppOut, pUnoI, pTypeDescr);
  96 }
  97
  98 extern "C" {
  99 static void SAL_CALL s_acquire(uno_Mapping * puno_Mapping)
 100     SAL_THROW_EXTERN_C()
 101 {
 102     Mapping * pMapping = static_cast<Mapping *>(puno_Mapping);
 103     pMapping->acquire();
 104 }
 105
 106 static void SAL_CALL s_release(uno_Mapping * puno_Mapping)
 107     SAL_THROW_EXTERN_C()
 108 {
 109     Mapping * pMapping = static_cast<Mapping * >(puno_Mapping);
 110     pMapping->release();
 111 }
 112
 113
 114 static void s_getIdentifier_v(va_list * pParam)
 115 {
 116     uno_ExtEnvironment *  pEnv  = va_arg(*pParam, uno_ExtEnvironment *);
 117     rtl_uString        ** ppOid = va_arg(*pParam, rtl_uString **);
 118     uno_Interface      *  pUnoI = va_arg(*pParam, uno_Interface *);
 119
 120     pEnv->getObjectIdentifier(pEnv, ppOid, pUnoI);
 121 }
 122
 123 static void SAL_CALL s_free(uno_Mapping * puno_Mapping)
 124     SAL_THROW_EXTERN_C()
 125 {
 126     Mapping * pMapping = static_cast<Mapping *>(puno_Mapping);
 127     delete pMapping;
 128 }
 129 }
 130
 131 Mapping::Mapping(uno_Environment                 * pFrom,
 132                  uno_Environment                 * pTo,
 133                  cppu::helper::purpenv::ProbeFun * probeFun,
 134                  void                            * pProbeContext
 135 ) SAL_THROW( () )
 136     : m_from    (pFrom),
 137       m_to      (pTo),
 138       m_nCount  (1),
 139       m_probeFun(probeFun),
 140       m_pContext(pProbeContext)
 141 {
 142     LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(fprintf(stderr, "LIFE: %s -> %p\n", "Mapping::Mapping(uno_Environment * pFrom, uno_Environment * pTo) SAL_THROW( () )", this));
 143
 144     uno_Mapping::acquire      = s_acquire;
 145     uno_Mapping::release      = s_release;
 146     uno_Mapping::mapInterface = (uno_MapInterfaceFunc)s_mapInterface;
 147 }
 148
 149 Mapping::~Mapping(void)
 150 {
 151     LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(fprintf(stderr, "LIFE: %s -> %p\n", "Mapping::~Mapping(void)", this));
 152 }
 153
 154
 155 void Mapping::mapInterface(
 156     uno_Interface                    ** ppOut,
 157     uno_Interface                     * pUnoI,
 158     typelib_InterfaceTypeDescription  * pTypeDescr)
 159 {
 160     OSL_ASSERT(ppOut && pTypeDescr);
 161     if (*ppOut)
 162     {
 163         (*ppOut)->release(*ppOut);
 164         *ppOut = 0;
 165     }
 166
 167     if (!pUnoI)
 168         return;
 169
 170     // get object id of uno interface to be wrapped
 171     // need to enter environment because of potential "queryInterface" call
 172     rtl_uString * pOId = 0;
 173     uno_Environment_invoke(m_from.get(), s_getIdentifier_v, m_from.get(), &pOId, pUnoI);
 174     OSL_ASSERT(pOId);
 175
 176      // try to get any known interface from target environment
 177     m_to.get()->pExtEnv->getRegisteredInterface(m_to.get()->pExtEnv, (void **)ppOut, pOId, pTypeDescr);
 178
 179     if (!*ppOut) // not yet there, register new proxy interface
 180     {
 181         // try to publish a new proxy (ref count initially 1)
 182         uno_Interface * pProxy = new Proxy(this,
 183                                            m_from.get(),
 184                                            m_to.get(),
 185                                            pUnoI,
 186                                            pTypeDescr,
 187                                            pOId,
 188                                            m_probeFun,
 189                                            m_pContext);
 190
 191         // proxy may be exchanged during registration
 192         m_to.get()->pExtEnv->registerProxyInterface(m_to.get()->pExtEnv,
 193                                                     (void **)&pProxy,
 194                                                     Proxy_free,
 195                                                     pOId,
 196                                                     pTypeDescr);
 197
 198         *ppOut = pProxy;
 199     }
 200
 201     rtl_uString_release(pOId);
 202 }
 203
 204
 205 void Mapping::acquire() SAL_THROW(())
 206 {
 207     if (osl_incrementInterlockedCount(&m_nCount) == 1)
 208     {
 209         uno_Mapping * pMapping = this;
 210
 211         ::uno_registerMapping(&pMapping, s_free, m_from.get(), m_to.get(), NULL);
 212     }
 213 }
 214
 215 void Mapping::release() SAL_THROW(())
 216 {
 217     if (osl_decrementInterlockedCount(&m_nCount) == 0)
 218         ::uno_revokeMapping(this);
 219 }
 220
 221
 222 namespace cppu { namespace helper { namespace purpenv {
 223
 224 void createMapping(uno_Mapping     ** ppMapping,
 225                    uno_Environment  * pFrom,
 226                    uno_Environment  * pTo,
 227                    ProbeFun         * probeFun,
 228                    void             * pContext
 229  )
 230 {
 231     *ppMapping = new Mapping(pFrom, pTo, probeFun, pContext);
 232
 233     ::uno_registerMapping(ppMapping, s_free, pFrom, pTo, NULL);
 234 }
 235
 236 }}}