cppu/test/cascade_mapping/TestProxy.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: TestProxy.cxx,v $
  10  * $Revision: 1.3 $
  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/mapping.hxx"
  32 #include "cppu/EnvDcp.hxx"
  33
  34 #include "../mapping_tester/Mapping.tester.hxx"
  35
  36 #include "TestProxy.hxx"
  37
  38
  39 #ifdef LOG_LIFECYCLE
  40 #define LOG_LIFECYCLE_TestProxy
  41 #endif
  42
  43 #define LOG_LIFECYCLE_TestProxy
  44 #ifdef LOG_LIFECYCLE_TestProxy
  45 #  include <iostream>
  46 #  define LOG_LIFECYCLE_TestProxy_emit(x) x
  47
  48 #else
  49 #  define LOG_LIFECYCLE_TestProxy_emit(x)
  50
  51 #endif
  52
  53
  54 using namespace com::sun::star;
  55
  56 extern "C" void SAL_CALL TestProxy_free(uno_ExtEnvironment * /*pEnv*/, void * pObject)
  57         SAL_THROW_EXTERN_C()
  58 {
  59     TestProxy * pTestProxy = reinterpret_cast<TestProxy *>(pObject);
  60         delete pTestProxy;
  61 }
  62
  63
  64 extern "C" {
  65 static void SAL_CALL s_acquire(uno_Interface * pUnoI) SAL_THROW_EXTERN_C()
  66 {
  67         TestProxy * pTestProxy = static_cast<TestProxy *>(pUnoI);
  68         pTestProxy->acquire();
  69 }
  70
  71 static void SAL_CALL s_release(uno_Interface * pUnoI) SAL_THROW_EXTERN_C()
  72 {
  73         TestProxy * pTestProxy = static_cast<TestProxy *>(pUnoI);
  74         pTestProxy->release();
  75 }
  76
  77 static void SAL_CALL s_dispatch(uno_Interface                 * pUnoI,
  78                                                                 typelib_TypeDescription const * pMemberType,
  79                                                                 void                          * pReturn,
  80                                                                 void                          * pArgs[],
  81                                                                 uno_Any                      ** ppException)
  82         SAL_THROW_EXTERN_C()
  83 {
  84     TestProxy * pThis = static_cast<TestProxy *>(pUnoI);
  85         pThis->dispatch(pMemberType, pReturn, pArgs, ppException);
  86 }
  87 }
  88
  89 TestProxy::TestProxy(uno_Interface                          * pObject,
  90                                          rtl::OUString                    const & oid,
  91                                          typelib_InterfaceTypeDescription       * pTypeDescr,
  92                                          uno_ExtEnvironment                     * pFrom_extEnv,
  93                                          uno_ExtEnvironment                     * pTo_extEnv)
  94         : m_nCount     (1),
  95           m_from_envDcp(pFrom_extEnv->aBase.pTypeName),
  96           m_to_envDcp  (pTo_extEnv  ->aBase.pTypeName),
  97           m_oid        (oid),
  98           m_pTypeDescr (pTypeDescr)
  99 {
 100         LOG_LIFECYCLE_TestProxy_emit(fprintf(stderr, "LIFE: %s -> %p\n", "TestProxy::TestProxy", this));
 101
 102         // uno_Interface
 103     uno_Interface::acquire     = s_acquire;
 104     uno_Interface::release     = s_release;
 105     uno_Interface::pDispatcher = s_dispatch;
 106
 107         m_theObject = pObject;
 108         m_theObject->acquire(m_theObject);
 109
 110         typelib_typedescription_acquire(&pTypeDescr->aBase);
 111
 112         m_pFrom_extEnv = pFrom_extEnv;
 113         m_pFrom_extEnv->aBase.acquire(&m_pFrom_extEnv->aBase);
 114
 115         m_pTo_extEnv = pTo_extEnv;
 116         m_pTo_extEnv->aBase.acquire(&m_pTo_extEnv->aBase);
 117
 118         m_pTo_extEnv->registerInterface(m_pTo_extEnv, reinterpret_cast<void **>(&pObject), oid.pData, pTypeDescr);
 119 }
 120
 121 TestProxy::~TestProxy(void)
 122 {
 123         LOG_LIFECYCLE_TestProxy_emit(fprintf(stderr, "LIFE: %s -> %p\n", "TestProxy::~TestProxy", this));
 124
 125         m_pTo_extEnv->revokeInterface(m_pTo_extEnv, reinterpret_cast<void *>(m_theObject));
 126
 127         typelib_typedescription_release(&m_pTypeDescr->aBase);
 128         m_theObject->release(m_theObject);
 129         m_pFrom_extEnv->aBase.release(&m_pFrom_extEnv->aBase);
 130         m_pTo_extEnv  ->aBase.release(&m_pTo_extEnv->aBase);
 131 }
 132
 133 void TestProxy::acquire() SAL_THROW(())
 134 {
 135         if (osl_incrementInterlockedCount(&m_nCount) == 1)
 136     {
 137                 uno_Interface * pThis = this;
 138         m_pTo_extEnv->registerProxyInterface(m_pTo_extEnv,
 139                                                                                          (void **)&pThis,
 140                                                                                          TestProxy_free,
 141                                                                                          m_oid.pData,
 142                                                                                          m_pTypeDescr);
 143         OSL_ASSERT(pThis == this);
 144     }
 145 }
 146
 147 void TestProxy::release() SAL_THROW(())
 148 {
 149         if (osl_decrementInterlockedCount(&m_nCount) == 0)
 150         {
 151                 m_pFrom_extEnv->revokeInterface(m_pFrom_extEnv, this);
 152         }
 153 }
 154
 155 void TestProxy::dispatch(typelib_TypeDescription const * pMemberType,
 156                                          void                          * pReturn,
 157                                          void                          * pArgs[],
 158                                          uno_Any                      ** ppException)
 159 {
 160         {
 161                 rtl::OUString arrow(RTL_CONSTASCII_USTRINGPARAM("-->"));
 162
 163                 if (!g_custom.getLength())
 164                         g_custom += m_from_envDcp;
 165
 166                 g_custom += arrow;
 167                 g_custom += m_to_envDcp;
 168
 169                 m_theObject->pDispatcher(m_theObject, pMemberType, pReturn, pArgs, ppException);
 170
 171                 uno_Any * any = (uno_Any *)pReturn;
 172
 173                 void * pout = NULL;
 174
 175                 uno::Mapping mapping(m_to_envDcp, m_from_envDcp);
 176                 mapping.mapInterface(&pout, any->pReserved, any->pType);
 177
 178                 ((uno_Interface *)any->pReserved)->release((uno_Interface*)any->pReserved);
 179                 any->pReserved = pout;
 180         }
 181 }
 182