/************************************************************** * * 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. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_stoc.hxx" #include "osl/diagnose.h" #include "osl/interlck.h" #include "osl/doublecheckedlocking.h" #include "osl/mutex.hxx" #include "rtl/ref.hxx" #include "uno/dispatcher.hxx" #include "uno/data.h" #include "uno/mapping.hxx" #include "uno/environment.hxx" #include "typelib/typedescription.hxx" #include "cppuhelper/exc_hlp.hxx" #include "cppuhelper/implbase2.hxx" #include "cppuhelper/implementationentry.hxx" #include "cppuhelper/factory.hxx" #include "com/sun/star/lang/XServiceInfo.hpp" #include "com/sun/star/registry/XRegistryKey.hpp" #include "com/sun/star/reflection/XProxyFactory.hpp" #include "com/sun/star/uno/RuntimeException.hpp" #define OUSTR(x) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(x) ) #define SERVICE_NAME "com.sun.star.reflection.ProxyFactory" #define IMPL_NAME "com.sun.star.comp.reflection.ProxyFactory" using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using ::rtl::OUString; namespace { static rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT; static OUString proxyfac_getImplementationName() { return OUSTR(IMPL_NAME); } static Sequence< OUString > proxyfac_getSupportedServiceNames() { OUString str_name = OUSTR(SERVICE_NAME); return Sequence< OUString >( &str_name, 1 ); } //============================================================================== struct FactoryImpl : public ::cppu::WeakImplHelper2< lang::XServiceInfo, reflection::XProxyFactory > { Environment m_uno_env; Environment m_cpp_env; Mapping m_uno2cpp; Mapping m_cpp2uno; UnoInterfaceReference binuno_queryInterface( UnoInterfaceReference const & unoI, typelib_InterfaceTypeDescription * pTypeDescr ); FactoryImpl(); virtual ~FactoryImpl(); // XServiceInfo virtual OUString SAL_CALL getImplementationName() throw (RuntimeException); virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException); virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw (RuntimeException); // XProxyFactory virtual Reference< XAggregation > SAL_CALL createProxy( Reference< XInterface > const & xTarget ) throw (RuntimeException); }; //______________________________________________________________________________ UnoInterfaceReference FactoryImpl::binuno_queryInterface( UnoInterfaceReference const & unoI, typelib_InterfaceTypeDescription * pTypeDescr ) { // init queryInterface() td static typelib_TypeDescription * s_pQITD = 0; if (s_pQITD == 0) { ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() ); if (s_pQITD == 0) { typelib_TypeDescription * pTXInterfaceDescr = 0; TYPELIB_DANGER_GET( &pTXInterfaceDescr, ::getCppuType( reinterpret_cast< Reference< XInterface > const * >(0) ).getTypeLibType() ); typelib_TypeDescription * pQITD = 0; typelib_typedescriptionreference_getDescription( &pQITD, reinterpret_cast< typelib_InterfaceTypeDescription * >( pTXInterfaceDescr )->ppAllMembers[ 0 ] ); TYPELIB_DANGER_RELEASE( pTXInterfaceDescr ); OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); s_pQITD = pQITD; } } else { OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER(); } void * args[ 1 ]; args[ 0 ] = &reinterpret_cast< typelib_TypeDescription * >( pTypeDescr )->pWeakRef; uno_Any ret_val, exc_space; uno_Any * exc = &exc_space; unoI.dispatch( s_pQITD, &ret_val, args, &exc ); if (exc == 0) { UnoInterfaceReference ret; if (ret_val.pType->eTypeClass == typelib_TypeClass_INTERFACE) { ret.set( *reinterpret_cast< uno_Interface ** >(ret_val.pData), SAL_NO_ACQUIRE ); typelib_typedescriptionreference_release( ret_val.pType ); } else { uno_any_destruct( &ret_val, 0 ); } return ret; } else { // exception occured: OSL_ENSURE( typelib_typedescriptionreference_isAssignableFrom( ::getCppuType( reinterpret_cast< RuntimeException const * >(0) ).getTypeLibType(), exc->pType ), "### RuntimeException expected!" ); Any cpp_exc; uno_type_copyAndConvertData( &cpp_exc, exc, ::getCppuType( &cpp_exc ).getTypeLibType(), m_uno2cpp.get() ); uno_any_destruct( exc, 0 ); ::cppu::throwException( cpp_exc ); OSL_ASSERT( 0 ); // way of no return return UnoInterfaceReference(); // for dummy } } //============================================================================== struct ProxyRoot : public ::cppu::OWeakAggObject { // XAggregation virtual Any SAL_CALL queryAggregation( Type const & rType ) throw (RuntimeException); virtual ~ProxyRoot(); inline ProxyRoot( ::rtl::Reference< FactoryImpl > const & factory, Reference< XInterface > const & xTarget ); ::rtl::Reference< FactoryImpl > m_factory; private: UnoInterfaceReference m_target; }; //============================================================================== struct binuno_Proxy : public uno_Interface { oslInterlockedCount m_nRefCount; ::rtl::Reference< ProxyRoot > m_root; UnoInterfaceReference m_target; OUString m_oid; TypeDescription m_typeDescr; inline binuno_Proxy( ::rtl::Reference< ProxyRoot > const & root, UnoInterfaceReference const & target, OUString const & oid, TypeDescription const & typeDescr ); }; extern "C" { //------------------------------------------------------------------------------ static void SAL_CALL binuno_proxy_free( uno_ExtEnvironment * pEnv, void * pProxy ) { (void) pEnv; // avoid warning about unused parameter binuno_Proxy * proxy = static_cast< binuno_Proxy * >( reinterpret_cast< uno_Interface * >( pProxy ) ); OSL_ASSERT( proxy->m_root->m_factory->m_uno_env.get()->pExtEnv == pEnv ); delete proxy; } //------------------------------------------------------------------------------ static void SAL_CALL binuno_proxy_acquire( uno_Interface * pUnoI ) { binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI ); if (osl_incrementInterlockedCount( &that->m_nRefCount ) == 1) { // rebirth of zombie uno_ExtEnvironment * uno_env = that->m_root->m_factory->m_uno_env.get()->pExtEnv; OSL_ASSERT( uno_env != 0 ); (*uno_env->registerProxyInterface)( uno_env, reinterpret_cast< void ** >( &pUnoI ), binuno_proxy_free, that->m_oid.pData, reinterpret_cast< typelib_InterfaceTypeDescription * >( that->m_typeDescr.get() ) ); OSL_ASSERT( that == static_cast< binuno_Proxy * >( pUnoI ) ); } } //------------------------------------------------------------------------------ static void SAL_CALL binuno_proxy_release( uno_Interface * pUnoI ) { binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI ); if (osl_decrementInterlockedCount( &that->m_nRefCount ) == 0) { uno_ExtEnvironment * uno_env = that->m_root->m_factory->m_uno_env.get()->pExtEnv; OSL_ASSERT( uno_env != 0 ); (*uno_env->revokeInterface)( uno_env, pUnoI ); } } //------------------------------------------------------------------------------ static void SAL_CALL binuno_proxy_dispatch( uno_Interface * pUnoI, const typelib_TypeDescription * pMemberType, void * pReturn, void * pArgs [], uno_Any ** ppException ) { binuno_Proxy * that = static_cast< binuno_Proxy * >( pUnoI ); switch (reinterpret_cast< typelib_InterfaceMemberTypeDescription const * >( pMemberType )->nPosition) { case 0: // queryInterface() { try { Type const & rType = *reinterpret_cast< Type const * >( pArgs[ 0 ] ); Any ret( that->m_root->queryInterface( rType ) ); uno_type_copyAndConvertData( pReturn, &ret, ::getCppuType( &ret ).getTypeLibType(), that->m_root->m_factory->m_cpp2uno.get() ); *ppException = 0; // no exc } catch (RuntimeException &) { Any exc( ::cppu::getCaughtException() ); uno_type_any_constructAndConvert( *ppException, const_cast< void * >(exc.getValue()), exc.getValueTypeRef(), that->m_root->m_factory->m_cpp2uno.get() ); } break; } case 1: // acquire() binuno_proxy_acquire( pUnoI ); *ppException = 0; // no exc break; case 2: // release() binuno_proxy_release( pUnoI ); *ppException = 0; // no exc break; default: that->m_target.dispatch( pMemberType, pReturn, pArgs, ppException ); break; } } } //______________________________________________________________________________ inline binuno_Proxy::binuno_Proxy( ::rtl::Reference< ProxyRoot > const & root, UnoInterfaceReference const & target, OUString const & oid, TypeDescription const & typeDescr ) : m_nRefCount( 1 ), m_root( root ), m_target( target ), m_oid( oid ), m_typeDescr( typeDescr ) { uno_Interface::acquire = binuno_proxy_acquire; uno_Interface::release = binuno_proxy_release; uno_Interface::pDispatcher = binuno_proxy_dispatch; } //______________________________________________________________________________ ProxyRoot::~ProxyRoot() { } //______________________________________________________________________________ inline ProxyRoot::ProxyRoot( ::rtl::Reference< FactoryImpl > const & factory, Reference< XInterface > const & xTarget ) : m_factory( factory ) { m_factory->m_cpp2uno.mapInterface( reinterpret_cast< void ** >( &m_target.m_pUnoI ), xTarget.get(), ::getCppuType( &xTarget ) ); OSL_ENSURE( m_target.is(), "### mapping interface failed!" ); } //______________________________________________________________________________ Any ProxyRoot::queryAggregation( Type const & rType ) throw (RuntimeException) { Any ret( OWeakAggObject::queryAggregation( rType ) ); if (! ret.hasValue()) { typelib_TypeDescription * pTypeDescr = 0; TYPELIB_DANGER_GET( &pTypeDescr, rType.getTypeLibType() ); try { Reference< XInterface > xProxy; uno_ExtEnvironment * cpp_env = m_factory->m_cpp_env.get()->pExtEnv; OSL_ASSERT( cpp_env != 0 ); // mind a new delegator, calculate current root: Reference< XInterface > xRoot( static_cast< OWeakObject * >(this), UNO_QUERY_THROW ); OUString oid; (*cpp_env->getObjectIdentifier)( cpp_env, &oid.pData, xRoot.get() ); OSL_ASSERT( oid.getLength() > 0 ); (*cpp_env->getRegisteredInterface)( cpp_env, reinterpret_cast< void ** >( &xProxy ), oid.pData, reinterpret_cast< typelib_InterfaceTypeDescription * >(pTypeDescr) ); if (! xProxy.is()) { // perform query on target: UnoInterfaceReference proxy_target( m_factory->binuno_queryInterface( m_target, reinterpret_cast< typelib_InterfaceTypeDescription * >(pTypeDescr) ) ); if (proxy_target.is()) { // ensure root's object entries: UnoInterfaceReference root; m_factory->m_cpp2uno.mapInterface( reinterpret_cast< void ** >( &root.m_pUnoI ), xRoot.get(), ::getCppuType( &xRoot ) ); UnoInterfaceReference proxy( // ref count initially 1: new binuno_Proxy( this, proxy_target, oid, pTypeDescr ), SAL_NO_ACQUIRE ); uno_ExtEnvironment * uno_env = m_factory->m_uno_env.get()->pExtEnv; OSL_ASSERT( uno_env != 0 ); (*uno_env->registerProxyInterface)( uno_env, reinterpret_cast< void ** >( &proxy.m_pUnoI ), binuno_proxy_free, oid.pData, reinterpret_cast< typelib_InterfaceTypeDescription * >( pTypeDescr ) ); m_factory->m_uno2cpp.mapInterface( reinterpret_cast< void ** >( &xProxy ), proxy.get(), pTypeDescr ); } } if (xProxy.is()) ret.setValue( &xProxy, pTypeDescr ); } catch (...) // finally { TYPELIB_DANGER_RELEASE( pTypeDescr ); throw; } TYPELIB_DANGER_RELEASE( pTypeDescr ); } return ret; } //############################################################################## //______________________________________________________________________________ FactoryImpl::FactoryImpl() { OUString uno = OUSTR(UNO_LB_UNO); OUString cpp = OUSTR(CPPU_CURRENT_LANGUAGE_BINDING_NAME); uno_getEnvironment( reinterpret_cast< uno_Environment ** >( &m_uno_env ), uno.pData, 0 ); OSL_ENSURE( m_uno_env.is(), "### cannot get binary uno env!" ); uno_getEnvironment( reinterpret_cast< uno_Environment ** >( &m_cpp_env ), cpp.pData, 0 ); OSL_ENSURE( m_cpp_env.is(), "### cannot get C++ uno env!" ); uno_getMapping( reinterpret_cast< uno_Mapping ** >( &m_uno2cpp ), m_uno_env.get(), m_cpp_env.get(), 0 ); OSL_ENSURE( m_uno2cpp.is(), "### cannot get bridge uno <-> C++!" ); uno_getMapping( reinterpret_cast< uno_Mapping ** >( &m_cpp2uno ), m_cpp_env.get(), m_uno_env.get(), 0 ); OSL_ENSURE( m_cpp2uno.is(), "### cannot get bridge C++ <-> uno!" ); g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); } //______________________________________________________________________________ FactoryImpl::~FactoryImpl() { g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); } // XProxyFactory //______________________________________________________________________________ Reference< XAggregation > FactoryImpl::createProxy( Reference< XInterface > const & xTarget ) throw (RuntimeException) { return new ProxyRoot( this, xTarget ); } // XServiceInfo //______________________________________________________________________________ OUString FactoryImpl::getImplementationName() throw (RuntimeException) { return proxyfac_getImplementationName();; } //______________________________________________________________________________ sal_Bool FactoryImpl::supportsService( const OUString & rServiceName ) throw (RuntimeException) { Sequence< OUString > const & rSNL = getSupportedServiceNames(); OUString const * pArray = rSNL.getConstArray(); for ( sal_Int32 nPos = rSNL.getLength(); nPos--; ) { if (rServiceName.equals( pArray[ nPos ] )) return true; } return false; } //______________________________________________________________________________ Sequence< OUString > FactoryImpl::getSupportedServiceNames() throw(::com::sun::star::uno::RuntimeException) { return proxyfac_getSupportedServiceNames(); } //============================================================================== static Reference< XInterface > SAL_CALL proxyfac_create( Reference< XComponentContext > const & ) throw (Exception) { Reference< XInterface > xRet; { ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() ); static WeakReference < XInterface > rwInstance; xRet = rwInstance; if (! xRet.is()) { xRet = static_cast< ::cppu::OWeakObject * >(new FactoryImpl); rwInstance = xRet; } } return xRet; } static ::cppu::ImplementationEntry g_entries [] = { { proxyfac_create, proxyfac_getImplementationName, proxyfac_getSupportedServiceNames, ::cppu::createSingleComponentFactory, &g_moduleCount.modCnt, 0 }, { 0, 0, 0, 0, 0, 0 } }; } extern "C" { sal_Bool SAL_CALL component_canUnload( TimeValue * pTime ) { return g_moduleCount.canUnload( &g_moduleCount, pTime ); } void SAL_CALL component_getImplementationEnvironment( const sal_Char ** ppEnvTypeName, uno_Environment ** ) { *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; } void * SAL_CALL component_getFactory( const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey ) { return ::cppu::component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey, g_entries ); } }