stoc/source/corereflection/crcomp.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 #include <cppuhelper/queryinterface.hxx>
  21 #include <cppuhelper/typeprovider.hxx>
  22
  23 #include <com/sun/star/reflection/XIdlField.hpp>
  24 #include <com/sun/star/reflection/XIdlField2.hpp>
  25 #include <com/sun/star/uno/TypeClass.hpp>
  26
  27 #include "base.hxx"
  28
  29 using namespace css::lang;
  30 using namespace css::reflection;
  31 using namespace css::uno;
  32
  33 namespace stoc_corefl
  34 {
  35
  36 namespace {
  37
  38 class IdlCompFieldImpl
  39     : public IdlMemberImpl
  40     , public XIdlField
  41     , public XIdlField2
  42 {
  43     sal_Int32                   _nOffset;
  44
  45 public:
  46     IdlCompFieldImpl( IdlReflectionServiceImpl * pReflection, const OUString & rName,
  47                       typelib_TypeDescription * pTypeDescr, typelib_TypeDescription * pDeclTypeDescr,
  48                       sal_Int32 nOffset )
  49         : IdlMemberImpl( pReflection, rName, pTypeDescr, pDeclTypeDescr )
  50         , _nOffset( nOffset )
  51         {}
  52
  53     // XInterface
  54     virtual Any SAL_CALL queryInterface( const Type & rType ) override;
  55     virtual void SAL_CALL acquire() throw () override;
  56     virtual void SAL_CALL release() throw () override;
  57
  58     // XTypeProvider
  59     virtual Sequence< Type > SAL_CALL getTypes() override;
  60     virtual Sequence< sal_Int8 > SAL_CALL getImplementationId() override;
  61
  62     // XIdlMember
  63     virtual Reference< XIdlClass > SAL_CALL getDeclaringClass() override;
  64     virtual OUString SAL_CALL getName() override;
  65     // XIdlField
  66     virtual Reference< XIdlClass > SAL_CALL getType() override;
  67     virtual FieldAccessMode SAL_CALL getAccessMode() override;
  68     virtual Any SAL_CALL get( const Any & rObj ) override;
  69     virtual void SAL_CALL set( const Any & rObj, const Any & rValue ) override;
  70     // XIdlField2: getType, getAccessMode and get are equal to XIdlField
  71     virtual void SAL_CALL set( Any & rObj, const Any & rValue ) override;
  72 };
  73
  74 }
  75
  76 // XInterface
  77
  78 Any IdlCompFieldImpl::queryInterface( const Type & rType )
  79 {
  80     Any aRet( ::cppu::queryInterface( rType,
  81                                       static_cast< XIdlField * >( this ),
  82                                       static_cast< XIdlField2 * >( this ) ) );
  83     return (aRet.hasValue() ? aRet : IdlMemberImpl::queryInterface( rType ));
  84 }
  85
  86 void IdlCompFieldImpl::acquire() throw()
  87 {
  88     IdlMemberImpl::acquire();
  89 }
  90
  91 void IdlCompFieldImpl::release() throw()
  92 {
  93     IdlMemberImpl::release();
  94 }
  95
  96 // XTypeProvider
  97
  98 Sequence< Type > IdlCompFieldImpl::getTypes()
  99 {
 100     static cppu::OTypeCollection s_aTypes(
 101         cppu::UnoType<XIdlField2>::get(),
 102         cppu::UnoType<XIdlField>::get(),
 103         IdlMemberImpl::getTypes() );
 104
 105     return s_aTypes.getTypes();
 106 }
 107
 108 Sequence< sal_Int8 > IdlCompFieldImpl::getImplementationId()
 109 {
 110     return css::uno::Sequence<sal_Int8>();
 111 }
 112
 113 // XIdlMember
 114
 115 Reference< XIdlClass > IdlCompFieldImpl::getDeclaringClass()
 116 {
 117     if (! _xDeclClass.is())
 118     {
 119         ::osl::MutexGuard aGuard( getMutexAccess() );
 120         if (! _xDeclClass.is())
 121         {
 122             typelib_CompoundTypeDescription * pTD =
 123                 reinterpret_cast<typelib_CompoundTypeDescription *>(getDeclTypeDescr());
 124             while (pTD)
 125             {
 126                 typelib_TypeDescriptionReference ** ppTypeRefs = pTD->ppTypeRefs;
 127                 for ( sal_Int32 nPos = pTD->nMembers; nPos--; )
 128                 {
 129                     if (td_equals( getTypeDescr(), ppTypeRefs[nPos] ))
 130                     {
 131                         _xDeclClass = getReflection()->forType( &pTD->aBase );
 132                         return _xDeclClass;
 133                     }
 134                 }
 135                 pTD = pTD->pBaseTypeDescription;
 136             }
 137         }
 138     }
 139     return _xDeclClass;
 140 }
 141
 142 OUString IdlCompFieldImpl::getName()
 143 {
 144     return IdlMemberImpl::getName();
 145 }
 146
 147 // XIdlField
 148
 149 Reference< XIdlClass > IdlCompFieldImpl::getType()
 150 {
 151     return getReflection()->forType( getTypeDescr() );
 152 }
 153
 154 FieldAccessMode IdlCompFieldImpl::getAccessMode()
 155 {
 156     return FieldAccessMode_READWRITE;
 157 }
 158
 159 Any IdlCompFieldImpl::get( const Any & rObj )
 160 {
 161     if (rObj.getValueTypeClass() == css::uno::TypeClass_STRUCT ||
 162         rObj.getValueTypeClass() == css::uno::TypeClass_EXCEPTION)
 163     {
 164         typelib_TypeDescription * pObjTD = nullptr;
 165         TYPELIB_DANGER_GET( &pObjTD, rObj.getValueTypeRef() );
 166
 167         typelib_TypeDescription * pTD = pObjTD;
 168         typelib_TypeDescription * pDeclTD = getDeclTypeDescr();
 169         while (pTD && !typelib_typedescription_equals( pTD, pDeclTD ))
 170             pTD = &reinterpret_cast<typelib_CompoundTypeDescription *>(pTD)->pBaseTypeDescription->aBase;
 171
 172         OSL_ENSURE( pTD, "### illegal object type!" );
 173         if (pTD)
 174         {
 175             TYPELIB_DANGER_RELEASE( pObjTD );
 176             Any aRet;
 177             uno_any_destruct(
 178                 &aRet, reinterpret_cast< uno_ReleaseFunc >(cpp_release) );
 179             uno_any_construct(
 180                 &aRet, const_cast<char *>(static_cast<char const *>(rObj.getValue()) + _nOffset), getTypeDescr(),
 181                 reinterpret_cast< uno_AcquireFunc >(cpp_acquire) );
 182             return aRet;
 183         }
 184         TYPELIB_DANGER_RELEASE( pObjTD );
 185     }
 186     throw IllegalArgumentException(
 187         "expected struct or exception, got " + rObj.getValueType().getTypeName(),
 188         static_cast<XWeak *>(static_cast<OWeakObject *>(this)), 0 );
 189 }
 190
 191 void IdlCompFieldImpl::set( const Any & rObj, const Any & rValue )
 192 {
 193     if (rObj.getValueTypeClass() == css::uno::TypeClass_STRUCT ||
 194         rObj.getValueTypeClass() == css::uno::TypeClass_EXCEPTION)
 195     {
 196         typelib_TypeDescription * pObjTD = nullptr;
 197         TYPELIB_DANGER_GET( &pObjTD, rObj.getValueTypeRef() );
 198
 199         typelib_TypeDescription * pTD = pObjTD;
 200         typelib_TypeDescription * pDeclTD = getDeclTypeDescr();
 201         while (pTD && !typelib_typedescription_equals( pTD, pDeclTD ))
 202             pTD = &reinterpret_cast<typelib_CompoundTypeDescription *>(pTD)->pBaseTypeDescription->aBase;
 203
 204         OSL_ENSURE( pTD, "### illegal object type!" );
 205         if (pTD)
 206         {
 207             TYPELIB_DANGER_RELEASE( pObjTD );
 208             if (!coerce_assign( const_cast<char *>(static_cast<char const *>(rObj.getValue()) + _nOffset), getTypeDescr(), rValue, getReflection() ))
 209             {
 210                 throw IllegalArgumentException(
 211                     "cannot assign value to destination",
 212                     static_cast<XWeak *>(static_cast<OWeakObject *>(this)), 1 );
 213             }
 214             return;
 215         }
 216         TYPELIB_DANGER_RELEASE( pObjTD );
 217     }
 218     throw IllegalArgumentException(
 219         "expected struct or exception, got " + rObj.getValueType().getTypeName(),
 220         static_cast<XWeak *>(static_cast<OWeakObject *>(this)), 0 );
 221 }
 222
 223
 224 void IdlCompFieldImpl::set( Any & rObj, const Any & rValue )
 225 {
 226     if (rObj.getValueTypeClass() == css::uno::TypeClass_STRUCT ||
 227         rObj.getValueTypeClass() == css::uno::TypeClass_EXCEPTION)
 228     {
 229         typelib_TypeDescription * pObjTD = nullptr;
 230         TYPELIB_DANGER_GET( &pObjTD, rObj.getValueTypeRef() );
 231
 232         typelib_TypeDescription * pTD = pObjTD;
 233         typelib_TypeDescription * pDeclTD = getDeclTypeDescr();
 234         while (pTD && !typelib_typedescription_equals( pTD, pDeclTD ))
 235             pTD = &reinterpret_cast<typelib_CompoundTypeDescription *>(pTD)->pBaseTypeDescription->aBase;
 236
 237         OSL_ENSURE( pTD, "### illegal object type!" );
 238         if (pTD)
 239         {
 240             TYPELIB_DANGER_RELEASE( pObjTD );
 241             if (!coerce_assign( const_cast<char *>(static_cast<char const *>(rObj.getValue()) + _nOffset), getTypeDescr(), rValue, getReflection() ))
 242             {
 243                 throw IllegalArgumentException(
 244                     "cannot assign to destination",
 245                     static_cast<XWeak *>(static_cast<OWeakObject *>(this)), 1 );
 246             }
 247             return;
 248         }
 249         TYPELIB_DANGER_RELEASE( pObjTD );
 250     }
 251     throw IllegalArgumentException(
 252         "expected struct or exception, got " + rObj.getValueType().getTypeName(),
 253         static_cast<XWeak *>(static_cast<OWeakObject *>(this)), 0 );
 254 }
 255
 256
 257 CompoundIdlClassImpl::~CompoundIdlClassImpl()
 258 {
 259 }
 260
 261
 262 sal_Bool CompoundIdlClassImpl::isAssignableFrom( const Reference< XIdlClass > & xType )
 263 {
 264     if (xType.is())
 265     {
 266         TypeClass eTC = xType->getTypeClass();
 267         if (eTC == TypeClass_STRUCT || eTC == TypeClass_EXCEPTION)
 268         {
 269             if (equals( xType ))
 270                 return true;
 271             else
 272             {
 273                 const Sequence< Reference< XIdlClass > > & rSeq = xType->getSuperclasses();
 274                 if (rSeq.hasElements())
 275                 {
 276                     OSL_ENSURE( rSeq.getLength() == 1, "### unexpected len of super classes!" );
 277                     return isAssignableFrom( rSeq[0] );
 278                 }
 279             }
 280         }
 281     }
 282     return false;
 283 }
 284
 285 Sequence< Reference< XIdlClass > > CompoundIdlClassImpl::getSuperclasses()
 286 {
 287     if (! _xSuperClass.is())
 288     {
 289         ::osl::MutexGuard aGuard( getMutexAccess() );
 290         if (! _xSuperClass.is())
 291         {
 292             typelib_CompoundTypeDescription * pCompTypeDescr = getTypeDescr()->pBaseTypeDescription;
 293             if (pCompTypeDescr)
 294                 _xSuperClass = getReflection()->forType( &pCompTypeDescr->aBase );
 295         }
 296     }
 297     if (_xSuperClass.is())
 298         return Sequence< Reference< XIdlClass > >( &_xSuperClass, 1 );
 299     else
 300         return Sequence< Reference< XIdlClass > >();
 301 }
 302
 303 Reference< XIdlField > CompoundIdlClassImpl::getField( const OUString & rName )
 304 {
 305     if (! _pFields)
 306         getFields(); // init fields
 307
 308     const OUString2Field::const_iterator iFind( _aName2Field.find( rName ) );
 309     if (iFind != _aName2Field.end())
 310         return Reference< XIdlField >( (*iFind).second );
 311     else
 312         return Reference< XIdlField >();
 313 }
 314
 315 Sequence< Reference< XIdlField > > CompoundIdlClassImpl::getFields()
 316 {
 317     ::osl::MutexGuard aGuard( getMutexAccess() );
 318     if (! _pFields)
 319     {
 320         sal_Int32 nAll = 0;
 321         typelib_CompoundTypeDescription * pCompTypeDescr = getTypeDescr();
 322         for ( ; pCompTypeDescr; pCompTypeDescr = pCompTypeDescr->pBaseTypeDescription )
 323             nAll += pCompTypeDescr->nMembers;
 324
 325         Sequence< Reference< XIdlField > > * pFields =
 326             new Sequence< Reference< XIdlField > >( nAll );
 327         Reference< XIdlField > * pSeq = pFields->getArray();
 328
 329         for ( pCompTypeDescr = getTypeDescr(); pCompTypeDescr;
 330               pCompTypeDescr = pCompTypeDescr->pBaseTypeDescription )
 331         {
 332             typelib_TypeDescriptionReference ** ppTypeRefs = pCompTypeDescr->ppTypeRefs;
 333             rtl_uString ** ppNames                         = pCompTypeDescr->ppMemberNames;
 334             sal_Int32 * pMemberOffsets                     = pCompTypeDescr->pMemberOffsets;
 335
 336             for ( sal_Int32 nPos = pCompTypeDescr->nMembers; nPos--; )
 337             {
 338                 typelib_TypeDescription * pTD = nullptr;
 339                 TYPELIB_DANGER_GET( &pTD, ppTypeRefs[nPos] );
 340                 OSL_ENSURE( pTD, "### cannot get field in struct!" );
 341                 if (pTD)
 342                 {
 343                     OUString aName( ppNames[nPos] );
 344                     _aName2Field[aName] = pSeq[--nAll] = new IdlCompFieldImpl(
 345                         getReflection(), aName, pTD, IdlClassImpl::getTypeDescr(), pMemberOffsets[nPos] );
 346                     TYPELIB_DANGER_RELEASE( pTD );
 347                 }
 348             }
 349         }
 350
 351         _pFields.reset( pFields );
 352     }
 353     return *_pFields;
 354 }
 355
 356 }
 357
 358
 359 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */