| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include <iostream> | |
| #include "osl/interlck.h" | |
| #include "rtl/ustring.hxx" | |
| #include "uno/environment.hxx" | |
| #include "uno/mapping.hxx" | |
| #include "uno/dispatcher.h" | |
| //#include "cascade_mappping.hxx" | |
| #include "cppu/EnvDcp.hxx" | |
| //#define LOG_CALLING_named_purpose_getMapping | |
| //#define LOG_LIFECYLE_MediatorMapping | |
| #ifdef LOG_LIFECYLE_MediatorMapping | |
| # define LOG_LIFECYLE_MediatorMapping_emit(x) x | |
| #else | |
| # define LOG_LIFECYLE_MediatorMapping_emit(x) | |
| #endif | |
| using namespace com::sun::star; | |
| class MediatorMapping : public uno_Mapping | |
| { | |
| oslInterlockedCount m_refCount; | |
| uno::Mapping m_from2uno; | |
| uno::Mapping m_uno2to; | |
| uno::Environment m_from; | |
| uno::Environment m_interm; | |
| uno::Environment m_to; | |
| public: | |
| void acquire(void); | |
| void release(void); | |
| void mapInterface(void ** ppOut, | |
| void * pInterface, | |
| typelib_InterfaceTypeDescription * pInterfaceTypeDescr); | |
| MediatorMapping(uno_Environment * pFrom, | |
| uno_Environment * pInterm, | |
| uno_Environment * pTo); | |
| ~MediatorMapping(); | |
| }; | |
| extern "C" { | |
| static void SAL_CALL s_acquire(uno_Mapping * mapping) | |
| { | |
| MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping); | |
| pMediatorMapping->acquire(); | |
| } | |
| static void SAL_CALL s_release(uno_Mapping * mapping) | |
| { | |
| MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping); | |
| pMediatorMapping->release(); | |
| } | |
| static void SAL_CALL s_mapInterface( | |
| uno_Mapping * mapping, | |
| void ** ppOut, | |
| void * pInterface, | |
| typelib_InterfaceTypeDescription * pInterfaceTypeDescr) | |
| { | |
| MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping); | |
| pMediatorMapping->mapInterface(ppOut, pInterface, pInterfaceTypeDescr); | |
| } | |
| } | |
| MediatorMapping::MediatorMapping(uno_Environment * pFrom, | |
| uno_Environment * pInterm, | |
| uno_Environment * pTo) | |
| : m_refCount(0), | |
| m_from2uno(pFrom, pInterm), | |
| m_uno2to (pInterm, pTo), | |
| m_from (pFrom), | |
| m_interm (pInterm), | |
| m_to (pTo) | |
| { | |
| LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl); | |
| if (!m_from2uno.get() || !m_uno2to.get()) | |
| abort(); | |
| uno_Mapping::acquire = s_acquire; | |
| uno_Mapping::release = s_release; | |
| uno_Mapping::mapInterface = s_mapInterface; | |
| } | |
| MediatorMapping::~MediatorMapping() | |
| { | |
| LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl); | |
| } | |
| void MediatorMapping::acquire(void) | |
| { | |
| LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl); | |
| osl_incrementInterlockedCount(&m_refCount); | |
| } | |
| void MediatorMapping::release(void) | |
| { | |
| LOG_LIFECYLE_MediatorMapping_emit(std::cerr << __FUNCTION__ << std::endl); | |
| if (osl_decrementInterlockedCount(&m_refCount) == 0) | |
| { | |
| ::uno_revokeMapping(this); | |
| } | |
| } | |
| extern "C" { static void s_mapInterface_v(va_list * pParam) | |
| { | |
| void ** ppOut = va_arg(*pParam, void **); | |
| void * pInterface = va_arg(*pParam, void *); | |
| typelib_InterfaceTypeDescription * pInterfaceTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *); | |
| uno_Mapping * pMapping = va_arg(*pParam, uno_Mapping *); | |
| pMapping->mapInterface(pMapping, ppOut, pInterface, pInterfaceTypeDescr); | |
| }} | |
| void MediatorMapping::mapInterface( | |
| void ** ppOut, | |
| void * pInterface, | |
| typelib_InterfaceTypeDescription * pInterfaceTypeDescr) | |
| { | |
| if (*ppOut != 0) | |
| { | |
| uno_ExtEnvironment * env = m_to.get()->pExtEnv; | |
| OSL_ASSERT( env != 0 ); | |
| env->releaseInterface( env, *ppOut ); | |
| *ppOut = NULL; | |
| } | |
| void * ret = 0; | |
| uno_Interface * pUnoI = 0; | |
| m_from.invoke(s_mapInterface_v, &pUnoI, pInterface, pInterfaceTypeDescr, m_from2uno.get()); | |
| m_uno2to.mapInterface(&ret, pUnoI, pInterfaceTypeDescr); | |
| if (pUnoI) | |
| m_interm.get()->pExtEnv->releaseInterface(m_interm.get()->pExtEnv, pUnoI); | |
| *ppOut = ret; | |
| } | |
| extern "C" { static void SAL_CALL s_MediatorMapping_free(uno_Mapping * pMapping) | |
| SAL_THROW_EXTERN_C() | |
| { | |
| delete static_cast<MediatorMapping *>(pMapping); | |
| }} | |
| static rtl::OUString getPrefix(rtl::OUString const & str1, rtl::OUString const & str2) | |
| { | |
| sal_Int32 nIndex1 = 0; | |
| sal_Int32 nIndex2 = 0; | |
| sal_Int32 sim = 0; | |
| rtl::OUString token1; | |
| rtl::OUString token2; | |
| do | |
| { | |
| token1 = str1.getToken(0, ':', nIndex1); | |
| token2 = str2.getToken(0, ':', nIndex2); | |
| if (token1.equals(token2)) | |
| sim += token1.getLength() + 1; | |
| } | |
| while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1.equals(token2)); | |
| rtl::OUString result; | |
| if (sim) | |
| result = str1.copy(0, sim - 1); | |
| return result; | |
| } | |
| // rtl::OUString str1(RTL_CONSTASCII_USTRINGPARAM("abc:def:ghi")); | |
| // rtl::OUString str2(RTL_CONSTASCII_USTRINGPARAM("abc:def")); | |
| // rtl::OUString str3(RTL_CONSTASCII_USTRINGPARAM("abc")); | |
| // rtl::OUString str4(RTL_CONSTASCII_USTRINGPARAM("")); | |
| // rtl::OUString pref; | |
| // pref = getPrefix(str1, str1); | |
| // pref = getPrefix(str1, str2); | |
| // pref = getPrefix(str1, str3); | |
| // pref = getPrefix(str1, str4); | |
| // pref = getPrefix(str2, str1); | |
| // pref = getPrefix(str3, str1); | |
| // pref = getPrefix(str4, str1); | |
| void getCascadeMapping(uno_Mapping ** ppMapping, | |
| uno_Environment * pFrom, | |
| uno_Environment * pTo, | |
| rtl_uString * pAddPurpose) | |
| { | |
| if (pAddPurpose && pAddPurpose->length) | |
| return; | |
| rtl::OUString uno_envType(RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO)); | |
| rtl::OUString from_envType = cppu::EnvDcp::getTypeName(pFrom->pTypeName); | |
| rtl::OUString to_envType = cppu::EnvDcp::getTypeName(pTo->pTypeName); | |
| rtl::OUString from_envPurpose = cppu::EnvDcp::getPurpose(pFrom->pTypeName); | |
| rtl::OUString to_envPurpose = cppu::EnvDcp::getPurpose(pTo->pTypeName); | |
| #ifdef LOG_CALLING_named_purpose_getMapping | |
| rtl::OString s_from_name = rtl::OUStringToOString(pFrom->pTypeName, RTL_TEXTENCODING_ASCII_US); | |
| rtl::OString s_to_name = rtl::OUStringToOString(pTo->pTypeName, RTL_TEXTENCODING_ASCII_US); | |
| std::cerr << __FUNCTION__ << " - creating mediation "; | |
| std::cerr << "pFrom: " << s_from_name.getStr(); | |
| std::cerr <<" pTo: " << s_to_name.getStr() << std::endl; | |
| #endif | |
| if (from_envPurpose == to_envPurpose) // gcc:bla => uno:bla | |
| return; | |
| // reaching this point means, we need a mediated mapping!!! | |
| // we generall mediate via uno[:free] | |
| uno_Environment * pInterm = NULL; | |
| // chained uno -> uno | |
| if (from_envType == uno_envType && to_envType == uno_envType) | |
| { | |
| rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose); | |
| rtl::OUString uno_envDcp = uno_envType; | |
| uno_envDcp += purpose; | |
| // direct mapping possible? | |
| // uno:bla-->uno:bla:blubb | |
| if (from_envPurpose.equals(purpose)) | |
| { | |
| rtl::OUString rest = to_envPurpose.copy(purpose.getLength()); | |
| sal_Int32 index = rest.indexOf(':', 1); | |
| if (index == -1) | |
| { | |
| uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData); | |
| return; | |
| } | |
| uno_envDcp += rest.copy(0, index); | |
| } | |
| else if (to_envPurpose.equals(purpose)) | |
| { | |
| rtl::OUString rest = from_envPurpose.copy(purpose.getLength()); | |
| sal_Int32 index = rest.indexOf(':', 1); | |
| if (index == -1) | |
| { | |
| uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData); | |
| return; | |
| } | |
| uno_envDcp += rest.copy(0, index); | |
| } | |
| uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL); | |
| } | |
| else if (from_envType != uno_envType && to_envType == uno_envType) // <ANY> -> UNO ? | |
| // mediate via uno:purpose(fromEnv) | |
| { | |
| rtl::OUString envDcp = uno_envType; | |
| envDcp += from_envPurpose; | |
| uno_getEnvironment(&pInterm, envDcp.pData, NULL); | |
| } | |
| else if (from_envType == uno_envType && to_envType != uno_envType) // UNO -> <ANY>? | |
| // mediate via uno(context) | |
| { | |
| rtl::OUString envDcp = uno_envType; | |
| envDcp += to_envPurpose; | |
| uno_getEnvironment(&pInterm, envDcp.pData, NULL); | |
| } | |
| else // everything else | |
| // mediate via uno:purpose | |
| { | |
| rtl::OUString purpose = getPrefix(from_envPurpose, to_envPurpose); | |
| rtl::OUString uno_envDcp = uno_envType; | |
| uno_envDcp += purpose; | |
| uno_getEnvironment(&pInterm, uno_envDcp.pData, NULL); | |
| } | |
| uno_Mapping * pMapping = new MediatorMapping(pFrom, pInterm, pTo); | |
| pInterm->release(pInterm); | |
| pMapping->acquire(pMapping); | |
| ::uno_registerMapping(&pMapping, s_MediatorMapping_free, pFrom, pTo, pAddPurpose); | |
| if (*ppMapping) | |
| (*ppMapping)->release(*ppMapping); | |
| *ppMapping = pMapping; | |
| } |