| /************************************************************** | |
| * | |
| * 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 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_stoc.hxx" | |
| #include <osl/mutex.hxx> | |
| #include <cppuhelper/queryinterface.hxx> | |
| #ifndef _CPPUHELER_WEAK_HXX_ | |
| #include <cppuhelper/weak.hxx> | |
| #endif | |
| #include <cppuhelper/factory.hxx> | |
| #ifndef _CPPUHELPER_IMPLEMENTATIONENTRY_HXX__ | |
| #include <cppuhelper/implementationentry.hxx> | |
| #endif | |
| #include <cppuhelper/typeprovider.hxx> | |
| #include <cppuhelper/implbase2.hxx> | |
| #include <com/sun/star/uno/DeploymentException.hpp> | |
| #include <com/sun/star/script/FailReason.hpp> | |
| #include <com/sun/star/script/XTypeConverter.hpp> | |
| #include <com/sun/star/script/XInvocation.hpp> | |
| #include <com/sun/star/script/XInvocation2.hpp> | |
| #include <com/sun/star/reflection/XIdlReflection.hpp> | |
| #include <com/sun/star/container/XNameContainer.hpp> | |
| #include <com/sun/star/container/XIndexContainer.hpp> | |
| #include <com/sun/star/container/XEnumerationAccess.hpp> | |
| #include <com/sun/star/beans/XExactName.hpp> | |
| #include <com/sun/star/beans/XMaterialHolder.hpp> | |
| #include <com/sun/star/beans/XIntrospection.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/beans/PropertyAttribute.hpp> | |
| #include <com/sun/star/beans/MethodConcept.hpp> | |
| #include <com/sun/star/beans/PropertyConcept.hpp> | |
| #include <com/sun/star/lang/XSingleServiceFactory.hpp> | |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> | |
| #include <com/sun/star/lang/XServiceInfo.hpp> | |
| #include <com/sun/star/lang/XTypeProvider.hpp> | |
| #include <com/sun/star/registry/XRegistryKey.hpp> | |
| #include <boost/scoped_array.hpp> | |
| #include <rtl/ustrbuf.hxx> | |
| #include <rtl/strbuf.hxx> | |
| #define SERVICENAME "com.sun.star.script.Invocation" | |
| #define IMPLNAME "com.sun.star.comp.stoc.Invocation" | |
| using namespace com::sun::star::uno; | |
| using namespace com::sun::star::lang; | |
| using namespace com::sun::star::script; | |
| using namespace com::sun::star::reflection; | |
| using namespace com::sun::star::beans; | |
| using namespace com::sun::star::registry; | |
| using namespace com::sun::star::container; | |
| using namespace cppu; | |
| using namespace rtl; | |
| using namespace osl; | |
| namespace stoc_inv | |
| { | |
| static rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT; | |
| static Sequence< OUString > inv_getSupportedServiceNames() | |
| { | |
| static Sequence < OUString > *pNames = 0; | |
| if( ! pNames ) | |
| { | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if( !pNames ) | |
| { | |
| static Sequence< OUString > seqNames(1); | |
| seqNames.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICENAME)); | |
| pNames = &seqNames; | |
| } | |
| } | |
| return *pNames; | |
| } | |
| static OUString inv_getImplementationName() | |
| { | |
| static OUString *pImplName = 0; | |
| if( ! pImplName ) | |
| { | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if( ! pImplName ) | |
| { | |
| static OUString implName( RTL_CONSTASCII_USTRINGPARAM( IMPLNAME ) ); | |
| pImplName = &implName; | |
| } | |
| } | |
| return *pImplName; | |
| } | |
| // TODO: Zentral implementieren | |
| inline Reference<XIdlClass> TypeToIdlClass( const Type& rType, const Reference< XIdlReflection > & xRefl ) | |
| { | |
| return xRefl->forName( rType.getTypeName() ); | |
| } | |
| //================================================================================================== | |
| class Invocation_Impl | |
| : public OWeakObject | |
| , public XInvocation2 | |
| , public XNameContainer | |
| , public XIndexContainer | |
| , public XEnumerationAccess | |
| , public XExactName | |
| , public XMaterialHolder | |
| , public XTypeProvider | |
| { | |
| public: | |
| Invocation_Impl( const Any & rAdapted, const Reference<XTypeConverter> &, | |
| const Reference<XIntrospection> &, | |
| const Reference<XIdlReflection> & ); | |
| virtual ~Invocation_Impl(); | |
| // XInterface | |
| virtual Any SAL_CALL queryInterface( const Type & aType); | |
| virtual void SAL_CALL acquire() throw() { OWeakObject::acquire(); } | |
| virtual void SAL_CALL release() throw() { OWeakObject::release(); } | |
| // XTypeProvider | |
| virtual Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes( ); | |
| virtual Sequence< sal_Int8 > SAL_CALL getImplementationId( ); | |
| // Methoden von XMaterialHolder | |
| virtual Any SAL_CALL getMaterial(void); | |
| // ? XTool | |
| virtual void SAL_CALL setMaterial( const Any& rMaterial ); | |
| // XInvocation | |
| virtual Reference<XIntrospectionAccess> SAL_CALL getIntrospection(void); | |
| virtual Any SAL_CALL invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam); | |
| virtual void SAL_CALL setValue(const OUString& PropertyName, const Any& Value); | |
| virtual Any SAL_CALL getValue(const OUString& PropertyName); | |
| virtual sal_Bool SAL_CALL hasMethod(const OUString& Name); | |
| virtual sal_Bool SAL_CALL hasProperty(const OUString& Name); | |
| // XInvocation2 | |
| virtual Sequence< OUString > SAL_CALL getMemberNames( ); | |
| virtual Sequence< InvocationInfo > SAL_CALL getInfo( ); | |
| virtual InvocationInfo SAL_CALL getInfoForName( const OUString& aName, sal_Bool bExact ); | |
| // All Access and Container methods are not thread save | |
| // XElementAccess | |
| virtual Type SAL_CALL getElementType(void) | |
| { return _xElementAccess->getElementType(); } | |
| virtual sal_Bool SAL_CALL hasElements(void) | |
| { return _xElementAccess->hasElements(); } | |
| // XNameContainer | |
| virtual void SAL_CALL insertByName( const OUString& Name, const Any& Element ) | |
| { _xNameContainer->insertByName( Name, Element ); } | |
| virtual void SAL_CALL replaceByName( const OUString& Name, const Any& Element ) | |
| { _xNameContainer->replaceByName( Name, Element ); } | |
| virtual void SAL_CALL removeByName( const OUString& Name ) | |
| { _xNameContainer->removeByName( Name ); } | |
| // XNameAccess | |
| virtual Any SAL_CALL getByName( const OUString& Name ) | |
| { return _xNameAccess->getByName( Name ); } | |
| virtual Sequence<OUString> SAL_CALL getElementNames(void) | |
| { return _xNameAccess->getElementNames(); } | |
| virtual sal_Bool SAL_CALL hasByName( const OUString& Name ) | |
| { return _xNameAccess->hasByName( Name ); } | |
| // XIndexContainer | |
| virtual void SAL_CALL insertByIndex( sal_Int32 Index, const Any& Element ) | |
| { _xIndexContainer->insertByIndex( Index, Element ); } | |
| virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) | |
| { _xIndexContainer->replaceByIndex( Index, Element ); } | |
| virtual void SAL_CALL removeByIndex( sal_Int32 Index ) | |
| { _xIndexContainer->removeByIndex( Index ); } | |
| // XIndexAccess | |
| virtual sal_Int32 SAL_CALL getCount(void) | |
| { return _xIndexAccess->getCount(); } | |
| virtual Any SAL_CALL getByIndex( sal_Int32 Index ) | |
| { return _xIndexAccess->getByIndex( Index ); } | |
| // XEnumerationAccess | |
| virtual Reference<XEnumeration> SAL_CALL createEnumeration(void) | |
| { return _xEnumerationAccess->createEnumeration(); } | |
| // XExactName | |
| virtual OUString SAL_CALL getExactName( const OUString& rApproximateName ); | |
| //===================================================================================================== | |
| private: | |
| void getInfoSequenceImpl( Sequence< OUString >* pStringSeq, Sequence< InvocationInfo >* pInfoSeq ); | |
| void fillInfoForNameAccess( InvocationInfo& rInfo, const OUString& aName ); | |
| void fillInfoForProperty( InvocationInfo& rInfo, const Property& rProp ); | |
| void fillInfoForMethod( InvocationInfo& rInfo, const Reference< XIdlMethod > xMethod ); | |
| Reference<XTypeConverter> xTypeConverter; | |
| Reference<XIntrospection> xIntrospection; | |
| Reference<XIdlReflection> xCoreReflection; | |
| Any _aMaterial; | |
| // _xDirect and (_xIntrospectionAccess, xPropertySet) are exclusive | |
| Reference<XInvocation> _xDirect; | |
| Reference<XInvocation2> _xDirect2; | |
| Reference<XPropertySet> _xPropertySet; | |
| Reference<XIntrospectionAccess> _xIntrospectionAccess; | |
| // supplied Interfaces | |
| Reference<XNameContainer> _xNameContainer; | |
| Reference<XNameAccess> _xNameAccess; | |
| Reference<XIndexContainer> _xIndexContainer; | |
| Reference<XIndexAccess> _xIndexAccess; | |
| Reference<XEnumerationAccess> _xEnumerationAccess; | |
| Reference<XElementAccess> _xElementAccess; | |
| // | |
| Reference<XExactName> _xENDirect, _xENIntrospection, _xENNameAccess; | |
| }; | |
| //================================================================================================== | |
| //================================================================================================== | |
| //================================================================================================== | |
| //-------------------------------------------------------------------------------------------------- | |
| Invocation_Impl::Invocation_Impl | |
| ( | |
| const Any & rAdapted, | |
| const Reference<XTypeConverter> & rTC, | |
| const Reference<XIntrospection> & rI, | |
| const Reference<XIdlReflection> & rCR | |
| ) | |
| : xTypeConverter( rTC ) | |
| , xIntrospection( rI ) | |
| , xCoreReflection( rCR ) | |
| { | |
| g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); | |
| setMaterial( rAdapted ); | |
| } | |
| Invocation_Impl::~Invocation_Impl() | |
| { | |
| g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); | |
| } | |
| //################################################################################################## | |
| //### INTERFACE IMPLEMENTATIONS #################################################################### | |
| //################################################################################################## | |
| Any SAL_CALL Invocation_Impl::queryInterface( const Type & aType ) | |
| { | |
| // PropertySet-Implementation | |
| Any a = ::cppu::queryInterface( aType, | |
| SAL_STATIC_CAST(XInvocation*, this), | |
| SAL_STATIC_CAST(XMaterialHolder*, this), | |
| SAL_STATIC_CAST(XTypeProvider *,this) ); | |
| if( a.hasValue() ) | |
| { | |
| return a; | |
| } | |
| if( aType == getCppuType( (Reference<XExactName>*) NULL ) ) | |
| { | |
| // Ivocation does not support XExactName, if direct object supports | |
| // XInvocation, but not XExactName. | |
| if ((_xDirect.is() && _xENDirect.is()) || | |
| (!_xDirect.is() && (_xENIntrospection.is() || _xENNameAccess.is()))) | |
| { | |
| return makeAny( Reference< XExactName >( SAL_STATIC_CAST(XExactName*, this) ) ); | |
| } | |
| } | |
| else if ( aType == getCppuType( (Reference<XNameContainer>*) NULL ) ) | |
| { | |
| if( _xNameContainer.is() ) | |
| return makeAny( Reference< XNameContainer >( SAL_STATIC_CAST(XNameContainer*, this) ) ); | |
| } | |
| else if ( aType == getCppuType( (Reference<XNameAccess>*) NULL ) ) | |
| { | |
| if( _xNameAccess.is() ) | |
| return makeAny( Reference< XNameAccess >( SAL_STATIC_CAST(XNameAccess*, this) ) ); | |
| } | |
| else if ( aType == getCppuType( (Reference<XIndexContainer>*) NULL ) ) | |
| { | |
| if (_xIndexContainer.is()) | |
| return makeAny( Reference< XIndexContainer >( SAL_STATIC_CAST(XIndexContainer*, this) ) ); | |
| } | |
| else if ( aType == getCppuType( (Reference<XIndexAccess>*) NULL ) ) | |
| { | |
| if (_xIndexAccess.is()) | |
| return makeAny( Reference< XIndexAccess >( SAL_STATIC_CAST(XIndexAccess*, this) ) ); | |
| } | |
| else if ( aType == getCppuType( (Reference<XEnumerationAccess>*) NULL ) ) | |
| { | |
| if (_xEnumerationAccess.is()) | |
| return makeAny( Reference< XEnumerationAccess >( SAL_STATIC_CAST(XEnumerationAccess*, this) ) ); | |
| } | |
| else if ( aType == getCppuType( (Reference<XElementAccess>*) NULL ) ) | |
| { | |
| if (_xElementAccess.is()) | |
| { | |
| return makeAny( Reference< XElementAccess >( | |
| SAL_STATIC_CAST(XElementAccess*, SAL_STATIC_CAST(XNameContainer*, this) ) ) ); | |
| } | |
| } | |
| else if ( aType == getCppuType( (Reference<XInvocation2>*) NULL ) ) | |
| { | |
| // Invocation does not support XInvocation2, if direct object supports | |
| // XInvocation, but not XInvocation2. | |
| if ( ( _xDirect.is() && _xDirect2.is()) || | |
| (!_xDirect.is() && _xIntrospectionAccess.is() ) ) | |
| { | |
| return makeAny( Reference< XInvocation2 >( SAL_STATIC_CAST(XInvocation2*, this) ) ); | |
| } | |
| } | |
| return OWeakObject::queryInterface( aType ); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Any Invocation_Impl::getMaterial(void) | |
| { | |
| // AB, 12.2.1999 Sicherstellen, dass das Material wenn moeglich | |
| // aus der direkten Invocation bzw. von der Introspection geholt | |
| // wird, da sonst Structs nicht korrekt behandelt werden | |
| Reference<XMaterialHolder> xMaterialHolder; | |
| if( _xDirect.is() ) | |
| { | |
| xMaterialHolder = Reference<XMaterialHolder>::query( _xDirect ); | |
| //_xDirect->queryInterface( XMaterialHolder::getSmartUik(), xMaterialHolder ); | |
| } | |
| else if( _xIntrospectionAccess.is() ) | |
| { | |
| xMaterialHolder = Reference<XMaterialHolder>::query( _xIntrospectionAccess ); | |
| //_xIntrospectionAccess->queryInterface( XMaterialHolder::getSmartUik(), xMaterialHolder ); | |
| } | |
| if( xMaterialHolder.is() ) | |
| { | |
| return xMaterialHolder->getMaterial(); | |
| } | |
| return _aMaterial; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| void Invocation_Impl::setMaterial( const Any& rMaterial ) | |
| { | |
| // set the material first and only once | |
| Reference<XInterface> xObj; | |
| if (rMaterial.getValueType().getTypeClass() == TypeClass_INTERFACE) | |
| xObj = *(Reference<XInterface>*)rMaterial.getValue(); | |
| _aMaterial = rMaterial; | |
| // Ersteinmal alles ausserhalb des guards machen | |
| _xDirect = Reference<XInvocation>::query( xObj ); | |
| if( _xDirect.is() ) | |
| { | |
| // Objekt direkt befragen | |
| _xElementAccess = Reference<XElementAccess>::query( _xDirect ); | |
| _xEnumerationAccess = Reference<XEnumerationAccess>::query( _xDirect ); | |
| _xIndexAccess = Reference<XIndexAccess>::query( _xDirect ); | |
| _xIndexContainer = Reference<XIndexContainer>::query( _xDirect ); | |
| _xNameAccess = Reference<XNameAccess>::query( _xDirect ); | |
| _xNameContainer = Reference<XNameContainer>::query( _xDirect ); | |
| _xENDirect = Reference<XExactName>::query( _xDirect ); | |
| _xDirect2 = Reference<XInvocation2>::query( _xDirect ); | |
| // only once!!! | |
| //_xIntrospectionAccess = XIntrospectionAccessRef(); | |
| //_xPropertySet = XPropertySetRef(); | |
| } | |
| else | |
| { | |
| // Invocation ueber die Introspection machen | |
| if (xIntrospection.is()) | |
| { | |
| _xIntrospectionAccess = xIntrospection->inspect( _aMaterial ); | |
| if( _xIntrospectionAccess.is() ) | |
| { | |
| _xElementAccess = Reference<XElementAccess>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XElementAccess>*) NULL ) ) ); | |
| _xEnumerationAccess = Reference<XEnumerationAccess>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XEnumerationAccess>*) NULL )) ); | |
| _xIndexAccess = Reference<XIndexAccess>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XIndexAccess>*) NULL ) ) ); | |
| _xIndexContainer = Reference<XIndexContainer>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XIndexContainer>*) NULL ) ) ); | |
| _xNameAccess = Reference<XNameAccess>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XNameAccess>*) NULL ) ) ); | |
| _xNameContainer = Reference<XNameContainer>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XNameContainer>*) NULL ) ) ); | |
| _xPropertySet = Reference<XPropertySet>::query( | |
| _xIntrospectionAccess->queryAdapter( | |
| getCppuType( (Reference<XPropertySet>*) NULL )) ); | |
| _xENIntrospection = Reference<XExactName>::query( _xIntrospectionAccess ); | |
| if (_xNameAccess.is()) | |
| _xENNameAccess = Reference<XExactName>::query( _xNameAccess ); | |
| } | |
| } | |
| /* only once !!! | |
| _xDirect = XInvocationRef(); | |
| if( !_xIntrospectionAccess.is() ) | |
| { | |
| // reset | |
| _xElementAccess = XElementAccessRef(); | |
| _xEnumerationAccess = XEnumerationAccessRef(); | |
| _xIndexAccess = XIndexAccessRef(); | |
| _xIndexContainer = XIndexContainerRef(); | |
| _xNameAccess = XNameAccessRef(); | |
| _xNameContainer = XNameContainerRef(); | |
| _xPropertySet = XPropertySetRef(); | |
| } | |
| */ | |
| } | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| OUString Invocation_Impl::getExactName( const OUString& rApproximateName ) | |
| { | |
| if (_xENDirect.is()) | |
| return _xENDirect->getExactName( rApproximateName ); | |
| OUString aRet; | |
| if (_xENIntrospection.is()) | |
| aRet = _xENIntrospection->getExactName( rApproximateName ); | |
| if (!aRet.getLength() && _xENNameAccess.is()) | |
| aRet = _xENNameAccess->getExactName( rApproximateName ); | |
| return aRet; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Reference<XIntrospectionAccess> Invocation_Impl::getIntrospection(void) | |
| { | |
| if( _xDirect.is() ) | |
| return _xDirect->getIntrospection(); | |
| else | |
| return _xIntrospectionAccess; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| sal_Bool Invocation_Impl::hasMethod( const OUString& Name ) | |
| { | |
| if (_xDirect.is()) | |
| return _xDirect->hasMethod( Name ); | |
| if( _xIntrospectionAccess.is() ) | |
| return _xIntrospectionAccess->hasMethod( Name, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); | |
| return sal_False; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| sal_Bool Invocation_Impl::hasProperty( const OUString& Name ) | |
| { | |
| if (_xDirect.is()) | |
| return _xDirect->hasProperty( Name ); | |
| // PropertySet | |
| if( _xIntrospectionAccess.is() | |
| && _xIntrospectionAccess->hasProperty( Name, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) | |
| return sal_True; | |
| // NameAccess | |
| if( _xNameAccess.is() ) | |
| return _xNameAccess->hasByName( Name ); | |
| return sal_False; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Any Invocation_Impl::getValue( const OUString& PropertyName ) | |
| { | |
| if (_xDirect.is()) | |
| return _xDirect->getValue( PropertyName ); | |
| try | |
| { | |
| // PropertySet | |
| if( _xIntrospectionAccess.is() && _xPropertySet.is() | |
| && _xIntrospectionAccess->hasProperty | |
| ( PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) | |
| { | |
| return _xPropertySet->getPropertyValue( PropertyName ); | |
| } | |
| // NameAccess | |
| if( _xNameAccess.is() && _xNameAccess->hasByName( PropertyName ) ) | |
| return _xNameAccess->getByName( PropertyName ); | |
| } | |
| catch (UnknownPropertyException &) | |
| { | |
| throw; | |
| } | |
| catch (RuntimeException &) | |
| { | |
| throw; | |
| } | |
| catch (Exception &) | |
| { | |
| } | |
| throw UnknownPropertyException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("cannot get value ") ) + PropertyName, | |
| Reference< XInterface >() ); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| void Invocation_Impl::setValue( const OUString& PropertyName, const Any& Value ) | |
| { | |
| if (_xDirect.is()) | |
| _xDirect->setValue( PropertyName, Value ); | |
| else | |
| { | |
| try | |
| { | |
| // Properties | |
| if( _xIntrospectionAccess.is() && _xPropertySet.is() | |
| && _xIntrospectionAccess->hasProperty( | |
| PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) | |
| { | |
| Property aProp = _xIntrospectionAccess->getProperty( | |
| PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ); | |
| Reference < XIdlClass > r = TypeToIdlClass( aProp.Type, xCoreReflection ); | |
| if( r->isAssignableFrom( TypeToIdlClass( Value.getValueType(), xCoreReflection ) ) ) | |
| _xPropertySet->setPropertyValue( PropertyName, Value ); | |
| else if( xTypeConverter.is() ) | |
| _xPropertySet->setPropertyValue( | |
| PropertyName, xTypeConverter->convertTo( Value, aProp.Type ) ); | |
| else | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("no type converter service!") ), | |
| Reference< XInterface >() ); | |
| } | |
| // NameContainer | |
| else if( _xNameContainer.is() ) | |
| { | |
| Any aConv; | |
| Reference < XIdlClass > r = | |
| TypeToIdlClass( _xNameContainer->getElementType(), xCoreReflection ); | |
| if( r->isAssignableFrom(TypeToIdlClass( Value.getValueType(), xCoreReflection ) ) ) | |
| aConv = Value; | |
| else if( xTypeConverter.is() ) | |
| aConv = xTypeConverter->convertTo( Value, _xNameContainer->getElementType() ); | |
| else | |
| throw RuntimeException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("no type converter service!") ), | |
| Reference< XInterface >() ); | |
| // bei Vorhandensein ersetzen, ansonsten einfuegen | |
| if (_xNameContainer->hasByName( PropertyName )) | |
| _xNameContainer->replaceByName( PropertyName, aConv ); | |
| else | |
| _xNameContainer->insertByName( PropertyName, aConv ); | |
| } | |
| else | |
| throw UnknownPropertyException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("no introspection nor name container!") ), | |
| Reference< XInterface >() ); | |
| } | |
| catch (UnknownPropertyException &) | |
| { | |
| throw; | |
| } | |
| catch (CannotConvertException &) | |
| { | |
| throw; | |
| } | |
| catch (InvocationTargetException &) | |
| { | |
| throw; | |
| } | |
| catch (RuntimeException &) | |
| { | |
| throw; | |
| } | |
| catch (Exception & exc) | |
| { | |
| throw InvocationTargetException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("exception occurred in setValue(): ") ) + | |
| exc.Message, Reference< XInterface >(), makeAny( exc /* though sliced */ ) ); | |
| } | |
| } | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>& InParams, | |
| Sequence<sal_Int16>& OutIndizes, Sequence<Any>& OutParams ) | |
| { | |
| if (_xDirect.is()) | |
| return _xDirect->invoke( FunctionName, InParams, OutIndizes, OutParams ); | |
| if (_xIntrospectionAccess.is()) | |
| { | |
| // throw NoSuchMethodException if not exist | |
| Reference<XIdlMethod> xMethod = _xIntrospectionAccess->getMethod( | |
| FunctionName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); | |
| // ParameterInfos | |
| Sequence<ParamInfo> aFParams = xMethod->getParameterInfos(); | |
| const ParamInfo* pFParams = aFParams.getConstArray(); | |
| sal_Int32 nFParamsLen = aFParams.getLength(); | |
| if (nFParamsLen != InParams.getLength()) | |
| { | |
| throw IllegalArgumentException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("incorrect number of parameters passed invoking function ") ) + FunctionName, | |
| (OWeakObject *) this, (sal_Int16) 1 ); | |
| } | |
| // IN Parameter | |
| const Any* pInParams = InParams.getConstArray(); | |
| // Introspection Invoke Parameter | |
| Sequence<Any> aInvokeParams( nFParamsLen ); | |
| Any* pInvokeParams = aInvokeParams.getArray(); | |
| // OUT Indizes | |
| OutIndizes.realloc( nFParamsLen ); | |
| sal_Int16* pOutIndizes = OutIndizes.getArray(); | |
| sal_uInt32 nOutIndex = 0; | |
| for ( sal_Int32 nPos = 0; nPos < nFParamsLen; ++nPos ) | |
| { | |
| try | |
| { | |
| const ParamInfo& rFParam = pFParams[nPos]; | |
| const Reference<XIdlClass>& rDestType = rFParam.aType; | |
| // is IN/INOUT parameter? | |
| if (rFParam.aMode != ParamMode_OUT) | |
| { | |
| if (rDestType->isAssignableFrom( TypeToIdlClass( pInParams[nPos].getValueType(), xCoreReflection ) )) | |
| { | |
| pInvokeParams[nPos] = pInParams[nPos]; | |
| } | |
| else if (xTypeConverter.is()) | |
| { | |
| Type aDestType( rDestType->getTypeClass(), rDestType->getName() ); | |
| pInvokeParams[nPos] = xTypeConverter->convertTo( pInParams[nPos], aDestType ); | |
| } | |
| else | |
| { | |
| CannotConvertException aExc; | |
| aExc.Context = *this; | |
| aExc.Message = OUString( RTL_CONSTASCII_USTRINGPARAM("invocation type mismatch!") ); | |
| throw aExc; | |
| } | |
| } | |
| // is OUT/INOUT parameter? | |
| if (rFParam.aMode != ParamMode_IN) | |
| { | |
| pOutIndizes[nOutIndex] = (sal_Int16)nPos; | |
| if (rFParam.aMode == ParamMode_OUT) | |
| rDestType->createObject( pInvokeParams[nPos] ); // default init | |
| ++nOutIndex; | |
| } | |
| } | |
| catch( CannotConvertException& rExc ) | |
| { | |
| rExc.ArgumentIndex = nPos; // optionalen Parameter Index hinzufuegen | |
| throw rExc; | |
| } | |
| } | |
| // execute Method | |
| Any aRet = xMethod->invoke( _aMaterial, aInvokeParams ); | |
| // OUT Params | |
| OutIndizes.realloc( nOutIndex ); | |
| pOutIndizes = OutIndizes.getArray(); | |
| OutParams.realloc( nOutIndex ); | |
| Any* pOutParams = OutParams.getArray(); | |
| while (nOutIndex--) | |
| { | |
| pOutParams[nOutIndex] = pInvokeParams[ pOutIndizes[nOutIndex] ]; | |
| } | |
| return aRet; | |
| } | |
| RuntimeException aExc; | |
| aExc.Context = *this; | |
| aExc.Message = OUString( RTL_CONSTASCII_USTRINGPARAM("invocation lacking of introspection access!") ); | |
| throw aExc; | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| // Struct to optimize sorting | |
| struct MemberItem | |
| { | |
| OUString aName; | |
| // Defines where the member comes from | |
| enum Mode { NAMEACCESS, PROPERTYSET, METHOD } eMode; | |
| // Index to respective sequence | |
| // (Index to NameAccess sequence for eMode==NAMEACCESS etc.) | |
| sal_Int32 nIndex; | |
| }; | |
| // Implementation of getting name or info | |
| // String sequence will be filled when pStringSeq != NULL | |
| // Info sequence will be filled when pInfoSeq != NULL | |
| void Invocation_Impl::getInfoSequenceImpl | |
| ( | |
| Sequence< OUString >* pStringSeq, | |
| Sequence< InvocationInfo >* pInfoSeq | |
| ) | |
| { | |
| //Sequence< OUString > aStrSeq; | |
| //if( !pStringSeq ) | |
| //pStringSeq = &aStrSeq; | |
| // Get all needed sequences | |
| Sequence<OUString> aNameAccessNames; | |
| Sequence<Property> aPropertySeq; | |
| Sequence< Reference< XIdlMethod > > aMethodSeq; | |
| if( _xNameAccess.is() ) | |
| { | |
| aNameAccessNames = _xNameAccess->getElementNames(); | |
| } | |
| if( _xIntrospectionAccess.is() ) | |
| { | |
| aPropertySeq = _xIntrospectionAccess->getProperties | |
| ( PropertyConcept::ALL - PropertyConcept::DANGEROUS ); | |
| aMethodSeq = _xIntrospectionAccess->getMethods | |
| ( MethodConcept::ALL - MethodConcept::DANGEROUS ); | |
| } | |
| sal_Int32 nNameAccessCount = aNameAccessNames.getLength(); | |
| sal_Int32 nPropertyCount = aPropertySeq.getLength(); | |
| sal_Int32 nMethodCount = aMethodSeq.getLength(); | |
| sal_Int32 nTotalCount = nNameAccessCount + nPropertyCount + nMethodCount; | |
| // Create and fill array of MemberItems | |
| boost::scoped_array< MemberItem > pItems( new MemberItem[ nTotalCount ] ); | |
| const OUString* pStrings = aNameAccessNames.getConstArray(); | |
| const Property* pProps = aPropertySeq.getConstArray(); | |
| const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray(); | |
| // Fill array of MemberItems | |
| sal_Int32 i, iTotal = 0; | |
| // Name Access | |
| for( i = 0 ; i < nNameAccessCount ; i++, iTotal++ ) | |
| { | |
| MemberItem& rItem = pItems[ iTotal ]; | |
| rItem.aName = pStrings[ i ]; | |
| rItem.eMode = MemberItem::NAMEACCESS; | |
| rItem.nIndex = i; | |
| } | |
| // Property set | |
| for( i = 0 ; i < nPropertyCount ; i++, iTotal++ ) | |
| { | |
| MemberItem& rItem = pItems[ iTotal ]; | |
| rItem.aName = pProps[ i ].Name; | |
| rItem.eMode = MemberItem::PROPERTYSET; | |
| rItem.nIndex = i; | |
| } | |
| // Methods | |
| for( i = 0 ; i < nMethodCount ; i++, iTotal++ ) | |
| { | |
| MemberItem& rItem = pItems[ iTotal ]; | |
| Reference< XIdlMethod > xMethod = pMethods[ i ]; | |
| rItem.aName = xMethod->getName(); | |
| rItem.eMode = MemberItem::METHOD; | |
| rItem.nIndex = i; | |
| } | |
| // Setting up result sequences | |
| OUString* pRetStrings = NULL; | |
| if( pStringSeq ) | |
| { | |
| pStringSeq->realloc( nTotalCount ); | |
| pRetStrings = pStringSeq->getArray(); | |
| } | |
| InvocationInfo* pRetInfos = NULL; | |
| if( pInfoSeq ) | |
| { | |
| pInfoSeq->realloc( nTotalCount ); | |
| pRetInfos = pInfoSeq->getArray(); | |
| } | |
| // Fill result sequences in the correct order of members | |
| for( iTotal = 0 ; iTotal < nTotalCount ; iTotal++ ) | |
| { | |
| MemberItem& rItem = pItems[ iTotal ]; | |
| if( pRetStrings ) | |
| { | |
| pRetStrings[ iTotal ] = rItem.aName; | |
| } | |
| if( pRetInfos ) | |
| { | |
| if( rItem.eMode == MemberItem::NAMEACCESS ) | |
| { | |
| fillInfoForNameAccess( pRetInfos[ iTotal ], rItem.aName ); | |
| } | |
| else if( rItem.eMode == MemberItem::PROPERTYSET ) | |
| { | |
| fillInfoForProperty( pRetInfos[ iTotal ], pProps[ rItem.nIndex ] ); | |
| } | |
| else if( rItem.eMode == MemberItem::METHOD ) | |
| { | |
| fillInfoForMethod( pRetInfos[ iTotal ], pMethods[ rItem.nIndex ] ); | |
| } | |
| } | |
| } | |
| } | |
| // XInvocation2 | |
| Sequence< OUString > SAL_CALL Invocation_Impl::getMemberNames( ) | |
| { | |
| if( _xDirect2.is() ) | |
| { | |
| return _xDirect2->getMemberNames(); | |
| } | |
| Sequence< OUString > aRetSeq; | |
| getInfoSequenceImpl( &aRetSeq, NULL ); | |
| return aRetSeq; | |
| } | |
| Sequence< InvocationInfo > SAL_CALL Invocation_Impl::getInfo( ) | |
| { | |
| if( _xDirect2.is() ) | |
| { | |
| return _xDirect2->getInfo(); | |
| } | |
| Sequence< InvocationInfo > aRetSeq; | |
| getInfoSequenceImpl( NULL, &aRetSeq ); | |
| return aRetSeq; | |
| } | |
| InvocationInfo SAL_CALL Invocation_Impl::getInfoForName( const OUString& aName, sal_Bool bExact ) | |
| { | |
| if( _xDirect2.is() ) | |
| { | |
| return _xDirect2->getInfoForName( aName, bExact ); | |
| } | |
| sal_Bool bFound = sal_False; | |
| OUString aExactName = aName; | |
| InvocationInfo aRetInfo; | |
| if( bExact ) | |
| aExactName = getExactName( aName ); | |
| if( aExactName.getLength() > 0 ) | |
| { | |
| if( _xIntrospectionAccess->hasMethod( aExactName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ) ) | |
| { | |
| Reference<XIdlMethod> xMethod = _xIntrospectionAccess->getMethod | |
| ( aExactName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); | |
| fillInfoForMethod( aRetInfo, xMethod ); | |
| bFound = sal_True; | |
| } | |
| else | |
| { | |
| if( _xIntrospectionAccess.is() && _xIntrospectionAccess->hasProperty | |
| ( aExactName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) | |
| { | |
| Property aProp = _xIntrospectionAccess->getProperty | |
| ( aExactName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ); | |
| fillInfoForProperty( aRetInfo, aProp ); | |
| bFound = sal_True; | |
| } | |
| // NameAccess | |
| else if( _xNameAccess.is() && _xNameAccess->hasByName( aExactName ) ) | |
| { | |
| fillInfoForNameAccess( aRetInfo, aExactName ); | |
| bFound = sal_True; | |
| } | |
| } | |
| } | |
| if( !bFound ) | |
| { | |
| throw IllegalArgumentException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("Unknown name, getExactName() failed!") ), | |
| (XWeak *)(OWeakObject *)this, 0 ); | |
| } | |
| return aRetInfo; | |
| } | |
| // Helper functions to fill InvocationInfo for XNameAccess | |
| void Invocation_Impl::fillInfoForNameAccess | |
| ( | |
| InvocationInfo& rInfo, | |
| const OUString& aName | |
| ) | |
| { | |
| rInfo.aName = aName; | |
| rInfo.eMemberType = MemberType_PROPERTY; | |
| rInfo.PropertyAttribute = 0; | |
| if( !_xNameContainer.is() ) | |
| { | |
| rInfo.PropertyAttribute = PropertyAttribute::READONLY; | |
| } | |
| rInfo.aType = _xNameAccess->getElementType(); | |
| } | |
| void Invocation_Impl::fillInfoForProperty | |
| ( | |
| InvocationInfo& rInfo, | |
| const Property& rProp | |
| ) | |
| { | |
| rInfo.aName = rProp.Name; | |
| rInfo.eMemberType = MemberType_PROPERTY; | |
| rInfo.PropertyAttribute = rProp.Attributes; | |
| rInfo.aType = rProp.Type; | |
| } | |
| void Invocation_Impl::fillInfoForMethod | |
| ( | |
| InvocationInfo& rInfo, | |
| const Reference< XIdlMethod > xMethod | |
| ) | |
| { | |
| rInfo.aName = xMethod->getName(); | |
| rInfo.eMemberType = MemberType_METHOD; | |
| Reference< XIdlClass > xReturnClass = xMethod->getReturnType(); | |
| Type aReturnType( xReturnClass->getTypeClass(), xReturnClass->getName() ); | |
| rInfo.aType = aReturnType; | |
| Sequence<ParamInfo> aParamInfos = xMethod->getParameterInfos(); | |
| sal_Int32 nParamCount = aParamInfos.getLength(); | |
| if( nParamCount > 0 ) | |
| { | |
| const ParamInfo* pInfos = aParamInfos.getConstArray(); | |
| rInfo.aParamTypes.realloc( nParamCount ); | |
| Type* pParamTypes = rInfo.aParamTypes.getArray(); | |
| rInfo.aParamModes.realloc( nParamCount ); | |
| ParamMode* pParamModes = rInfo.aParamModes.getArray(); | |
| for( sal_Int32 i = 0 ; i < nParamCount ; i++ ) | |
| { | |
| Reference< XIdlClass > xParamClass = pInfos[i].aType; | |
| Type aParamType( xParamClass->getTypeClass(), xParamClass->getName() ); | |
| pParamTypes[ i ] = aParamType; | |
| pParamModes[ i ] = pInfos[i].aMode; | |
| } | |
| } | |
| } | |
| // XTypeProvider | |
| Sequence< Type > SAL_CALL Invocation_Impl::getTypes(void) | |
| { | |
| static Sequence< Type > const * s_pTypes = 0; | |
| if (! s_pTypes) | |
| { | |
| Sequence< Type > types( 4 +8 ); | |
| Type * pTypes = types.getArray(); | |
| sal_Int32 n = 0; | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XTypeProvider > const *)0 ); | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XWeak > const *)0 ); | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XInvocation > const *)0 ); | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XMaterialHolder > const *)0 ); | |
| // Ivocation does not support XExactName, if direct object supports | |
| // XInvocation, but not XExactName. | |
| if ((_xDirect.is() && _xENDirect.is()) || | |
| (!_xDirect.is() && (_xENIntrospection.is() || _xENNameAccess.is()))) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XExactName > const *)0 ); | |
| } | |
| if( _xNameContainer.is() ) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XNameContainer > const *)0 ); | |
| } | |
| if( _xNameAccess.is() ) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XNameAccess > const *)0 ); | |
| } | |
| if (_xIndexContainer.is()) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XIndexContainer > const *)0 ); | |
| } | |
| if (_xIndexAccess.is()) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XIndexAccess > const *)0 ); | |
| } | |
| if (_xEnumerationAccess.is()) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XEnumerationAccess > const *)0 ); | |
| } | |
| if (_xElementAccess.is()) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XElementAccess > const *)0 ); | |
| } | |
| // Invocation does not support XInvocation2, if direct object supports | |
| // XInvocation, but not XInvocation2. | |
| if ( ( _xDirect.is() && _xDirect2.is()) || | |
| (!_xDirect.is() && _xIntrospectionAccess.is() ) ) | |
| { | |
| pTypes[ n++ ] = ::getCppuType( (Reference< XInvocation2 > const *)0 ); | |
| } | |
| types.realloc( n ); | |
| // store types | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if (! s_pTypes) | |
| { | |
| static Sequence< Type > s_types( types ); | |
| s_pTypes = &s_types; | |
| } | |
| } | |
| return *s_pTypes; | |
| } | |
| Sequence< sal_Int8 > SAL_CALL Invocation_Impl::getImplementationId( ) | |
| { | |
| static OImplementationId *pId = 0; | |
| if( ! pId ) | |
| { | |
| MutexGuard guard( Mutex::getGlobalMutex() ); | |
| if( ! pId ) | |
| { | |
| static OImplementationId id( sal_False ); | |
| pId = &id; | |
| } | |
| } | |
| return pId->getImplementationId(); | |
| } | |
| //================================================================================================== | |
| //================================================================================================== | |
| //================================================================================================== | |
| class InvocationService | |
| : public WeakImplHelper2< XSingleServiceFactory, XServiceInfo > | |
| { | |
| public: | |
| InvocationService( const Reference<XComponentContext> & xCtx ); | |
| virtual ~InvocationService(); | |
| // XServiceInfo | |
| OUString SAL_CALL getImplementationName(); | |
| sal_Bool SAL_CALL supportsService(const OUString& ServiceName); | |
| Sequence< OUString > SAL_CALL getSupportedServiceNames(void); | |
| // XSingleServiceFactory | |
| Reference<XInterface> SAL_CALL createInstance(void); | |
| Reference<XInterface> SAL_CALL createInstanceWithArguments( | |
| const Sequence<Any>& rArguments ); | |
| private: | |
| Reference<XComponentContext> mxCtx; | |
| Reference<XMultiComponentFactory> mxSMgr; | |
| Reference<XTypeConverter> xTypeConverter; | |
| Reference<XIntrospection> xIntrospection; | |
| Reference<XIdlReflection> xCoreReflection; | |
| }; | |
| InvocationService::InvocationService( const Reference<XComponentContext> & xCtx ) | |
| : mxCtx( xCtx ) | |
| , mxSMgr( xCtx->getServiceManager() ) | |
| { | |
| g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); | |
| xTypeConverter = Reference<XTypeConverter>( | |
| mxSMgr->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter")), | |
| xCtx ), | |
| UNO_QUERY ); | |
| xIntrospection = Reference<XIntrospection>( | |
| mxSMgr->createInstanceWithContext( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.beans.Introspection")), | |
| xCtx), | |
| UNO_QUERY); | |
| mxCtx->getValueByName( | |
| OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection")) ) | |
| >>= xCoreReflection; | |
| OSL_ENSURE( xCoreReflection.is(), "### CoreReflection singleton not accessible!?" ); | |
| if (! xCoreReflection.is()) | |
| { | |
| throw DeploymentException( | |
| OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible") ), | |
| Reference< XInterface >() ); | |
| } | |
| // xCoreReflection = Reference<XIdlReflection>( | |
| // mxSMgr->createInstanceWithContext( | |
| // OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.CoreReflection")), | |
| // xCtx), | |
| // UNO_QUERY); | |
| } | |
| InvocationService::~InvocationService() | |
| { | |
| g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); | |
| } | |
| // XServiceInfo | |
| OUString InvocationService::getImplementationName() | |
| { | |
| return inv_getImplementationName(); | |
| } | |
| // XServiceInfo | |
| sal_Bool InvocationService::supportsService(const OUString& ServiceName) | |
| { | |
| Sequence< OUString > aSNL = getSupportedServiceNames(); | |
| const OUString * pArray = aSNL.getConstArray(); | |
| for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) | |
| if( pArray[i] == ServiceName ) | |
| return sal_True; | |
| return sal_False; | |
| } | |
| // XServiceInfo | |
| Sequence< OUString > InvocationService::getSupportedServiceNames(void) | |
| { | |
| return inv_getSupportedServiceNames(); | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Reference<XInterface> InvocationService::createInstance(void) | |
| { | |
| //TODO:throw( Exception(OUString( RTL_CONSTASCII_USTRINGPARAM("no default construction of invocation adapter possible!")), *this) ); | |
| return Reference<XInterface>(); // dummy | |
| } | |
| //-------------------------------------------------------------------------------------------------- | |
| Reference<XInterface> InvocationService::createInstanceWithArguments( | |
| const Sequence<Any>& rArguments ) | |
| { | |
| if (rArguments.getLength() == 1) | |
| { | |
| return Reference< XInterface > | |
| ( *new Invocation_Impl( *rArguments.getConstArray(), | |
| xTypeConverter, xIntrospection, xCoreReflection ) ); | |
| } | |
| else | |
| { | |
| //TODO:throw( Exception(OUString( RTL_CONSTASCII_USTRINGPARAM("no default construction of invocation adapter possible!")), *this) ); | |
| return Reference<XInterface>(); | |
| } | |
| } | |
| //************************************************************************* | |
| Reference<XInterface> SAL_CALL InvocationService_CreateInstance( const Reference<XComponentContext> & xCtx ) | |
| { | |
| Reference<XInterface> xService = Reference< XInterface > ( *new InvocationService( xCtx ) ); | |
| return xService; | |
| } | |
| } | |
| using namespace stoc_inv; | |
| static struct ImplementationEntry g_entries[] = | |
| { | |
| { | |
| InvocationService_CreateInstance, inv_getImplementationName, | |
| inv_getSupportedServiceNames, createSingleComponentFactory, | |
| &g_moduleCount.modCnt , 0 | |
| }, | |
| { 0, 0, 0, 0, 0, 0 } | |
| }; | |
| extern "C" | |
| { | |
| sal_Bool SAL_CALL component_canUnload( TimeValue *pTime ) | |
| { | |
| return g_moduleCount.canUnload( &g_moduleCount , pTime ); | |
| } | |
| //================================================================================================== | |
| void SAL_CALL component_getImplementationEnvironment( | |
| const sal_Char ** ppEnvTypeName, uno_Environment ** ) | |
| { | |
| *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; | |
| } | |
| //================================================================================================== | |
| void * SAL_CALL component_getFactory( | |
| const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey ) | |
| { | |
| return component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries ); | |
| } | |
| } |