| /************************************************************** |
| * |
| * 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 "sal/config.h" |
| |
| #include <exception> |
| #include <vector> |
| |
| #include "cppuhelper/exc_hlp.hxx" |
| #include "osl/diagnose.h" |
| #include "rtl/ref.hxx" |
| #include "rtl/ustring.hxx" |
| #include "sal/types.h" |
| #include "typelib/typedescription.h" |
| #include "typelib/typedescription.hxx" |
| #include "uno/any2.h" |
| #include "uno/dispatcher.h" |
| #include "uno/dispatcher.hxx" |
| |
| #include "binaryany.hxx" |
| #include "bridge.hxx" |
| #include "proxy.hxx" |
| |
| namespace binaryurp { |
| |
| namespace { |
| |
| namespace css = com::sun::star; |
| |
| extern "C" void SAL_CALL proxy_acquireInterface(uno_Interface * pInterface) { |
| OSL_ASSERT(pInterface != 0); |
| static_cast< Proxy * >(pInterface)->do_acquire(); |
| } |
| |
| extern "C" void SAL_CALL proxy_releaseInterface(uno_Interface * pInterface) { |
| OSL_ASSERT(pInterface != 0); |
| static_cast< Proxy * >(pInterface)->do_release(); |
| } |
| |
| extern "C" void SAL_CALL proxy_dispatchInterface( |
| uno_Interface * pUnoI, typelib_TypeDescription const * pMemberType, |
| void * pReturn, void ** pArgs, uno_Any ** ppException) |
| { |
| OSL_ASSERT(pUnoI != 0); |
| static_cast< Proxy * >(pUnoI)->do_dispatch( |
| pMemberType, pReturn, pArgs, ppException); |
| } |
| |
| } |
| |
| Proxy::Proxy( |
| rtl::Reference< Bridge > const & bridge, rtl::OUString const & oid, |
| css::uno::TypeDescription const & type): |
| bridge_(bridge), oid_(oid), type_(type), references_(1) |
| { |
| OSL_ASSERT(bridge.is()); |
| acquire = &proxy_acquireInterface; |
| release = &proxy_releaseInterface; |
| pDispatcher = &proxy_dispatchInterface; |
| } |
| |
| rtl::OUString Proxy::getOid() const { |
| return oid_; |
| } |
| |
| css::uno::TypeDescription Proxy::getType() const { |
| return type_; |
| } |
| |
| void Proxy::do_acquire() { |
| if (osl_incrementInterlockedCount(&references_) == 1) { |
| bridge_->resurrectProxy(*this); |
| } |
| } |
| |
| void Proxy::do_release() { |
| if (osl_decrementInterlockedCount(&references_) == 0) { |
| bridge_->revokeProxy(*this); |
| } |
| } |
| |
| void Proxy::do_free() { |
| bridge_->freeProxy(*this); |
| delete this; |
| } |
| |
| void Proxy::do_dispatch( |
| typelib_TypeDescription const * member, void * returnValue, |
| void ** arguments, uno_Any ** exception) const |
| { |
| try { |
| try { |
| do_dispatch_throw(member, returnValue, arguments, exception); |
| } catch (std::exception & e) { |
| throw css::uno::RuntimeException( |
| (rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM("caught C++ exception: ")) + |
| rtl::OStringToOUString( |
| rtl::OString(e.what()), RTL_TEXTENCODING_ASCII_US)), |
| css::uno::Reference< css::uno::XInterface >()); |
| // best-effort string conversion |
| } |
| } catch (css::uno::RuntimeException &) { |
| css::uno::Any exc(cppu::getCaughtException()); |
| uno_copyAndConvertData( |
| *exception, &exc, |
| (css::uno::TypeDescription(cppu::UnoType< css::uno::Any >::get()). |
| get()), |
| bridge_->getCppToBinaryMapping().get()); |
| } |
| } |
| |
| bool Proxy::isProxy( |
| rtl::Reference< Bridge > const & bridge, |
| css::uno::UnoInterfaceReference const & object, rtl::OUString * oid) |
| { |
| OSL_ASSERT(object.is()); |
| return object.m_pUnoI->acquire == &proxy_acquireInterface && |
| static_cast< Proxy * >(object.m_pUnoI)->isProxy(bridge, oid); |
| } |
| |
| Proxy::~Proxy() {} |
| |
| void Proxy::do_dispatch_throw( |
| typelib_TypeDescription const * member, void * returnValue, |
| void ** arguments, uno_Any ** exception) const |
| { |
| //TODO: Optimize queryInterface: |
| OSL_ASSERT(member != 0); |
| bool setter = false; |
| std::vector< BinaryAny > inArgs; |
| switch (member->eTypeClass) { |
| case typelib_TypeClass_INTERFACE_ATTRIBUTE: |
| setter = returnValue == 0; |
| if (setter) { |
| inArgs.push_back( |
| BinaryAny( |
| css::uno::TypeDescription( |
| reinterpret_cast< |
| typelib_InterfaceAttributeTypeDescription const * >( |
| member)-> |
| pAttributeTypeRef), |
| arguments[0])); |
| } |
| break; |
| case typelib_TypeClass_INTERFACE_METHOD: |
| { |
| typelib_InterfaceMethodTypeDescription const * mtd = |
| reinterpret_cast< |
| typelib_InterfaceMethodTypeDescription const * >(member); |
| for (sal_Int32 i = 0; i != mtd->nParams; ++i) { |
| if (mtd->pParams[i].bIn) { |
| inArgs.push_back( |
| BinaryAny( |
| css::uno::TypeDescription(mtd->pParams[i].pTypeRef), |
| arguments[i])); |
| } |
| } |
| break; |
| } |
| default: |
| OSL_ASSERT(false); // this cannot happen |
| break; |
| } |
| BinaryAny ret; |
| std::vector< BinaryAny > outArgs; |
| if (bridge_->makeCall( |
| oid_, |
| css::uno::TypeDescription( |
| const_cast< typelib_TypeDescription * >(member)), |
| setter, inArgs, &ret, &outArgs)) |
| { |
| OSL_ASSERT( |
| ret.getType().get()->eTypeClass == typelib_TypeClass_EXCEPTION); |
| uno_any_construct( |
| *exception, ret.getValue(ret.getType()), ret.getType().get(), 0); |
| } else { |
| switch (member->eTypeClass) { |
| case typelib_TypeClass_INTERFACE_ATTRIBUTE: |
| if (!setter) { |
| css::uno::TypeDescription t( |
| reinterpret_cast< |
| typelib_InterfaceAttributeTypeDescription const * >( |
| member)-> |
| pAttributeTypeRef); |
| uno_copyData(returnValue, ret.getValue(t), t.get(), 0); |
| } |
| break; |
| case typelib_TypeClass_INTERFACE_METHOD: |
| { |
| typelib_InterfaceMethodTypeDescription const * mtd = |
| reinterpret_cast< |
| typelib_InterfaceMethodTypeDescription const * >( |
| member); |
| css::uno::TypeDescription t(mtd->pReturnTypeRef); |
| if (t.get()->eTypeClass != typelib_TypeClass_VOID) { |
| uno_copyData(returnValue, ret.getValue(t), t.get(), 0); |
| } |
| std::vector< BinaryAny >::iterator i(outArgs.begin()); |
| for (sal_Int32 j = 0; j != mtd->nParams; ++j) { |
| if (mtd->pParams[j].bOut) { |
| css::uno::TypeDescription pt(mtd->pParams[j].pTypeRef); |
| if (mtd->pParams[j].bIn) { |
| uno_assignData( |
| arguments[j], pt.get(), i++->getValue(pt), |
| pt.get(), 0, 0, 0); |
| } else { |
| uno_copyData( |
| arguments[j], i++->getValue(pt), pt.get(), 0); |
| } |
| } |
| } |
| OSL_ASSERT(i == outArgs.end()); |
| break; |
| } |
| default: |
| OSL_ASSERT(false); // this cannot happen |
| break; |
| } |
| *exception = 0; |
| } |
| } |
| |
| bool Proxy::isProxy( |
| rtl::Reference< Bridge > const & bridge, rtl::OUString * oid) const |
| { |
| OSL_ASSERT(oid != 0); |
| if (bridge == bridge_) { |
| *oid = oid_; |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| } |
