LCOV - code coverage report
Current view: top level - stoc/source/corereflection - criface.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 414 0.0 %
Date: 2014-04-14 Functions: 0 45 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <sal/config.h>
      22             : #ifdef SAL_UNX
      23             : #include <sal/alloca.h>
      24             : #endif
      25             : #if !(defined(MACOSX) || defined(IOS) || defined(FREEBSD))
      26             : #include <malloc.h>
      27             : #endif
      28             : #include <rtl/alloc.h>
      29             : #include <typelib/typedescription.hxx>
      30             : #include <uno/data.h>
      31             : 
      32             : #include "base.hxx"
      33             : 
      34             : #include "com/sun/star/lang/WrappedTargetRuntimeException.hpp"
      35             : #include "com/sun/star/uno/RuntimeException.hpp"
      36             : #include "cppuhelper/exc_hlp.hxx"
      37             : 
      38             : namespace stoc_corefl
      39             : {
      40             : 
      41             : 
      42           0 : class IdlAttributeFieldImpl
      43             :     : public IdlMemberImpl
      44             :     , public XIdlField
      45             :     , public XIdlField2
      46             : {
      47             : public:
      48           0 :     typelib_InterfaceAttributeTypeDescription * getAttributeTypeDescr()
      49           0 :         { return (typelib_InterfaceAttributeTypeDescription *)getTypeDescr(); }
      50             : 
      51           0 :     IdlAttributeFieldImpl( IdlReflectionServiceImpl * pReflection, const OUString & rName,
      52             :                            typelib_TypeDescription * pTypeDescr, typelib_TypeDescription * pDeclTypeDescr )
      53           0 :         : IdlMemberImpl( pReflection, rName, pTypeDescr, pDeclTypeDescr )
      54           0 :         {}
      55             : 
      56             :     // XInterface
      57             :     virtual Any SAL_CALL queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      58             :     virtual void SAL_CALL acquire() throw() SAL_OVERRIDE;
      59             :     virtual void SAL_CALL release() throw() SAL_OVERRIDE;
      60             : 
      61             :     // XTypeProvider
      62             :     virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      63             :     virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      64             : 
      65             :     // XIdlMember
      66             :     virtual Reference< XIdlClass > SAL_CALL getDeclaringClass() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      67             :     virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      68             :     // XIdlField
      69             :     virtual Reference< XIdlClass > SAL_CALL getType() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      70             :     virtual FieldAccessMode SAL_CALL getAccessMode() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      71             :     virtual Any SAL_CALL get( const Any & rObj ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      72             :     virtual void SAL_CALL set( const Any & rObj, const Any & rValue ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      73             :     // XIdlField2: getType, getAccessMode and get are equal to XIdlField
      74             :     virtual void SAL_CALL set( Any & rObj, const Any & rValue ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
      75             : 
      76             : private:
      77             :     void checkException(
      78             :         uno_Any * exception, Reference< XInterface > const & context);
      79             : };
      80             : 
      81             : // XInterface
      82             : 
      83           0 : Any IdlAttributeFieldImpl::queryInterface( const Type & rType )
      84             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
      85             : {
      86             :     Any aRet( ::cppu::queryInterface( rType,
      87             :                                       static_cast< XIdlField * >( this ),
      88           0 :                                       static_cast< XIdlField2 * >( this ) ) );
      89           0 :     return (aRet.hasValue() ? aRet : IdlMemberImpl::queryInterface( rType ));
      90             : }
      91             : 
      92           0 : void IdlAttributeFieldImpl::acquire() throw()
      93             : {
      94           0 :     IdlMemberImpl::acquire();
      95           0 : }
      96             : 
      97           0 : void IdlAttributeFieldImpl::release() throw()
      98             : {
      99           0 :     IdlMemberImpl::release();
     100           0 : }
     101             : 
     102             : // XTypeProvider
     103             : 
     104           0 : Sequence< Type > IdlAttributeFieldImpl::getTypes()
     105             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     106             : {
     107             :     static OTypeCollection * s_pTypes = 0;
     108           0 :     if (! s_pTypes)
     109             :     {
     110           0 :         MutexGuard aGuard( getMutexAccess() );
     111           0 :         if (! s_pTypes)
     112             :         {
     113             :             static OTypeCollection s_aTypes(
     114           0 :                 ::getCppuType( (const Reference< XIdlField2 > *)0 ),
     115           0 :                 ::getCppuType( (const Reference< XIdlField > *)0 ),
     116           0 :                 IdlMemberImpl::getTypes() );
     117           0 :             s_pTypes = &s_aTypes;
     118           0 :         }
     119             :     }
     120           0 :     return s_pTypes->getTypes();
     121             : }
     122             : 
     123           0 : Sequence< sal_Int8 > IdlAttributeFieldImpl::getImplementationId()
     124             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     125             : {
     126           0 :     return css::uno::Sequence<sal_Int8>();
     127             : }
     128             : 
     129             : // XIdlMember
     130             : 
     131           0 : Reference< XIdlClass > IdlAttributeFieldImpl::getDeclaringClass()
     132             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     133             : {
     134           0 :     if (! _xDeclClass.is())
     135             :     {
     136           0 :         MutexGuard aGuard( getMutexAccess() );
     137           0 :         if (! _xDeclClass.is())
     138             :         {
     139           0 :             OUString aName(getAttributeTypeDescr()->aBase.aBase.pTypeName);
     140           0 :             sal_Int32 i = aName.indexOf(':');
     141             :             OSL_ASSERT(i >= 0);
     142           0 :             _xDeclClass = getReflection()->forName(aName.copy(0, i));
     143           0 :         }
     144             :     }
     145           0 :     return _xDeclClass;
     146             : }
     147             : 
     148           0 : OUString IdlAttributeFieldImpl::getName()
     149             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     150             : {
     151           0 :     return IdlMemberImpl::getName();
     152             : }
     153             : 
     154             : // XIdlField
     155             : 
     156           0 : Reference< XIdlClass > IdlAttributeFieldImpl::getType()
     157             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     158             : {
     159             :     return getReflection()->forType(
     160           0 :         getAttributeTypeDescr()->pAttributeTypeRef );
     161             : }
     162             : 
     163           0 : FieldAccessMode IdlAttributeFieldImpl::getAccessMode()
     164             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     165             : {
     166           0 :     return (((typelib_InterfaceAttributeTypeDescription *)getAttributeTypeDescr())->bReadOnly
     167           0 :             ? FieldAccessMode_READONLY : FieldAccessMode_READWRITE);
     168             : }
     169             : 
     170           0 : Any IdlAttributeFieldImpl::get( const Any & rObj )
     171             :     throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException, std::exception)
     172             : {
     173             :     uno_Interface * pUnoI = getReflection()->mapToUno(
     174           0 :         rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
     175             :     OSL_ENSURE( pUnoI, "### illegal destination object given!" );
     176           0 :     if (pUnoI)
     177             :     {
     178           0 :         TypeDescription aTD( getAttributeTypeDescr()->pAttributeTypeRef );
     179           0 :         typelib_TypeDescription * pTD = aTD.get();
     180             : 
     181             :         uno_Any aExc;
     182           0 :         uno_Any * pExc = &aExc;
     183           0 :         void * pReturn = alloca( pTD->nSize );
     184             : 
     185           0 :         (*pUnoI->pDispatcher)( pUnoI, getTypeDescr(), pReturn, 0, &pExc );
     186           0 :         (*pUnoI->release)( pUnoI );
     187             : 
     188             :         checkException(
     189             :             pExc,
     190           0 :             *static_cast< Reference< XInterface > const * >(rObj.getValue()));
     191           0 :         Any aRet;
     192             :         uno_any_destruct(
     193           0 :             &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
     194           0 :         uno_any_constructAndConvert( &aRet, pReturn, pTD, getReflection()->getUno2Cpp().get() );
     195           0 :         uno_destructData( pReturn, pTD, 0 );
     196           0 :         return aRet;
     197             :     }
     198             :     throw IllegalArgumentException(
     199             :         OUString("illegal object given!"),
     200           0 :         (XWeak *)(OWeakObject *)this, 0 );
     201             : }
     202             : 
     203           0 : void IdlAttributeFieldImpl::set( Any & rObj, const Any & rValue )
     204             :     throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException, std::exception)
     205             : {
     206           0 :     if (getAttributeTypeDescr()->bReadOnly)
     207             :     {
     208             :         throw IllegalAccessException(
     209             :             OUString("cannot set readonly attribute!"),
     210           0 :             (XWeak *)(OWeakObject *)this );
     211             :     }
     212             : 
     213             :     uno_Interface * pUnoI = getReflection()->mapToUno(
     214           0 :         rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
     215             :     OSL_ENSURE( pUnoI, "### illegal destination object given!" );
     216           0 :     if (pUnoI)
     217             :     {
     218           0 :         TypeDescription aTD( getAttributeTypeDescr()->pAttributeTypeRef );
     219           0 :         typelib_TypeDescription * pTD = aTD.get();
     220             : 
     221             :         // construct uno value to be set
     222             :         void * pArgs[1];
     223           0 :         void * pArg = pArgs[0] = alloca( pTD->nSize );
     224             : 
     225             :         sal_Bool bAssign;
     226           0 :         if (pTD->eTypeClass == typelib_TypeClass_ANY)
     227             :         {
     228             :             uno_copyAndConvertData( pArg, (const_cast< Any * >(&rValue)),
     229           0 :                                     pTD, getReflection()->getCpp2Uno().get() );
     230           0 :             bAssign = sal_True;
     231             :         }
     232           0 :         else if (typelib_typedescriptionreference_equals( rValue.getValueTypeRef(), pTD->pWeakRef ))
     233             :         {
     234           0 :             uno_copyAndConvertData( pArg, (const_cast< void * >(rValue.getValue()) ),
     235           0 :                                     pTD, getReflection()->getCpp2Uno().get() );
     236           0 :             bAssign = sal_True;
     237             :         }
     238           0 :         else if (pTD->eTypeClass == typelib_TypeClass_INTERFACE)
     239             :         {
     240           0 :             Reference< XInterface > xObj;
     241             :             bAssign = extract(
     242             :                 rValue, (typelib_InterfaceTypeDescription *)pTD, xObj,
     243           0 :                 getReflection() );
     244           0 :             if (bAssign)
     245             :             {
     246           0 :                 *(void **)pArg = getReflection()->getCpp2Uno().mapInterface(
     247           0 :                     xObj.get(), (typelib_InterfaceTypeDescription *)pTD );
     248           0 :             }
     249             :         }
     250             :         else
     251             :         {
     252           0 :             typelib_TypeDescription * pValueTD = 0;
     253           0 :             TYPELIB_DANGER_GET( &pValueTD, rValue.getValueTypeRef() );
     254             :             // construct temp uno val to do proper assignment: todo opt
     255           0 :             void * pTemp = alloca( pValueTD->nSize );
     256             :             uno_copyAndConvertData(
     257           0 :                 pTemp, (void *)rValue.getValue(), pValueTD, getReflection()->getCpp2Uno().get() );
     258             :             uno_constructData(
     259           0 :                 pArg, pTD );
     260             :             // assignment does simple conversion
     261             :             bAssign = uno_assignData(
     262           0 :                 pArg, pTD, pTemp, pValueTD, 0, 0, 0 );
     263             :             uno_destructData(
     264           0 :                 pTemp, pValueTD, 0 );
     265           0 :             TYPELIB_DANGER_RELEASE( pValueTD );
     266             :         }
     267             : 
     268           0 :         if (bAssign)
     269             :         {
     270             :             uno_Any aExc;
     271           0 :             uno_Any * pExc = &aExc;
     272           0 :             (*pUnoI->pDispatcher)( pUnoI, getTypeDescr(), 0, pArgs, &pExc );
     273           0 :             (*pUnoI->release)( pUnoI );
     274             : 
     275           0 :             uno_destructData( pArg, pTD, 0 );
     276             :             checkException(
     277             :                 pExc,
     278             :                 *static_cast< Reference< XInterface > const * >(
     279           0 :                     rObj.getValue()));
     280           0 :             return;
     281             :         }
     282           0 :         (*pUnoI->release)( pUnoI );
     283             : 
     284             :         throw IllegalArgumentException(
     285             :             OUString("illegal value given!"),
     286           0 :             *(const Reference< XInterface > *)rObj.getValue(), 1 );
     287             :     }
     288             :     throw IllegalArgumentException(
     289             :         OUString("illegal destination object given!"),
     290           0 :         (XWeak *)(OWeakObject *)this, 0 );
     291             : }
     292             : 
     293           0 : void IdlAttributeFieldImpl::set( const Any & rObj, const Any & rValue )
     294             :     throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::IllegalAccessException, ::com::sun::star::uno::RuntimeException, std::exception)
     295             : {
     296           0 :     IdlAttributeFieldImpl::set( const_cast< Any & >( rObj ), rValue );
     297           0 : }
     298             : 
     299           0 : void IdlAttributeFieldImpl::checkException(
     300             :     uno_Any * exception, Reference< XInterface > const & context)
     301             : {
     302           0 :     if (exception != 0) {
     303           0 :         Any e;
     304           0 :         uno_any_destruct(&e, reinterpret_cast< uno_ReleaseFunc >(cpp_release));
     305             :         uno_type_any_constructAndConvert(
     306             :             &e, exception->pData, exception->pType,
     307           0 :             getReflection()->getUno2Cpp().get());
     308           0 :         uno_any_destruct(exception, 0);
     309           0 :         if (e.isExtractableTo(
     310           0 :                 getCppuType(static_cast< RuntimeException const * >(0))))
     311             :         {
     312           0 :             cppu::throwException(e);
     313             :         } else {
     314             :             throw WrappedTargetRuntimeException(
     315             :                 OUString(
     316             :                         "non-RuntimeException occurred when accessing an"
     317             :                         " interface type attribute"),
     318           0 :                 context, e);
     319           0 :         }
     320             :     }
     321           0 : }
     322             : 
     323             : 
     324             : 
     325             : 
     326             : 
     327             : 
     328             : 
     329             : class IdlInterfaceMethodImpl
     330             :     : public IdlMemberImpl
     331             :     , public XIdlMethod
     332             : {
     333             :     Sequence< Reference< XIdlClass > > * _pExceptionTypes;
     334             :     Sequence< Reference< XIdlClass > > * _pParamTypes;
     335             :     Sequence< ParamInfo > *              _pParamInfos;
     336             : 
     337             : public:
     338           0 :     typelib_InterfaceMethodTypeDescription * getMethodTypeDescr()
     339           0 :         { return (typelib_InterfaceMethodTypeDescription *)getTypeDescr(); }
     340             : 
     341           0 :     IdlInterfaceMethodImpl( IdlReflectionServiceImpl * pReflection, const OUString & rName,
     342             :                             typelib_TypeDescription * pTypeDescr, typelib_TypeDescription * pDeclTypeDescr )
     343             :         : IdlMemberImpl( pReflection, rName, pTypeDescr, pDeclTypeDescr )
     344             :         , _pExceptionTypes( 0 )
     345             :         , _pParamTypes( 0 )
     346           0 :         , _pParamInfos( 0 )
     347           0 :         {}
     348             :     virtual ~IdlInterfaceMethodImpl();
     349             : 
     350             :     // XInterface
     351             :     virtual Any SAL_CALL queryInterface( const Type & rType ) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     352             :     virtual void SAL_CALL acquire() throw() SAL_OVERRIDE;
     353             :     virtual void SAL_CALL release() throw() SAL_OVERRIDE;
     354             : 
     355             :     // XTypeProvider
     356             :     virtual Sequence< Type > SAL_CALL getTypes() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     357             :     virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() throw (::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     358             : 
     359             :     // XIdlMember
     360             :     virtual Reference< XIdlClass > SAL_CALL getDeclaringClass() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     361             :     virtual OUString SAL_CALL getName() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     362             :     // XIdlMethod
     363             :     virtual Reference< XIdlClass > SAL_CALL getReturnType() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     364             :     virtual Sequence< Reference< XIdlClass > > SAL_CALL getParameterTypes() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     365             :     virtual Sequence< ParamInfo > SAL_CALL getParameterInfos() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     366             :     virtual Sequence< Reference< XIdlClass > > SAL_CALL getExceptionTypes() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     367             :     virtual MethodMode SAL_CALL getMode() throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     368             :     virtual Any SAL_CALL invoke( const Any & rObj, Sequence< Any > & rArgs ) throw(::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::reflection::InvocationTargetException, ::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
     369             : };
     370             : 
     371           0 : IdlInterfaceMethodImpl::~IdlInterfaceMethodImpl()
     372             : {
     373           0 :     delete _pParamInfos;
     374           0 :     delete _pParamTypes;
     375           0 :     delete _pExceptionTypes;
     376           0 : }
     377             : 
     378             : // XInterface
     379             : 
     380           0 : Any IdlInterfaceMethodImpl::queryInterface( const Type & rType )
     381             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     382             : {
     383           0 :     Any aRet( ::cppu::queryInterface( rType, static_cast< XIdlMethod * >( this ) ) );
     384           0 :     return (aRet.hasValue() ? aRet : IdlMemberImpl::queryInterface( rType ));
     385             : }
     386             : 
     387           0 : void IdlInterfaceMethodImpl::acquire() throw()
     388             : {
     389           0 :     IdlMemberImpl::acquire();
     390           0 : }
     391             : 
     392           0 : void IdlInterfaceMethodImpl::release() throw()
     393             : {
     394           0 :     IdlMemberImpl::release();
     395           0 : }
     396             : 
     397             : // XTypeProvider
     398             : 
     399           0 : Sequence< Type > IdlInterfaceMethodImpl::getTypes()
     400             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     401             : {
     402             :     static OTypeCollection * s_pTypes = 0;
     403           0 :     if (! s_pTypes)
     404             :     {
     405           0 :         MutexGuard aGuard( getMutexAccess() );
     406           0 :         if (! s_pTypes)
     407             :         {
     408             :             static OTypeCollection s_aTypes(
     409           0 :                 ::getCppuType( (const Reference< XIdlMethod > *)0 ),
     410           0 :                 IdlMemberImpl::getTypes() );
     411           0 :             s_pTypes = &s_aTypes;
     412           0 :         }
     413             :     }
     414           0 :     return s_pTypes->getTypes();
     415             : }
     416             : 
     417           0 : Sequence< sal_Int8 > IdlInterfaceMethodImpl::getImplementationId()
     418             :     throw (::com::sun::star::uno::RuntimeException, std::exception)
     419             : {
     420           0 :     return css::uno::Sequence<sal_Int8>();
     421             : }
     422             : 
     423             : // XIdlMember
     424             : 
     425           0 : Reference< XIdlClass > IdlInterfaceMethodImpl::getDeclaringClass()
     426             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     427             : {
     428           0 :     if (! _xDeclClass.is())
     429             :     {
     430           0 :         MutexGuard aGuard( getMutexAccess() );
     431           0 :         if (! _xDeclClass.is())
     432             :         {
     433           0 :             OUString aName(getMethodTypeDescr()->aBase.aBase.pTypeName);
     434           0 :             sal_Int32 i = aName.indexOf(':');
     435             :             OSL_ASSERT(i >= 0);
     436           0 :             _xDeclClass = getReflection()->forName(aName.copy(0, i));
     437           0 :         }
     438             :     }
     439           0 :     return _xDeclClass;
     440             : }
     441             : 
     442           0 : OUString IdlInterfaceMethodImpl::getName()
     443             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     444             : {
     445           0 :     return IdlMemberImpl::getName();
     446             : }
     447             : 
     448             : // XIdlMethod
     449             : 
     450           0 : Reference< XIdlClass > SAL_CALL IdlInterfaceMethodImpl::getReturnType()
     451             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     452             : {
     453           0 :     return getReflection()->forType( getMethodTypeDescr()->pReturnTypeRef );
     454             : }
     455             : 
     456           0 : Sequence< Reference< XIdlClass > > IdlInterfaceMethodImpl::getExceptionTypes()
     457             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     458             : {
     459           0 :     if (! _pExceptionTypes)
     460             :     {
     461           0 :         MutexGuard aGuard( getMutexAccess() );
     462           0 :         if (! _pExceptionTypes)
     463             :         {
     464           0 :             sal_Int32 nExc = getMethodTypeDescr()->nExceptions;
     465             :             Sequence< Reference< XIdlClass > > * pTempExceptionTypes =
     466           0 :                 new Sequence< Reference< XIdlClass > >( nExc );
     467           0 :             Reference< XIdlClass > * pExceptionTypes = pTempExceptionTypes->getArray();
     468             : 
     469             :             typelib_TypeDescriptionReference ** ppExc =
     470           0 :                 getMethodTypeDescr()->ppExceptions;
     471           0 :             IdlReflectionServiceImpl * pRefl = getReflection();
     472             : 
     473           0 :             while (nExc--)
     474           0 :                 pExceptionTypes[nExc] = pRefl->forType( ppExc[nExc] );
     475             : 
     476           0 :             _pExceptionTypes = pTempExceptionTypes;
     477           0 :         }
     478             :     }
     479           0 :     return *_pExceptionTypes;
     480             : }
     481             : 
     482           0 : Sequence< Reference< XIdlClass > > IdlInterfaceMethodImpl::getParameterTypes()
     483             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     484             : {
     485           0 :     if (! _pParamTypes)
     486             :     {
     487           0 :         MutexGuard aGuard( getMutexAccess() );
     488           0 :         if (! _pParamTypes)
     489             :         {
     490           0 :             sal_Int32 nParams = getMethodTypeDescr()->nParams;
     491             :             Sequence< Reference< XIdlClass > > * pTempParamTypes =
     492           0 :                 new Sequence< Reference< XIdlClass > >( nParams );
     493           0 :             Reference< XIdlClass > * pParamTypes = pTempParamTypes->getArray();
     494             : 
     495             :             typelib_MethodParameter * pTypelibParams =
     496           0 :                 getMethodTypeDescr()->pParams;
     497           0 :             IdlReflectionServiceImpl * pRefl = getReflection();
     498             : 
     499           0 :             while (nParams--)
     500           0 :                 pParamTypes[nParams] = pRefl->forType( pTypelibParams[nParams].pTypeRef );
     501             : 
     502           0 :             _pParamTypes = pTempParamTypes;
     503           0 :         }
     504             :     }
     505           0 :     return *_pParamTypes;
     506             : }
     507             : 
     508           0 : Sequence< ParamInfo > IdlInterfaceMethodImpl::getParameterInfos()
     509             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     510             : {
     511           0 :     if (! _pParamInfos)
     512             :     {
     513           0 :         MutexGuard aGuard( getMutexAccess() );
     514           0 :         if (! _pParamInfos)
     515             :         {
     516           0 :             sal_Int32 nParams = getMethodTypeDescr()->nParams;
     517           0 :             Sequence< ParamInfo > * pTempParamInfos = new Sequence< ParamInfo >( nParams );
     518           0 :             ParamInfo * pParamInfos = pTempParamInfos->getArray();
     519             : 
     520             :             typelib_MethodParameter * pTypelibParams =
     521           0 :                 getMethodTypeDescr()->pParams;
     522             : 
     523           0 :             if (_pParamTypes) // use param types
     524             :             {
     525           0 :                 const Reference< XIdlClass > * pParamTypes = _pParamTypes->getConstArray();
     526             : 
     527           0 :                 while (nParams--)
     528             :                 {
     529           0 :                     const typelib_MethodParameter & rParam = pTypelibParams[nParams];
     530           0 :                     ParamInfo & rInfo = pParamInfos[nParams];
     531           0 :                     rInfo.aName = rParam.pName;
     532           0 :                     if (rParam.bIn)
     533           0 :                         rInfo.aMode = (rParam.bOut ? ParamMode_INOUT : ParamMode_IN);
     534             :                     else
     535           0 :                         rInfo.aMode = ParamMode_OUT;
     536           0 :                     rInfo.aType = pParamTypes[nParams];
     537             :                 }
     538             :             }
     539             :             else // make also param types sequence if not already initialized
     540             :             {
     541             :                 Sequence< Reference< XIdlClass > > * pTempParamTypes =
     542           0 :                     new Sequence< Reference< XIdlClass > >( nParams );
     543           0 :                 Reference< XIdlClass > * pParamTypes = pTempParamTypes->getArray();
     544             : 
     545           0 :                 IdlReflectionServiceImpl * pRefl = getReflection();
     546             : 
     547           0 :                 while (nParams--)
     548             :                 {
     549           0 :                     const typelib_MethodParameter & rParam = pTypelibParams[nParams];
     550           0 :                     ParamInfo & rInfo = pParamInfos[nParams];
     551           0 :                     rInfo.aName = rParam.pName;
     552           0 :                     if (rParam.bIn)
     553           0 :                         rInfo.aMode = (rParam.bOut ? ParamMode_INOUT : ParamMode_IN);
     554             :                     else
     555           0 :                         rInfo.aMode = ParamMode_OUT;
     556           0 :                     rInfo.aType = pParamTypes[nParams] = pRefl->forType( rParam.pTypeRef );
     557             :                 }
     558             : 
     559           0 :                 _pParamTypes = pTempParamTypes;
     560             :             }
     561             : 
     562           0 :             _pParamInfos = pTempParamInfos;
     563           0 :         }
     564             :     }
     565           0 :     return *_pParamInfos;
     566             : }
     567             : 
     568           0 : MethodMode SAL_CALL IdlInterfaceMethodImpl::getMode()
     569             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     570             : {
     571             :     return
     572           0 :         getMethodTypeDescr()->bOneWay ? MethodMode_ONEWAY : MethodMode_TWOWAY;
     573             : }
     574             : 
     575           0 : Any SAL_CALL IdlInterfaceMethodImpl::invoke( const Any & rObj, Sequence< Any > & rArgs )
     576             :     throw(::com::sun::star::lang::IllegalArgumentException,
     577             :           ::com::sun::star::reflection::InvocationTargetException,
     578             :           ::com::sun::star::uno::RuntimeException, std::exception)
     579             : {
     580           0 :     if (rObj.getValueTypeClass() == TypeClass_INTERFACE)
     581             :     {
     582             :         // acquire()/ release()
     583           0 :         if (rtl_ustr_ascii_compare( getTypeDescr()->pTypeName->buffer,
     584           0 :                                     "com.sun.star.uno.XInterface::acquire" ) == 0)
     585             :         {
     586           0 :             (*(const Reference< XInterface > *)rObj.getValue())->acquire();
     587           0 :             return Any();
     588             :         }
     589           0 :         else if (rtl_ustr_ascii_compare( getTypeDescr()->pTypeName->buffer,
     590           0 :                                          "com.sun.star.uno.XInterface::release" ) == 0)
     591             :         {
     592           0 :             (*(const Reference< XInterface > *)rObj.getValue())->release();
     593           0 :             return Any();
     594             :         }
     595             :     }
     596             : 
     597             :     uno_Interface * pUnoI = getReflection()->mapToUno(
     598           0 :         rObj, (typelib_InterfaceTypeDescription *)getDeclTypeDescr() );
     599             :     OSL_ENSURE( pUnoI, "### illegal destination object given!" );
     600           0 :     if (pUnoI)
     601             :     {
     602           0 :         sal_Int32 nParams = getMethodTypeDescr()->nParams;
     603           0 :         if (rArgs.getLength() != nParams)
     604             :         {
     605           0 :             (*pUnoI->release)( pUnoI );
     606             :             throw IllegalArgumentException(
     607             :                 OUString("arguments len differ!"),
     608           0 :                 *(const Reference< XInterface > *)rObj.getValue(), 1 );
     609             :         }
     610             : 
     611           0 :         Any * pCppArgs = rArgs.getArray();
     612           0 :         typelib_MethodParameter * pParams = getMethodTypeDescr()->pParams;
     613           0 :         typelib_TypeDescription * pReturnType = 0;
     614             :         TYPELIB_DANGER_GET(
     615           0 :             &pReturnType, getMethodTypeDescr()->pReturnTypeRef );
     616             : 
     617           0 :         void * pUnoReturn = alloca( pReturnType->nSize );
     618           0 :         void ** ppUnoArgs = (void **)alloca( sizeof(void *) * nParams *2 );
     619           0 :         typelib_TypeDescription ** ppParamTypes = (typelib_TypeDescription **)(ppUnoArgs + nParams);
     620             : 
     621             :         // convert arguments
     622           0 :         for ( sal_Int32 nPos = 0; nPos < nParams; ++nPos )
     623             :         {
     624           0 :             ppParamTypes[nPos] = 0;
     625           0 :             TYPELIB_DANGER_GET( ppParamTypes + nPos, pParams[nPos].pTypeRef );
     626           0 :             typelib_TypeDescription * pTD = ppParamTypes[nPos];
     627             : 
     628           0 :             ppUnoArgs[nPos] = alloca( pTD->nSize );
     629           0 :             if (pParams[nPos].bIn)
     630             :             {
     631             :                 sal_Bool bAssign;
     632           0 :                 if (typelib_typedescriptionreference_equals(
     633           0 :                         pCppArgs[nPos].getValueTypeRef(), pTD->pWeakRef ))
     634             :                 {
     635             :                     uno_type_copyAndConvertData(
     636           0 :                         ppUnoArgs[nPos], (void *)pCppArgs[nPos].getValue(),
     637           0 :                         pCppArgs[nPos].getValueTypeRef(), getReflection()->getCpp2Uno().get() );
     638           0 :                     bAssign = sal_True;
     639             :                 }
     640           0 :                 else if (pTD->eTypeClass == typelib_TypeClass_ANY)
     641             :                 {
     642             :                     uno_type_any_constructAndConvert(
     643           0 :                         (uno_Any *)ppUnoArgs[nPos], (void *)pCppArgs[nPos].getValue(),
     644           0 :                         pCppArgs[nPos].getValueTypeRef(), getReflection()->getCpp2Uno().get() );
     645           0 :                     bAssign = sal_True;
     646             :                 }
     647           0 :                 else if (pTD->eTypeClass == typelib_TypeClass_INTERFACE)
     648             :                 {
     649           0 :                     Reference< XInterface > xDest;
     650             :                     bAssign = extract(
     651             :                         pCppArgs[nPos], (typelib_InterfaceTypeDescription *)pTD,
     652           0 :                         xDest, getReflection() );
     653           0 :                     if (bAssign)
     654             :                     {
     655           0 :                         *(void **)ppUnoArgs[nPos] = getReflection()->getCpp2Uno().mapInterface(
     656           0 :                             xDest.get(), (typelib_InterfaceTypeDescription *)pTD );
     657           0 :                     }
     658             :                 }
     659             :                 else
     660             :                 {
     661           0 :                     typelib_TypeDescription * pValueTD = 0;
     662           0 :                     TYPELIB_DANGER_GET( &pValueTD, pCppArgs[nPos].getValueTypeRef() );
     663             :                     // construct temp uno val to do proper assignment: todo opt
     664           0 :                     void * pTemp = alloca( pValueTD->nSize );
     665             :                     uno_copyAndConvertData(
     666           0 :                         pTemp, (void *)pCppArgs[nPos].getValue(), pValueTD,
     667           0 :                         getReflection()->getCpp2Uno().get() );
     668             :                     uno_constructData(
     669           0 :                         ppUnoArgs[nPos], pTD );
     670             :                     // assignment does simple conversion
     671             :                     bAssign = uno_assignData(
     672           0 :                         ppUnoArgs[nPos], pTD, pTemp, pValueTD, 0, 0, 0 );
     673             :                     uno_destructData(
     674           0 :                         pTemp, pValueTD, 0 );
     675           0 :                     TYPELIB_DANGER_RELEASE( pValueTD );
     676             :                 }
     677             : 
     678           0 :                 if (! bAssign)
     679             :                 {
     680             :                     IllegalArgumentException aExc(
     681             :                         OUString("cannot coerce argument type during corereflection call!"),
     682           0 :                         *(const Reference< XInterface > *)rObj.getValue(), (sal_Int16)nPos );
     683             : 
     684             :                     // cleanup
     685           0 :                     while (nPos--)
     686             :                     {
     687           0 :                         if (pParams[nPos].bIn)
     688           0 :                             uno_destructData( ppUnoArgs[nPos], ppParamTypes[nPos], 0 );
     689           0 :                         TYPELIB_DANGER_RELEASE( ppParamTypes[nPos] );
     690             :                     }
     691           0 :                     TYPELIB_DANGER_RELEASE( pReturnType );
     692           0 :                     (*pUnoI->release)( pUnoI );
     693             : 
     694           0 :                     throw aExc;
     695             :                 }
     696             :             }
     697             :         }
     698             : 
     699             :         uno_Any aUnoExc;
     700           0 :         uno_Any * pUnoExc = &aUnoExc;
     701             : 
     702             :         (*pUnoI->pDispatcher)(
     703           0 :             pUnoI, getTypeDescr(), pUnoReturn, ppUnoArgs, &pUnoExc );
     704           0 :         (*pUnoI->release)( pUnoI );
     705             : 
     706           0 :         Any aRet;
     707           0 :         if (pUnoExc)
     708             :         {
     709             :             // cleanup
     710           0 :             while (nParams--)
     711             :             {
     712           0 :                 if (pParams[nParams].bIn)
     713           0 :                     uno_destructData( ppUnoArgs[nParams], ppParamTypes[nParams], 0 );
     714           0 :                 TYPELIB_DANGER_RELEASE( ppParamTypes[nParams] );
     715             :             }
     716           0 :             TYPELIB_DANGER_RELEASE( pReturnType );
     717             : 
     718           0 :             InvocationTargetException aExc;
     719           0 :             aExc.Context = *(const Reference< XInterface > *)rObj.getValue();
     720           0 :             aExc.Message = "exception occurred during invocation!";
     721             :             uno_any_destruct(
     722             :                 &aExc.TargetException,
     723           0 :                 reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
     724             :             uno_type_copyAndConvertData(
     725           0 :                 &aExc.TargetException, pUnoExc, ::getCppuType( (const Any *)0 ).getTypeLibType(),
     726           0 :                 getReflection()->getUno2Cpp().get() );
     727           0 :             uno_any_destruct( pUnoExc, 0 );
     728           0 :             throw aExc;
     729             :         }
     730             :         else
     731             :         {
     732             :             // reconvert arguments and cleanup
     733           0 :             while (nParams--)
     734             :             {
     735           0 :                 if (pParams[nParams].bOut) // write back
     736             :                 {
     737             :                     uno_any_destruct(
     738           0 :                         &pCppArgs[nParams],
     739           0 :                         reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
     740             :                     uno_any_constructAndConvert(
     741           0 :                         &pCppArgs[nParams], ppUnoArgs[nParams], ppParamTypes[nParams],
     742           0 :                         getReflection()->getUno2Cpp().get() );
     743             :                 }
     744           0 :                 uno_destructData( ppUnoArgs[nParams], ppParamTypes[nParams], 0 );
     745           0 :                 TYPELIB_DANGER_RELEASE( ppParamTypes[nParams] );
     746             :             }
     747             :             uno_any_destruct(
     748           0 :                 &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
     749             :             uno_any_constructAndConvert(
     750             :                 &aRet, pUnoReturn, pReturnType,
     751           0 :                 getReflection()->getUno2Cpp().get() );
     752           0 :             uno_destructData( pUnoReturn, pReturnType, 0 );
     753           0 :             TYPELIB_DANGER_RELEASE( pReturnType );
     754             :         }
     755           0 :         return aRet;
     756             :     }
     757             :     throw IllegalArgumentException(
     758             :         OUString("illegal destination object given!"),
     759           0 :         (XWeak *)(OWeakObject *)this, 0 );
     760             : }
     761             : 
     762             : 
     763             : 
     764             : 
     765             : 
     766             : 
     767             : 
     768             : 
     769           0 : InterfaceIdlClassImpl::~InterfaceIdlClassImpl()
     770             : {
     771           0 :     for ( sal_Int32 nPos = _nMethods + _nAttributes; nPos--; )
     772           0 :         typelib_typedescription_release( _pSortedMemberInit[nPos].second );
     773             : 
     774           0 :     delete [] _pSortedMemberInit;
     775           0 : }
     776             : 
     777             : 
     778           0 : Sequence< Reference< XIdlClass > > InterfaceIdlClassImpl::getSuperclasses()
     779             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     780             : {
     781           0 :     MutexGuard aGuard(getMutexAccess());
     782           0 :     if (_xSuperClasses.getLength() == 0) {
     783           0 :         typelib_InterfaceTypeDescription * pType = getTypeDescr();
     784           0 :         _xSuperClasses.realloc(pType->nBaseTypes);
     785           0 :         for (sal_Int32 i = 0; i < pType->nBaseTypes; ++i) {
     786           0 :             _xSuperClasses[i] = getReflection()->forType(
     787           0 :                 &pType->ppBaseTypes[i]->aBase);
     788             :             OSL_ASSERT(_xSuperClasses[i].is());
     789             :         }
     790             :     }
     791           0 :     return Sequence< Reference< XIdlClass > >(_xSuperClasses);
     792             : }
     793             : 
     794           0 : void InterfaceIdlClassImpl::initMembers()
     795             : {
     796           0 :     sal_Int32 nAll = getTypeDescr()->nAllMembers;
     797           0 :     MemberInit * pSortedMemberInit = new MemberInit[nAll];
     798           0 :     typelib_TypeDescriptionReference ** ppAllMembers = getTypeDescr()->ppAllMembers;
     799             : 
     800           0 :     for ( sal_Int32 nPos = 0; nPos < nAll; ++nPos )
     801             :     {
     802             :         sal_Int32 nIndex;
     803           0 :         if (ppAllMembers[nPos]->eTypeClass == typelib_TypeClass_INTERFACE_METHOD)
     804             :         {
     805             :             // methods to front
     806           0 :             nIndex = _nMethods;
     807           0 :             ++_nMethods;
     808             :         }
     809             :         else
     810             :         {
     811           0 :             ++_nAttributes;
     812           0 :             nIndex = (nAll - _nAttributes);
     813             :             // attributes at the back
     814             :         }
     815             : 
     816           0 :         typelib_TypeDescription * pTD = 0;
     817           0 :         typelib_typedescriptionreference_getDescription( &pTD, ppAllMembers[nPos] );
     818             :         OSL_ENSURE( pTD, "### cannot get type description!" );
     819           0 :         pSortedMemberInit[nIndex].first = ((typelib_InterfaceMemberTypeDescription *)pTD)->pMemberName;
     820           0 :         pSortedMemberInit[nIndex].second = pTD;
     821             :     }
     822             : 
     823           0 :     _pSortedMemberInit = pSortedMemberInit;
     824           0 : }
     825             : 
     826           0 : sal_Bool InterfaceIdlClassImpl::isAssignableFrom( const Reference< XIdlClass > & xType )
     827             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     828             : {
     829           0 :     if (xType.is() && xType->getTypeClass() == TypeClass_INTERFACE)
     830             :     {
     831           0 :         if (equals( xType ))
     832           0 :             return sal_True;
     833             :         else
     834             :         {
     835           0 :             const Sequence< Reference< XIdlClass > > & rSeq = xType->getSuperclasses();
     836           0 :             for (sal_Int32 i = 0; i < rSeq.getLength(); ++i) {
     837           0 :                 if (isAssignableFrom(rSeq[i])) {
     838           0 :                     return true;
     839             :                 }
     840           0 :             }
     841             :         }
     842             :     }
     843           0 :     return sal_False;
     844             : }
     845             : 
     846           0 : Uik InterfaceIdlClassImpl::getUik()
     847             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     848             : {
     849           0 :     return Uik(0, 0, 0, 0, 0);
     850             :         // Uiks are deprecated and this function must not be called
     851             : }
     852             : 
     853           0 : Sequence< Reference< XIdlMethod > > InterfaceIdlClassImpl::getMethods()
     854             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     855             : {
     856           0 :     MutexGuard aGuard( getMutexAccess() );
     857           0 :     if (! _pSortedMemberInit)
     858           0 :         initMembers();
     859             : 
     860             :     // create methods sequence
     861           0 :     Sequence< Reference< XIdlMethod > > aRet( _nMethods );
     862           0 :     Reference< XIdlMethod > * pRet = aRet.getArray();
     863           0 :     for ( sal_Int32 nPos = _nMethods; nPos--; )
     864             :     {
     865             : 
     866           0 :         /*_aName2Method[_pSortedMemberInit[nPos].first] = */pRet[nPos] = new IdlInterfaceMethodImpl(
     867           0 :             getReflection(), _pSortedMemberInit[nPos].first,
     868           0 :             _pSortedMemberInit[nPos].second, IdlClassImpl::getTypeDescr() );
     869             :     }
     870           0 :     return aRet;
     871             : }
     872             : 
     873           0 : Sequence< Reference< XIdlField > > InterfaceIdlClassImpl::getFields()
     874             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     875             : {
     876           0 :     MutexGuard aGuard( getMutexAccess() );
     877           0 :     if (! _pSortedMemberInit)
     878           0 :         initMembers();
     879             : 
     880             :     // create fields sequence
     881           0 :     Sequence< Reference< XIdlField > > aRet( _nAttributes );
     882           0 :     Reference< XIdlField > * pRet = aRet.getArray();
     883           0 :     for ( sal_Int32 nPos = _nAttributes; nPos--; )
     884             :     {
     885           0 :         /*_aName2Field[_pSortedMemberInit[_nMethods+nPos].first] = */pRet[_nAttributes-nPos-1] =
     886             :             new IdlAttributeFieldImpl(
     887           0 :                 getReflection(), _pSortedMemberInit[_nMethods+nPos].first,
     888           0 :                 _pSortedMemberInit[_nMethods+nPos].second, IdlClassImpl::getTypeDescr() );
     889             :     }
     890           0 :     return aRet;
     891             : }
     892             : 
     893           0 : Reference< XIdlMethod > InterfaceIdlClassImpl::getMethod( const OUString & rName )
     894             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     895             : {
     896           0 :     MutexGuard aGuard( getMutexAccess() );
     897           0 :     if (! _pSortedMemberInit)
     898           0 :         initMembers();
     899             : 
     900           0 :     Reference< XIdlMethod > xRet;
     901             : 
     902             :     // try weak map
     903           0 :     const OUString2Method::const_iterator iFind( _aName2Method.find( rName ) );
     904           0 :     if (iFind != _aName2Method.end())
     905           0 :         xRet = (*iFind).second; // harden ref
     906             : 
     907           0 :     if (! xRet.is())
     908             :     {
     909           0 :         for ( sal_Int32 nPos = _nMethods; nPos--; )
     910             :         {
     911           0 :             if (_pSortedMemberInit[nPos].first == rName)
     912             :             {
     913           0 :                 _aName2Method[rName] = xRet = new IdlInterfaceMethodImpl(
     914           0 :                     getReflection(), rName,
     915           0 :                     _pSortedMemberInit[nPos].second, IdlClassImpl::getTypeDescr() );
     916           0 :                 break;
     917             :             }
     918             :         }
     919             :     }
     920           0 :     return xRet;
     921             : }
     922             : 
     923           0 : Reference< XIdlField > InterfaceIdlClassImpl::getField( const OUString & rName )
     924             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     925             : {
     926           0 :     MutexGuard aGuard( getMutexAccess() );
     927           0 :     if (! _pSortedMemberInit)
     928           0 :         initMembers();
     929             : 
     930           0 :     Reference< XIdlField > xRet;
     931             : 
     932             :     // try weak map
     933           0 :     const OUString2Field::const_iterator iFind( _aName2Field.find( rName ) );
     934           0 :     if (iFind != _aName2Field.end())
     935           0 :         xRet = (*iFind).second; // harden ref
     936             : 
     937           0 :     if (! xRet.is())
     938             :     {
     939           0 :         for ( sal_Int32 nPos = _nAttributes; nPos--; )
     940             :         {
     941           0 :             if (_pSortedMemberInit[_nMethods+nPos].first == rName)
     942             :             {
     943           0 :                 _aName2Field[rName] = xRet = new IdlAttributeFieldImpl(
     944           0 :                     getReflection(), rName,
     945           0 :                     _pSortedMemberInit[_nMethods+nPos].second, IdlClassImpl::getTypeDescr() );
     946           0 :                 break;
     947             :             }
     948             :         }
     949             :     }
     950           0 :     return xRet;
     951             : }
     952             : 
     953           0 : void InterfaceIdlClassImpl::createObject( Any & rObj )
     954             :     throw(::com::sun::star::uno::RuntimeException, std::exception)
     955             : {
     956             :     // interfaces cannot be constructed
     957           0 :     rObj.clear();
     958           0 : }
     959             : 
     960             : }
     961             : 
     962             : 
     963             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10