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