| /************************************************************** |
| * |
| * 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) throw( RuntimeException ); |
| 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( ) |
| throw(RuntimeException); |
| virtual Sequence< sal_Int8 > SAL_CALL getImplementationId( ) |
| throw( RuntimeException); |
| |
| // Methoden von XMaterialHolder |
| virtual Any SAL_CALL getMaterial(void) throw(RuntimeException); |
| |
| // ? XTool |
| virtual void SAL_CALL setMaterial( const Any& rMaterial ); |
| |
| // XInvocation |
| virtual Reference<XIntrospectionAccess> SAL_CALL getIntrospection(void) throw( RuntimeException ); |
| virtual Any SAL_CALL invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam) |
| throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException ); |
| virtual void SAL_CALL setValue(const OUString& PropertyName, const Any& Value) |
| throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException ); |
| virtual Any SAL_CALL getValue(const OUString& PropertyName) |
| throw( UnknownPropertyException, RuntimeException ); |
| virtual sal_Bool SAL_CALL hasMethod(const OUString& Name) throw( RuntimeException ); |
| virtual sal_Bool SAL_CALL hasProperty(const OUString& Name) throw( RuntimeException ); |
| |
| // XInvocation2 |
| virtual Sequence< OUString > SAL_CALL getMemberNames( ) |
| throw( RuntimeException ); |
| virtual Sequence< InvocationInfo > SAL_CALL getInfo( ) |
| throw( RuntimeException ); |
| virtual InvocationInfo SAL_CALL getInfoForName( const OUString& aName, sal_Bool bExact ) |
| throw( IllegalArgumentException, RuntimeException ); |
| |
| // All Access and Container methods are not thread save |
| // XElementAccess |
| virtual Type SAL_CALL getElementType(void) throw( RuntimeException ) |
| { return _xElementAccess->getElementType(); } |
| |
| virtual sal_Bool SAL_CALL hasElements(void) throw( RuntimeException ) |
| { return _xElementAccess->hasElements(); } |
| |
| // XNameContainer |
| virtual void SAL_CALL insertByName( const OUString& Name, const Any& Element ) |
| throw( IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException ) |
| { _xNameContainer->insertByName( Name, Element ); } |
| |
| virtual void SAL_CALL replaceByName( const OUString& Name, const Any& Element ) |
| throw( IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException ) |
| { _xNameContainer->replaceByName( Name, Element ); } |
| |
| virtual void SAL_CALL removeByName( const OUString& Name ) |
| throw( NoSuchElementException, WrappedTargetException, RuntimeException ) |
| { _xNameContainer->removeByName( Name ); } |
| |
| // XNameAccess |
| virtual Any SAL_CALL getByName( const OUString& Name ) |
| throw( NoSuchElementException, WrappedTargetException, RuntimeException ) |
| { return _xNameAccess->getByName( Name ); } |
| |
| virtual Sequence<OUString> SAL_CALL getElementNames(void) throw( RuntimeException ) |
| { return _xNameAccess->getElementNames(); } |
| |
| virtual sal_Bool SAL_CALL hasByName( const OUString& Name ) throw( RuntimeException ) |
| { return _xNameAccess->hasByName( Name ); } |
| |
| // XIndexContainer |
| virtual void SAL_CALL insertByIndex( sal_Int32 Index, const Any& Element ) |
| throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) |
| { _xIndexContainer->insertByIndex( Index, Element ); } |
| |
| virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) |
| throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) |
| { _xIndexContainer->replaceByIndex( Index, Element ); } |
| |
| virtual void SAL_CALL removeByIndex( sal_Int32 Index ) |
| throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) |
| { _xIndexContainer->removeByIndex( Index ); } |
| |
| // XIndexAccess |
| virtual sal_Int32 SAL_CALL getCount(void) throw( RuntimeException ) |
| { return _xIndexAccess->getCount(); } |
| |
| virtual Any SAL_CALL getByIndex( sal_Int32 Index ) |
| throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) |
| { return _xIndexAccess->getByIndex( Index ); } |
| |
| // XEnumerationAccess |
| virtual Reference<XEnumeration> SAL_CALL createEnumeration(void) throw( RuntimeException ) |
| { return _xEnumerationAccess->createEnumeration(); } |
| |
| // XExactName |
| virtual OUString SAL_CALL getExactName( const OUString& rApproximateName ) throw( RuntimeException ); |
| |
| |
| //===================================================================================================== |
| 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 ) |
| throw( RuntimeException ) |
| { |
| // 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) throw(RuntimeException) |
| { |
| // 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 ) |
| throw( RuntimeException ) |
| { |
| 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) |
| throw( RuntimeException ) |
| { |
| if( _xDirect.is() ) |
| return _xDirect->getIntrospection(); |
| else |
| return _xIntrospectionAccess; |
| } |
| |
| //-------------------------------------------------------------------------------------------------- |
| sal_Bool Invocation_Impl::hasMethod( const OUString& Name ) |
| throw( RuntimeException ) |
| { |
| 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 ) |
| throw( RuntimeException ) |
| { |
| 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 ) |
| throw( UnknownPropertyException, RuntimeException ) |
| { |
| 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 ) |
| throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException ) |
| { |
| 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 ) |
| throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException ) |
| { |
| 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( ) |
| throw( RuntimeException ) |
| { |
| if( _xDirect2.is() ) |
| { |
| return _xDirect2->getMemberNames(); |
| } |
| Sequence< OUString > aRetSeq; |
| getInfoSequenceImpl( &aRetSeq, NULL ); |
| return aRetSeq; |
| } |
| |
| Sequence< InvocationInfo > SAL_CALL Invocation_Impl::getInfo( ) |
| throw( RuntimeException ) |
| { |
| 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 ) |
| throw( IllegalArgumentException, RuntimeException ) |
| { |
| 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) throw( RuntimeException ) |
| { |
| 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( ) throw( RuntimeException) |
| { |
| 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() throw( RuntimeException ); |
| sal_Bool SAL_CALL supportsService(const OUString& ServiceName) throw( RuntimeException ); |
| Sequence< OUString > SAL_CALL getSupportedServiceNames(void) throw( RuntimeException ); |
| |
| // XSingleServiceFactory |
| Reference<XInterface> SAL_CALL createInstance(void) throw( Exception, RuntimeException ); |
| Reference<XInterface> SAL_CALL createInstanceWithArguments( |
| const Sequence<Any>& rArguments ) throw( Exception, RuntimeException ); |
| 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() throw( RuntimeException ) |
| { |
| return inv_getImplementationName(); |
| } |
| |
| // XServiceInfo |
| sal_Bool InvocationService::supportsService(const OUString& ServiceName) throw( RuntimeException ) |
| { |
| 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) throw( RuntimeException ) |
| { |
| return inv_getSupportedServiceNames(); |
| } |
| |
| //-------------------------------------------------------------------------------------------------- |
| Reference<XInterface> InvocationService::createInstance(void) throw( Exception, RuntimeException ) |
| { |
| //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 ) throw( Exception, RuntimeException ) |
| { |
| 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 ) |
| throw( RuntimeException ) |
| { |
| 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 ); |
| } |
| } |
| |
| |
| |