1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_stoc.hxx" 26 #include <osl/mutex.hxx> 27 #include <cppuhelper/queryinterface.hxx> 28 #ifndef _CPPUHELER_WEAK_HXX_ 29 #include <cppuhelper/weak.hxx> 30 #endif 31 #include <cppuhelper/factory.hxx> 32 #ifndef _CPPUHELPER_IMPLEMENTATIONENTRY_HXX__ 33 #include <cppuhelper/implementationentry.hxx> 34 #endif 35 #include <cppuhelper/typeprovider.hxx> 36 #include <cppuhelper/implbase2.hxx> 37 38 #include <com/sun/star/uno/DeploymentException.hpp> 39 #include <com/sun/star/script/FailReason.hpp> 40 #include <com/sun/star/script/XTypeConverter.hpp> 41 #include <com/sun/star/script/XInvocation.hpp> 42 #include <com/sun/star/script/XInvocation2.hpp> 43 #include <com/sun/star/reflection/XIdlReflection.hpp> 44 #include <com/sun/star/container/XNameContainer.hpp> 45 #include <com/sun/star/container/XIndexContainer.hpp> 46 #include <com/sun/star/container/XEnumerationAccess.hpp> 47 #include <com/sun/star/beans/XExactName.hpp> 48 #include <com/sun/star/beans/XMaterialHolder.hpp> 49 #include <com/sun/star/beans/XIntrospection.hpp> 50 #include <com/sun/star/beans/XPropertySet.hpp> 51 #include <com/sun/star/beans/PropertyAttribute.hpp> 52 #include <com/sun/star/beans/MethodConcept.hpp> 53 #include <com/sun/star/beans/PropertyConcept.hpp> 54 #include <com/sun/star/lang/XSingleServiceFactory.hpp> 55 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 56 #include <com/sun/star/lang/XServiceInfo.hpp> 57 #include <com/sun/star/lang/XTypeProvider.hpp> 58 #include <com/sun/star/registry/XRegistryKey.hpp> 59 60 #include <boost/scoped_array.hpp> 61 #include <rtl/ustrbuf.hxx> 62 #include <rtl/strbuf.hxx> 63 64 #define SERVICENAME "com.sun.star.script.Invocation" 65 #define IMPLNAME "com.sun.star.comp.stoc.Invocation" 66 67 using namespace com::sun::star::uno; 68 using namespace com::sun::star::lang; 69 using namespace com::sun::star::script; 70 using namespace com::sun::star::reflection; 71 using namespace com::sun::star::beans; 72 using namespace com::sun::star::registry; 73 using namespace com::sun::star::container; 74 using namespace cppu; 75 using namespace rtl; 76 using namespace osl; 77 78 79 namespace stoc_inv 80 { 81 static rtl_StandardModuleCount g_moduleCount = MODULE_COUNT_INIT; 82 83 static Sequence< OUString > inv_getSupportedServiceNames() 84 { 85 static Sequence < OUString > *pNames = 0; 86 if( ! pNames ) 87 { 88 MutexGuard guard( Mutex::getGlobalMutex() ); 89 if( !pNames ) 90 { 91 static Sequence< OUString > seqNames(1); 92 seqNames.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICENAME)); 93 pNames = &seqNames; 94 } 95 } 96 return *pNames; 97 } 98 99 static OUString inv_getImplementationName() 100 { 101 static OUString *pImplName = 0; 102 if( ! pImplName ) 103 { 104 MutexGuard guard( Mutex::getGlobalMutex() ); 105 if( ! pImplName ) 106 { 107 static OUString implName( RTL_CONSTASCII_USTRINGPARAM( IMPLNAME ) ); 108 pImplName = &implName; 109 } 110 } 111 return *pImplName; 112 } 113 114 // TODO: Zentral implementieren 115 inline Reference<XIdlClass> TypeToIdlClass( const Type& rType, const Reference< XIdlReflection > & xRefl ) 116 { 117 return xRefl->forName( rType.getTypeName() ); 118 } 119 120 121 //================================================================================================== 122 class Invocation_Impl 123 : public OWeakObject 124 , public XInvocation2 125 , public XNameContainer 126 , public XIndexContainer 127 , public XEnumerationAccess 128 , public XExactName 129 , public XMaterialHolder 130 , public XTypeProvider 131 { 132 public: 133 Invocation_Impl( const Any & rAdapted, const Reference<XTypeConverter> &, 134 const Reference<XIntrospection> &, 135 const Reference<XIdlReflection> & ); 136 virtual ~Invocation_Impl(); 137 138 // XInterface 139 virtual Any SAL_CALL queryInterface( const Type & aType) throw( RuntimeException ); 140 virtual void SAL_CALL acquire() throw() { OWeakObject::acquire(); } 141 virtual void SAL_CALL release() throw() { OWeakObject::release(); } 142 143 144 // XTypeProvider 145 virtual Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes( ) 146 throw(RuntimeException); 147 virtual Sequence< sal_Int8 > SAL_CALL getImplementationId( ) 148 throw( RuntimeException); 149 150 // Methoden von XMaterialHolder 151 virtual Any SAL_CALL getMaterial(void) throw(RuntimeException); 152 153 // ? XTool 154 virtual void SAL_CALL setMaterial( const Any& rMaterial ); 155 156 // XInvocation 157 virtual Reference<XIntrospectionAccess> SAL_CALL getIntrospection(void) throw( RuntimeException ); 158 virtual Any SAL_CALL invoke(const OUString& FunctionName, const Sequence< Any >& Params, Sequence< sal_Int16 >& OutParamIndex, Sequence< Any >& OutParam) 159 throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException ); 160 virtual void SAL_CALL setValue(const OUString& PropertyName, const Any& Value) 161 throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException ); 162 virtual Any SAL_CALL getValue(const OUString& PropertyName) 163 throw( UnknownPropertyException, RuntimeException ); 164 virtual sal_Bool SAL_CALL hasMethod(const OUString& Name) throw( RuntimeException ); 165 virtual sal_Bool SAL_CALL hasProperty(const OUString& Name) throw( RuntimeException ); 166 167 // XInvocation2 168 virtual Sequence< OUString > SAL_CALL getMemberNames( ) 169 throw( RuntimeException ); 170 virtual Sequence< InvocationInfo > SAL_CALL getInfo( ) 171 throw( RuntimeException ); 172 virtual InvocationInfo SAL_CALL getInfoForName( const OUString& aName, sal_Bool bExact ) 173 throw( IllegalArgumentException, RuntimeException ); 174 175 // All Access and Container methods are not thread save 176 // XElementAccess 177 virtual Type SAL_CALL getElementType(void) throw( RuntimeException ) 178 { return _xElementAccess->getElementType(); } 179 180 virtual sal_Bool SAL_CALL hasElements(void) throw( RuntimeException ) 181 { return _xElementAccess->hasElements(); } 182 183 // XNameContainer 184 virtual void SAL_CALL insertByName( const OUString& Name, const Any& Element ) 185 throw( IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException ) 186 { _xNameContainer->insertByName( Name, Element ); } 187 188 virtual void SAL_CALL replaceByName( const OUString& Name, const Any& Element ) 189 throw( IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException ) 190 { _xNameContainer->replaceByName( Name, Element ); } 191 192 virtual void SAL_CALL removeByName( const OUString& Name ) 193 throw( NoSuchElementException, WrappedTargetException, RuntimeException ) 194 { _xNameContainer->removeByName( Name ); } 195 196 // XNameAccess 197 virtual Any SAL_CALL getByName( const OUString& Name ) 198 throw( NoSuchElementException, WrappedTargetException, RuntimeException ) 199 { return _xNameAccess->getByName( Name ); } 200 201 virtual Sequence<OUString> SAL_CALL getElementNames(void) throw( RuntimeException ) 202 { return _xNameAccess->getElementNames(); } 203 204 virtual sal_Bool SAL_CALL hasByName( const OUString& Name ) throw( RuntimeException ) 205 { return _xNameAccess->hasByName( Name ); } 206 207 // XIndexContainer 208 virtual void SAL_CALL insertByIndex( sal_Int32 Index, const Any& Element ) 209 throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) 210 { _xIndexContainer->insertByIndex( Index, Element ); } 211 212 virtual void SAL_CALL replaceByIndex( sal_Int32 Index, const Any& Element ) 213 throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) 214 { _xIndexContainer->replaceByIndex( Index, Element ); } 215 216 virtual void SAL_CALL removeByIndex( sal_Int32 Index ) 217 throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) 218 { _xIndexContainer->removeByIndex( Index ); } 219 220 // XIndexAccess 221 virtual sal_Int32 SAL_CALL getCount(void) throw( RuntimeException ) 222 { return _xIndexAccess->getCount(); } 223 224 virtual Any SAL_CALL getByIndex( sal_Int32 Index ) 225 throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException ) 226 { return _xIndexAccess->getByIndex( Index ); } 227 228 // XEnumerationAccess 229 virtual Reference<XEnumeration> SAL_CALL createEnumeration(void) throw( RuntimeException ) 230 { return _xEnumerationAccess->createEnumeration(); } 231 232 // XExactName 233 virtual OUString SAL_CALL getExactName( const OUString& rApproximateName ) throw( RuntimeException ); 234 235 236 //===================================================================================================== 237 private: 238 void getInfoSequenceImpl( Sequence< OUString >* pStringSeq, Sequence< InvocationInfo >* pInfoSeq ); 239 void fillInfoForNameAccess( InvocationInfo& rInfo, const OUString& aName ); 240 void fillInfoForProperty( InvocationInfo& rInfo, const Property& rProp ); 241 void fillInfoForMethod( InvocationInfo& rInfo, const Reference< XIdlMethod > xMethod ); 242 243 Reference<XTypeConverter> xTypeConverter; 244 Reference<XIntrospection> xIntrospection; 245 Reference<XIdlReflection> xCoreReflection; 246 247 Any _aMaterial; 248 // _xDirect and (_xIntrospectionAccess, xPropertySet) are exclusive 249 Reference<XInvocation> _xDirect; 250 Reference<XInvocation2> _xDirect2; 251 Reference<XPropertySet> _xPropertySet; 252 Reference<XIntrospectionAccess> _xIntrospectionAccess; 253 254 // supplied Interfaces 255 Reference<XNameContainer> _xNameContainer; 256 Reference<XNameAccess> _xNameAccess; 257 Reference<XIndexContainer> _xIndexContainer; 258 Reference<XIndexAccess> _xIndexAccess; 259 Reference<XEnumerationAccess> _xEnumerationAccess; 260 Reference<XElementAccess> _xElementAccess; 261 262 // 263 Reference<XExactName> _xENDirect, _xENIntrospection, _xENNameAccess; 264 }; 265 266 267 //================================================================================================== 268 //================================================================================================== 269 //================================================================================================== 270 271 //-------------------------------------------------------------------------------------------------- 272 Invocation_Impl::Invocation_Impl 273 ( 274 const Any & rAdapted, 275 const Reference<XTypeConverter> & rTC, 276 const Reference<XIntrospection> & rI, 277 const Reference<XIdlReflection> & rCR 278 ) 279 : xTypeConverter( rTC ) 280 , xIntrospection( rI ) 281 , xCoreReflection( rCR ) 282 { 283 g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); 284 setMaterial( rAdapted ); 285 } 286 287 Invocation_Impl::~Invocation_Impl() 288 { 289 g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); 290 } 291 292 //################################################################################################## 293 //### INTERFACE IMPLEMENTATIONS #################################################################### 294 //################################################################################################## 295 296 297 Any SAL_CALL Invocation_Impl::queryInterface( const Type & aType ) 298 throw( RuntimeException ) 299 { 300 // PropertySet-Implementation 301 Any a = ::cppu::queryInterface( aType, 302 SAL_STATIC_CAST(XInvocation*, this), 303 SAL_STATIC_CAST(XMaterialHolder*, this), 304 SAL_STATIC_CAST(XTypeProvider *,this) ); 305 if( a.hasValue() ) 306 { 307 return a; 308 } 309 310 if( aType == getCppuType( (Reference<XExactName>*) NULL ) ) 311 { 312 // Ivocation does not support XExactName, if direct object supports 313 // XInvocation, but not XExactName. 314 if ((_xDirect.is() && _xENDirect.is()) || 315 (!_xDirect.is() && (_xENIntrospection.is() || _xENNameAccess.is()))) 316 { 317 return makeAny( Reference< XExactName >( SAL_STATIC_CAST(XExactName*, this) ) ); 318 } 319 } 320 else if ( aType == getCppuType( (Reference<XNameContainer>*) NULL ) ) 321 { 322 if( _xNameContainer.is() ) 323 return makeAny( Reference< XNameContainer >( SAL_STATIC_CAST(XNameContainer*, this) ) ); 324 } 325 else if ( aType == getCppuType( (Reference<XNameAccess>*) NULL ) ) 326 { 327 if( _xNameAccess.is() ) 328 return makeAny( Reference< XNameAccess >( SAL_STATIC_CAST(XNameAccess*, this) ) ); 329 } 330 else if ( aType == getCppuType( (Reference<XIndexContainer>*) NULL ) ) 331 { 332 if (_xIndexContainer.is()) 333 return makeAny( Reference< XIndexContainer >( SAL_STATIC_CAST(XIndexContainer*, this) ) ); 334 } 335 else if ( aType == getCppuType( (Reference<XIndexAccess>*) NULL ) ) 336 { 337 if (_xIndexAccess.is()) 338 return makeAny( Reference< XIndexAccess >( SAL_STATIC_CAST(XIndexAccess*, this) ) ); 339 } 340 else if ( aType == getCppuType( (Reference<XEnumerationAccess>*) NULL ) ) 341 { 342 if (_xEnumerationAccess.is()) 343 return makeAny( Reference< XEnumerationAccess >( SAL_STATIC_CAST(XEnumerationAccess*, this) ) ); 344 } 345 else if ( aType == getCppuType( (Reference<XElementAccess>*) NULL ) ) 346 { 347 if (_xElementAccess.is()) 348 { 349 return makeAny( Reference< XElementAccess >( 350 SAL_STATIC_CAST(XElementAccess*, SAL_STATIC_CAST(XNameContainer*, this) ) ) ); 351 } 352 } 353 else if ( aType == getCppuType( (Reference<XInvocation2>*) NULL ) ) 354 { 355 // Invocation does not support XInvocation2, if direct object supports 356 // XInvocation, but not XInvocation2. 357 if ( ( _xDirect.is() && _xDirect2.is()) || 358 (!_xDirect.is() && _xIntrospectionAccess.is() ) ) 359 { 360 return makeAny( Reference< XInvocation2 >( SAL_STATIC_CAST(XInvocation2*, this) ) ); 361 } 362 } 363 364 return OWeakObject::queryInterface( aType ); 365 } 366 367 368 //-------------------------------------------------------------------------------------------------- 369 Any Invocation_Impl::getMaterial(void) throw(RuntimeException) 370 { 371 // AB, 12.2.1999 Sicherstellen, dass das Material wenn moeglich 372 // aus der direkten Invocation bzw. von der Introspection geholt 373 // wird, da sonst Structs nicht korrekt behandelt werden 374 Reference<XMaterialHolder> xMaterialHolder; 375 if( _xDirect.is() ) 376 { 377 xMaterialHolder = Reference<XMaterialHolder>::query( _xDirect ); 378 //_xDirect->queryInterface( XMaterialHolder::getSmartUik(), xMaterialHolder ); 379 } 380 else if( _xIntrospectionAccess.is() ) 381 { 382 xMaterialHolder = Reference<XMaterialHolder>::query( _xIntrospectionAccess ); 383 //_xIntrospectionAccess->queryInterface( XMaterialHolder::getSmartUik(), xMaterialHolder ); 384 } 385 if( xMaterialHolder.is() ) 386 { 387 return xMaterialHolder->getMaterial(); 388 } 389 return _aMaterial; 390 } 391 392 //-------------------------------------------------------------------------------------------------- 393 void Invocation_Impl::setMaterial( const Any& rMaterial ) 394 { 395 // set the material first and only once 396 Reference<XInterface> xObj; 397 398 if (rMaterial.getValueType().getTypeClass() == TypeClass_INTERFACE) 399 xObj = *(Reference<XInterface>*)rMaterial.getValue(); 400 _aMaterial = rMaterial; 401 402 // Ersteinmal alles ausserhalb des guards machen 403 _xDirect = Reference<XInvocation>::query( xObj ); 404 405 if( _xDirect.is() ) 406 { 407 // Objekt direkt befragen 408 _xElementAccess = Reference<XElementAccess>::query( _xDirect ); 409 _xEnumerationAccess = Reference<XEnumerationAccess>::query( _xDirect ); 410 _xIndexAccess = Reference<XIndexAccess>::query( _xDirect ); 411 _xIndexContainer = Reference<XIndexContainer>::query( _xDirect ); 412 _xNameAccess = Reference<XNameAccess>::query( _xDirect ); 413 _xNameContainer = Reference<XNameContainer>::query( _xDirect ); 414 _xENDirect = Reference<XExactName>::query( _xDirect ); 415 _xDirect2 = Reference<XInvocation2>::query( _xDirect ); 416 417 // only once!!! 418 //_xIntrospectionAccess = XIntrospectionAccessRef(); 419 //_xPropertySet = XPropertySetRef(); 420 } 421 else 422 { 423 // Invocation ueber die Introspection machen 424 if (xIntrospection.is()) 425 { 426 _xIntrospectionAccess = xIntrospection->inspect( _aMaterial ); 427 if( _xIntrospectionAccess.is() ) 428 { 429 430 _xElementAccess = Reference<XElementAccess>::query( 431 _xIntrospectionAccess->queryAdapter( 432 getCppuType( (Reference<XElementAccess>*) NULL ) ) ); 433 434 _xEnumerationAccess = Reference<XEnumerationAccess>::query( 435 _xIntrospectionAccess->queryAdapter( 436 getCppuType( (Reference<XEnumerationAccess>*) NULL )) ); 437 438 _xIndexAccess = Reference<XIndexAccess>::query( 439 _xIntrospectionAccess->queryAdapter( 440 getCppuType( (Reference<XIndexAccess>*) NULL ) ) ); 441 442 _xIndexContainer = Reference<XIndexContainer>::query( 443 _xIntrospectionAccess->queryAdapter( 444 getCppuType( (Reference<XIndexContainer>*) NULL ) ) ); 445 446 _xNameAccess = Reference<XNameAccess>::query( 447 _xIntrospectionAccess->queryAdapter( 448 getCppuType( (Reference<XNameAccess>*) NULL ) ) ); 449 450 _xNameContainer = Reference<XNameContainer>::query( 451 _xIntrospectionAccess->queryAdapter( 452 getCppuType( (Reference<XNameContainer>*) NULL ) ) ); 453 454 _xPropertySet = Reference<XPropertySet>::query( 455 _xIntrospectionAccess->queryAdapter( 456 getCppuType( (Reference<XPropertySet>*) NULL )) ); 457 458 _xENIntrospection = Reference<XExactName>::query( _xIntrospectionAccess ); 459 if (_xNameAccess.is()) 460 _xENNameAccess = Reference<XExactName>::query( _xNameAccess ); 461 } 462 } 463 /* only once !!! 464 _xDirect = XInvocationRef(); 465 if( !_xIntrospectionAccess.is() ) 466 { 467 // reset 468 _xElementAccess = XElementAccessRef(); 469 _xEnumerationAccess = XEnumerationAccessRef(); 470 _xIndexAccess = XIndexAccessRef(); 471 _xIndexContainer = XIndexContainerRef(); 472 _xNameAccess = XNameAccessRef(); 473 _xNameContainer = XNameContainerRef(); 474 _xPropertySet = XPropertySetRef(); 475 } 476 */ 477 } 478 } 479 480 //-------------------------------------------------------------------------------------------------- 481 OUString Invocation_Impl::getExactName( const OUString& rApproximateName ) 482 throw( RuntimeException ) 483 { 484 if (_xENDirect.is()) 485 return _xENDirect->getExactName( rApproximateName ); 486 487 OUString aRet; 488 if (_xENIntrospection.is()) 489 aRet = _xENIntrospection->getExactName( rApproximateName ); 490 if (!aRet.getLength() && _xENNameAccess.is()) 491 aRet = _xENNameAccess->getExactName( rApproximateName ); 492 return aRet; 493 } 494 495 //-------------------------------------------------------------------------------------------------- 496 Reference<XIntrospectionAccess> Invocation_Impl::getIntrospection(void) 497 throw( RuntimeException ) 498 { 499 if( _xDirect.is() ) 500 return _xDirect->getIntrospection(); 501 else 502 return _xIntrospectionAccess; 503 } 504 505 //-------------------------------------------------------------------------------------------------- 506 sal_Bool Invocation_Impl::hasMethod( const OUString& Name ) 507 throw( RuntimeException ) 508 { 509 if (_xDirect.is()) 510 return _xDirect->hasMethod( Name ); 511 if( _xIntrospectionAccess.is() ) 512 return _xIntrospectionAccess->hasMethod( Name, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); 513 return sal_False; 514 } 515 516 //-------------------------------------------------------------------------------------------------- 517 sal_Bool Invocation_Impl::hasProperty( const OUString& Name ) 518 throw( RuntimeException ) 519 { 520 if (_xDirect.is()) 521 return _xDirect->hasProperty( Name ); 522 // PropertySet 523 if( _xIntrospectionAccess.is() 524 && _xIntrospectionAccess->hasProperty( Name, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) 525 return sal_True; 526 // NameAccess 527 if( _xNameAccess.is() ) 528 return _xNameAccess->hasByName( Name ); 529 return sal_False; 530 } 531 532 //-------------------------------------------------------------------------------------------------- 533 Any Invocation_Impl::getValue( const OUString& PropertyName ) 534 throw( UnknownPropertyException, RuntimeException ) 535 { 536 if (_xDirect.is()) 537 return _xDirect->getValue( PropertyName ); 538 try 539 { 540 // PropertySet 541 if( _xIntrospectionAccess.is() && _xPropertySet.is() 542 && _xIntrospectionAccess->hasProperty 543 ( PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) 544 { 545 return _xPropertySet->getPropertyValue( PropertyName ); 546 } 547 // NameAccess 548 if( _xNameAccess.is() && _xNameAccess->hasByName( PropertyName ) ) 549 return _xNameAccess->getByName( PropertyName ); 550 } 551 catch (UnknownPropertyException &) 552 { 553 throw; 554 } 555 catch (RuntimeException &) 556 { 557 throw; 558 } 559 catch (Exception &) 560 { 561 } 562 563 throw UnknownPropertyException( 564 OUString( RTL_CONSTASCII_USTRINGPARAM("cannot get value ") ) + PropertyName, 565 Reference< XInterface >() ); 566 } 567 568 //-------------------------------------------------------------------------------------------------- 569 void Invocation_Impl::setValue( const OUString& PropertyName, const Any& Value ) 570 throw( UnknownPropertyException, CannotConvertException, InvocationTargetException, RuntimeException ) 571 { 572 if (_xDirect.is()) 573 _xDirect->setValue( PropertyName, Value ); 574 else 575 { 576 try 577 { 578 // Properties 579 if( _xIntrospectionAccess.is() && _xPropertySet.is() 580 && _xIntrospectionAccess->hasProperty( 581 PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) 582 { 583 Property aProp = _xIntrospectionAccess->getProperty( 584 PropertyName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ); 585 Reference < XIdlClass > r = TypeToIdlClass( aProp.Type, xCoreReflection ); 586 if( r->isAssignableFrom( TypeToIdlClass( Value.getValueType(), xCoreReflection ) ) ) 587 _xPropertySet->setPropertyValue( PropertyName, Value ); 588 else if( xTypeConverter.is() ) 589 _xPropertySet->setPropertyValue( 590 PropertyName, xTypeConverter->convertTo( Value, aProp.Type ) ); 591 else 592 throw RuntimeException( 593 OUString( RTL_CONSTASCII_USTRINGPARAM("no type converter service!") ), 594 Reference< XInterface >() ); 595 } 596 // NameContainer 597 else if( _xNameContainer.is() ) 598 { 599 Any aConv; 600 Reference < XIdlClass > r = 601 TypeToIdlClass( _xNameContainer->getElementType(), xCoreReflection ); 602 if( r->isAssignableFrom(TypeToIdlClass( Value.getValueType(), xCoreReflection ) ) ) 603 aConv = Value; 604 else if( xTypeConverter.is() ) 605 aConv = xTypeConverter->convertTo( Value, _xNameContainer->getElementType() ); 606 else 607 throw RuntimeException( 608 OUString( RTL_CONSTASCII_USTRINGPARAM("no type converter service!") ), 609 Reference< XInterface >() ); 610 611 // bei Vorhandensein ersetzen, ansonsten einfuegen 612 if (_xNameContainer->hasByName( PropertyName )) 613 _xNameContainer->replaceByName( PropertyName, aConv ); 614 else 615 _xNameContainer->insertByName( PropertyName, aConv ); 616 } 617 else 618 throw UnknownPropertyException( 619 OUString( RTL_CONSTASCII_USTRINGPARAM("no introspection nor name container!") ), 620 Reference< XInterface >() ); 621 } 622 catch (UnknownPropertyException &) 623 { 624 throw; 625 } 626 catch (CannotConvertException &) 627 { 628 throw; 629 } 630 catch (InvocationTargetException &) 631 { 632 throw; 633 } 634 catch (RuntimeException &) 635 { 636 throw; 637 } 638 catch (Exception & exc) 639 { 640 throw InvocationTargetException( 641 OUString( RTL_CONSTASCII_USTRINGPARAM("exception occured in setValue(): ") ) + 642 exc.Message, Reference< XInterface >(), makeAny( exc /* though sliced */ ) ); 643 } 644 } 645 } 646 647 //-------------------------------------------------------------------------------------------------- 648 Any Invocation_Impl::invoke( const OUString& FunctionName, const Sequence<Any>& InParams, 649 Sequence<sal_Int16>& OutIndizes, Sequence<Any>& OutParams ) 650 throw( IllegalArgumentException, CannotConvertException, InvocationTargetException, RuntimeException ) 651 { 652 if (_xDirect.is()) 653 return _xDirect->invoke( FunctionName, InParams, OutIndizes, OutParams ); 654 655 if (_xIntrospectionAccess.is()) 656 { 657 // throw NoSuchMethodException if not exist 658 Reference<XIdlMethod> xMethod = _xIntrospectionAccess->getMethod( 659 FunctionName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); 660 661 // ParameterInfos 662 Sequence<ParamInfo> aFParams = xMethod->getParameterInfos(); 663 const ParamInfo* pFParams = aFParams.getConstArray(); 664 sal_Int32 nFParamsLen = aFParams.getLength(); 665 if (nFParamsLen != InParams.getLength()) 666 { 667 throw IllegalArgumentException( 668 OUString( RTL_CONSTASCII_USTRINGPARAM("incorrect number of parameters passed invoking function ") ) + FunctionName, 669 (OWeakObject *) this, (sal_Int16) 1 ); 670 } 671 672 // IN Parameter 673 const Any* pInParams = InParams.getConstArray(); 674 675 // Introspection Invoke Parameter 676 Sequence<Any> aInvokeParams( nFParamsLen ); 677 Any* pInvokeParams = aInvokeParams.getArray(); 678 679 // OUT Indizes 680 OutIndizes.realloc( nFParamsLen ); 681 sal_Int16* pOutIndizes = OutIndizes.getArray(); 682 sal_uInt32 nOutIndex = 0; 683 684 for ( sal_Int32 nPos = 0; nPos < nFParamsLen; ++nPos ) 685 { 686 try 687 { 688 const ParamInfo& rFParam = pFParams[nPos]; 689 const Reference<XIdlClass>& rDestType = rFParam.aType; 690 691 // is IN/INOUT parameter? 692 if (rFParam.aMode != ParamMode_OUT) 693 { 694 if (rDestType->isAssignableFrom( TypeToIdlClass( pInParams[nPos].getValueType(), xCoreReflection ) )) 695 { 696 pInvokeParams[nPos] = pInParams[nPos]; 697 } 698 else if (xTypeConverter.is()) 699 { 700 Type aDestType( rDestType->getTypeClass(), rDestType->getName() ); 701 pInvokeParams[nPos] = xTypeConverter->convertTo( pInParams[nPos], aDestType ); 702 } 703 else 704 { 705 CannotConvertException aExc; 706 aExc.Context = *this; 707 aExc.Message = OUString( RTL_CONSTASCII_USTRINGPARAM("invocation type mismatch!") ); 708 throw aExc; 709 } 710 } 711 712 // is OUT/INOUT parameter? 713 if (rFParam.aMode != ParamMode_IN) 714 { 715 pOutIndizes[nOutIndex] = (sal_Int16)nPos; 716 if (rFParam.aMode == ParamMode_OUT) 717 rDestType->createObject( pInvokeParams[nPos] ); // default init 718 ++nOutIndex; 719 } 720 } 721 catch( CannotConvertException& rExc ) 722 { 723 rExc.ArgumentIndex = nPos; // optionalen Parameter Index hinzufuegen 724 throw rExc; 725 } 726 } 727 728 // execute Method 729 Any aRet = xMethod->invoke( _aMaterial, aInvokeParams ); 730 731 // OUT Params 732 OutIndizes.realloc( nOutIndex ); 733 pOutIndizes = OutIndizes.getArray(); 734 OutParams.realloc( nOutIndex ); 735 Any* pOutParams = OutParams.getArray(); 736 737 while (nOutIndex--) 738 { 739 pOutParams[nOutIndex] = pInvokeParams[ pOutIndizes[nOutIndex] ]; 740 } 741 742 return aRet; 743 } 744 745 RuntimeException aExc; 746 aExc.Context = *this; 747 aExc.Message = OUString( RTL_CONSTASCII_USTRINGPARAM("invocation lacking of introspection access!") ); 748 throw aExc; 749 } 750 751 //-------------------------------------------------------------------------------------------------- 752 753 // Struct to optimize sorting 754 struct MemberItem 755 { 756 OUString aName; 757 758 // Defines where the member comes from 759 enum Mode { NAMEACCESS, PROPERTYSET, METHOD } eMode; 760 761 // Index to respective sequence 762 // (Index to NameAccess sequence for eMode==NAMEACCESS etc.) 763 sal_Int32 nIndex; 764 }; 765 766 // Implementation of getting name or info 767 // String sequence will be filled when pStringSeq != NULL 768 // Info sequence will be filled when pInfoSeq != NULL 769 void Invocation_Impl::getInfoSequenceImpl 770 ( 771 Sequence< OUString >* pStringSeq, 772 Sequence< InvocationInfo >* pInfoSeq 773 ) 774 { 775 //Sequence< OUString > aStrSeq; 776 //if( !pStringSeq ) 777 //pStringSeq = &aStrSeq; 778 779 780 // Get all needed sequences 781 Sequence<OUString> aNameAccessNames; 782 Sequence<Property> aPropertySeq; 783 Sequence< Reference< XIdlMethod > > aMethodSeq; 784 785 if( _xNameAccess.is() ) 786 { 787 aNameAccessNames = _xNameAccess->getElementNames(); 788 } 789 790 if( _xIntrospectionAccess.is() ) 791 { 792 aPropertySeq = _xIntrospectionAccess->getProperties 793 ( PropertyConcept::ALL - PropertyConcept::DANGEROUS ); 794 795 aMethodSeq = _xIntrospectionAccess->getMethods 796 ( MethodConcept::ALL - MethodConcept::DANGEROUS ); 797 } 798 799 sal_Int32 nNameAccessCount = aNameAccessNames.getLength(); 800 sal_Int32 nPropertyCount = aPropertySeq.getLength(); 801 sal_Int32 nMethodCount = aMethodSeq.getLength(); 802 sal_Int32 nTotalCount = nNameAccessCount + nPropertyCount + nMethodCount; 803 804 // Create and fill array of MemberItems 805 boost::scoped_array< MemberItem > pItems( new MemberItem[ nTotalCount ] ); 806 const OUString* pStrings = aNameAccessNames.getConstArray(); 807 const Property* pProps = aPropertySeq.getConstArray(); 808 const Reference< XIdlMethod >* pMethods = aMethodSeq.getConstArray(); 809 810 // Fill array of MemberItems 811 sal_Int32 i, iTotal = 0; 812 813 // Name Access 814 for( i = 0 ; i < nNameAccessCount ; i++, iTotal++ ) 815 { 816 MemberItem& rItem = pItems[ iTotal ]; 817 rItem.aName = pStrings[ i ]; 818 rItem.eMode = MemberItem::NAMEACCESS; 819 rItem.nIndex = i; 820 } 821 822 // Property set 823 for( i = 0 ; i < nPropertyCount ; i++, iTotal++ ) 824 { 825 MemberItem& rItem = pItems[ iTotal ]; 826 rItem.aName = pProps[ i ].Name; 827 rItem.eMode = MemberItem::PROPERTYSET; 828 rItem.nIndex = i; 829 } 830 831 // Methods 832 for( i = 0 ; i < nMethodCount ; i++, iTotal++ ) 833 { 834 MemberItem& rItem = pItems[ iTotal ]; 835 Reference< XIdlMethod > xMethod = pMethods[ i ]; 836 rItem.aName = xMethod->getName(); 837 rItem.eMode = MemberItem::METHOD; 838 rItem.nIndex = i; 839 } 840 841 // Setting up result sequences 842 OUString* pRetStrings = NULL; 843 if( pStringSeq ) 844 { 845 pStringSeq->realloc( nTotalCount ); 846 pRetStrings = pStringSeq->getArray(); 847 } 848 849 InvocationInfo* pRetInfos = NULL; 850 if( pInfoSeq ) 851 { 852 pInfoSeq->realloc( nTotalCount ); 853 pRetInfos = pInfoSeq->getArray(); 854 } 855 856 // Fill result sequences in the correct order of members 857 for( iTotal = 0 ; iTotal < nTotalCount ; iTotal++ ) 858 { 859 MemberItem& rItem = pItems[ iTotal ]; 860 if( pRetStrings ) 861 { 862 pRetStrings[ iTotal ] = rItem.aName; 863 } 864 865 if( pRetInfos ) 866 { 867 if( rItem.eMode == MemberItem::NAMEACCESS ) 868 { 869 fillInfoForNameAccess( pRetInfos[ iTotal ], rItem.aName ); 870 } 871 else if( rItem.eMode == MemberItem::PROPERTYSET ) 872 { 873 fillInfoForProperty( pRetInfos[ iTotal ], pProps[ rItem.nIndex ] ); 874 } 875 else if( rItem.eMode == MemberItem::METHOD ) 876 { 877 fillInfoForMethod( pRetInfos[ iTotal ], pMethods[ rItem.nIndex ] ); 878 } 879 } 880 } 881 } 882 883 // XInvocation2 884 Sequence< OUString > SAL_CALL Invocation_Impl::getMemberNames( ) 885 throw( RuntimeException ) 886 { 887 if( _xDirect2.is() ) 888 { 889 return _xDirect2->getMemberNames(); 890 } 891 Sequence< OUString > aRetSeq; 892 getInfoSequenceImpl( &aRetSeq, NULL ); 893 return aRetSeq; 894 } 895 896 Sequence< InvocationInfo > SAL_CALL Invocation_Impl::getInfo( ) 897 throw( RuntimeException ) 898 { 899 if( _xDirect2.is() ) 900 { 901 return _xDirect2->getInfo(); 902 } 903 Sequence< InvocationInfo > aRetSeq; 904 getInfoSequenceImpl( NULL, &aRetSeq ); 905 return aRetSeq; 906 } 907 908 InvocationInfo SAL_CALL Invocation_Impl::getInfoForName( const OUString& aName, sal_Bool bExact ) 909 throw( IllegalArgumentException, RuntimeException ) 910 { 911 if( _xDirect2.is() ) 912 { 913 return _xDirect2->getInfoForName( aName, bExact ); 914 } 915 916 sal_Bool bFound = sal_False; 917 OUString aExactName = aName; 918 InvocationInfo aRetInfo; 919 920 if( bExact ) 921 aExactName = getExactName( aName ); 922 if( aExactName.getLength() > 0 ) 923 { 924 if( _xIntrospectionAccess->hasMethod( aExactName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ) ) 925 { 926 Reference<XIdlMethod> xMethod = _xIntrospectionAccess->getMethod 927 ( aExactName, MethodConcept::ALL ^ MethodConcept::DANGEROUS ); 928 fillInfoForMethod( aRetInfo, xMethod ); 929 bFound = sal_True; 930 } 931 else 932 { 933 if( _xIntrospectionAccess.is() && _xIntrospectionAccess->hasProperty 934 ( aExactName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ) ) 935 { 936 Property aProp = _xIntrospectionAccess->getProperty 937 ( aExactName, PropertyConcept::ALL ^ PropertyConcept::DANGEROUS ); 938 fillInfoForProperty( aRetInfo, aProp ); 939 bFound = sal_True; 940 } 941 // NameAccess 942 else if( _xNameAccess.is() && _xNameAccess->hasByName( aExactName ) ) 943 { 944 fillInfoForNameAccess( aRetInfo, aExactName ); 945 bFound = sal_True; 946 } 947 } 948 } 949 if( !bFound ) 950 { 951 throw IllegalArgumentException( 952 OUString( RTL_CONSTASCII_USTRINGPARAM("Unknown name, getExactName() failed!") ), 953 (XWeak *)(OWeakObject *)this, 0 ); 954 } 955 return aRetInfo; 956 } 957 958 // Helper functions to fill InvocationInfo for XNameAccess 959 void Invocation_Impl::fillInfoForNameAccess 960 ( 961 InvocationInfo& rInfo, 962 const OUString& aName 963 ) 964 { 965 rInfo.aName = aName; 966 rInfo.eMemberType = MemberType_PROPERTY; 967 rInfo.PropertyAttribute = 0; 968 if( !_xNameContainer.is() ) 969 { 970 rInfo.PropertyAttribute = PropertyAttribute::READONLY; 971 } 972 rInfo.aType = _xNameAccess->getElementType(); 973 } 974 975 void Invocation_Impl::fillInfoForProperty 976 ( 977 InvocationInfo& rInfo, 978 const Property& rProp 979 ) 980 { 981 rInfo.aName = rProp.Name; 982 rInfo.eMemberType = MemberType_PROPERTY; 983 rInfo.PropertyAttribute = rProp.Attributes; 984 rInfo.aType = rProp.Type; 985 } 986 987 void Invocation_Impl::fillInfoForMethod 988 ( 989 InvocationInfo& rInfo, 990 const Reference< XIdlMethod > xMethod 991 ) 992 { 993 rInfo.aName = xMethod->getName(); 994 rInfo.eMemberType = MemberType_METHOD; 995 Reference< XIdlClass > xReturnClass = xMethod->getReturnType(); 996 Type aReturnType( xReturnClass->getTypeClass(), xReturnClass->getName() ); 997 rInfo.aType = aReturnType; 998 Sequence<ParamInfo> aParamInfos = xMethod->getParameterInfos(); 999 sal_Int32 nParamCount = aParamInfos.getLength(); 1000 if( nParamCount > 0 ) 1001 { 1002 const ParamInfo* pInfos = aParamInfos.getConstArray(); 1003 1004 rInfo.aParamTypes.realloc( nParamCount ); 1005 Type* pParamTypes = rInfo.aParamTypes.getArray(); 1006 rInfo.aParamModes.realloc( nParamCount ); 1007 ParamMode* pParamModes = rInfo.aParamModes.getArray(); 1008 1009 for( sal_Int32 i = 0 ; i < nParamCount ; i++ ) 1010 { 1011 Reference< XIdlClass > xParamClass = pInfos[i].aType; 1012 Type aParamType( xParamClass->getTypeClass(), xParamClass->getName() ); 1013 pParamTypes[ i ] = aParamType; 1014 pParamModes[ i ] = pInfos[i].aMode; 1015 } 1016 } 1017 } 1018 1019 1020 // XTypeProvider 1021 Sequence< Type > SAL_CALL Invocation_Impl::getTypes(void) throw( RuntimeException ) 1022 { 1023 static Sequence< Type > const * s_pTypes = 0; 1024 if (! s_pTypes) 1025 { 1026 Sequence< Type > types( 4 +8 ); 1027 Type * pTypes = types.getArray(); 1028 sal_Int32 n = 0; 1029 1030 pTypes[ n++ ] = ::getCppuType( (Reference< XTypeProvider > const *)0 ); 1031 pTypes[ n++ ] = ::getCppuType( (Reference< XWeak > const *)0 ); 1032 pTypes[ n++ ] = ::getCppuType( (Reference< XInvocation > const *)0 ); 1033 pTypes[ n++ ] = ::getCppuType( (Reference< XMaterialHolder > const *)0 ); 1034 1035 // Ivocation does not support XExactName, if direct object supports 1036 // XInvocation, but not XExactName. 1037 if ((_xDirect.is() && _xENDirect.is()) || 1038 (!_xDirect.is() && (_xENIntrospection.is() || _xENNameAccess.is()))) 1039 { 1040 pTypes[ n++ ] = ::getCppuType( (Reference< XExactName > const *)0 ); 1041 } 1042 if( _xNameContainer.is() ) 1043 { 1044 pTypes[ n++ ] = ::getCppuType( (Reference< XNameContainer > const *)0 ); 1045 } 1046 if( _xNameAccess.is() ) 1047 { 1048 pTypes[ n++ ] = ::getCppuType( (Reference< XNameAccess > const *)0 ); 1049 } 1050 if (_xIndexContainer.is()) 1051 { 1052 pTypes[ n++ ] = ::getCppuType( (Reference< XIndexContainer > const *)0 ); 1053 } 1054 if (_xIndexAccess.is()) 1055 { 1056 pTypes[ n++ ] = ::getCppuType( (Reference< XIndexAccess > const *)0 ); 1057 } 1058 if (_xEnumerationAccess.is()) 1059 { 1060 pTypes[ n++ ] = ::getCppuType( (Reference< XEnumerationAccess > const *)0 ); 1061 } 1062 if (_xElementAccess.is()) 1063 { 1064 pTypes[ n++ ] = ::getCppuType( (Reference< XElementAccess > const *)0 ); 1065 } 1066 // Invocation does not support XInvocation2, if direct object supports 1067 // XInvocation, but not XInvocation2. 1068 if ( ( _xDirect.is() && _xDirect2.is()) || 1069 (!_xDirect.is() && _xIntrospectionAccess.is() ) ) 1070 { 1071 pTypes[ n++ ] = ::getCppuType( (Reference< XInvocation2 > const *)0 ); 1072 } 1073 1074 types.realloc( n ); 1075 1076 // store types 1077 MutexGuard guard( Mutex::getGlobalMutex() ); 1078 if (! s_pTypes) 1079 { 1080 static Sequence< Type > s_types( types ); 1081 s_pTypes = &s_types; 1082 } 1083 } 1084 return *s_pTypes; 1085 } 1086 1087 Sequence< sal_Int8 > SAL_CALL Invocation_Impl::getImplementationId( ) throw( RuntimeException) 1088 { 1089 static OImplementationId *pId = 0; 1090 if( ! pId ) 1091 { 1092 MutexGuard guard( Mutex::getGlobalMutex() ); 1093 if( ! pId ) 1094 { 1095 static OImplementationId id( sal_False ); 1096 pId = &id; 1097 } 1098 } 1099 return pId->getImplementationId(); 1100 } 1101 1102 //================================================================================================== 1103 //================================================================================================== 1104 //================================================================================================== 1105 class InvocationService 1106 : public WeakImplHelper2< XSingleServiceFactory, XServiceInfo > 1107 { 1108 public: 1109 InvocationService( const Reference<XComponentContext> & xCtx ); 1110 virtual ~InvocationService(); 1111 1112 // XServiceInfo 1113 OUString SAL_CALL getImplementationName() throw( RuntimeException ); 1114 sal_Bool SAL_CALL supportsService(const OUString& ServiceName) throw( RuntimeException ); 1115 Sequence< OUString > SAL_CALL getSupportedServiceNames(void) throw( RuntimeException ); 1116 1117 // XSingleServiceFactory 1118 Reference<XInterface> SAL_CALL createInstance(void) throw( Exception, RuntimeException ); 1119 Reference<XInterface> SAL_CALL createInstanceWithArguments( 1120 const Sequence<Any>& rArguments ) throw( Exception, RuntimeException ); 1121 private: 1122 Reference<XComponentContext> mxCtx; 1123 Reference<XMultiComponentFactory> mxSMgr; 1124 Reference<XTypeConverter> xTypeConverter; 1125 Reference<XIntrospection> xIntrospection; 1126 Reference<XIdlReflection> xCoreReflection; 1127 }; 1128 1129 InvocationService::InvocationService( const Reference<XComponentContext> & xCtx ) 1130 : mxCtx( xCtx ) 1131 , mxSMgr( xCtx->getServiceManager() ) 1132 { 1133 g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt ); 1134 xTypeConverter = Reference<XTypeConverter>( 1135 mxSMgr->createInstanceWithContext( 1136 OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.script.Converter")), 1137 xCtx ), 1138 UNO_QUERY ); 1139 xIntrospection = Reference<XIntrospection>( 1140 mxSMgr->createInstanceWithContext( 1141 OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.beans.Introspection")), 1142 xCtx), 1143 UNO_QUERY); 1144 mxCtx->getValueByName( 1145 OUString( 1146 RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection")) ) 1147 >>= xCoreReflection; 1148 OSL_ENSURE( xCoreReflection.is(), "### CoreReflection singleton not accessable!?" ); 1149 if (! xCoreReflection.is()) 1150 { 1151 throw DeploymentException( 1152 OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessable") ), 1153 Reference< XInterface >() ); 1154 } 1155 // xCoreReflection = Reference<XIdlReflection>( 1156 // mxSMgr->createInstanceWithContext( 1157 // OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.CoreReflection")), 1158 // xCtx), 1159 // UNO_QUERY); 1160 } 1161 1162 InvocationService::~InvocationService() 1163 { 1164 g_moduleCount.modCnt.release( &g_moduleCount.modCnt ); 1165 } 1166 1167 // XServiceInfo 1168 OUString InvocationService::getImplementationName() throw( RuntimeException ) 1169 { 1170 return inv_getImplementationName(); 1171 } 1172 1173 // XServiceInfo 1174 sal_Bool InvocationService::supportsService(const OUString& ServiceName) throw( RuntimeException ) 1175 { 1176 Sequence< OUString > aSNL = getSupportedServiceNames(); 1177 const OUString * pArray = aSNL.getConstArray(); 1178 for( sal_Int32 i = 0; i < aSNL.getLength(); i++ ) 1179 if( pArray[i] == ServiceName ) 1180 return sal_True; 1181 return sal_False; 1182 } 1183 1184 // XServiceInfo 1185 Sequence< OUString > InvocationService::getSupportedServiceNames(void) throw( RuntimeException ) 1186 { 1187 return inv_getSupportedServiceNames(); 1188 } 1189 1190 //-------------------------------------------------------------------------------------------------- 1191 Reference<XInterface> InvocationService::createInstance(void) throw( Exception, RuntimeException ) 1192 { 1193 //TODO:throw( Exception(OUString( RTL_CONSTASCII_USTRINGPARAM("no default construction of invocation adapter possible!")), *this) ); 1194 return Reference<XInterface>(); // dummy 1195 } 1196 1197 //-------------------------------------------------------------------------------------------------- 1198 Reference<XInterface> InvocationService::createInstanceWithArguments( 1199 const Sequence<Any>& rArguments ) throw( Exception, RuntimeException ) 1200 { 1201 if (rArguments.getLength() == 1) 1202 { 1203 return Reference< XInterface > 1204 ( *new Invocation_Impl( *rArguments.getConstArray(), 1205 xTypeConverter, xIntrospection, xCoreReflection ) ); 1206 } 1207 else 1208 { 1209 //TODO:throw( Exception(OUString( RTL_CONSTASCII_USTRINGPARAM("no default construction of invocation adapter possible!")), *this) ); 1210 return Reference<XInterface>(); 1211 } 1212 } 1213 1214 1215 //************************************************************************* 1216 Reference<XInterface> SAL_CALL InvocationService_CreateInstance( const Reference<XComponentContext> & xCtx ) 1217 throw( RuntimeException ) 1218 { 1219 Reference<XInterface> xService = Reference< XInterface > ( *new InvocationService( xCtx ) ); 1220 return xService; 1221 } 1222 1223 } 1224 1225 using namespace stoc_inv; 1226 static struct ImplementationEntry g_entries[] = 1227 { 1228 { 1229 InvocationService_CreateInstance, inv_getImplementationName, 1230 inv_getSupportedServiceNames, createSingleComponentFactory, 1231 &g_moduleCount.modCnt , 0 1232 }, 1233 { 0, 0, 0, 0, 0, 0 } 1234 }; 1235 1236 extern "C" 1237 { 1238 sal_Bool SAL_CALL component_canUnload( TimeValue *pTime ) 1239 { 1240 return g_moduleCount.canUnload( &g_moduleCount , pTime ); 1241 } 1242 1243 //================================================================================================== 1244 void SAL_CALL component_getImplementationEnvironment( 1245 const sal_Char ** ppEnvTypeName, uno_Environment ** ) 1246 { 1247 *ppEnvTypeName = CPPU_CURRENT_LANGUAGE_BINDING_NAME; 1248 } 1249 //================================================================================================== 1250 void * SAL_CALL component_getFactory( 1251 const sal_Char * pImplName, void * pServiceManager, void * pRegistryKey ) 1252 { 1253 return component_getFactoryHelper( pImplName, pServiceManager, pRegistryKey , g_entries ); 1254 } 1255 } 1256 1257 1258 1259