cppuhelper/source/implbase_ex.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 <sal/alloca.h>
  21
  22 #include <string.h>
  23 #include <osl/diagnose.h>
  24 #include <rtl/byteseq.hxx>
  25 #include <rtl/ustrbuf.hxx>
  26 #include <rtl/uuid.h>
  27 #include <sal/log.hxx>
  28 #include <cppuhelper/compbase_ex.hxx>
  29
  30 #include <com/sun/star/uno/RuntimeException.hpp>
  31
  32 using namespace ::cppu;
  33 using namespace ::osl;
  34 using namespace ::com::sun::star;
  35 using namespace ::com::sun::star::uno;
  36
  37 using rtl::OUString;
  38
  39 namespace
  40 {
  41     class theImplHelperInitMutex : public rtl::Static<Mutex, theImplHelperInitMutex>{};
  42 }
  43
  44 namespace cppu
  45 {
  46
  47 /** Shared mutex for implementation helper initialization.
  48     Not for public use.
  49 */
  50 ::osl::Mutex & getImplHelperInitMutex()
  51 {
  52     return theImplHelperInitMutex::get();
  53 }
  54
  55
  56 static inline void checkInterface( Type const & rType )
  57 {
  58     if (TypeClass_INTERFACE != rType.getTypeClass())
  59     {
  60         OUString msg( "querying for interface \"" + rType.getTypeName() + "\": no interface type!" );
  61         SAL_WARN( "cppuhelper", msg );
  62         throw RuntimeException( msg );
  63     }
  64 }
  65
  66 static inline bool isXInterface( rtl_uString * pStr )
  67 {
  68     return OUString::unacquired(&pStr) == "com.sun.star.uno.XInterface";
  69 }
  70
  71 static inline void * makeInterface( sal_IntPtr nOffset, void * that )
  72 {
  73     return (static_cast<char *>(that) + nOffset);
  74 }
  75
  76 static inline bool td_equals(
  77     typelib_TypeDescriptionReference const * pTDR1,
  78     typelib_TypeDescriptionReference const * pTDR2 )
  79 {
  80     return ((pTDR1 == pTDR2) ||
  81             OUString::unacquired(&pTDR1->pTypeName) == OUString::unacquired(&pTDR2->pTypeName));
  82 }
  83
  84 static inline type_entry * getTypeEntries( class_data * cd )
  85 {
  86     type_entry * pEntries = cd->m_typeEntries;
  87     if (! cd->m_storedTypeRefs) // not inited?
  88     {
  89         MutexGuard guard( getImplHelperInitMutex() );
  90         if (! cd->m_storedTypeRefs) // not inited?
  91         {
  92             // get all types
  93             for ( sal_Int32 n = cd->m_nTypes; n--; )
  94             {
  95                 type_entry * pEntry = &pEntries[ n ];
  96                 Type const & rType = (*pEntry->m_type.getCppuType)( nullptr );
  97                 OSL_ENSURE( rType.getTypeClass() == TypeClass_INTERFACE, "### wrong helper init: expected interface!" );
  98                 OSL_ENSURE( ! isXInterface( rType.getTypeLibType()->pTypeName ), "### want to implement XInterface: template argument is XInterface?!?!?!" );
  99                 if (rType.getTypeClass() != TypeClass_INTERFACE)
 100                 {
 101                     OUString msg( "type \"" + rType.getTypeName() + "\" is no interface type!" );
 102                     SAL_WARN( "cppuhelper", msg );
 103                     throw RuntimeException( msg );
 104                 }
 105                 // ref is statically held by getCppuType()
 106                 pEntry->m_type.typeRef = rType.getTypeLibType();
 107             }
 108             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 109             cd->m_storedTypeRefs = true;
 110         }
 111     }
 112     else
 113     {
 114         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 115     }
 116     return pEntries;
 117 }
 118
 119 static inline void fillTypes( Type * types, class_data * cd )
 120 {
 121     type_entry * pEntries = getTypeEntries( cd );
 122     for ( sal_Int32 n = cd->m_nTypes; n--; )
 123     {
 124         types[ n ] = pEntries[ n ].m_type.typeRef;
 125     }
 126 }
 127
 128 namespace {
 129
 130 bool recursivelyFindType(
 131     typelib_TypeDescriptionReference const * demandedType,
 132     typelib_InterfaceTypeDescription const * type, sal_IntPtr * offset)
 133 {
 134     // This code assumes that the vtables of a multiple-inheritance class (the
 135     // offset amount by which to adjust the this pointer) follow one another in
 136     // the object layout, and that they contain slots for the inherited classes
 137     // in a specific order.  In theory, that need not hold for any given
 138     // platform; in practice, it seems to work well on all supported platforms:
 139  next:
 140     for (sal_Int32 i = 0; i < type->nBaseTypes; ++i) {
 141         if (i > 0) {
 142             *offset += sizeof (void *);
 143         }
 144         typelib_InterfaceTypeDescription const * base = type->ppBaseTypes[i];
 145         // ignore XInterface:
 146         if (base->nBaseTypes > 0) {
 147             if (td_equals(
 148                     reinterpret_cast<
 149                         typelib_TypeDescriptionReference const * >(base),
 150                     demandedType))
 151             {
 152                 return true;
 153             }
 154             // Profiling showed that it is important to speed up the common case
 155             // of only one base:
 156             if (type->nBaseTypes == 1) {
 157                 type = base;
 158                 goto next;
 159             }
 160             if (recursivelyFindType(demandedType, base, offset)) {
 161                 return true;
 162             }
 163         }
 164     }
 165     return false;
 166 }
 167
 168 }
 169
 170 static inline void * queryDeepNoXInterface(
 171     typelib_TypeDescriptionReference const * pDemandedTDR, class_data * cd, void * that )
 172 {
 173     type_entry * pEntries = getTypeEntries( cd );
 174     sal_Int32 nTypes = cd->m_nTypes;
 175     sal_Int32 n;
 176
 177     // try top interfaces without getting td
 178     for ( n = 0; n < nTypes; ++n )
 179     {
 180         if (td_equals( pEntries[ n ].m_type.typeRef, pDemandedTDR ))
 181         {
 182             return makeInterface( pEntries[ n ].m_offset, that );
 183         }
 184     }
 185     // query deep getting td
 186     for ( n = 0; n < nTypes; ++n )
 187     {
 188         typelib_TypeDescription * pTD = nullptr;
 189         TYPELIB_DANGER_GET( &pTD, pEntries[ n ].m_type.typeRef );
 190         if (pTD)
 191         {
 192             // exclude top (already tested) and bottom (XInterface) interface
 193             OSL_ENSURE(
 194                 reinterpret_cast< typelib_InterfaceTypeDescription * >(pTD)->
 195                     nBaseTypes > 0,
 196                 "### want to implement XInterface:"
 197                     " template argument is XInterface?!?!?!" );
 198             sal_IntPtr offset = pEntries[n].m_offset;
 199             bool found = recursivelyFindType(
 200                 pDemandedTDR,
 201                 reinterpret_cast< typelib_InterfaceTypeDescription * >(pTD),
 202                 &offset);
 203             TYPELIB_DANGER_RELEASE( pTD );
 204             if (found) {
 205                 return makeInterface( offset, that );
 206             }
 207         }
 208         else
 209         {
 210             OUString msg( "cannot get type description for type \"" + OUString(pEntries[ n ].m_type.typeRef->pTypeName) + "\"!" );
 211             SAL_WARN( "cppuhelper", msg );
 212             throw RuntimeException( msg );
 213         }
 214     }
 215     return nullptr;
 216 }
 217
 218 // ImplHelper
 219
 220 Any SAL_CALL ImplHelper_query(
 221     Type const & rType, class_data * cd, void * that )
 222 {
 223     checkInterface( rType );
 224     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 225
 226     void * p;
 227     // shortcut for XInterface
 228     if (isXInterface( pTDR->pTypeName ))
 229     {
 230         // take first one
 231         p = makeInterface( cd->m_typeEntries[ 0 ].m_offset, that );
 232     }
 233     else
 234     {
 235         p = queryDeepNoXInterface( pTDR, cd, that );
 236         if (! p)
 237         {
 238             return Any();
 239         }
 240     }
 241     return Any( &p, pTDR );
 242 }
 243
 244 Any SAL_CALL ImplHelper_queryNoXInterface(
 245     Type const & rType, class_data * cd, void * that )
 246 {
 247     checkInterface( rType );
 248     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 249
 250     void * p = queryDeepNoXInterface( pTDR, cd, that );
 251     if (p)
 252     {
 253         return Any( &p, pTDR );
 254     }
 255     return Any();
 256 }
 257
 258 css::uno::Sequence<sal_Int8> ImplHelper_getImplementationId(
 259     SAL_UNUSED_PARAMETER class_data *)
 260 {
 261     return css::uno::Sequence<sal_Int8>();
 262 }
 263
 264 Sequence< Type > SAL_CALL ImplHelper_getTypes(
 265     class_data * cd )
 266 {
 267     Sequence< Type > types( cd->m_nTypes );
 268     Type * pTypes = types.getArray();
 269     fillTypes( pTypes, cd );
 270     return types;
 271 }
 272
 273 Sequence< Type >  SAL_CALL ImplInhHelper_getTypes(
 274     class_data * cd, Sequence< Type > const & rAddTypes )
 275 {
 276     sal_Int32 nImplTypes = cd->m_nTypes;
 277     sal_Int32 nAddTypes = rAddTypes.getLength();
 278     Sequence< Type > types( nImplTypes + nAddTypes );
 279     Type * pTypes = types.getArray();
 280     fillTypes( pTypes, cd );
 281     // append base types
 282     Type const * pAddTypes = rAddTypes.getConstArray();
 283     while (nAddTypes--)
 284     {
 285         pTypes[ nImplTypes + nAddTypes ] = pAddTypes[ nAddTypes ];
 286     }
 287     return types;
 288 }
 289
 290 // WeakImplHelper
 291
 292 Any SAL_CALL WeakImplHelper_query(
 293     Type const & rType, class_data * cd, void * that, OWeakObject * pBase )
 294 {
 295     checkInterface( rType );
 296     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 297
 298     // shortcut XInterface to OWeakObject
 299     if (! isXInterface( pTDR->pTypeName ))
 300     {
 301         void * p = queryDeepNoXInterface( pTDR, cd, that );
 302         if (p)
 303         {
 304             return Any( &p, pTDR );
 305         }
 306     }
 307     return pBase->OWeakObject::queryInterface( rType );
 308 }
 309
 310 Sequence< Type > SAL_CALL WeakImplHelper_getTypes(
 311     class_data * cd )
 312 {
 313     sal_Int32 nTypes = cd->m_nTypes;
 314     Sequence< Type > types( nTypes +1 );
 315     Type * pTypes = types.getArray();
 316     fillTypes( pTypes, cd );
 317     pTypes[ nTypes ] = cppu::UnoType<XWeak>::get();
 318     return types;
 319 }
 320
 321 // WeakAggImplHelper
 322
 323 Any SAL_CALL WeakAggImplHelper_queryAgg(
 324     Type const & rType, class_data * cd, void * that, OWeakAggObject * pBase )
 325 {
 326     checkInterface( rType );
 327     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 328
 329     // shortcut XInterface to OWeakAggObject
 330     if (! isXInterface( pTDR->pTypeName ))
 331     {
 332         void * p = queryDeepNoXInterface( pTDR, cd, that );
 333         if (p)
 334         {
 335             return Any( &p, pTDR );
 336         }
 337     }
 338     return pBase->OWeakAggObject::queryAggregation( rType );
 339 }
 340
 341 Sequence< Type > SAL_CALL WeakAggImplHelper_getTypes(
 342     class_data * cd )
 343 {
 344     sal_Int32 nTypes = cd->m_nTypes;
 345     Sequence< Type > types( nTypes +2 );
 346     Type * pTypes = types.getArray();
 347     fillTypes( pTypes, cd );
 348     pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
 349     pTypes[ nTypes ] = cppu::UnoType<XAggregation>::get();
 350     return types;
 351 }
 352
 353 // WeakComponentImplHelper
 354
 355 Any SAL_CALL WeakComponentImplHelper_query(
 356     Type const & rType, class_data * cd, void * that, WeakComponentImplHelperBase * pBase )
 357 {
 358     checkInterface( rType );
 359     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 360
 361     // shortcut XInterface to WeakComponentImplHelperBase
 362     if (! isXInterface( pTDR->pTypeName ))
 363     {
 364         void * p = queryDeepNoXInterface( pTDR, cd, that );
 365         if (p)
 366         {
 367             return Any( &p, pTDR );
 368         }
 369     }
 370     return pBase->WeakComponentImplHelperBase::queryInterface( rType );
 371 }
 372
 373 Sequence< Type > SAL_CALL WeakComponentImplHelper_getTypes(
 374     class_data * cd )
 375 {
 376     sal_Int32 nTypes = cd->m_nTypes;
 377     Sequence< Type > types( nTypes +2 );
 378     Type * pTypes = types.getArray();
 379     fillTypes( pTypes, cd );
 380     pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
 381     pTypes[ nTypes ] = cppu::UnoType<lang::XComponent>::get();
 382     return types;
 383 }
 384
 385 // WeakAggComponentImplHelper
 386
 387 Any SAL_CALL WeakAggComponentImplHelper_queryAgg(
 388     Type const & rType, class_data * cd, void * that, WeakAggComponentImplHelperBase * pBase )
 389 {
 390     checkInterface( rType );
 391     typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
 392
 393     // shortcut XInterface to WeakAggComponentImplHelperBase
 394     if (! isXInterface( pTDR->pTypeName ))
 395     {
 396         void * p = queryDeepNoXInterface( pTDR, cd, that );
 397         if (p)
 398         {
 399             return Any( &p, pTDR );
 400         }
 401     }
 402     return pBase->WeakAggComponentImplHelperBase::queryAggregation( rType );
 403 }
 404
 405 Sequence< Type > SAL_CALL WeakAggComponentImplHelper_getTypes(
 406     class_data * cd )
 407 {
 408     sal_Int32 nTypes = cd->m_nTypes;
 409     Sequence< Type > types( nTypes +3 );
 410     Type * pTypes = types.getArray();
 411     fillTypes( pTypes, cd );
 412     pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
 413     pTypes[ nTypes++ ] = cppu::UnoType<XAggregation>::get();
 414     pTypes[ nTypes ] = cppu::UnoType<lang::XComponent>::get();
 415     return types;
 416 }
 417
 418 }
 419
 420 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */