/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/alloca.h>
#include <string.h>
#include <osl/diagnose.h>
#include <rtl/byteseq.hxx>
#include <rtl/ustrbuf.hxx>
#include <rtl/uuid.h>
#include <sal/log.hxx>
#include <cppuhelper/compbase_ex.hxx>
#include <cppuhelper/implbase_ex.hxx>
#include <com/sun/star/uno/RuntimeException.hpp>
using namespace ::cppu;
using namespace ::osl;
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using rtl::OUString;
namespace
{
class theImplHelperInitMutex : public rtl::Static<Mutex, theImplHelperInitMutex>{};
}
namespace cppu
{
/** Shared mutex for implementation helper initialization.
Not for public use.
*/
::osl::Mutex & getImplHelperInitMutex()
{
return theImplHelperInitMutex::get();
}
static inline void checkInterface( Type const & rType )
{
if (TypeClass_INTERFACE != rType.getTypeClass())
{
OUString msg( "querying for interface \"" + rType.getTypeName() + "\": no interface type!" );
SAL_WARN( "cppuhelper", msg );
throw RuntimeException( msg );
}
}
static inline bool isXInterface( rtl_uString * pStr )
{
return OUString::unacquired(&pStr) == "com.sun.star.uno.XInterface";
}
static inline void * makeInterface( sal_IntPtr nOffset, void * that )
{
return (static_cast<char *>(that) + nOffset);
}
static inline bool td_equals(
typelib_TypeDescriptionReference const * pTDR1,
typelib_TypeDescriptionReference const * pTDR2 )
{
return ((pTDR1 == pTDR2) ||
OUString::unacquired(&pTDR1->pTypeName) == OUString::unacquired(&pTDR2->pTypeName));
}
static inline type_entry * getTypeEntries( class_data * cd )
{
type_entry * pEntries = cd->m_typeEntries;
if (! cd->m_storedTypeRefs) // not inited?
{
MutexGuard guard( getImplHelperInitMutex() );
if (! cd->m_storedTypeRefs) // not inited?
{
// get all types
for ( sal_Int32 n = cd->m_nTypes; n--; )
{
type_entry * pEntry = &pEntries[ n ];
Type const & rType = (*pEntry->m_type.getCppuType)( nullptr );
OSL_ENSURE( rType.getTypeClass() == TypeClass_INTERFACE, "### wrong helper init: expected interface!" );
OSL_ENSURE( ! isXInterface( rType.getTypeLibType()->pTypeName ), "### want to implement XInterface: template argument is XInterface?!?!?!" );
if (rType.getTypeClass() != TypeClass_INTERFACE)
{
OUString msg( "type \"" + rType.getTypeName() + "\" is no interface type!" );
SAL_WARN( "cppuhelper", msg );
throw RuntimeException( msg );
}
// ref is statically held by getCppuType()
pEntry->m_type.typeRef = rType.getTypeLibType();
}
OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
cd->m_storedTypeRefs = true;
}
}
else
{
OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
}
return pEntries;
}
static inline void fillTypes( Type * types, class_data * cd )
{
type_entry * pEntries = getTypeEntries( cd );
for ( sal_Int32 n = cd->m_nTypes; n--; )
{
types[ n ] = pEntries[ n ].m_type.typeRef;
}
}
namespace {
bool recursivelyFindType(
typelib_TypeDescriptionReference const * demandedType,
typelib_InterfaceTypeDescription const * type, sal_IntPtr * offset)
{
// This code assumes that the vtables of a multiple-inheritance class (the
// offset amount by which to adjust the this pointer) follow one another in
// the object layout, and that they contain slots for the inherited classes
// in a specific order. In theory, that need not hold for any given
// platform; in practice, it seems to work well on all supported platforms:
next:
for (sal_Int32 i = 0; i < type->nBaseTypes; ++i) {
if (i > 0) {
*offset += sizeof (void *);
}
typelib_InterfaceTypeDescription const * base = type->ppBaseTypes[i];
// ignore XInterface:
if (base->nBaseTypes > 0) {
if (td_equals(
reinterpret_cast<
typelib_TypeDescriptionReference const * >(base),
demandedType))
{
return true;
}
// Profiling showed that it is important to speed up the common case
// of only one base:
if (type->nBaseTypes == 1) {
type = base;
goto next;
}
if (recursivelyFindType(demandedType, base, offset)) {
return true;
}
}
}
return false;
}
}
static inline void * queryDeepNoXInterface(
typelib_TypeDescriptionReference const * pDemandedTDR, class_data * cd, void * that )
{
type_entry * pEntries = getTypeEntries( cd );
sal_Int32 nTypes = cd->m_nTypes;
sal_Int32 n;
// try top interfaces without getting td
for ( n = 0; n < nTypes; ++n )
{
if (td_equals( pEntries[ n ].m_type.typeRef, pDemandedTDR ))
{
return makeInterface( pEntries[ n ].m_offset, that );
}
}
// query deep getting td
for ( n = 0; n < nTypes; ++n )
{
typelib_TypeDescription * pTD = nullptr;
TYPELIB_DANGER_GET( &pTD, pEntries[ n ].m_type.typeRef );
if (pTD)
{
// exclude top (already tested) and bottom (XInterface) interface
OSL_ENSURE(
reinterpret_cast< typelib_InterfaceTypeDescription * >(pTD)->
nBaseTypes > 0,
"### want to implement XInterface:"
" template argument is XInterface?!?!?!" );
sal_IntPtr offset = pEntries[n].m_offset;
bool found = recursivelyFindType(
pDemandedTDR,
reinterpret_cast< typelib_InterfaceTypeDescription * >(pTD),
&offset);
TYPELIB_DANGER_RELEASE( pTD );
if (found) {
return makeInterface( offset, that );
}
}
else
{
OUString msg( "cannot get type description for type \"" + OUString(pEntries[ n ].m_type.typeRef->pTypeName) + "\"!" );
SAL_WARN( "cppuhelper", msg );
throw RuntimeException( msg );
}
}
return nullptr;
}
// ImplHelper
Any SAL_CALL ImplHelper_query(
Type const & rType, class_data * cd, void * that )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
void * p;
// shortcut for XInterface
if (isXInterface( pTDR->pTypeName ))
{
// take first one
p = makeInterface( cd->m_typeEntries[ 0 ].m_offset, that );
}
else
{
p = queryDeepNoXInterface( pTDR, cd, that );
if (! p)
{
return Any();
}
}
return Any( &p, pTDR );
}
Any SAL_CALL ImplHelper_queryNoXInterface(
Type const & rType, class_data * cd, void * that )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
void * p = queryDeepNoXInterface( pTDR, cd, that );
if (p)
{
return Any( &p, pTDR );
}
return Any();
}
css::uno::Sequence<sal_Int8> ImplHelper_getImplementationId(
SAL_UNUSED_PARAMETER class_data *)
{
return css::uno::Sequence<sal_Int8>();
}
Sequence< Type > SAL_CALL ImplHelper_getTypes(
class_data * cd )
{
Sequence< Type > types( cd->m_nTypes );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
return types;
}
Sequence< Type > SAL_CALL ImplInhHelper_getTypes(
class_data * cd, Sequence< Type > const & rAddTypes )
{
sal_Int32 nImplTypes = cd->m_nTypes;
sal_Int32 nAddTypes = rAddTypes.getLength();
Sequence< Type > types( nImplTypes + nAddTypes );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
// append base types
Type const * pAddTypes = rAddTypes.getConstArray();
while (nAddTypes--)
{
pTypes[ nImplTypes + nAddTypes ] = pAddTypes[ nAddTypes ];
}
return types;
}
// WeakImplHelper
Any SAL_CALL WeakImplHelper_query(
Type const & rType, class_data * cd, void * that, OWeakObject * pBase )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
// shortcut XInterface to OWeakObject
if (! isXInterface( pTDR->pTypeName ))
{
void * p = queryDeepNoXInterface( pTDR, cd, that );
if (p)
{
return Any( &p, pTDR );
}
}
return pBase->OWeakObject::queryInterface( rType );
}
Sequence< Type > SAL_CALL WeakImplHelper_getTypes(
class_data * cd )
{
sal_Int32 nTypes = cd->m_nTypes;
Sequence< Type > types( nTypes +1 );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
pTypes[ nTypes ] = cppu::UnoType<XWeak>::get();
return types;
}
// WeakAggImplHelper
Any SAL_CALL WeakAggImplHelper_queryAgg(
Type const & rType, class_data * cd, void * that, OWeakAggObject * pBase )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
// shortcut XInterface to OWeakAggObject
if (! isXInterface( pTDR->pTypeName ))
{
void * p = queryDeepNoXInterface( pTDR, cd, that );
if (p)
{
return Any( &p, pTDR );
}
}
return pBase->OWeakAggObject::queryAggregation( rType );
}
Sequence< Type > SAL_CALL WeakAggImplHelper_getTypes(
class_data * cd )
{
sal_Int32 nTypes = cd->m_nTypes;
Sequence< Type > types( nTypes +2 );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
pTypes[ nTypes ] = cppu::UnoType<XAggregation>::get();
return types;
}
// WeakComponentImplHelper
Any SAL_CALL WeakComponentImplHelper_query(
Type const & rType, class_data * cd, void * that, WeakComponentImplHelperBase * pBase )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
// shortcut XInterface to WeakComponentImplHelperBase
if (! isXInterface( pTDR->pTypeName ))
{
void * p = queryDeepNoXInterface( pTDR, cd, that );
if (p)
{
return Any( &p, pTDR );
}
}
return pBase->WeakComponentImplHelperBase::queryInterface( rType );
}
Sequence< Type > SAL_CALL WeakComponentImplHelper_getTypes(
class_data * cd )
{
sal_Int32 nTypes = cd->m_nTypes;
Sequence< Type > types( nTypes +2 );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
pTypes[ nTypes ] = cppu::UnoType<lang::XComponent>::get();
return types;
}
// WeakAggComponentImplHelper
Any SAL_CALL WeakAggComponentImplHelper_queryAgg(
Type const & rType, class_data * cd, void * that, WeakAggComponentImplHelperBase * pBase )
{
checkInterface( rType );
typelib_TypeDescriptionReference * pTDR = rType.getTypeLibType();
// shortcut XInterface to WeakAggComponentImplHelperBase
if (! isXInterface( pTDR->pTypeName ))
{
void * p = queryDeepNoXInterface( pTDR, cd, that );
if (p)
{
return Any( &p, pTDR );
}
}
return pBase->WeakAggComponentImplHelperBase::queryAggregation( rType );
}
Sequence< Type > SAL_CALL WeakAggComponentImplHelper_getTypes(
class_data * cd )
{
sal_Int32 nTypes = cd->m_nTypes;
Sequence< Type > types( nTypes +3 );
Type * pTypes = types.getArray();
fillTypes( pTypes, cd );
pTypes[ nTypes++ ] = cppu::UnoType<XWeak>::get();
pTypes[ nTypes++ ] = cppu::UnoType<XAggregation>::get();
pTypes[ nTypes ] = cppu::UnoType<lang::XComponent>::get();
return types;
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V547 Expression '!cd->m_storedTypeRefs' is always true.