forked from amazingfate/loongoffice
55b534660e
It had been using cppu::OComponentHelper (which derives from XAggregation) ever
since b525a3115f54576017a576ff842dede5e2e3545d "initial import", bug e.g.
ORegistryFactoryHelper deriving from it implements queryInterface in a way that
is incompatible with XAggregation (it should only have forwarded to
OFactoryComponentHelper::queryInterface, and rather implemented its logic in an
ORegistryFactoryHelper::queryAggregation override).
Also, without this commit but instead with a local
> diff --git a/cppuhelper/source/factory.cxx b/cppuhelper/source/factory.cxx
> index c8efcab0e604..9011264b3f3a 100644
> --- a/cppuhelper/source/factory.cxx
> +++ b/cppuhelper/source/factory.cxx
> @@ -241,6 +241,7 @@ class OFactoryComponentHelper
> , public OComponentHelper
> , public OSingleFactoryHelper
> {
> + void SAL_CALL setDelegator(css::uno::Reference<css::uno::XInterface> const &) final { assert(false); }
> public:
> OFactoryComponentHelper(
> const Reference<XMultiServiceFactory > & rServiceManager,
`make check` still succeeded for me on Linux, without hitting that injected
assert that should have fired if that XAggregation mechanism had been used after
all.
So switch from OComponentHelper to WeakComponentImplHelper here (which is the
simplest implementation helper to use, even if it still needs the non-standard
OFactoryComponentHelper::getTypes overriding the non-fitting
WeakComponentImplHelper default implementation).
Change-Id: I9fc2f4f2ef36bd016f9a943a8efd5e4ac5f3baaf
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/145428
Tested-by: Jenkins
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>
867 lines
27 KiB
C++
867 lines
27 KiB
C++
/* -*- 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/log.hxx>
|
|
#include <osl/diagnose.h>
|
|
#include <osl/mutex.hxx>
|
|
#include <cppuhelper/weak.hxx>
|
|
#include <cppuhelper/compbase.hxx>
|
|
#include <cppuhelper/factory.hxx>
|
|
#include <cppuhelper/implbase.hxx>
|
|
#include <cppuhelper/queryinterface.hxx>
|
|
#include <cppuhelper/supportsservice.hxx>
|
|
#include <rtl/unload.h>
|
|
|
|
#include <cppuhelper/propshlp.hxx>
|
|
#include <o3tl/string_view.hxx>
|
|
|
|
#include <com/sun/star/lang/XServiceInfo.hpp>
|
|
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
|
|
#include <com/sun/star/lang/XSingleComponentFactory.hpp>
|
|
#include <com/sun/star/lang/XInitialization.hpp>
|
|
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
|
|
#include <com/sun/star/loader/XImplementationLoader.hpp>
|
|
#include <com/sun/star/lang/XComponent.hpp>
|
|
#include <com/sun/star/lang/IllegalArgumentException.hpp>
|
|
#include <com/sun/star/uno/XUnloadingPreference.hpp>
|
|
#include <com/sun/star/beans/PropertyAttribute.hpp>
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
|
|
using namespace osl;
|
|
using namespace com::sun::star;
|
|
using namespace com::sun::star::uno;
|
|
using namespace com::sun::star::lang;
|
|
using namespace com::sun::star::loader;
|
|
using namespace com::sun::star::registry;
|
|
|
|
namespace cppu
|
|
{
|
|
|
|
namespace {
|
|
|
|
struct OFactoryComponentHelper_Mutex
|
|
{
|
|
Mutex aMutex;
|
|
};
|
|
|
|
class OFactoryComponentHelper
|
|
: public OFactoryComponentHelper_Mutex
|
|
, public WeakComponentImplHelper<
|
|
XServiceInfo,
|
|
XSingleServiceFactory,
|
|
lang::XSingleComponentFactory,
|
|
XUnloadingPreference>
|
|
{
|
|
public:
|
|
OFactoryComponentHelper(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
OUString aImplementationName_,
|
|
ComponentInstantiation pCreateFunction_,
|
|
ComponentFactoryFunc fptr,
|
|
const Sequence< OUString > * pServiceNames_,
|
|
bool bOneInstance_ )
|
|
: WeakComponentImplHelper( aMutex )
|
|
, bOneInstance( bOneInstance_ )
|
|
, xSMgr( rServiceManager )
|
|
, pCreateFunction( pCreateFunction_ )
|
|
, m_fptr( fptr )
|
|
, aImplementationName(std::move( aImplementationName_ ))
|
|
{
|
|
if( pServiceNames_ )
|
|
aServiceNames = *pServiceNames_;
|
|
}
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > SAL_CALL createInstance() override;
|
|
Reference<XInterface > SAL_CALL createInstanceWithArguments( const Sequence<Any>& Arguments ) override;
|
|
// XSingleComponentFactory
|
|
virtual Reference< XInterface > SAL_CALL createInstanceWithContext(
|
|
Reference< XComponentContext > const & xContext ) override;
|
|
virtual Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
|
|
Sequence< Any > const & rArguments,
|
|
Reference< XComponentContext > const & xContext ) override;
|
|
|
|
// XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
|
|
// XTypeProvider
|
|
virtual Sequence< Type > SAL_CALL getTypes() override;
|
|
|
|
// XUnloadingPreference
|
|
virtual sal_Bool SAL_CALL releaseOnNotification() override;
|
|
|
|
// WeakComponentImplHelper
|
|
void SAL_CALL disposing() override;
|
|
|
|
private:
|
|
css::uno::Reference<css::uno::XInterface> createInstanceWithArgumentsEveryTime(
|
|
css::uno::Sequence<css::uno::Any> const & rArguments,
|
|
css::uno::Reference<css::uno::XComponentContext> const & xContext);
|
|
|
|
Reference<XInterface > xTheInstance;
|
|
bool bOneInstance;
|
|
protected:
|
|
// needed for implementing XUnloadingPreference in inheriting classes
|
|
bool isOneInstance() const {return bOneInstance;}
|
|
bool isInstance() const {return xTheInstance.is();}
|
|
|
|
/**
|
|
* Create an instance specified by the factory. The one instance logic is implemented
|
|
* in the createInstance and createInstanceWithArguments methods.
|
|
* @return the newly created instance. Do not return a previous (one instance) instance.
|
|
* @throw css::uno::Exception
|
|
* @throw css::uno::RuntimeException
|
|
*/
|
|
virtual Reference<XInterface > createInstanceEveryTime(
|
|
Reference< XComponentContext > const & xContext );
|
|
|
|
Reference<XMultiServiceFactory > xSMgr;
|
|
ComponentInstantiation pCreateFunction;
|
|
ComponentFactoryFunc m_fptr;
|
|
Sequence< OUString > aServiceNames;
|
|
OUString aImplementationName;
|
|
};
|
|
|
|
}
|
|
|
|
// XTypeProvider
|
|
Sequence< Type > OFactoryComponentHelper::getTypes()
|
|
{
|
|
Type ar[ 4 ];
|
|
ar[ 0 ] = cppu::UnoType<XSingleServiceFactory>::get();
|
|
ar[ 1 ] = cppu::UnoType<XServiceInfo>::get();
|
|
ar[ 2 ] = cppu::UnoType<XUnloadingPreference>::get();
|
|
|
|
if (m_fptr)
|
|
ar[ 3 ] = cppu::UnoType<XSingleComponentFactory>::get();
|
|
|
|
return Sequence< Type >( ar, m_fptr ? 4 : 3 );
|
|
}
|
|
|
|
// OFactoryComponentHelper
|
|
Reference<XInterface > OFactoryComponentHelper::createInstanceEveryTime(
|
|
Reference< XComponentContext > const & xContext )
|
|
{
|
|
if (m_fptr)
|
|
{
|
|
return (*m_fptr)( xContext );
|
|
}
|
|
if( pCreateFunction )
|
|
{
|
|
if (xContext.is())
|
|
{
|
|
Reference< lang::XMultiServiceFactory > xContextMgr(
|
|
xContext->getServiceManager(), UNO_QUERY );
|
|
if (xContextMgr.is())
|
|
return (*pCreateFunction)( xContextMgr );
|
|
}
|
|
return (*pCreateFunction)( xSMgr );
|
|
}
|
|
return Reference< XInterface >();
|
|
}
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > OFactoryComponentHelper::createInstance()
|
|
{
|
|
if( bOneInstance )
|
|
{
|
|
if( !xTheInstance.is() )
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
if( !xTheInstance.is() )
|
|
xTheInstance = createInstanceEveryTime( Reference< XComponentContext >() );
|
|
}
|
|
return xTheInstance;
|
|
}
|
|
return createInstanceEveryTime( Reference< XComponentContext >() );
|
|
}
|
|
|
|
Reference<XInterface > OFactoryComponentHelper::createInstanceWithArguments(
|
|
const Sequence<Any>& Arguments )
|
|
{
|
|
if( bOneInstance )
|
|
{
|
|
if( !xTheInstance.is() )
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
// OSL_ENSURE( !xTheInstance.is(), "### arguments will be ignored!" );
|
|
if( !xTheInstance.is() )
|
|
xTheInstance = createInstanceWithArgumentsEveryTime(
|
|
Arguments, Reference< XComponentContext >() );
|
|
}
|
|
return xTheInstance;
|
|
}
|
|
return createInstanceWithArgumentsEveryTime( Arguments, Reference< XComponentContext >() );
|
|
}
|
|
|
|
// XSingleComponentFactory
|
|
|
|
Reference< XInterface > OFactoryComponentHelper::createInstanceWithContext(
|
|
Reference< XComponentContext > const & xContext )
|
|
{
|
|
if( bOneInstance )
|
|
{
|
|
if( !xTheInstance.is() )
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
// OSL_ENSURE( !xTheInstance.is(), "### context will be ignored!" );
|
|
if( !xTheInstance.is() )
|
|
xTheInstance = createInstanceEveryTime( xContext );
|
|
}
|
|
return xTheInstance;
|
|
}
|
|
return createInstanceEveryTime( xContext );
|
|
}
|
|
|
|
Reference< XInterface > OFactoryComponentHelper::createInstanceWithArgumentsAndContext(
|
|
Sequence< Any > const & rArguments,
|
|
Reference< XComponentContext > const & xContext )
|
|
{
|
|
if( bOneInstance )
|
|
{
|
|
if( !xTheInstance.is() )
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
// OSL_ENSURE( !xTheInstance.is(), "### context and arguments will be ignored!" );
|
|
if( !xTheInstance.is() )
|
|
xTheInstance = createInstanceWithArgumentsEveryTime( rArguments, xContext );
|
|
}
|
|
return xTheInstance;
|
|
}
|
|
return createInstanceWithArgumentsEveryTime( rArguments, xContext );
|
|
}
|
|
|
|
css::uno::Reference<css::uno::XInterface>
|
|
OFactoryComponentHelper::createInstanceWithArgumentsEveryTime(
|
|
css::uno::Sequence<css::uno::Any> const & rArguments,
|
|
css::uno::Reference<css::uno::XComponentContext> const & xContext)
|
|
{
|
|
Reference< XInterface > xRet( createInstanceEveryTime( xContext ) );
|
|
|
|
Reference< lang::XInitialization > xInit( xRet, UNO_QUERY );
|
|
// always call initialize, even if there are no arguments. #i63511#
|
|
if (xInit.is())
|
|
{
|
|
xInit->initialize( rArguments );
|
|
}
|
|
else
|
|
{
|
|
if ( rArguments.hasElements() )
|
|
{
|
|
// dispose the here created UNO object before throwing out exception
|
|
// to avoid risk of memory leaks #i113722#
|
|
Reference<XComponent> xComp( xRet, UNO_QUERY );
|
|
if (xComp.is())
|
|
xComp->dispose();
|
|
|
|
throw lang::IllegalArgumentException(
|
|
"cannot pass arguments to component => no XInitialization implemented!",
|
|
Reference< XInterface >(), 0 );
|
|
}
|
|
}
|
|
|
|
return xRet;
|
|
}
|
|
|
|
|
|
// WeakComponentImplHelper
|
|
void OFactoryComponentHelper::disposing()
|
|
{
|
|
Reference<XInterface > x;
|
|
{
|
|
// do not delete in the guard section
|
|
MutexGuard aGuard( aMutex );
|
|
x = xTheInstance;
|
|
xTheInstance.clear();
|
|
}
|
|
// if it is a component call dispose at the component
|
|
Reference<XComponent > xComp( x, UNO_QUERY );
|
|
if( xComp.is() )
|
|
xComp->dispose();
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString OFactoryComponentHelper::getImplementationName()
|
|
{
|
|
return aImplementationName;
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool OFactoryComponentHelper::supportsService(
|
|
const OUString& ServiceName )
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > OFactoryComponentHelper::getSupportedServiceNames()
|
|
{
|
|
return aServiceNames;
|
|
}
|
|
|
|
// XUnloadingPreference
|
|
// This class is used for single factories, component factories and
|
|
// one-instance factories. Depending on the usage this function has
|
|
// to return different values.
|
|
// one-instance factory: sal_False
|
|
// single factory: sal_True
|
|
// component factory: sal_True
|
|
sal_Bool SAL_CALL OFactoryComponentHelper::releaseOnNotification()
|
|
{
|
|
if( bOneInstance)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
namespace {
|
|
|
|
class ORegistryFactoryHelper : public OFactoryComponentHelper,
|
|
public OPropertySetHelper
|
|
|
|
{
|
|
public:
|
|
ORegistryFactoryHelper(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
const OUString & rImplementationName_,
|
|
const Reference<XRegistryKey > & xImplementationKey_,
|
|
bool bOneInstance_ )
|
|
: OFactoryComponentHelper(
|
|
rServiceManager, rImplementationName_, nullptr, nullptr, nullptr, bOneInstance_ ),
|
|
OPropertySetHelper( WeakComponentImplHelper::rBHelper ),
|
|
xImplementationKey( xImplementationKey_ )
|
|
{}
|
|
|
|
// XInterface
|
|
virtual Any SAL_CALL queryInterface( Type const & type ) override;
|
|
virtual void SAL_CALL acquire() noexcept override;
|
|
virtual void SAL_CALL release() noexcept override;
|
|
// XTypeProvider
|
|
virtual Sequence< Type > SAL_CALL getTypes() override;
|
|
// XPropertySet
|
|
virtual Reference< beans::XPropertySetInfo > SAL_CALL getPropertySetInfo() override;
|
|
|
|
// OPropertySetHelper
|
|
virtual IPropertyArrayHelper & SAL_CALL getInfoHelper() override;
|
|
virtual sal_Bool SAL_CALL convertFastPropertyValue(
|
|
Any & rConvertedValue, Any & rOldValue,
|
|
sal_Int32 nHandle, Any const & rValue ) override;
|
|
virtual void SAL_CALL setFastPropertyValue_NoBroadcast(
|
|
sal_Int32 nHandle, Any const & rValue ) override;
|
|
using OPropertySetHelper::getFastPropertyValue;
|
|
virtual void SAL_CALL getFastPropertyValue(
|
|
Any & rValue, sal_Int32 nHandle ) const override;
|
|
|
|
// OFactoryComponentHelper
|
|
Reference<XInterface > createInstanceEveryTime(
|
|
Reference< XComponentContext > const & xContext ) override;
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments) override;
|
|
// XSingleComponentFactory
|
|
Reference< XInterface > SAL_CALL createInstanceWithArgumentsAndContext(
|
|
Sequence< Any > const & rArguments,
|
|
Reference< XComponentContext > const & xContext ) override;
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
// XUnloadingPreference
|
|
sal_Bool SAL_CALL releaseOnNotification() override;
|
|
|
|
|
|
private:
|
|
/// @throws css::uno::Exception
|
|
/// @throws css::uno::RuntimeException
|
|
Reference< XInterface > createModuleFactory();
|
|
|
|
/** The registry key of the implementation section */
|
|
Reference<XRegistryKey > xImplementationKey;
|
|
/** The factory created with the loader. */
|
|
Reference<XSingleComponentFactory > xModuleFactory;
|
|
Reference<XSingleServiceFactory > xModuleFactoryDepr;
|
|
Reference< beans::XPropertySetInfo > m_xInfo;
|
|
std::unique_ptr< IPropertyArrayHelper > m_property_array_helper;
|
|
protected:
|
|
using OPropertySetHelper::getTypes;
|
|
};
|
|
|
|
}
|
|
|
|
// XInterface
|
|
|
|
Any SAL_CALL ORegistryFactoryHelper::queryInterface(
|
|
Type const & type )
|
|
{
|
|
Any ret( OFactoryComponentHelper::queryInterface( type ) );
|
|
if (ret.hasValue())
|
|
return ret;
|
|
return OPropertySetHelper::queryInterface( type );
|
|
}
|
|
|
|
|
|
void ORegistryFactoryHelper::acquire() noexcept
|
|
{
|
|
OFactoryComponentHelper::acquire();
|
|
}
|
|
|
|
|
|
void ORegistryFactoryHelper::release() noexcept
|
|
{
|
|
OFactoryComponentHelper::release();
|
|
}
|
|
|
|
// XTypeProvider
|
|
|
|
Sequence< Type > ORegistryFactoryHelper::getTypes()
|
|
{
|
|
Sequence< Type > types( OFactoryComponentHelper::getTypes() );
|
|
sal_Int32 pos = types.getLength();
|
|
types.realloc( pos + 3 );
|
|
Type * p = types.getArray();
|
|
p[ pos++ ] = cppu::UnoType<beans::XMultiPropertySet>::get();
|
|
p[ pos++ ] = cppu::UnoType<beans::XFastPropertySet>::get();
|
|
p[ pos++ ] = cppu::UnoType<beans::XPropertySet>::get();
|
|
return types;
|
|
}
|
|
|
|
// XPropertySet
|
|
|
|
Reference< beans::XPropertySetInfo >
|
|
ORegistryFactoryHelper::getPropertySetInfo()
|
|
{
|
|
::osl::MutexGuard guard( aMutex );
|
|
if (! m_xInfo.is())
|
|
m_xInfo = createPropertySetInfo( getInfoHelper() );
|
|
return m_xInfo;
|
|
}
|
|
|
|
// OPropertySetHelper
|
|
|
|
IPropertyArrayHelper & ORegistryFactoryHelper::getInfoHelper()
|
|
{
|
|
::osl::MutexGuard guard( aMutex );
|
|
if (m_property_array_helper == nullptr)
|
|
{
|
|
beans::Property prop(
|
|
"ImplementationKey" /* name */,
|
|
0 /* handle */,
|
|
cppu::UnoType<decltype(xImplementationKey)>::get(),
|
|
beans::PropertyAttribute::READONLY |
|
|
beans::PropertyAttribute::OPTIONAL );
|
|
m_property_array_helper.reset(
|
|
new ::cppu::OPropertyArrayHelper( &prop, 1 ) );
|
|
}
|
|
return *m_property_array_helper;
|
|
}
|
|
|
|
|
|
sal_Bool ORegistryFactoryHelper::convertFastPropertyValue(
|
|
Any &, Any &, sal_Int32, Any const & )
|
|
{
|
|
OSL_FAIL( "unexpected!" );
|
|
return false;
|
|
}
|
|
|
|
|
|
void ORegistryFactoryHelper::setFastPropertyValue_NoBroadcast(
|
|
sal_Int32, Any const & )
|
|
{
|
|
throw beans::PropertyVetoException(
|
|
"unexpected: only readonly properties!",
|
|
static_cast< OWeakObject * >(this) );
|
|
}
|
|
|
|
|
|
void ORegistryFactoryHelper::getFastPropertyValue(
|
|
Any & rValue, sal_Int32 nHandle ) const
|
|
{
|
|
if (nHandle == 0)
|
|
{
|
|
rValue <<= xImplementationKey;
|
|
}
|
|
else
|
|
{
|
|
rValue.clear();
|
|
throw beans::UnknownPropertyException(
|
|
"unknown property!", static_cast< OWeakObject * >(
|
|
const_cast< ORegistryFactoryHelper * >(this) ) );
|
|
}
|
|
}
|
|
|
|
Reference<XInterface > ORegistryFactoryHelper::createInstanceEveryTime(
|
|
Reference< XComponentContext > const & xContext )
|
|
{
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
Reference< XInterface > x( createModuleFactory() );
|
|
if (x.is())
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
xModuleFactory.set( x, UNO_QUERY );
|
|
xModuleFactoryDepr.set( x, UNO_QUERY );
|
|
}
|
|
}
|
|
}
|
|
if( xModuleFactory.is() )
|
|
{
|
|
return xModuleFactory->createInstanceWithContext( xContext );
|
|
}
|
|
if( xModuleFactoryDepr.is() )
|
|
{
|
|
return xModuleFactoryDepr->createInstance();
|
|
}
|
|
|
|
return Reference<XInterface >();
|
|
}
|
|
|
|
Reference<XInterface > SAL_CALL ORegistryFactoryHelper::createInstanceWithArguments(
|
|
const Sequence<Any>& Arguments )
|
|
{
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
Reference< XInterface > x( createModuleFactory() );
|
|
if (x.is())
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
xModuleFactory.set( x, UNO_QUERY );
|
|
xModuleFactoryDepr.set( x, UNO_QUERY );
|
|
}
|
|
}
|
|
}
|
|
if( xModuleFactoryDepr.is() )
|
|
{
|
|
return xModuleFactoryDepr->createInstanceWithArguments( Arguments );
|
|
}
|
|
if( xModuleFactory.is() )
|
|
{
|
|
SAL_INFO("cppuhelper", "no context ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!");
|
|
return xModuleFactory->createInstanceWithArgumentsAndContext( Arguments, Reference< XComponentContext >() );
|
|
}
|
|
|
|
return Reference<XInterface >();
|
|
}
|
|
|
|
Reference< XInterface > ORegistryFactoryHelper::createInstanceWithArgumentsAndContext(
|
|
Sequence< Any > const & rArguments,
|
|
Reference< XComponentContext > const & xContext )
|
|
{
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
Reference< XInterface > x( createModuleFactory() );
|
|
if (x.is())
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
if( !xModuleFactory.is() && !xModuleFactoryDepr.is() )
|
|
{
|
|
xModuleFactory.set( x, UNO_QUERY );
|
|
xModuleFactoryDepr.set( x, UNO_QUERY );
|
|
}
|
|
}
|
|
}
|
|
if( xModuleFactory.is() )
|
|
{
|
|
return xModuleFactory->createInstanceWithArgumentsAndContext( rArguments, xContext );
|
|
}
|
|
if( xModuleFactoryDepr.is() )
|
|
{
|
|
SAL_INFO_IF(xContext.is(), "cppuhelper", "ignoring context calling ORegistryFactoryHelper::createInstanceWithArgumentsAndContext()!");
|
|
return xModuleFactoryDepr->createInstanceWithArguments( rArguments );
|
|
}
|
|
|
|
return Reference<XInterface >();
|
|
}
|
|
|
|
|
|
Reference< XInterface > ORegistryFactoryHelper::createModuleFactory()
|
|
{
|
|
OUString aActivatorUrl;
|
|
OUString aActivatorName;
|
|
OUString aLocation;
|
|
|
|
Reference<XRegistryKey > xActivatorKey = xImplementationKey->openKey(
|
|
"/UNO/ACTIVATOR" );
|
|
if( xActivatorKey.is() && xActivatorKey->getValueType() == RegistryValueType_ASCII )
|
|
{
|
|
aActivatorUrl = xActivatorKey->getAsciiValue();
|
|
|
|
aActivatorName = o3tl::getToken(aActivatorUrl, 0, ':');
|
|
|
|
Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
|
|
"/UNO/LOCATION" );
|
|
if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
|
|
aLocation = xLocationKey->getAsciiValue();
|
|
}
|
|
else
|
|
{
|
|
// old style"url"
|
|
// the location of the program code of the implementation
|
|
Reference<XRegistryKey > xLocationKey = xImplementationKey->openKey(
|
|
"/UNO/URL" );
|
|
// is the key of the right type ?
|
|
if( xLocationKey.is() && xLocationKey->getValueType() == RegistryValueType_ASCII )
|
|
{
|
|
// one implementation found -> try to activate
|
|
aLocation = xLocationKey->getAsciiValue();
|
|
|
|
// search protocol delimiter
|
|
sal_Int32 nPos = aLocation.indexOf("://");
|
|
if( nPos != -1 )
|
|
{
|
|
aActivatorName = aLocation.subView( 0, nPos );
|
|
if( aActivatorName == u"java" )
|
|
aActivatorName = u"com.sun.star.loader.Java";
|
|
else if( aActivatorName == u"module" )
|
|
aActivatorName = u"com.sun.star.loader.SharedLibrary";
|
|
aLocation = aLocation.copy( nPos + 3 );
|
|
}
|
|
}
|
|
}
|
|
|
|
Reference< XInterface > xFactory;
|
|
if( !aActivatorName.isEmpty() )
|
|
{
|
|
Reference<XInterface > x = xSMgr->createInstance( aActivatorName );
|
|
Reference<XImplementationLoader > xLoader( x, UNO_QUERY );
|
|
if (xLoader.is())
|
|
{
|
|
xFactory = xLoader->activate( aImplementationName, aActivatorUrl, aLocation, xImplementationKey );
|
|
}
|
|
}
|
|
return xFactory;
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > ORegistryFactoryHelper::getSupportedServiceNames()
|
|
{
|
|
MutexGuard aGuard( aMutex );
|
|
if( !aServiceNames.hasElements() )
|
|
{
|
|
// not yet loaded
|
|
try
|
|
{
|
|
Reference<XRegistryKey > xKey = xImplementationKey->openKey( "UNO/SERVICES" );
|
|
|
|
if (xKey.is())
|
|
{
|
|
// length of prefix. +1 for the '/' at the end
|
|
sal_Int32 nPrefixLen = xKey->getKeyName().getLength() + 1;
|
|
|
|
// Full qualified names like "IMPLEMENTATIONS/TEST/UNO/SERVICES/com.sun.star..."
|
|
Sequence<OUString> seqKeys = xKey->getKeyNames();
|
|
for( OUString & key : asNonConstRange(seqKeys) )
|
|
key = key.copy(nPrefixLen);
|
|
|
|
aServiceNames = seqKeys;
|
|
}
|
|
}
|
|
catch (InvalidRegistryException &)
|
|
{
|
|
}
|
|
}
|
|
return aServiceNames;
|
|
}
|
|
|
|
sal_Bool SAL_CALL ORegistryFactoryHelper::releaseOnNotification()
|
|
{
|
|
bool retVal= true;
|
|
if( isOneInstance() && isInstance())
|
|
{
|
|
retVal= false;
|
|
}
|
|
else if( ! isOneInstance())
|
|
{
|
|
// try to delegate
|
|
if( xModuleFactory.is())
|
|
{
|
|
Reference<XUnloadingPreference> xunloading( xModuleFactory, UNO_QUERY);
|
|
if( xunloading.is())
|
|
retVal= xunloading->releaseOnNotification();
|
|
}
|
|
else if( xModuleFactoryDepr.is())
|
|
{
|
|
Reference<XUnloadingPreference> xunloading( xModuleFactoryDepr, UNO_QUERY);
|
|
if( xunloading.is())
|
|
retVal= xunloading->releaseOnNotification();
|
|
}
|
|
}
|
|
return retVal;
|
|
}
|
|
|
|
namespace {
|
|
|
|
class OFactoryProxyHelper : public WeakImplHelper< XServiceInfo, XSingleServiceFactory,
|
|
XUnloadingPreference >
|
|
{
|
|
Reference<XSingleServiceFactory > xFactory;
|
|
|
|
public:
|
|
|
|
explicit OFactoryProxyHelper( const Reference<XSingleServiceFactory > & rFactory )
|
|
: xFactory( rFactory )
|
|
{}
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > SAL_CALL createInstance() override;
|
|
Reference<XInterface > SAL_CALL createInstanceWithArguments(const Sequence<Any>& Arguments) override;
|
|
|
|
// XServiceInfo
|
|
OUString SAL_CALL getImplementationName() override;
|
|
sal_Bool SAL_CALL supportsService(const OUString& ServiceName) override;
|
|
Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
|
|
//XUnloadingPreference
|
|
sal_Bool SAL_CALL releaseOnNotification() override;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > OFactoryProxyHelper::createInstance()
|
|
{
|
|
return xFactory->createInstance();
|
|
}
|
|
|
|
// XSingleServiceFactory
|
|
Reference<XInterface > OFactoryProxyHelper::createInstanceWithArguments
|
|
(
|
|
const Sequence<Any>& Arguments
|
|
)
|
|
{
|
|
return xFactory->createInstanceWithArguments( Arguments );
|
|
}
|
|
|
|
// XServiceInfo
|
|
OUString OFactoryProxyHelper::getImplementationName()
|
|
{
|
|
Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY );
|
|
if( xInfo.is() )
|
|
return xInfo->getImplementationName();
|
|
return OUString();
|
|
}
|
|
|
|
// XServiceInfo
|
|
sal_Bool OFactoryProxyHelper::supportsService(const OUString& ServiceName)
|
|
{
|
|
return cppu::supportsService(this, ServiceName);
|
|
}
|
|
|
|
// XServiceInfo
|
|
Sequence< OUString > OFactoryProxyHelper::getSupportedServiceNames()
|
|
{
|
|
Reference<XServiceInfo > xInfo( xFactory, UNO_QUERY );
|
|
if( xInfo.is() )
|
|
return xInfo->getSupportedServiceNames();
|
|
return Sequence< OUString >();
|
|
}
|
|
|
|
sal_Bool SAL_CALL OFactoryProxyHelper::releaseOnNotification()
|
|
{
|
|
|
|
Reference<XUnloadingPreference> pref( xFactory, UNO_QUERY);
|
|
if( pref.is())
|
|
return pref->releaseOnNotification();
|
|
return true;
|
|
}
|
|
|
|
// global function
|
|
Reference<XSingleServiceFactory > SAL_CALL createSingleFactory(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
const OUString & rImplementationName,
|
|
ComponentInstantiation pCreateFunction,
|
|
const Sequence< OUString > & rServiceNames,
|
|
rtl_ModuleCount * )
|
|
{
|
|
return new OFactoryComponentHelper(
|
|
rServiceManager, rImplementationName, pCreateFunction, nullptr, &rServiceNames, false );
|
|
}
|
|
|
|
// global function
|
|
Reference<XSingleServiceFactory > SAL_CALL createFactoryProxy(
|
|
SAL_UNUSED_PARAMETER const Reference<XMultiServiceFactory > &,
|
|
const Reference<XSingleServiceFactory > & rFactory )
|
|
{
|
|
return new OFactoryProxyHelper( rFactory );
|
|
}
|
|
|
|
// global function
|
|
Reference<XSingleServiceFactory > SAL_CALL createOneInstanceFactory(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
const OUString & rImplementationName,
|
|
ComponentInstantiation pCreateFunction,
|
|
const Sequence< OUString > & rServiceNames,
|
|
rtl_ModuleCount * )
|
|
{
|
|
return new OFactoryComponentHelper(
|
|
rServiceManager, rImplementationName, pCreateFunction, nullptr, &rServiceNames, true );
|
|
}
|
|
|
|
// global function
|
|
Reference<XSingleServiceFactory > SAL_CALL createSingleRegistryFactory(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
const OUString & rImplementationName,
|
|
const Reference<XRegistryKey > & rImplementationKey )
|
|
{
|
|
return new ORegistryFactoryHelper(
|
|
rServiceManager, rImplementationName, rImplementationKey, false );
|
|
}
|
|
|
|
// global function
|
|
Reference<XSingleServiceFactory > SAL_CALL createOneInstanceRegistryFactory(
|
|
const Reference<XMultiServiceFactory > & rServiceManager,
|
|
const OUString & rImplementationName,
|
|
const Reference<XRegistryKey > & rImplementationKey )
|
|
{
|
|
return new ORegistryFactoryHelper(
|
|
rServiceManager, rImplementationName, rImplementationKey, true );
|
|
}
|
|
|
|
|
|
Reference< lang::XSingleComponentFactory > SAL_CALL createSingleComponentFactory(
|
|
ComponentFactoryFunc fptr,
|
|
OUString const & rImplementationName,
|
|
Sequence< OUString > const & rServiceNames,
|
|
rtl_ModuleCount *)
|
|
{
|
|
return new OFactoryComponentHelper(
|
|
Reference< XMultiServiceFactory >(), rImplementationName, nullptr, fptr, &rServiceNames, false );
|
|
}
|
|
|
|
Reference< lang::XSingleComponentFactory > SAL_CALL createOneInstanceComponentFactory(
|
|
ComponentFactoryFunc fptr,
|
|
OUString const & rImplementationName,
|
|
Sequence< OUString > const & rServiceNames,
|
|
rtl_ModuleCount *)
|
|
{
|
|
return new OFactoryComponentHelper(
|
|
Reference< XMultiServiceFactory >(), rImplementationName, nullptr, fptr, &rServiceNames, true );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|