cppuhelper/source/exc_thrower.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <rtl/instance.hxx>
  22 #include <osl/diagnose.h>
  23 #include <osl/doublecheckedlocking.h>
  24 #include <uno/dispatcher.hxx>
  25 #include <uno/lbnames.h>
  26 #include <uno/mapping.hxx>
  27 #include <cppuhelper/detail/XExceptionThrower.hpp>
  28 #include <com/sun/star/uno/RuntimeException.hpp>
  29
  30 #include <cppuhelper/exc_hlp.hxx>
  31
  32 using namespace ::osl;
  33 using namespace ::cppu;
  34 using namespace ::com::sun::star;
  35 using namespace ::com::sun::star::uno;
  36
  37 namespace
  38 {
  39
  40 using cppuhelper::detail::XExceptionThrower;
  41
  42
  43 struct ExceptionThrower : public uno_Interface, XExceptionThrower
  44 {
  45     inline ExceptionThrower();
  46
  47     virtual ~ExceptionThrower() {}
  48
  49     static Type const & getCppuType()
  50     {
  51         return cppu::UnoType<XExceptionThrower>::get();
  52     }
  53
  54     // XInterface
  55     virtual Any SAL_CALL queryInterface( Type const & type ) override;
  56     virtual void SAL_CALL acquire() throw () override;
  57     virtual void SAL_CALL release() throw () override;
  58
  59     // XExceptionThrower
  60     virtual void SAL_CALL throwException( Any const & exc ) override;
  61     virtual void SAL_CALL rethrowException() override;
  62 };
  63
  64 extern "C"
  65 {
  66
  67
  68 void ExceptionThrower_acquire_release_nop(
  69     SAL_UNUSED_PARAMETER uno_Interface * )
  70 {}
  71
  72
  73 void ExceptionThrower_dispatch(
  74     uno_Interface * pUnoI, typelib_TypeDescription const * pMemberType,
  75     void * pReturn, void * pArgs [], uno_Any ** ppException )
  76 {
  77     OSL_ASSERT( pMemberType->eTypeClass == typelib_TypeClass_INTERFACE_METHOD );
  78
  79     switch (reinterpret_cast< typelib_InterfaceMemberTypeDescription * >(
  80                 const_cast< typelib_TypeDescription * >( pMemberType ) )->
  81             nPosition)
  82     {
  83     case 0: // queryInterface()
  84     {
  85         Type const & rType_demanded =
  86             *static_cast< Type const * >( pArgs[ 0 ] );
  87         if (rType_demanded.equals( cppu::UnoType<XInterface>::get() ) ||
  88             rType_demanded.equals( ExceptionThrower::getCppuType() ))
  89         {
  90             typelib_TypeDescription * pTD = nullptr;
  91             TYPELIB_DANGER_GET( &pTD, rType_demanded.getTypeLibType() );
  92             uno_any_construct(
  93                 static_cast< uno_Any * >( pReturn ), &pUnoI, pTD, nullptr );
  94             TYPELIB_DANGER_RELEASE( pTD );
  95         }
  96         else
  97         {
  98             uno_any_construct(
  99                 static_cast< uno_Any * >( pReturn ), nullptr, nullptr, nullptr );
 100         }
 101         *ppException = nullptr;
 102         break;
 103     }
 104     case 1: // acquire()
 105     case 2: // release()
 106         *ppException = nullptr;
 107         break;
 108     case 3: // throwException()
 109     {
 110         uno_Any * pAny = static_cast< uno_Any * >( pArgs[ 0 ] );
 111         OSL_ASSERT( pAny->pType->eTypeClass == typelib_TypeClass_EXCEPTION );
 112         uno_type_any_construct( *ppException, pAny->pData, pAny->pType, nullptr );
 113         break;
 114     }
 115     default:
 116     {
 117         OSL_ASSERT( false );
 118         RuntimeException exc( "not implemented!" );
 119         uno_type_any_construct(
 120             *ppException, &exc, cppu::UnoType<decltype(exc)>::get().getTypeLibType(), nullptr );
 121         break;
 122     }
 123     }
 124 }
 125
 126 } // extern "C"
 127
 128
 129 Any ExceptionThrower::queryInterface( Type const & type )
 130 {
 131     if (type.equals( cppu::UnoType<XInterface>::get() ) ||
 132         type.equals( ExceptionThrower::getCppuType() ))
 133     {
 134         XExceptionThrower * that = static_cast< XExceptionThrower * >( this );
 135         return Any( &that, type );
 136     }
 137     return Any();
 138 }
 139
 140
 141 void ExceptionThrower::acquire() throw ()
 142 {
 143 }
 144
 145 void ExceptionThrower::release() throw ()
 146 {
 147 }
 148
 149
 150 void ExceptionThrower::throwException( Any const & exc )
 151 {
 152     OSL_FAIL( "unexpected!" );
 153     cppu::throwException( exc );
 154 }
 155
 156
 157 void ExceptionThrower::rethrowException()
 158 {
 159     throw;
 160 }
 161
 162
 163 inline ExceptionThrower::ExceptionThrower()
 164 {
 165     uno_Interface::acquire = ExceptionThrower_acquire_release_nop;
 166     uno_Interface::release = ExceptionThrower_acquire_release_nop;
 167     uno_Interface::pDispatcher = ExceptionThrower_dispatch;
 168 }
 169
 170 class theExceptionThrower : public rtl::Static<ExceptionThrower, theExceptionThrower> {};
 171
 172 } // anonymous namespace
 173
 174
 175 namespace cppu
 176 {
 177
 178
 179 void SAL_CALL throwException( Any const & exc )
 180 {
 181     if (exc.getValueTypeClass() != TypeClass_EXCEPTION)
 182     {
 183         throw RuntimeException(
 184             "no UNO exception given "
 185             "(must be derived from com::sun::star::uno::Exception)!" );
 186     }
 187
 188     Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent());
 189     if (! uno2cpp.is())
 190     {
 191         throw RuntimeException(
 192             "cannot get binary UNO to C++ mapping!" );
 193     }
 194
 195     Reference< XExceptionThrower > xThrower;
 196     uno2cpp.mapInterface(
 197         reinterpret_cast< void ** >( &xThrower ),
 198         static_cast< uno_Interface * >( &theExceptionThrower::get() ),
 199         ExceptionThrower::getCppuType() );
 200     OSL_ASSERT( xThrower.is() );
 201     xThrower->throwException( exc );
 202 }
 203
 204
 205 Any SAL_CALL getCaughtException()
 206 {
 207     Mapping cpp2uno(Environment::getCurrent(), Environment(UNO_LB_UNO));
 208     if (! cpp2uno.is())
 209     {
 210         throw RuntimeException(
 211             "cannot get C++ to binary UNO mapping!" );
 212     }
 213     Mapping uno2cpp(Environment(UNO_LB_UNO), Environment::getCurrent());
 214     if (! uno2cpp.is())
 215     {
 216         throw RuntimeException(
 217             "cannot get binary UNO to C++ mapping!" );
 218     }
 219
 220     typelib_TypeDescription * pTD = nullptr;
 221     TYPELIB_DANGER_GET(
 222         &pTD, ExceptionThrower::getCppuType().getTypeLibType() );
 223
 224     UnoInterfaceReference unoI;
 225     cpp2uno.mapInterface(
 226         reinterpret_cast< void ** >( &unoI.m_pUnoI ),
 227         static_cast< XExceptionThrower * >( &theExceptionThrower::get() ), pTD );
 228     OSL_ASSERT( unoI.is() );
 229
 230     typelib_TypeDescription * pMemberTD = nullptr;
 231     TYPELIB_DANGER_GET(
 232         &pMemberTD,
 233         reinterpret_cast< typelib_InterfaceTypeDescription * >( pTD )->
 234         ppMembers[ 1 ] /* rethrowException() */ );
 235
 236     uno_Any exc_mem;
 237     uno_Any * exc = &exc_mem;
 238     unoI.dispatch( pMemberTD, nullptr, nullptr, &exc );
 239
 240     TYPELIB_DANGER_RELEASE( pMemberTD );
 241     TYPELIB_DANGER_RELEASE( pTD );
 242
 243     if (exc == nullptr)
 244     {
 245         throw RuntimeException( "rethrowing C++ exception failed!" );
 246     }
 247
 248     Any ret;
 249     uno_any_destruct( &ret, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 250     uno_type_any_constructAndConvert(
 251         &ret, exc->pData, exc->pType, uno2cpp.get() );
 252     uno_any_destruct( exc, nullptr );
 253     return ret;
 254 }
 255
 256 }
 257
 258 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */