bridges/source/remote/static/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: 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_bridges.hxx"
  33 #include <osl/diagnose.h>
  34
  35 #include <bridges/remote/proxy.hxx>
  36 #include <bridges/remote/stub.hxx>
  37 #include <bridges/remote/counter.hxx>
  38 #include <bridges/remote/mapping.hxx>
  39
  40 using namespace bridges_remote;
  41
  42 extern "C" {
  43
  44 static void SAL_CALL thisAcquire( uno_Mapping *pMap )
  45 {
  46     RemoteMapping *p = SAL_REINTERPRET_CAST( RemoteMapping * , pMap );
  47     if( 1 == osl_incrementInterlockedCount( &(p->m_nRef) ) )
  48     {
  49         if( remoteToUno == pMap->mapInterface )
  50         {
  51             uno_registerMapping( &pMap ,
  52                                  freeRemoteMapping,
  53                                  p->pEnvRemote ,
  54                                  p->pEnvUno ,
  55                                  p->m_sPurpose.pData );
  56         }
  57         else
  58         {
  59             uno_registerMapping( &pMap ,
  60                                  freeRemoteMapping,
  61                                  p->pEnvUno ,
  62                                  p->pEnvRemote ,
  63                                  p->m_sPurpose.pData );
  64         }
  65
  66     }
  67 }
  68
  69 static void SAL_CALL thisRelease( uno_Mapping *pMap )
  70 {
  71     RemoteMapping *p = SAL_REINTERPRET_CAST( RemoteMapping * , pMap );
  72     if (! osl_decrementInterlockedCount( &(p->m_nRef) ))
  73     {
  74         uno_revokeMapping( pMap );
  75     }
  76 }
  77
  78 }
  79
  80 namespace bridges_remote {
  81
  82 void remoteToUno( uno_Mapping *pMapping, void **ppUnoI, void *pRemoteI,
  83                   typelib_InterfaceTypeDescription *pTypeDescr )
  84 {
  85     remote_Mapping *pRemoteMapping = ( remote_Mapping * ) pMapping;
  86
  87     OSL_ASSERT( ppUnoI && pTypeDescr );
  88     if (*ppUnoI)
  89     {
  90         ((uno_Interface *)*ppUnoI)->release( (uno_Interface *)*ppUnoI );
  91         *ppUnoI = 0;
  92     }
  93
  94     if (pRemoteI && pTypeDescr)
  95     {
  96         // get object id of interface to be wrapped
  97         rtl_uString * pOid = 0;
  98         pRemoteMapping->pEnvRemote->pExtEnv->getObjectIdentifier(
  99             pRemoteMapping->pEnvRemote->pExtEnv,
 100             &pOid,
 101             pRemoteI );
 102
 103         OSL_ASSERT(pOid);
 104         if( ! pOid )
 105         {
 106             return;
 107         }
 108
 109         // try to get any known interface from target environment
 110         pRemoteMapping->pEnvUno->pExtEnv->getRegisteredInterface(
 111             pRemoteMapping->pEnvUno->pExtEnv,
 112             ppUnoI,
 113             pOid,
 114             pTypeDescr);
 115
 116         if ( ! *ppUnoI) // already existing interface
 117         {
 118             // try to publish a new proxy; proxy may be exchanged during registration
 119             *ppUnoI = new Remote2UnoProxy(
 120                 ( remote_Interface * ) pRemoteI,
 121                 pOid,
 122                 pTypeDescr ,
 123                 pRemoteMapping->pEnvUno,
 124                 pRemoteMapping->pEnvRemote);
 125
 126             pRemoteMapping->pEnvUno->pExtEnv->registerProxyInterface(
 127                 pRemoteMapping->pEnvUno->pExtEnv,
 128                 ppUnoI,
 129                 freeRemote2UnoProxy,
 130                 pOid,
 131                 pTypeDescr );
 132
 133             OSL_ASSERT( *ppUnoI );
 134         }
 135         rtl_uString_release( pOid );
 136     }
 137 }
 138
 139 void unoToRemote( uno_Mapping *pMapping, void **ppRemoteI, void *pUnoI,
 140                   typelib_InterfaceTypeDescription *pTypeDescr )
 141 {
 142     remote_Mapping *pRemoteMapping = ( remote_Mapping * ) pMapping;
 143     OSL_ASSERT( ppRemoteI && pTypeDescr );
 144     if (*ppRemoteI)
 145     {
 146         ((remote_Interface *)*ppRemoteI)->release( (remote_Interface *)*ppRemoteI);
 147         *ppRemoteI = 0;
 148     }
 149     if (pUnoI && pTypeDescr)
 150     {
 151         // get object id of interface to be wrapped
 152         rtl_uString * pOid = 0;
 153         pRemoteMapping->pEnvUno->pExtEnv->getObjectIdentifier(
 154             pRemoteMapping->pEnvUno->pExtEnv,
 155             &pOid,
 156             pUnoI );
 157
 158         OSL_ASSERT( pOid );
 159         if( ! pOid )
 160         {
 161             return;
 162         }
 163
 164         pRemoteMapping->pEnvRemote->pExtEnv->getRegisteredInterface(
 165             pRemoteMapping->pEnvRemote->pExtEnv,
 166             (void**)ppRemoteI,
 167             pOid,
 168             pTypeDescr );
 169
 170         if( !*ppRemoteI )
 171         {
 172             // try to publish a new proxy;
 173             *ppRemoteI = new Uno2RemoteStub(
 174                 ( uno_Interface * ) pUnoI,
 175                 pOid,
 176                 pTypeDescr,
 177                 pRemoteMapping->pEnvUno,
 178                 pRemoteMapping->pEnvRemote );
 179
 180             // note : ppRemoteI may change during registration
 181             pRemoteMapping->pEnvRemote->pExtEnv->registerProxyInterface(
 182                 pRemoteMapping->pEnvRemote->pExtEnv,
 183                 (void**) ppRemoteI,
 184                 freeUno2RemoteStub,
 185                 pOid,
 186                 pTypeDescr );
 187         }
 188
 189         rtl_uString_release( pOid );
 190     }
 191 }
 192
 193 void freeRemoteMapping(uno_Mapping * mapping) {
 194     delete reinterpret_cast< RemoteMapping * >(mapping);
 195 }
 196
 197 RemoteMapping::RemoteMapping( uno_Environment *pEnvUno_ ,
 198                               uno_Environment *pEnvRemote_,
 199                               uno_MapInterfaceFunc func,
 200                               const ::rtl::OUString sPurpose) :
 201     m_nRef( 1 ),
 202     m_sPurpose( sPurpose )
 203 {
 204     pEnvUno = pEnvUno_;
 205     pEnvRemote = pEnvRemote_;
 206
 207     pEnvUno->acquire( pEnvUno );
 208     pEnvRemote->acquire( pEnvRemote );
 209
 210     aBase.mapInterface = func;
 211     aBase.acquire = thisAcquire;
 212     aBase.release = thisRelease;
 213 }
 214
 215 RemoteMapping::~RemoteMapping( )
 216 {
 217     pEnvUno->release( pEnvUno );
 218     pEnvRemote->release( pEnvRemote );
 219 }
 220
 221 }