/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx

Bug Summary

File:	stoc/source/inspect/introspection.cxx
Location:	line 1186, column 19
Description:	Called C++ object pointer is null

Annotated Source Code

1	/* -- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- */
2	/*
3	* This file is part of the LibreOffice project.
4	*
5	* This Source Code Form is subject to the terms of the Mozilla Public
6	* License, v. 2.0. If a copy of the MPL was not distributed with this
7	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
8	*
9	* This file incorporates work covered by the following license notice:
10	*
11	* Licensed to the Apache Software Foundation (ASF) under one or more
12	* contributor license agreements. See the NOTICE file distributed
13	* with this work for additional information regarding copyright
14	* ownership. The ASF licenses this file to you under the Apache
15	* License, Version 2.0 (the "License"); you may not use this file
16	* except in compliance with the License. You may obtain a copy of
17	* the License at http://www.apache.org/licenses/LICENSE-2.0 .
18	*/
19
20	#include <string.h>
21
22	#define INTROSPECTION_CACHE_MAX_SIZE100 100
23
24	#include <osl/diagnose.h>
25	#include <osl/mutex.hxx>
26	#include <osl/thread.h>
27	#include <cppuhelper/queryinterface.hxx>
28	#include <cppuhelper/weak.hxx>
29	#include <cppuhelper/component.hxx>
30	#include <cppuhelper/factory.hxx>
31	#include <cppuhelper/implbase3.hxx>
32	#include <cppuhelper/typeprovider.hxx>
33	#include <salhelper/simplereferenceobject.hxx>
34
35	#include <com/sun/star/uno/DeploymentException.hpp>
36	#include <com/sun/star/lang/XSingleServiceFactory.hpp>
37	#include <com/sun/star/lang/XMultiServiceFactory.hpp>
38	#include <com/sun/star/lang/XServiceInfo.hpp>
39	#include <com/sun/star/lang/XEventListener.hpp>
40	#include <com/sun/star/reflection/XIdlReflection.hpp>
41	#include <com/sun/star/reflection/XIdlClass.hpp>
42	#include <com/sun/star/reflection/XIdlField2.hpp>
43	#include <com/sun/star/beans/UnknownPropertyException.hpp>
44	#include <com/sun/star/beans/Property.hpp>
45	#include <com/sun/star/beans/XPropertySet.hpp>
46	#include <com/sun/star/beans/XFastPropertySet.hpp>
47	#include <com/sun/star/beans/XIntrospection.hpp>
48	#include <com/sun/star/beans/XIntrospectionAccess.hpp>
49	#include <com/sun/star/beans/XMaterialHolder.hpp>
50	#include <com/sun/star/beans/XExactName.hpp>
51	#include <com/sun/star/beans/PropertyAttribute.hpp>
52	#include <com/sun/star/beans/PropertyConcept.hpp>
53	#include <com/sun/star/beans/MethodConcept.hpp>
54	#include <com/sun/star/container/XNameContainer.hpp>
55	#include <com/sun/star/container/XIndexContainer.hpp>
56	#include <com/sun/star/container/XEnumerationAccess.hpp>
57
58	#include <rtl/ref.hxx>
59	#include <rtl/ustrbuf.hxx>
60	#include <rtl/ref.hxx>
61	#include <rtl/strbuf.hxx>
62	#include <boost/unordered_map.hpp>
63
64	using namespace com::sun::star::uno;
65	using namespace com::sun::star::lang;
66	using namespace com::sun::star::reflection;
67	using namespace com::sun::star::container;
68	using namespace com::sun::star::registry;
69	using namespace com::sun::star::beans;
70	using namespace com::sun::star::beans::PropertyAttribute;
71	using namespace com::sun::star::beans::PropertyConcept;
72	using namespace com::sun::star::beans::MethodConcept;
73	using namespace cppu;
74	using namespace osl;
75
76	#define IMPLEMENTATION_NAME"com.sun.star.comp.stoc.Introspection" "com.sun.star.comp.stoc.Introspection"
77	#define SERVICE_NAME"com.sun.star.beans.Introspection" "com.sun.star.beans.Introspection"
78
79	namespace stoc_inspect
80	{
81
82	typedef WeakImplHelper3< XIntrospectionAccess, XMaterialHolder, XExactName > IntrospectionAccessHelper;
83
84
85	//==================================================================================================
86
87	// Spezial-Wert fuer Method-Concept, um "normale" Funktionen kennzeichnen zu koennen
88	#define MethodConcept_NORMAL_IMPL0x80000000 0x80000000
89
90
91	// Methode zur Feststellung, ob eine Klasse von einer anderen abgeleitet ist
92	sal_Bool isDerivedFrom( Reference<XIdlClass> xToTestClass, Reference<XIdlClass> xDerivedFromClass )
93	{
94	Sequence< Reference<XIdlClass> > aClassesSeq = xToTestClass->getSuperclasses();
95	const Reference<XIdlClass>* pClassesArray = aClassesSeq.getConstArray();
96
97	sal_Int32 nSuperClassCount = aClassesSeq.getLength();
98	for ( sal_Int32 i = 0; i < nSuperClassCount; ++i )
99	{
100	const Reference<XIdlClass>& rxClass = pClassesArray[i];
101
102	if ( xDerivedFromClass->equals( rxClass ) \|\|
103	isDerivedFrom( rxClass, xDerivedFromClass )
104	)
105	return sal_True((sal_Bool)1);
106	}
107
108	return sal_False((sal_Bool)0);
109	}
110
111	//========================================================================
112
113	// * Klassifizierung der Properties (kein enum, um Sequence verwenden zu koennen) *
114	// Properties aus einem PropertySet-Interface
115	#define MAP_PROPERTY_SET0 0
116	// Properties aus Fields
117	#define MAP_FIELD1 1
118	// Properties, die durch get/set-Methoden beschrieben werden
119	#define MAP_GETSET2 2
120	// Properties, die nur eine set-Methode haben
121	#define MAP_SETONLY3 3
122
123
124	// Schrittweite, in der die Groesse der Sequences angepasst wird
125	#define ARRAY_SIZE_STEP20 20
126
127
128
129	//**************************************
130	//* IntrospectionAccessStatic_Impl *
131	//**************************************
132	// Entspricht dem alten IntrospectionAccessImpl, bildet jetzt den statischen
133	// Anteil des neuen Instanz-bezogenen ImplIntrospectionAccess
134
135	// Hashtable fuer die Suche nach Namen
136	struct hashName_Impl
137	{
138	size_t operator()(const ::rtl::OUString Str) const
139	{
140	return (size_t)Str.hashCode();
141	}
142	};
143
144	struct eqName_Impl
145	{
146	sal_Bool operator()(const ::rtl::OUString Str1, const ::rtl::OUString Str2) const
147	{
148	return ( Str1 == Str2 );
149	}
150	};
151
152	typedef boost::unordered_map
153	<
154	::rtl::OUString,
155	sal_Int32,
156	hashName_Impl,
157	eqName_Impl
158	>
159	IntrospectionNameMap;
160
161
162	// Hashtable zur Zuordnung der exakten Namen zu den zu Lower-Case
163	// konvertierten Namen, dient zur Unterst�tzung von XExactName
164	typedef boost::unordered_map
165	<
166	::rtl::OUString,
167	::rtl::OUString,
168	hashName_Impl,
169	eqName_Impl
170	>
171	LowerToExactNameMap;
172
173
174	class ImplIntrospectionAccess;
175	class IntrospectionAccessStatic_Impl: public salhelper::SimpleReferenceObject
176	{
177	friend class ImplIntrospection;
178	friend class ImplIntrospectionAccess;
179
180	// CoreReflection halten
181	Reference< XIdlReflection > mxCoreReflection;
182
183	// InterfaceSequences, um Zusatz-Infos zu einer Property speichern zu koennen.
184	// z.B. das Field bei MAP_FIELD, die get/set-Methoden bei MAP_GETSET usw.
185	Sequence< Reference<XInterface> > aInterfaceSeq1;
186	Sequence< Reference<XInterface> > aInterfaceSeq2;
187
188	// Hashtables fuer die Namen
189	IntrospectionNameMap maPropertyNameMap;
190	IntrospectionNameMap maMethodNameMap;
191	LowerToExactNameMap maLowerToExactNameMap;
192
193	// Sequence aller Properties, auch zum Liefern aus getProperties()
194	Sequence<Property> maAllPropertySeq;
195
196	// Mapping der Properties auf Zugriffs-Arten
197	Sequence<sal_Int16> maMapTypeSeq;
198
199	// Klassifizierung der gefundenen Methoden
200	Sequence<sal_Int32> maPropertyConceptSeq;
201
202	// Anzahl der Properties
203	sal_Int32 mnPropCount;
204
205	// Anzahl der Properties, die den jeweiligen Konzepten zugeordnet sind
206	//sal_Int32 mnDangerousPropCount;
207	sal_Int32 mnPropertySetPropCount;
208	sal_Int32 mnAttributePropCount;
209	sal_Int32 mnMethodPropCount;
210
211	// Flag, ob ein FastPropertySet unterstuetzt wird
212	sal_Bool mbFastPropSet;
213
214	// Original-Handles eines FastPropertySets
215	sal_Int32* mpOrgPropertyHandleArray;
216
217	// MethodSequence, die alle Methoden aufnimmt
218	Sequence< Reference<XIdlMethod> > maAllMethodSeq;
219
220	// Klassifizierung der gefundenen Methoden
221	Sequence<sal_Int32> maMethodConceptSeq;
222
223	// Anzahl der Methoden
224	sal_Int32 mnMethCount;
225
226	// Sequence der Listener, die angemeldet werden koennen
227	Sequence< Type > maSupportedListenerSeq;
228
229	// BaseInit (soll spaeter in der Applikation erfolgen!)
230	void BaseInit( void );
231
232	// Hilfs-Methoden zur Groessen-Anpassung der Sequences
233	void checkPropertyArraysSize
234	(
235	Property*& rpAllPropArray,
236	sal_Int16*& rpMapTypeArray,
237	sal_Int32*& rpPropertyConceptArray,
238	sal_Int32 iNextIndex
239	);
240	void checkInterfaceArraySize( Sequence< Reference<XInterface> >& rSeq, Reference<XInterface>*& rpInterfaceArray,
241	sal_Int32 iNextIndex );
242
243	public:
244	IntrospectionAccessStatic_Impl( Reference< XIdlReflection > xCoreReflection_ );
245	~IntrospectionAccessStatic_Impl()
246	{
247	delete[] mpOrgPropertyHandleArray;
248	}
249	sal_Int32 getPropertyIndex( const ::rtl::OUString& aPropertyName ) const;
250	sal_Int32 getMethodIndex( const ::rtl::OUString& aMethodName ) const;
251
252	// Methoden von XIntrospectionAccess (ALT, jetzt nur Impl)
253	void setPropertyValue(const Any& obj, const ::rtl::OUString& aPropertyName, const Any& aValue) const;
254	// void setPropertyValue(Any& obj, const ::rtl::OUString& aPropertyName, const Any& aValue) const;
255	Any getPropertyValue(const Any& obj, const ::rtl::OUString& aPropertyName) const;
256	void setPropertyValueByIndex(const Any& obj, sal_Int32 nIndex, const Any& aValue) const;
257	// void setPropertyValueByIndex(Any& obj, sal_Int32 nIndex, const Any& aValue) const;
258	Any getPropertyValueByIndex(const Any& obj, sal_Int32 nIndex) const;
259
260	Sequence<Property> getProperties(void) const { return maAllPropertySeq; }
261	Sequence< Reference<XIdlMethod> > getMethods(void) const { return maAllMethodSeq; }
262	Sequence< Type > getSupportedListeners(void) const { return maSupportedListenerSeq; }
263	Sequence<sal_Int32> getPropertyConcepts(void) const { return maPropertyConceptSeq; }
264	Sequence<sal_Int32> getMethodConcepts(void) const { return maMethodConceptSeq; }
265	};
266
267
268	// Ctor
269	IntrospectionAccessStatic_Impl::IntrospectionAccessStatic_Impl( Reference< XIdlReflection > xCoreReflection_ )
270	: mxCoreReflection( xCoreReflection_ )
271	{
272	aInterfaceSeq1.realloc( ARRAY_SIZE_STEP20 );
273	aInterfaceSeq2.realloc( ARRAY_SIZE_STEP20 );
274
275	// Property-Daten
276	maAllPropertySeq.realloc( ARRAY_SIZE_STEP20 );
277	maMapTypeSeq.realloc( ARRAY_SIZE_STEP20 );
278	maPropertyConceptSeq.realloc( ARRAY_SIZE_STEP20 );
279
280	mbFastPropSet = sal_False((sal_Bool)0);
281	mpOrgPropertyHandleArray = NULL__null;
282
283	mnPropCount = 0;
284	//mnDangerousPropCount = 0;
285	mnPropertySetPropCount = 0;
286	mnAttributePropCount = 0;
287	mnMethodPropCount = 0;
288
289	// Method-Daten
290	mnMethCount = 0;
291	}
292
293	sal_Int32 IntrospectionAccessStatic_Impl::getPropertyIndex( const ::rtl::OUString& aPropertyName ) const
294	{
295	sal_Int32 iHashResult = -1;
296	IntrospectionAccessStatic_Impl* pThis = (IntrospectionAccessStatic_Impl*)this;
297	IntrospectionNameMap::iterator aIt = pThis->maPropertyNameMap.find( aPropertyName );
298	if( !( aIt == pThis->maPropertyNameMap.end() ) )
299	iHashResult = (*aIt).second;
300	return iHashResult;
301	}
302
303	sal_Int32 IntrospectionAccessStatic_Impl::getMethodIndex( const ::rtl::OUString& aMethodName ) const
304	{
305	sal_Int32 iHashResult = -1;
306	IntrospectionAccessStatic_Impl* pThis = (IntrospectionAccessStatic_Impl*)this;
307	IntrospectionNameMap::iterator aIt = pThis->maMethodNameMap.find( aMethodName );
308	if( !( aIt == pThis->maMethodNameMap.end() ) )
309	{
310	iHashResult = (*aIt).second;
311	}
312	// #95159 Check if full qualified name matches
313	else
314	{
315	sal_Int32 nSearchFrom = aMethodName.getLength();
316	nSearchFrom = aMethodName.getLength();
317	while( true )
318	{
319	// Strategy: Search back until the first '_' is found
320	sal_Int32 nFound = aMethodName.lastIndexOf( '_', nSearchFrom );
321	if( nFound == -1 )
322	break;
323
324	::rtl::OUString aPureMethodName = aMethodName.copy( nFound + 1 );
325
326	aIt = pThis->maMethodNameMap.find( aPureMethodName );
327	if( !( aIt == pThis->maMethodNameMap.end() ) )
328	{
329	// Check if it can be a type?
330	// Problem: Does not work if package names contain _ ?!
331	::rtl::OUString aStr = aMethodName.copy( 0, nFound );
332	::rtl::OUString aTypeName = aStr.replace( '_', '.' );
333	Reference< XIdlClass > xClass = mxCoreReflection->forName( aTypeName );
334	if( xClass.is() )
335	{
336	// If this is a valid class it could be the right method
337
338	// Could be the right method, type has to be checked
339	iHashResult = (*aIt).second;
340
341	const Reference<XIdlMethod>* pMethods = maAllMethodSeq.getConstArray();
342	const Reference<XIdlMethod> xMethod = pMethods[ iHashResult ];
343
344	Reference< XIdlClass > xMethClass = xMethod->getDeclaringClass();
345	if( xClass->equals( xMethClass ) )
346	{
347	break;
348	}
349	else
350	{
351	iHashResult = -1;
352
353	// Could also be another method with the same name
354	// Iterate over all methods
355	sal_Int32 nLen = maAllMethodSeq.getLength();
356	for( int i = 0 ; i < nLen ; ++i )
357	{
358	const Reference<XIdlMethod> xMethod2 = pMethods[ i ];
359
360	::rtl::OUString aTestClassName = xMethod2->getDeclaringClass()->getName();
361	::rtl::OUString aTestMethodName = xMethod2->getName();
362
363	if( xMethod2->getName() == aPureMethodName )
364	{
365	Reference< XIdlClass > xMethClass2 = xMethod2->getDeclaringClass();
366
367	if( xClass->equals( xMethClass2 ) )
368	{
369	iHashResult = i;
370	break;
371	}
372	}
373	}
374
375	if( iHashResult != -1 )
376	break;
377	}
378	}
379	}
380
381	nSearchFrom = nFound - 1;
382	if( nSearchFrom < 0 )
383	break;
384	}
385	}
386	return iHashResult;
387	}
388
389	void IntrospectionAccessStatic_Impl::setPropertyValue( const Any& obj, const ::rtl::OUString& aPropertyName, const Any& aValue ) const
390	//void IntrospectionAccessStatic_Impl::setPropertyValue( Any& obj, const ::rtl::OUString& aPropertyName, const Any& aValue ) const
391	{
392	sal_Int32 i = getPropertyIndex( aPropertyName );
393	if( i != -1 )
394	setPropertyValueByIndex( obj, (sal_Int32)i, aValue );
395	else
396	throw UnknownPropertyException();
397	}
398
399	void IntrospectionAccessStatic_Impl::setPropertyValueByIndex(const Any& obj, sal_Int32 nSequenceIndex, const Any& aValue) const
400	//void IntrospectionAccessStatic_Impl::setPropertyValueByIndex( Any& obj, sal_Int32 nSequenceIndex, const Any& aValue) const
401	{
402	// Handelt es sich bei dem uebergebenen Objekt ueberhaupt um was passendes?
403	TypeClass eObjType = obj.getValueType().getTypeClass();
404
405	Reference<XInterface> xInterface;
406	if( eObjType == TypeClass_INTERFACE )
407	{
408	xInterface = ( Reference<XInterface>)obj.getValue();
409	}
410	else if( nSequenceIndex >= mnPropCount \|\| ( eObjType != TypeClass_STRUCT && eObjType != TypeClass_EXCEPTION ) )
411	{
412	throw IllegalArgumentException();
413	}
414
415	// Flags pruefen
416	const Property* pProps = maAllPropertySeq.getConstArray();
417	if( (pProps[ nSequenceIndex ].Attributes & READONLY) != 0 )
418	{
419	throw UnknownPropertyException();
420	}
421
422	const sal_Int16* pMapTypeArray = maMapTypeSeq.getConstArray();
423	switch( pMapTypeArray[ nSequenceIndex ] )
424	{
425	case MAP_PROPERTY_SET0:
426	{
427	// Property besorgen
428	const Property& rProp = maAllPropertySeq.getConstArray()[ nSequenceIndex ];
429
430	// Interface-Parameter auf den richtigen Typ bringen
431	sal_Bool bUseCopy = sal_False((sal_Bool)0);
432	Any aRealValue;
433
434	TypeClass eValType = aValue.getValueType().getTypeClass();
435	if( eValType == TypeClass_INTERFACE )
436	{
437	Type aPropType = rProp.Type;
438	::rtl::OUString aTypeName( aPropType.getTypeName() );
439	Reference< XIdlClass > xPropClass = mxCoreReflection->forName( aTypeName );
440	//Reference<XIdlClass> xPropClass = rProp.Type;
441	if( xPropClass.is() && xPropClass->getTypeClass() == TypeClass_INTERFACE )
442	{
443	Reference<XInterface> valInterface = (Reference<XInterface>)aValue.getValue();
444	if( valInterface.is() )
445	{
446	//Any queryInterface( const Type& rType );
447	aRealValue = valInterface->queryInterface( aPropType );
448	if( aRealValue.hasValue() )
449	bUseCopy = sal_True((sal_Bool)1);
450	}
451	}
452	}
453
454	// Haben wir ein FastPropertySet und ein gueltiges Handle?
455	// ACHTUNG: An dieser Stelle wird ausgenutzt, dass das PropertySet
456	// zu Beginn des Introspection-Vorgangs abgefragt wird.
457	sal_Int32 nOrgHandle;
458	if( mbFastPropSet && ( nOrgHandle = mpOrgPropertyHandleArray[ nSequenceIndex ] ) != -1 )
459	{
460	// PropertySet-Interface holen
461	Reference<XFastPropertySet> xFastPropSet =
462	Reference<XFastPropertySet>::query( xInterface );
463	if( xFastPropSet.is() )
464	{
465	xFastPropSet->setFastPropertyValue( nOrgHandle, bUseCopy ? aRealValue : aValue );
466	}
467	else
468	{
469	// throw UnknownPropertyException
470	}
471	}
472	// sonst eben das normale nehmen
473	else
474	{
475	// PropertySet-Interface holen
476	Reference<XPropertySet> xPropSet =
477	Reference<XPropertySet>::query( xInterface );
478	if( xPropSet.is() )
479	{
480	xPropSet->setPropertyValue( rProp.Name, bUseCopy ? aRealValue : aValue );
481	}
482	else
483	{
484	// throw UnknownPropertyException
485	}
486	}
487	}
488	break;
489
490	case MAP_FIELD1:
491	{
492	Reference<XIdlField> xField = (XIdlField*)(aInterfaceSeq1.getConstArray()[ nSequenceIndex ].get());
493	Reference<XIdlField2> xField2(xField, UNO_QUERY);
494	if( xField2.is() )
495	{
496	xField2->set( (Any&)obj, aValue );
497	// IllegalArgumentException
498	// NullPointerException
499	} else
500	if( xField.is() )
501	{
502	xField->set( obj, aValue );
503	// IllegalArgumentException
504	// NullPointerException
505	}
506	else
507	{
508	// throw IllegalArgumentException();
509	}
510	}
511	break;
512
513	case MAP_GETSET2:
514	case MAP_SETONLY3:
515	{
516	// set-Methode holen
517	Reference<XIdlMethod> xMethod = (XIdlMethod*)(aInterfaceSeq2.getConstArray()[ nSequenceIndex ].get());
518	if( xMethod.is() )
519	{
520	Sequence<Any> args( 1 );
521	args.getArray()[0] = aValue;
522	xMethod->invoke( obj, args );
523	}
524	else
525	{
526	// throw IllegalArgumentException();
527	}
528	}
529	break;
530	}
531	}
532
533	Any IntrospectionAccessStatic_Impl::getPropertyValue( const Any& obj, const ::rtl::OUString& aPropertyName ) const
534	{
535	sal_Int32 i = getPropertyIndex( aPropertyName );
536	if( i != -1 )
537	return getPropertyValueByIndex( obj, i );
538
539	throw UnknownPropertyException();
540	}
541
542	Any IntrospectionAccessStatic_Impl::getPropertyValueByIndex(const Any& obj, sal_Int32 nSequenceIndex) const
543	{
544	Any aRet;
545
546	// Handelt es sich bei dem uebergebenen Objekt ueberhaupt um was passendes?
547	TypeClass eObjType = obj.getValueType().getTypeClass();
548
549	Reference<XInterface> xInterface;
550	if( eObjType == TypeClass_INTERFACE )
551	{
552	xInterface = (Reference<XInterface>)obj.getValue();
553	}
554	else if( nSequenceIndex >= mnPropCount \|\| ( eObjType != TypeClass_STRUCT && eObjType != TypeClass_EXCEPTION ) )
555	{
556	// throw IllegalArgumentException();
557	return aRet;
558	}
559
560	const sal_Int16* pMapTypeArray = maMapTypeSeq.getConstArray();
561	switch( pMapTypeArray[ nSequenceIndex ] )
562	{
563	case MAP_PROPERTY_SET0:
564	{
565	// Property besorgen
566	const Property& rProp = maAllPropertySeq.getConstArray()[ nSequenceIndex ];
567
568	// Haben wir ein FastPropertySet und ein gueltiges Handle?
569	// ACHTUNG: An dieser Stelle wird ausgenutzt, dass das PropertySet
570	// zu Beginn des Introspection-Vorgangs abgefragt wird.
571	sal_Int32 nOrgHandle;
572	if( mbFastPropSet && ( nOrgHandle = mpOrgPropertyHandleArray[ nSequenceIndex ] ) != -1 )
573	{
574	// PropertySet-Interface holen
575	Reference<XFastPropertySet> xFastPropSet =
576	Reference<XFastPropertySet>::query( xInterface );
577	if( xFastPropSet.is() )
578	{
579	aRet = xFastPropSet->getFastPropertyValue( nOrgHandle);
580	}
581	else
582	{
583	// throw UnknownPropertyException
584	return aRet;
585	}
586	}
587	// sonst eben das normale nehmen
588	else
589	{
590	// PropertySet-Interface holen
591	Reference<XPropertySet> xPropSet =
592	Reference<XPropertySet>::query( xInterface );
593	if( xPropSet.is() )
594	{
595	aRet = xPropSet->getPropertyValue( rProp.Name );
596	}
597	else
598	{
599	// throw UnknownPropertyException
600	return aRet;
601	}
602	}
603	}
604	break;
605
606	case MAP_FIELD1:
607	{
608	Reference<XIdlField> xField = (XIdlField*)(aInterfaceSeq1.getConstArray()[ nSequenceIndex ].get());
609	if( xField.is() )
610	{
611	aRet = xField->get( obj );
612	// IllegalArgumentException
613	// NullPointerException
614	}
615	else
616	{
617	// throw IllegalArgumentException();
618	return aRet;
619	}
620	}
621	break;
622
623	case MAP_GETSET2:
624	{
625	// get-Methode holen
626	Reference<XIdlMethod> xMethod = (XIdlMethod*)(aInterfaceSeq1.getConstArray()[ nSequenceIndex ].get());
627	if( xMethod.is() )
628	{
629	Sequence<Any> args;
630	aRet = xMethod->invoke( obj, args );
631	}
632	else
633	{
634	// throw IllegalArgumentException();
635	return aRet;
636	}
637	}
638	break;
639
640	case MAP_SETONLY3:
641	// get-Methode gibt es nicht
642	// throw WriteOnlyPropertyException();
643	return aRet;
644	}
645	return aRet;
646	}
647
648
649	// Hilfs-Methoden zur Groessen-Anpassung der Sequences
650	void IntrospectionAccessStatic_Impl::checkPropertyArraysSize
651	(
652	Property*& rpAllPropArray,
653	sal_Int16*& rpMapTypeArray,
654	sal_Int32*& rpPropertyConceptArray,
655	sal_Int32 iNextIndex
656	)
657	{
658	sal_Int32 nLen = maAllPropertySeq.getLength();
659	if( iNextIndex >= nLen )
660	{
661	maAllPropertySeq.realloc( nLen + ARRAY_SIZE_STEP20 );
662	rpAllPropArray = maAllPropertySeq.getArray();
663
664	maMapTypeSeq.realloc( nLen + ARRAY_SIZE_STEP20 );
665	rpMapTypeArray = maMapTypeSeq.getArray();
666
667	maPropertyConceptSeq.realloc( nLen + ARRAY_SIZE_STEP20 );
668	rpPropertyConceptArray = maPropertyConceptSeq.getArray();
669	}
670	}
671
672	void IntrospectionAccessStatic_Impl::checkInterfaceArraySize( Sequence< Reference<XInterface> >& rSeq,
673	Reference<XInterface>*& rpInterfaceArray, sal_Int32 iNextIndex )
674	{
675	sal_Int32 nLen = rSeq.getLength();
676	if( iNextIndex >= nLen )
677	{
678	// Neue Groesse mit ARRAY_SIZE_STEP abgleichen
679	sal_Int32 nMissingSize = iNextIndex - nLen + 1;
680	sal_Int32 nSteps = nMissingSize / ARRAY_SIZE_STEP20 + 1;
681	sal_Int32 nNewSize = nLen + nSteps * ARRAY_SIZE_STEP20;
682
683	rSeq.realloc( nNewSize );
684	rpInterfaceArray = rSeq.getArray();
685	}
686	}
687
688
689	//*******************************
690	//* ImplIntrospectionAccess *
691	//*******************************
692
693	// Neue Impl-Klasse im Rahmen der Introspection-Umstellung auf Instanz-gebundene
694	// Introspection mit Property-Zugriff ueber XPropertySet. Die alte Klasse
695	// ImplIntrospectionAccess lebt als IntrospectionAccessStatic_Impl
696	class ImplIntrospectionAccess : public IntrospectionAccessHelper
697	{
698	friend class ImplIntrospection;
699
700	// Untersuchtes Objekt
701	Any maInspectedObject;
702
703	// Als Interface
704	Reference<XInterface> mxIface;
705
706	// Statische Daten der Introspection
707	rtl::Reference< IntrospectionAccessStatic_Impl > mpStaticImpl;
708
709	// Adapter-Implementation
710	WeakReference< XInterface > maAdapter;
711
712	// Letzte Sequence, die bei getProperties geliefert wurde (Optimierung)
713	Sequence<Property> maLastPropertySeq;
714	sal_Int32 mnLastPropertyConcept;
715
716	// Letzte Sequence, die bei getMethods geliefert wurde (Optimierung)
717	Sequence<Reference<XIdlMethod> > maLastMethodSeq;
718	sal_Int32 mnLastMethodConcept;
719
720	public:
721	ImplIntrospectionAccess( const Any& obj, rtl::Reference< IntrospectionAccessStatic_Impl > const & pStaticImpl_ );
722	~ImplIntrospectionAccess();
723
724	// Methoden von XIntrospectionAccess
725	virtual sal_Int32 SAL_CALL getSuppliedMethodConcepts(void)
726	throw( RuntimeException );
727	virtual sal_Int32 SAL_CALL getSuppliedPropertyConcepts(void)
728	throw( RuntimeException );
729	virtual Property SAL_CALL getProperty(const ::rtl::OUString& Name, sal_Int32 PropertyConcepts)
730	throw( NoSuchElementException, RuntimeException );
731	virtual sal_Bool SAL_CALL hasProperty(const ::rtl::OUString& Name, sal_Int32 PropertyConcepts)
732	throw( RuntimeException );
733	virtual Sequence< Property > SAL_CALL getProperties(sal_Int32 PropertyConcepts)
734	throw( RuntimeException );
735	virtual Reference<XIdlMethod> SAL_CALL getMethod(const ::rtl::OUString& Name, sal_Int32 MethodConcepts)
736	throw( NoSuchMethodException, RuntimeException );
737	virtual sal_Bool SAL_CALL hasMethod(const ::rtl::OUString& Name, sal_Int32 MethodConcepts)
738	throw( RuntimeException );
739	virtual Sequence< Reference<XIdlMethod> > SAL_CALL getMethods(sal_Int32 MethodConcepts)
740	throw( RuntimeException );
741	virtual Sequence< Type > SAL_CALL getSupportedListeners(void)
742	throw( RuntimeException );
743	using OWeakObject::queryAdapter;
744	virtual Reference<XInterface> SAL_CALL queryAdapter( const Type& rType )
745	throw( IllegalTypeException, RuntimeException );
746
747	// Methoden von XMaterialHolder
748	virtual Any SAL_CALL getMaterial(void) throw(RuntimeException);
749
750	// Methoden von XExactName
751	virtual ::rtl::OUString SAL_CALL getExactName( const ::rtl::OUString& rApproximateName ) throw( RuntimeException );
752	};
753
754	ImplIntrospectionAccess::ImplIntrospectionAccess
755	( const Any& obj, rtl::Reference< IntrospectionAccessStatic_Impl > const & pStaticImpl_ )
756	: maInspectedObject( obj ), mpStaticImpl( pStaticImpl_ ), maAdapter()
757	{
758	// Objekt als Interface merken, wenn moeglich
759	TypeClass eType = maInspectedObject.getValueType().getTypeClass();
760	if( eType == TypeClass_INTERFACE )
761	mxIface = (Reference<XInterface>)maInspectedObject.getValue();
762
763	mnLastPropertyConcept = -1;
764	mnLastMethodConcept = -1;
765	}
766
767	ImplIntrospectionAccess::~ImplIntrospectionAccess()
768	{
769	}
770
771
772	//*******************************
773	//* ImplIntrospectionAdapter *
774	//*******************************
775
776	// Neue Impl-Klasse im Rahmen der Introspection-Umstellung auf Instanz-gebundene
777	// Introspection mit Property-Zugriff ueber XPropertySet. Die alte Klasse
778	// ImplIntrospectionAccess lebt als IntrospectionAccessStatic_Impl
779	class ImplIntrospectionAdapter :
780	public XPropertySet, public XFastPropertySet, public XPropertySetInfo,
781	public XNameContainer, public XIndexContainer,
782	public XEnumerationAccess, public XIdlArray,
783	public OWeakObject
784	{
785	// Parent-Objekt
786	::rtl::Reference< ImplIntrospectionAccess > mpAccess;
787
788	// Untersuchtes Objekt
789	const Any& mrInspectedObject;
790
791	// Statische Daten der Introspection
792	rtl::Reference< IntrospectionAccessStatic_Impl > mpStaticImpl;
793
794	// Objekt als Interface
795	Reference<XInterface> mxIface;
796
797	// Original-Interfaces des Objekts
798	Reference<XElementAccess> mxObjElementAccess;
799	Reference<XNameContainer> mxObjNameContainer;
800	Reference<XNameAccess> mxObjNameAccess;
801	Reference<XIndexAccess> mxObjIndexAccess;
802	Reference<XIndexContainer> mxObjIndexContainer;
803	Reference<XEnumerationAccess> mxObjEnumerationAccess;
804	Reference<XIdlArray> mxObjIdlArray;
805
806	public:
807	ImplIntrospectionAdapter( ImplIntrospectionAccess* pAccess_,
808	const Any& obj,
809	rtl::Reference< IntrospectionAccessStatic_Impl > const & pStaticImpl_ );
810
811	// Methoden von XInterface
812	virtual Any SAL_CALL queryInterface( const Type& rType ) throw( RuntimeException );
813	virtual void SAL_CALL acquire() throw() { OWeakObject::acquire(); }
814	virtual void SAL_CALL release() throw() { OWeakObject::release(); }
815
816	// Methoden von XPropertySet
817	virtual Reference<XPropertySetInfo> SAL_CALL getPropertySetInfo() throw( RuntimeException );
818	virtual void SAL_CALL setPropertyValue(const ::rtl::OUString& aPropertyName, const Any& aValue)
819	throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException );
820	virtual Any SAL_CALL getPropertyValue(const ::rtl::OUString& aPropertyName)
821	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
822	virtual void SAL_CALL addPropertyChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener)
823	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
824	virtual void SAL_CALL removePropertyChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener)
825	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
826	virtual void SAL_CALL addVetoableChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XVetoableChangeListener>& aListener)
827	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
828	virtual void SAL_CALL removeVetoableChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XVetoableChangeListener>& aListener)
829	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
830
831	// Methoden von XFastPropertySet
832	virtual void SAL_CALL setFastPropertyValue(sal_Int32 nHandle, const Any& aValue)
833	throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException );
834	virtual Any SAL_CALL getFastPropertyValue(sal_Int32 nHandle)
835	throw( UnknownPropertyException, WrappedTargetException, RuntimeException );
836
837	// Methoden von XPropertySetInfo
838	virtual Sequence< Property > SAL_CALL getProperties(void) throw( RuntimeException );
839	virtual Property SAL_CALL getPropertyByName(const ::rtl::OUString& Name) throw( RuntimeException );
840	virtual sal_Bool SAL_CALL hasPropertyByName(const ::rtl::OUString& Name) throw( RuntimeException );
841
842	// Methoden von XElementAccess
843	virtual Type SAL_CALL getElementType(void) throw( RuntimeException );
844	virtual sal_Bool SAL_CALL hasElements(void) throw( RuntimeException );
845
846	// Methoden von XNameAccess
847	virtual Any SAL_CALL getByName(const ::rtl::OUString& Name)
848	throw( NoSuchElementException, WrappedTargetException, RuntimeException );
849	virtual Sequence< ::rtl::OUString > SAL_CALL getElementNames(void) throw( RuntimeException );
850	virtual sal_Bool SAL_CALL hasByName(const ::rtl::OUString& Name) throw( RuntimeException );
851
852	// Methoden von XNameContainer
853	virtual void SAL_CALL insertByName(const ::rtl::OUString& Name, const Any& Element)
854	throw( IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException );
855	virtual void SAL_CALL replaceByName(const ::rtl::OUString& Name, const Any& Element)
856	throw( IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException );
857	virtual void SAL_CALL removeByName(const ::rtl::OUString& Name)
858	throw( NoSuchElementException, WrappedTargetException, RuntimeException );
859
860	// Methoden von XIndexAccess
861	virtual sal_Int32 SAL_CALL getCount(void) throw( RuntimeException );
862	virtual Any SAL_CALL getByIndex(sal_Int32 Index)
863	throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException );
864
865	// Methoden von XIndexContainer
866	virtual void SAL_CALL insertByIndex(sal_Int32 Index, const Any& Element)
867	throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException );
868	virtual void SAL_CALL replaceByIndex(sal_Int32 Index, const Any& Element)
869	throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException );
870	virtual void SAL_CALL removeByIndex(sal_Int32 Index)
871	throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException );
872
873	// Methoden von XEnumerationAccess
874	virtual Reference<XEnumeration> SAL_CALL createEnumeration(void) throw( RuntimeException );
875
876	// Methoden von XIdlArray
877	virtual void SAL_CALL realloc(Any& array, sal_Int32 length)
878	throw( IllegalArgumentException, RuntimeException );
879	virtual sal_Int32 SAL_CALL getLen(const Any& array) throw( IllegalArgumentException, RuntimeException );
880	virtual Any SAL_CALL get(const Any& array, sal_Int32 index)
881	throw( IllegalArgumentException, ArrayIndexOutOfBoundsException, RuntimeException );
882	virtual void SAL_CALL set(Any& array, sal_Int32 index, const Any& value)
883	throw( IllegalArgumentException, ArrayIndexOutOfBoundsException, RuntimeException );
884	};
885
886	ImplIntrospectionAdapter::ImplIntrospectionAdapter( ImplIntrospectionAccess* pAccess_,
887	const Any& obj,
888	rtl::Reference< IntrospectionAccessStatic_Impl > const & pStaticImpl_ )
889	: mpAccess( pAccess_), mrInspectedObject( obj ), mpStaticImpl( pStaticImpl_ )
890	{
891	// Objekt als Interfaceholen
892	TypeClass eType = mrInspectedObject.getValueType().getTypeClass();
893	if( eType == TypeClass_INTERFACE )
894	{
895	mxIface = ( Reference< XInterface >)mrInspectedObject.getValue();
896
897	mxObjElementAccess = Reference<XElementAccess>::query( mxIface );
898	mxObjNameAccess = Reference<XNameAccess>::query( mxIface );
899	mxObjNameContainer = Reference<XNameContainer>::query( mxIface );
900	mxObjIndexAccess = Reference<XIndexAccess>::query( mxIface );
901	mxObjIndexContainer = Reference<XIndexContainer>::query( mxIface );
902	mxObjEnumerationAccess = Reference<XEnumerationAccess>::query( mxIface );
903	mxObjIdlArray = Reference<XIdlArray>::query( mxIface );
904	}
905	}
906
907	// Methoden von XInterface
908	Any SAL_CALL ImplIntrospectionAdapter::queryInterface( const Type& rType )
909	throw( RuntimeException )
910	{
911	Any aRet( ::cppu::queryInterface(
912	rType,
913	static_cast< XPropertySet * >( this ),
914	static_cast< XFastPropertySet * >( this ),
915	static_cast< XPropertySetInfo * >( this ) ) );
916	if( !aRet.hasValue() )
917	aRet = OWeakObject::queryInterface( rType );
918
919	if( !aRet.hasValue() )
920	{
921	// Wrapper fuer die Objekt-Interfaces
922	if( ( mxObjElementAccess.is() && (aRet = ::cppu::queryInterface
923	( rType, static_cast< XElementAccess* >( static_cast< XNameAccess* >( this ) ) ) ).hasValue() )
924	\|\| ( mxObjNameAccess.is() && (aRet = ::cppu::queryInterface( rType, static_cast< XNameAccess* >( this ) ) ).hasValue() )
925	\|\| ( mxObjNameContainer.is() && (aRet = ::cppu::queryInterface( rType, static_cast< XNameContainer* >( this ) ) ).hasValue() )
926	\|\| ( mxObjIndexAccess.is() && (aRet = ::cppu::queryInterface( rType, static_cast< XIndexAccess* >( this ) ) ).hasValue() )
927	\|\| ( mxObjIndexContainer.is() && (aRet = ::cppu::queryInterface( rType, static_cast< XIndexContainer* >( this ) ) ).hasValue() )
928	\|\| ( mxObjEnumerationAccess .is() && (aRet = ::cppu::queryInterface( rType, static_cast< XEnumerationAccess* >( this ) ) ).hasValue() )
929	\|\| ( mxObjIdlArray.is() && (aRet = ::cppu::queryInterface( rType, static_cast< XIdlArray* >( this ) ) ).hasValue() )
930	)
931	{
932	}
933	}
934	return aRet;
935	}
936
937
938	//***************************************************
939	//* Implementation von ImplIntrospectionAdapter *
940	//***************************************************
941
942	// Methoden von XPropertySet
943	Reference<XPropertySetInfo> ImplIntrospectionAdapter::getPropertySetInfo(void)
944	throw( RuntimeException )
945	{
946	return (XPropertySetInfo *)this;
947	}
948
949	void ImplIntrospectionAdapter::setPropertyValue(const ::rtl::OUString& aPropertyName, const Any& aValue)
950	throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException )
951	{
952	mpStaticImpl->setPropertyValue( mrInspectedObject, aPropertyName, aValue );
953	}
954
955	Any ImplIntrospectionAdapter::getPropertyValue(const ::rtl::OUString& aPropertyName)
956	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
957	{
958	return mpStaticImpl->getPropertyValue( mrInspectedObject, aPropertyName );
959	}
960
961	void ImplIntrospectionAdapter::addPropertyChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener)
962	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
963	{
964	if( mxIface.is() )
965	{
966	Reference<XPropertySet> xPropSet =
967	Reference<XPropertySet>::query( mxIface );
968	//Reference<XPropertySet> xPropSet( mxIface, USR_QUERY );
969	if( xPropSet.is() )
970	xPropSet->addPropertyChangeListener(aPropertyName, aListener);
971	}
972	}
973
974	void ImplIntrospectionAdapter::removePropertyChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XPropertyChangeListener>& aListener)
975	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
976	{
977	if( mxIface.is() )
978	{
979	Reference<XPropertySet> xPropSet =
980	Reference<XPropertySet>::query( mxIface );
981	//Reference<XPropertySet> xPropSet( mxIface, USR_QUERY );
982	if( xPropSet.is() )
983	xPropSet->removePropertyChangeListener(aPropertyName, aListener);
984	}
985	}
986
987	void ImplIntrospectionAdapter::addVetoableChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XVetoableChangeListener>& aListener)
988	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
989	{
990	if( mxIface.is() )
991	{
992	Reference<XPropertySet> xPropSet =
993	Reference<XPropertySet>::query( mxIface );
994	//Reference<XPropertySet> xPropSet( mxIface, USR_QUERY );
995	if( xPropSet.is() )
996	xPropSet->addVetoableChangeListener(aPropertyName, aListener);
997	}
998	}
999
1000	void ImplIntrospectionAdapter::removeVetoableChangeListener(const ::rtl::OUString& aPropertyName, const Reference<XVetoableChangeListener>& aListener)
1001	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
1002	{
1003	if( mxIface.is() )
1004	{
1005	Reference<XPropertySet> xPropSet =
1006	Reference<XPropertySet>::query( mxIface );
1007	if( xPropSet.is() )
1008	xPropSet->removeVetoableChangeListener(aPropertyName, aListener);
1009	}
1010	}
1011
1012
1013	// Methoden von XFastPropertySet
1014	void ImplIntrospectionAdapter::setFastPropertyValue(sal_Int32, const Any&)
1015	throw( UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException )
1016	{
1017	}
1018
1019	Any ImplIntrospectionAdapter::getFastPropertyValue(sal_Int32)
1020	throw( UnknownPropertyException, WrappedTargetException, RuntimeException )
1021	{
1022	return Any();
1023	}
1024
1025	// Methoden von XPropertySetInfo
1026	Sequence< Property > ImplIntrospectionAdapter::getProperties(void) throw( RuntimeException )
1027	{
1028	return mpStaticImpl->getProperties();
1029	}
1030
1031	Property ImplIntrospectionAdapter::getPropertyByName(const ::rtl::OUString& Name)
1032	throw( RuntimeException )
1033	{
1034	return mpAccess->getProperty( Name, PropertyConcept::ALL );
1035	}
1036
1037	sal_Bool ImplIntrospectionAdapter::hasPropertyByName(const ::rtl::OUString& Name)
1038	throw( RuntimeException )
1039	{
1040	return mpAccess->hasProperty( Name, PropertyConcept::ALL );
1041	}
1042
1043	// Methoden von XElementAccess
1044	Type ImplIntrospectionAdapter::getElementType(void) throw( RuntimeException )
1045	{
1046	return mxObjElementAccess->getElementType();
1047	}
1048
1049	sal_Bool ImplIntrospectionAdapter::hasElements(void) throw( RuntimeException )
1050	{
1051	return mxObjElementAccess->hasElements();
1052	}
1053
1054	// Methoden von XNameAccess
1055	Any ImplIntrospectionAdapter::getByName(const ::rtl::OUString& Name)
1056	throw( NoSuchElementException, WrappedTargetException, RuntimeException )
1057	{
1058	return mxObjNameAccess->getByName( Name );
1059	}
1060
1061	Sequence< ::rtl::OUString > ImplIntrospectionAdapter::getElementNames(void)
1062	throw( RuntimeException )
1063	{
1064	return mxObjNameAccess->getElementNames();
1065	}
1066
1067	sal_Bool ImplIntrospectionAdapter::hasByName(const ::rtl::OUString& Name)
1068	throw( RuntimeException )
1069	{
1070	return mxObjNameAccess->hasByName( Name );
1071	}
1072
1073	// Methoden von XNameContainer
1074	void ImplIntrospectionAdapter::insertByName(const ::rtl::OUString& Name, const Any& Element)
1075	throw( IllegalArgumentException, ElementExistException, WrappedTargetException, RuntimeException )
1076	{
1077	mxObjNameContainer->insertByName( Name, Element );
1078	}
1079
1080	void ImplIntrospectionAdapter::replaceByName(const ::rtl::OUString& Name, const Any& Element)
1081	throw( IllegalArgumentException, NoSuchElementException, WrappedTargetException, RuntimeException )
1082	{
1083	mxObjNameContainer->replaceByName( Name, Element );
1084	}
1085
1086	void ImplIntrospectionAdapter::removeByName(const ::rtl::OUString& Name)
1087	throw( NoSuchElementException, WrappedTargetException, RuntimeException )
1088	{
1089	mxObjNameContainer->removeByName( Name );
1090	}
1091
1092	// Methoden von XIndexAccess
1093	// Schon in XNameAccess: virtual Reference<XIdlClass> getElementType(void) const
1094	sal_Int32 ImplIntrospectionAdapter::getCount(void) throw( RuntimeException )
1095	{
1096	return mxObjIndexAccess->getCount();
1097	}
1098
1099	Any ImplIntrospectionAdapter::getByIndex(sal_Int32 Index)
1100	throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
1101	{
1102	return mxObjIndexAccess->getByIndex( Index );
1103	}
1104
1105	// Methoden von XIndexContainer
1106	void ImplIntrospectionAdapter::insertByIndex(sal_Int32 Index, const Any& Element)
1107	throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
1108	{
1109	mxObjIndexContainer->insertByIndex( Index, Element );
1110	}
1111
1112	void ImplIntrospectionAdapter::replaceByIndex(sal_Int32 Index, const Any& Element)
1113	throw( IllegalArgumentException, IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
1114	{
1115	mxObjIndexContainer->replaceByIndex( Index, Element );
1116	}
1117
1118	void ImplIntrospectionAdapter::removeByIndex(sal_Int32 Index)
1119	throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException )
1120	{
1121	mxObjIndexContainer->removeByIndex( Index );
1122	}
1123
1124	// Methoden von XEnumerationAccess
1125	// Schon in XNameAccess: virtual Reference<XIdlClass> getElementType(void) const;
1126	Reference<XEnumeration> ImplIntrospectionAdapter::createEnumeration(void) throw( RuntimeException )
1127	{
1128	return mxObjEnumerationAccess->createEnumeration();
1129	}
1130
1131	// Methoden von XIdlArray
1132	void ImplIntrospectionAdapter::realloc(Any& array, sal_Int32 length)
1133	throw( IllegalArgumentException, RuntimeException )
1134	{
1135	mxObjIdlArray->realloc( array, length );
1136	}
1137
1138	sal_Int32 ImplIntrospectionAdapter::getLen(const Any& array)
1139	throw( IllegalArgumentException, RuntimeException )
1140	{
1141	return mxObjIdlArray->getLen( array );
1142	}
1143
1144	Any ImplIntrospectionAdapter::get(const Any& array, sal_Int32 index)
1145	throw( IllegalArgumentException, ArrayIndexOutOfBoundsException, RuntimeException )
1146	{
1147	return mxObjIdlArray->get( array, index );
1148	}
1149
1150	void ImplIntrospectionAdapter::set(Any& array, sal_Int32 index, const Any& value)
1151	throw( IllegalArgumentException, ArrayIndexOutOfBoundsException, RuntimeException )
1152	{
1153	mxObjIdlArray->set( array, index, value );
1154	}
1155
1156
1157	//**************************************************
1158	//* Implementation von ImplIntrospectionAccess *
1159	//**************************************************
1160
1161	// Methoden von XIntrospectionAccess
1162	sal_Int32 ImplIntrospectionAccess::getSuppliedMethodConcepts(void)
1163	throw( RuntimeException )
1164	{
1165	return MethodConcept::DANGEROUS \|
1166	PROPERTY \|
1167	LISTENER \|
1168	ENUMERATION \|
1169	NAMECONTAINER \|
1170	INDEXCONTAINER;
1171	}
1172
1173	sal_Int32 ImplIntrospectionAccess::getSuppliedPropertyConcepts(void)
1174	throw( RuntimeException )
1175	{
1176	return PropertyConcept::DANGEROUS \|
1177	PROPERTYSET \|
1178	ATTRIBUTES \|
1179	METHODS;
1180	}
1181
1182	Property ImplIntrospectionAccess::getProperty(const ::rtl::OUString& Name, sal_Int32 PropertyConcepts)
1183	throw( NoSuchElementException, RuntimeException )
1184	{
1185	Property aRet;
1186	sal_Int32 i = mpStaticImpl->getPropertyIndex( Name );
	Called C++ object pointer is null
1187	sal_Bool bFound = sal_False((sal_Bool)0);
1188	if( i != -1 )
1189	{
1190	sal_Int32 nConcept = mpStaticImpl->getPropertyConcepts().getConstArray()[ i ];
1191	if( (PropertyConcepts & nConcept) != 0 )
1192	{
1193	const Property* pProps = mpStaticImpl->getProperties().getConstArray();
1194	aRet = pProps[ i ];
1195	bFound = sal_True((sal_Bool)1);
1196	}
1197	}
1198	if( !bFound )
1199	throw NoSuchElementException() ;
1200	return aRet;
1201	}
1202
1203	sal_Bool ImplIntrospectionAccess::hasProperty(const ::rtl::OUString& Name, sal_Int32 PropertyConcepts)
1204	throw( RuntimeException )
1205	{
1206	sal_Int32 i = mpStaticImpl->getPropertyIndex( Name );
1207	sal_Bool bRet = sal_False((sal_Bool)0);
1208	if( i != -1 )
1209	{
1210	sal_Int32 nConcept = mpStaticImpl->getPropertyConcepts().getConstArray()[ i ];
1211	if( (PropertyConcepts & nConcept) != 0 )
1212	bRet = sal_True((sal_Bool)1);
1213	}
1214	return bRet;
1215	}
1216
1217	Sequence< Property > ImplIntrospectionAccess::getProperties(sal_Int32 PropertyConcepts)
1218	throw( RuntimeException )
1219	{
1220	// Wenn alle unterstuetzten Konzepte gefordert werden, Sequence einfach durchreichen
1221	sal_Int32 nAllSupportedMask = PROPERTYSET \|
1222	ATTRIBUTES \|
1223	METHODS;
1224	if( ( PropertyConcepts & nAllSupportedMask ) == nAllSupportedMask )
1225	{
1226	return mpStaticImpl->getProperties();
1227	}
1228
1229	// Gleiche Sequence wie beim vorigen mal?
1230	if( mnLastPropertyConcept == PropertyConcepts )
1231	{
1232	return maLastPropertySeq;
1233	}
1234
1235	// Anzahl der zu liefernden Properties
1236	sal_Int32 nCount = 0;
1237
1238	// Es gibt zur Zeit keine DANGEROUS-Properties
1239	// if( PropertyConcepts & DANGEROUS )
1240	// nCount += mpStaticImpl->mnDangerousPropCount;
1241	if( PropertyConcepts & PROPERTYSET )
1242	nCount += mpStaticImpl->mnPropertySetPropCount;
1243	if( PropertyConcepts & ATTRIBUTES )
1244	nCount += mpStaticImpl->mnAttributePropCount;
1245	if( PropertyConcepts & METHODS )
1246	nCount += mpStaticImpl->mnMethodPropCount;
1247
1248	// Sequence entsprechend der geforderten Anzahl reallocieren
1249	ImplIntrospectionAccess* pThis = (ImplIntrospectionAccess*)this; // const umgehen
1250	pThis->maLastPropertySeq.realloc( nCount );
1251	Property* pDestProps = pThis->maLastPropertySeq.getArray();
1252
1253	// Alle Properties durchgehen und entsprechend der Concepte uebernehmen
1254	Sequence<Property> aPropSeq = mpStaticImpl->getProperties();
1255	const Property* pSourceProps = aPropSeq.getConstArray();
1256	const sal_Int32* pConcepts = mpStaticImpl->getPropertyConcepts().getConstArray();
1257	sal_Int32 nLen = aPropSeq.getLength();
1258
1259	sal_Int32 iDest = 0;
1260	for( sal_Int32 i = 0 ; i < nLen ; i++ )
1261	{
1262	sal_Int32 nConcept = pConcepts[ i ];
1263	if( nConcept & PropertyConcepts )
1264	pDestProps[ iDest++ ] = pSourceProps[ i ];
1265	}
1266
1267	// PropertyConcept merken, dies entspricht maLastPropertySeq
1268	pThis->mnLastPropertyConcept = PropertyConcepts;
1269
1270	// Zusammengebastelte Sequence liefern
1271	return maLastPropertySeq;
1272	}
1273
1274	Reference<XIdlMethod> ImplIntrospectionAccess::getMethod(const ::rtl::OUString& Name, sal_Int32 MethodConcepts)
1275	throw( NoSuchMethodException, RuntimeException )
1276	{
1277	Reference<XIdlMethod> xRet;
1278	sal_Int32 i = mpStaticImpl->getMethodIndex( Name );
1279	if( i != -1 )
1280	{
1281
1282	sal_Int32 nConcept = mpStaticImpl->getMethodConcepts().getConstArray()[ i ];
1283	if( (MethodConcepts & nConcept) != 0 )
1284	{
1285	const Reference<XIdlMethod>* pMethods = mpStaticImpl->getMethods().getConstArray();
1286	xRet = pMethods[i];
1287	}
1288	}
1289	if( !xRet.is() )
1290	throw NoSuchMethodException();
1291	return xRet;
1292	}
1293
1294	sal_Bool ImplIntrospectionAccess::hasMethod(const ::rtl::OUString& Name, sal_Int32 MethodConcepts)
1295	throw( RuntimeException )
1296	{
1297	sal_Int32 i = mpStaticImpl->getMethodIndex( Name );
1298	sal_Bool bRet = sal_False((sal_Bool)0);
1299	if( i != -1 )
1300	{
1301	sal_Int32 nConcept = mpStaticImpl->getMethodConcepts().getConstArray()[ i ];
1302	if( (MethodConcepts & nConcept) != 0 )
1303	bRet = sal_True((sal_Bool)1);
1304	}
1305	return bRet;
1306	}
1307
1308	Sequence< Reference<XIdlMethod> > ImplIntrospectionAccess::getMethods(sal_Int32 MethodConcepts)
1309	throw( RuntimeException )
1310	{
1311	ImplIntrospectionAccess* pThis = (ImplIntrospectionAccess*)this; // const umgehen
1312
1313	// Wenn alle unterstuetzten Konzepte gefordert werden, Sequence einfach durchreichen
1314	sal_Int32 nAllSupportedMask = MethodConcept::DANGEROUS \|
1315	PROPERTY \|
1316	LISTENER \|
1317	ENUMERATION \|
1318	NAMECONTAINER \|
1319	INDEXCONTAINER \|
1320	MethodConcept_NORMAL_IMPL0x80000000;
1321	if( ( MethodConcepts & nAllSupportedMask ) == nAllSupportedMask )
1322	{
1323	return mpStaticImpl->getMethods();
1324	}
1325
1326	// Gleiche Sequence wie beim vorigen mal?
1327	if( mnLastMethodConcept == MethodConcepts )
1328	{
1329	return maLastMethodSeq;
1330	}
1331
1332	// Methoden-Sequences besorgen
1333	Sequence< Reference<XIdlMethod> > aMethodSeq = mpStaticImpl->getMethods();
1334	const Reference<XIdlMethod>* pSourceMethods = aMethodSeq.getConstArray();
1335	const sal_Int32* pConcepts = mpStaticImpl->getMethodConcepts().getConstArray();
1336	sal_Int32 nLen = aMethodSeq.getLength();
1337
1338	// Sequence entsprechend der geforderten Anzahl reallocieren
1339	// Anders als bei den Properties kann die Anzahl nicht durch
1340	// Zaehler in inspect() vorher ermittelt werden, da Methoden
1341	// mehreren Konzepten angehoeren koennen
1342	pThis->maLastMethodSeq.realloc( nLen );
1343	Reference<XIdlMethod>* pDestMethods = pThis->maLastMethodSeq.getArray();
1344
1345	// Alle Methods durchgehen und entsprechend der Concepte uebernehmen
1346	sal_Int32 iDest = 0;
1347	for( sal_Int32 i = 0 ; i < nLen ; i++ )
1348	{
1349	sal_Int32 nConcept = pConcepts[ i ];
1350	if( nConcept & MethodConcepts )
1351	pDestMethods[ iDest++ ] = pSourceMethods[ i ];
1352
1353	#if OSL_DEBUG_LEVEL1 > 0
1354	static bool debug = false;
1355	if ( debug )
1356	{
1357	// Methode mit Concepts ausgeben
1358	const Reference< XIdlMethod >& rxMethod = pSourceMethods[ i ];
1359	::rtl::OString aNameStr = ::rtl::OUStringToOString( rxMethod->getName(), osl_getThreadTextEncoding() );
1360	::rtl::OString ConceptStr;
1361	if( nConcept & MethodConcept::DANGEROUS )
1362	ConceptStr += "DANGEROUS \|";
1363	if( nConcept & MethodConcept::PROPERTY )
1364	ConceptStr += "PROPERTY \|";
1365	if( nConcept & MethodConcept::LISTENER )
1366	ConceptStr += "LISTENER \|";
1367	if( nConcept & MethodConcept::ENUMERATION )
1368	ConceptStr += "ENUMERATION \|";
1369	if( nConcept & MethodConcept::NAMECONTAINER )
1370	ConceptStr += "NAMECONTAINER \|";
1371	if( nConcept & MethodConcept::INDEXCONTAINER )
1372	ConceptStr += "INDEXCONTAINER \|";
1373	OSL_TRACE( "Method %ld: %s, Concepts = %s", i, aNameStr.getStr(), ConceptStr.getStr() )do { if (true && (1 > 0)) { sal_detail_logFormat(( SAL_DETAIL_LOG_LEVEL_INFO), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "1373" ": "), "Method %ld: %s, Concepts = %s", i, aNameStr .getStr(), ConceptStr.getStr()); } } while (false);
1374	}
1375	#endif
1376	}
1377
1378	// Auf die richtige Laenge bringen
1379	pThis->maLastMethodSeq.realloc( iDest );
1380
1381	// MethodConcept merken, dies entspricht maLastMethodSeq
1382	pThis->mnLastMethodConcept = MethodConcepts;
1383
1384	// Zusammengebastelte Sequence liefern
1385	return maLastMethodSeq;
1386	}
1387
1388	Sequence< Type > ImplIntrospectionAccess::getSupportedListeners(void)
1389	throw( RuntimeException )
1390	{
1391	return mpStaticImpl->getSupportedListeners();
1392	}
1393
1394	Reference<XInterface> SAL_CALL ImplIntrospectionAccess::queryAdapter( const Type& rType )
1395	throw( IllegalTypeException, RuntimeException )
1396	{
1397	// Gibt es schon einen Adapter?
1398	Reference< XInterface > xAdapter( maAdapter );
1399	if( !xAdapter.is() )
1400	{
1401	xAdapter = *( new ImplIntrospectionAdapter( this, maInspectedObject, mpStaticImpl ) );
1402	maAdapter = xAdapter;
1403	}
1404
1405	Reference<XInterface> xRet;
1406	xAdapter->queryInterface( rType ) >>= xRet;
1407	return xRet;
1408	}
1409
1410	// Methoden von XMaterialHolder
1411	Any ImplIntrospectionAccess::getMaterial(void) throw(RuntimeException)
1412	{
1413	return maInspectedObject;
1414	}
1415
1416	// Hilfs-Funktion zur LowerCase-Wandlung eines ::rtl::OUString
1417	::rtl::OUString toLower( ::rtl::OUString aUStr )
1418	{
1419	// Tabelle fuer XExactName pflegen
1420	::rtl::OUString aOWStr( aUStr.getStr() );
1421	::rtl::OUString aOWLowerStr = aOWStr.toAsciiLowerCase();
1422	::rtl::OUString aLowerUStr( aOWLowerStr.getStr() );
1423	return aLowerUStr;
1424	}
1425
1426	// Methoden von XExactName
1427	::rtl::OUString ImplIntrospectionAccess::getExactName( const ::rtl::OUString& rApproximateName ) throw( RuntimeException )
1428	{
1429	::rtl::OUString aRetStr;
1430	LowerToExactNameMap::iterator aIt =
1431	mpStaticImpl->maLowerToExactNameMap.find( toLower( rApproximateName ) );
1432	if( !( aIt == mpStaticImpl->maLowerToExactNameMap.end() ) )
1433	aRetStr = (*aIt).second;
1434	return aRetStr;
1435	}
1436
1437
1438	//-----------------------------------------------------------------------------
1439
1440	struct hashIntrospectionKey_Impl
1441	{
1442	Sequence< Reference<XIdlClass> > aIdlClasses;
1443	Reference<XPropertySetInfo> xPropInfo;
1444	Reference<XIdlClass> xImplClass;
1445	sal_Int32 nHitCount;
1446
1447	void IncHitCount() const { ((hashIntrospectionKey_Impl*)this)->nHitCount++; }
1448	hashIntrospectionKey_Impl() : nHitCount( 0 ) {}
1449	hashIntrospectionKey_Impl( const Sequence< Reference<XIdlClass> > & rIdlClasses,
1450	const Reference<XPropertySetInfo> & rxPropInfo,
1451	const Reference<XIdlClass> & rxImplClass );
1452	};
1453
1454	hashIntrospectionKey_Impl::hashIntrospectionKey_Impl
1455	(
1456	const Sequence< Reference<XIdlClass> > & rIdlClasses,
1457	const Reference<XPropertySetInfo> & rxPropInfo,
1458	const Reference<XIdlClass> & rxImplClass
1459	)
1460	: aIdlClasses( rIdlClasses )
1461	, xPropInfo( rxPropInfo )
1462	, xImplClass( rxImplClass )
1463	, nHitCount( 0 )
1464	{}
1465
1466
1467	struct hashIntrospectionAccessCache_Impl
1468	{
1469	size_t operator()(const hashIntrospectionKey_Impl & rObj ) const
1470	{
1471	return (size_t)rObj.xImplClass.get() ^ (size_t)rObj.xPropInfo.get();
1472	}
1473
1474	bool operator()( const hashIntrospectionKey_Impl & rObj1,
1475	const hashIntrospectionKey_Impl & rObj2 ) const
1476	{
1477	if( rObj1.xPropInfo != rObj2.xPropInfo
1478	\|\| rObj1.xImplClass != rObj2.xImplClass )
1479	return sal_False((sal_Bool)0);
1480
1481	sal_Int32 nCount1 = rObj1.aIdlClasses.getLength();
1482	sal_Int32 nCount2 = rObj2.aIdlClasses.getLength();
1483	if( nCount1 != nCount2 )
1484	return sal_False((sal_Bool)0);
1485
1486	const Reference<XIdlClass>* pRefs1 = rObj1.aIdlClasses.getConstArray();
1487	const Reference<XIdlClass>* pRefs2 = rObj2.aIdlClasses.getConstArray();
1488	return memcmp( pRefs1, pRefs2, nCount1 * sizeof( Reference<XIdlClass> ) ) == 0;
1489	}
1490
1491	};
1492
1493	typedef boost::unordered_map
1494	<
1495	hashIntrospectionKey_Impl,
1496	rtl::Reference< IntrospectionAccessStatic_Impl >,
1497	hashIntrospectionAccessCache_Impl,
1498	hashIntrospectionAccessCache_Impl
1499	>
1500	IntrospectionAccessCacheMap;
1501
1502	// For XTypeProvider
1503	struct hashTypeProviderKey_Impl
1504	{
1505	Reference<XPropertySetInfo> xPropInfo;
1506	Sequence< sal_Int8 > maImpIdSeq;
1507	sal_Int32 nHitCount;
1508
1509	void IncHitCount() const { ((hashTypeProviderKey_Impl*)this)->nHitCount++; }
1510	hashTypeProviderKey_Impl() : nHitCount( 0 ) {}
1511	hashTypeProviderKey_Impl( const Reference<XPropertySetInfo> & rxPropInfo, const Sequence< sal_Int8 > & aImpIdSeq_ );
1512	};
1513
1514	hashTypeProviderKey_Impl::hashTypeProviderKey_Impl
1515	(
1516	const Reference<XPropertySetInfo> & rxPropInfo,
1517	const Sequence< sal_Int8 > & aImpIdSeq_
1518	)
1519	: xPropInfo( rxPropInfo )
1520	, maImpIdSeq( aImpIdSeq_ )
1521	, nHitCount( 0 )
1522	{}
1523
1524
1525	struct TypeProviderAccessCache_Impl
1526	{
1527	size_t operator()(const hashTypeProviderKey_Impl & rObj ) const;
1528
1529	bool operator()( const hashTypeProviderKey_Impl & rObj1,
1530	const hashTypeProviderKey_Impl & rObj2 ) const
1531	{
1532	if( rObj1.xPropInfo != rObj2.xPropInfo )
1533	return sal_False((sal_Bool)0);
1534
1535	bool bEqual = false;
1536	sal_Int32 nLen1 = rObj1.maImpIdSeq.getLength();
1537	sal_Int32 nLen2 = rObj2.maImpIdSeq.getLength();
1538	if( nLen1 == nLen2 && nLen1 > 0 )
1539	{
1540	const sal_Int8* pId1 = rObj1.maImpIdSeq.getConstArray();
1541	const sal_Int8* pId2 = rObj2.maImpIdSeq.getConstArray();
1542	bEqual = (memcmp( pId1, pId2, nLen1 * sizeof( sal_Int8 ) ) == 0 );
1543	}
1544	return bEqual;
1545	}
1546	};
1547
1548	size_t TypeProviderAccessCache_Impl::operator()(const hashTypeProviderKey_Impl & rObj ) const
1549	{
1550	const sal_Int32* pBytesAsInt32Array = (const sal_Int32*)rObj.maImpIdSeq.getConstArray();
1551	sal_Int32 nLen = rObj.maImpIdSeq.getLength();
1552	sal_Int32 nCount32 = nLen / 4;
1553	sal_Int32 nMod32 = nLen % 4;
1554
1555	// XOR with full 32 bit values
1556	sal_Int32 nId32 = 0;
1557	sal_Int32 i;
1558	for( i = 0 ; i < nCount32 ; i++ )
1559	nId32 ^= *(pBytesAsInt32Array++);
1560
1561	// XOR with remaining byte values
1562	if( nMod32 )
1563	{
1564	const sal_Int8* pBytes = (const sal_Int8*)pBytesAsInt32Array;
1565	sal_Int8* pInt8_Id32 = (sal_Int8*)&nId32;
1566	for( i = 0 ; i < nMod32 ; i++ )
1567	(pInt8_Id32++) ^= (pBytes++);
1568	}
1569
1570	return (size_t)nId32;
1571	}
1572
1573
1574	typedef boost::unordered_map
1575	<
1576	hashTypeProviderKey_Impl,
1577	rtl::Reference< IntrospectionAccessStatic_Impl >,
1578	TypeProviderAccessCache_Impl,
1579	TypeProviderAccessCache_Impl
1580	>
1581	TypeProviderAccessCacheMap;
1582
1583	//*************************
1584	//* ImplIntrospection *
1585	//*************************
1586
1587	struct OIntrospectionMutex
1588	{
1589	Mutex m_mutex;
1590	};
1591
1592	class ImplIntrospection : public XIntrospection
1593	, public XServiceInfo
1594	, public OIntrospectionMutex
1595	, public OComponentHelper
1596	{
1597	// Implementation der Introspection.
1598	rtl::Reference< IntrospectionAccessStatic_Impl > implInspect(const Any& aToInspectObj);
1599
1600	// Save XMultiServiceFactory from createComponent
1601	Reference<XMultiServiceFactory> m_xSMgr;
1602
1603	// CoreReflection halten
1604	Reference< XIdlReflection > mxCoreReflection;
1605
1606	// Klassen, deren Methoden eine spezielle Rolle spielen
1607	Reference<XIdlClass> mxElementAccessClass;
1608	Reference<XIdlClass> mxNameContainerClass;
1609	Reference<XIdlClass> mxNameAccessClass;
1610	Reference<XIdlClass> mxIndexContainerClass;
1611	Reference<XIdlClass> mxIndexAccessClass;
1612	Reference<XIdlClass> mxEnumerationAccessClass;
1613	Reference<XIdlClass> mxInterfaceClass;
1614	Reference<XIdlClass> mxAggregationClass;
1615	sal_Bool mbDisposed;
1616
1617	sal_uInt16 mnCacheEntryCount;
1618	sal_uInt16 mnTPCacheEntryCount;
1619	IntrospectionAccessCacheMap* mpCache;
1620	TypeProviderAccessCacheMap* mpTypeProviderCache;
1621
1622	public:
1623	ImplIntrospection( const Reference<XMultiServiceFactory> & rXSMgr );
1624
1625	// Methoden von XInterface
1626	virtual Any SAL_CALL queryInterface( const Type& rType ) throw( RuntimeException );
1627	virtual void SAL_CALL acquire() throw() { OComponentHelper::acquire(); }
1628	virtual void SAL_CALL release() throw() { OComponentHelper::release(); }
1629
1630	// XTypeProvider
1631	Sequence< Type > SAL_CALL getTypes( ) throw( RuntimeException );
1632	Sequence<sal_Int8> SAL_CALL getImplementationId( ) throw( RuntimeException );
1633
1634	// XServiceInfo
1635	::rtl::OUString SAL_CALL getImplementationName() throw();
1636	sal_Bool SAL_CALL supportsService(const ::rtl::OUString& ServiceName) throw();
1637	Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames(void) throw();
1638	static ::rtl::OUString SAL_CALL getImplementationName_Static( );
1639	static Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames_Static(void) throw();
1640
1641	// Methoden von XIntrospection
1642	virtual Reference<XIntrospectionAccess> SAL_CALL inspect(const Any& aToInspectObj)
1643	throw( RuntimeException );
1644
1645	protected:
1646	// some XComponent part from OComponentHelper
1647	virtual void SAL_CALL dispose() throw(::com::sun::star::uno::RuntimeException);
1648	};
1649
1650	enum MethodType
1651	{
1652	STANDARD_METHOD, // normale Methode, kein Bezug zu Properties oder Listenern
1653	GETSET_METHOD, // gehoert zu einer get/set-Property
1654	ADD_LISTENER_METHOD, // add-Methode einer Listener-Schnittstelle
1655	REMOVE_LISTENER_METHOD, // remove-Methode einer Listener-Schnittstelle
1656	INVALID_METHOD // Methode, deren Klasse nicht beruecksichtigt wird, z.B. XPropertySet
1657	};
1658
1659	// Ctor
1660	ImplIntrospection::ImplIntrospection( const Reference<XMultiServiceFactory> & rXSMgr )
1661	: OComponentHelper( m_mutex )
1662	, m_xSMgr( rXSMgr )
1663	{
1664	mnCacheEntryCount = 0;
1665	mnTPCacheEntryCount = 0;
1666	mpCache = NULL__null;
1667	mpTypeProviderCache = NULL__null;
1668
1669	// Spezielle Klassen holen
1670	// Reference< XInterface > xServiceIface = m_xSMgr->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.CoreReflection")) );
1671	// if( xServiceIface.is() )
1672	// mxCoreReflection = Reference< XIdlReflection >::query( xServiceIface );
1673	Reference< XPropertySet > xProps( rXSMgr, UNO_QUERY );
1674	OSL_ASSERT( xProps.is() )do { if (true && (!(xProps.is()))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "1674" ": "), "OSL_ASSERT: %s", "xProps.is()"); } } while (false);
1675	if (xProps.is())
1676	{
1677	Reference< XComponentContext > xContext;
1678	xProps->getPropertyValue(
1679	::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("DefaultContext")(&("DefaultContext")[0]), ((sal_Int32)((sizeof ("DefaultContext" ) / sizeof (("DefaultContext")[0]))-1)), (((rtl_TextEncoding) 11)) ) ) >>= xContext;
1680	OSL_ASSERT( xContext.is() )do { if (true && (!(xContext.is()))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "1680" ": "), "OSL_ASSERT: %s", "xContext.is()"); } } while (false);
1681	if (xContext.is())
1682	{
1683	xContext->getValueByName(
1684	::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection")(&("/singletons/com.sun.star.reflection.theCoreReflection" )[0]), ((sal_Int32)((sizeof ("/singletons/com.sun.star.reflection.theCoreReflection" ) / sizeof (("/singletons/com.sun.star.reflection.theCoreReflection" )[0]))-1)), (((rtl_TextEncoding) 11)) ) ) >>= mxCoreReflection;
1685	OSL_ENSURE( mxCoreReflection.is(), "### CoreReflection singleton not accessible!?" )do { if (true && (!(mxCoreReflection.is()))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "1685" ": "), "%s", "### CoreReflection singleton not accessible!?" ); } } while (false);
1686	}
1687	}
1688	if (! mxCoreReflection.is())
1689	{
1690	throw DeploymentException(
1691	::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible")(&("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible" )[0]), ((sal_Int32)((sizeof ("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible" ) / sizeof (("/singletons/com.sun.star.reflection.theCoreReflection singleton not accessible" )[0]))-1)), (((rtl_TextEncoding) 11)) ),
1692	Reference< XInterface >() );
1693	}
1694
1695	mxElementAccessClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XElementAccess")(&("com.sun.star.container.XElementAccess")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XElementAccess") / sizeof ( ("com.sun.star.container.XElementAccess")[0]))-1)), (((rtl_TextEncoding ) 11))) );
1696	mxNameContainerClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XNameContainer")(&("com.sun.star.container.XNameContainer")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XNameContainer") / sizeof ( ("com.sun.star.container.XNameContainer")[0]))-1)), (((rtl_TextEncoding ) 11))) );
1697	mxNameAccessClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XNameAccess")(&("com.sun.star.container.XNameAccess")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XNameAccess") / sizeof (("com.sun.star.container.XNameAccess" )[0]))-1)), (((rtl_TextEncoding) 11))) );
1698	mxIndexContainerClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XIndexContainer")(&("com.sun.star.container.XIndexContainer")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XIndexContainer") / sizeof (("com.sun.star.container.XIndexContainer")[0]))-1)), (((rtl_TextEncoding ) 11))) );
1699	mxIndexAccessClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XIndexAccess")(&("com.sun.star.container.XIndexAccess")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XIndexAccess") / sizeof (( "com.sun.star.container.XIndexAccess")[0]))-1)), (((rtl_TextEncoding ) 11))) );
1700	mxEnumerationAccessClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.container.XEnumerationAccess")(&("com.sun.star.container.XEnumerationAccess")[0]), ((sal_Int32 )((sizeof ("com.sun.star.container.XEnumerationAccess") / sizeof (("com.sun.star.container.XEnumerationAccess")[0]))-1)), ((( rtl_TextEncoding) 11))) );
1701	mxInterfaceClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uno.XInterface")(&("com.sun.star.uno.XInterface")[0]), ((sal_Int32)((sizeof ("com.sun.star.uno.XInterface") / sizeof (("com.sun.star.uno.XInterface" )[0]))-1)), (((rtl_TextEncoding) 11))) );
1702	mxAggregationClass = mxCoreReflection->forName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.uno.XAggregation")(&("com.sun.star.uno.XAggregation")[0]), ((sal_Int32)((sizeof ("com.sun.star.uno.XAggregation") / sizeof (("com.sun.star.uno.XAggregation" )[0]))-1)), (((rtl_TextEncoding) 11))) );
1703	mbDisposed = sal_False((sal_Bool)0);
1704	}
1705
1706	// XComponent
1707	void ImplIntrospection::dispose() throw(::com::sun::star::uno::RuntimeException)
1708	{
1709	OComponentHelper::dispose();
1710
1711	// Cache loeschen
1712	delete mpCache;
1713	mpCache = NULL__null;
1714	delete mpTypeProviderCache;
1715	mpTypeProviderCache = NULL__null;
1716
1717	mxElementAccessClass = NULL__null;
1718	mxNameContainerClass = NULL__null;
1719	mxNameAccessClass = NULL__null;
1720	mxIndexContainerClass = NULL__null;
1721	mxIndexAccessClass = NULL__null;
1722	mxEnumerationAccessClass = NULL__null;
1723	mxInterfaceClass = NULL__null;
1724	mxAggregationClass = NULL__null;
1725	mbDisposed = sal_True((sal_Bool)1);
1726	}
1727
1728
1729	//-----------------------------------------------------------------------------
1730
1731	// XInterface
1732	Any ImplIntrospection::queryInterface( const Type & rType )
1733	throw(::com::sun::star::uno::RuntimeException)
1734	{
1735	Any aRet( ::cppu::queryInterface(
1736	rType,
1737	static_cast< XIntrospection * >( this ),
1738	static_cast< XServiceInfo * >( this ) ) );
1739
1740	return (aRet.hasValue() ? aRet : OComponentHelper::queryInterface( rType ));
1741	}
1742
1743	// XTypeProvider
1744	Sequence< Type > ImplIntrospection::getTypes()
1745	throw( RuntimeException )
1746	{
1747	static OTypeCollection * s_pTypes = 0;
1748	if (! s_pTypes)
1749	{
1750	MutexGuard aGuard( Mutex::getGlobalMutex() );
1751	if (! s_pTypes)
1752	{
1753	static OTypeCollection s_aTypes(
1754	::getCppuType( (const Reference< XIntrospection > *)0 ),
1755	::getCppuType( (const Reference< XServiceInfo > *)0 ),
1756	OComponentHelper::getTypes() );
1757	s_pTypes = &s_aTypes;
1758	}
1759	}
1760	return s_pTypes->getTypes();
1761	}
1762
1763	Sequence< sal_Int8 > ImplIntrospection::getImplementationId()
1764	throw( RuntimeException )
1765	{
1766	static OImplementationId * s_pId = 0;
1767	if (! s_pId)
1768	{
1769	MutexGuard aGuard( Mutex::getGlobalMutex() );
1770	if (! s_pId)
1771	{
1772	static OImplementationId s_aId;
1773	s_pId = &s_aId;
1774	}
1775	}
1776	return s_pId->getImplementationId();
1777	}
1778
1779
1780	// XServiceInfo
1781	::rtl::OUString ImplIntrospection::getImplementationName() throw()
1782	{
1783	return getImplementationName_Static();
1784	}
1785
1786	// XServiceInfo
1787	sal_Bool ImplIntrospection::supportsService(const ::rtl::OUString& ServiceName) throw()
1788	{
1789	Sequence< ::rtl::OUString > aSNL = getSupportedServiceNames();
1790	const ::rtl::OUString * pArray = aSNL.getConstArray();
1791	for( sal_Int32 i = 0; i < aSNL.getLength(); i++ )
1792	if( pArray[i] == ServiceName )
1793	return sal_True((sal_Bool)1);
1794	return sal_False((sal_Bool)0);
1795	}
1796
1797	// XServiceInfo
1798	Sequence< ::rtl::OUString > ImplIntrospection::getSupportedServiceNames(void) throw()
1799	{
1800	return getSupportedServiceNames_Static();
1801	}
1802
1803	//*************************************************************************
1804	// Helper XServiceInfo
1805	::rtl::OUString ImplIntrospection::getImplementationName_Static( )
1806	{
1807	return ::rtl::OUString::createFromAscii( IMPLEMENTATION_NAME"com.sun.star.comp.stoc.Introspection" );
1808	}
1809
1810	// ORegistryServiceManager_Static
1811	Sequence< ::rtl::OUString > ImplIntrospection::getSupportedServiceNames_Static(void) throw()
1812	{
1813	Sequence< ::rtl::OUString > aSNS( 1 );
1814	aSNS.getArray()[0] = ::rtl::OUString::createFromAscii( SERVICE_NAME"com.sun.star.beans.Introspection" );
1815	return aSNS;
1816	}
1817
1818	//*************************************************************************
1819
1820	// Methoden von XIntrospection
1821	Reference<XIntrospectionAccess> ImplIntrospection::inspect(const Any& aToInspectObj)
1822	throw( RuntimeException )
1823	{
1824	Reference<XIntrospectionAccess> xAccess;
1825
1826	if ( aToInspectObj.getValueType().getTypeClass() == TypeClass_TYPE )
1827	{
1828	Type aType;
1829	aToInspectObj >>= aType;
1830
1831	Reference< XIdlClass > xIdlClass = mxCoreReflection->forName(((Type*)(aToInspectObj.getValue()))->getTypeName());
1832
1833	if ( xIdlClass.is() )
1834	{
1835	Any aRealInspectObj;
1836	aRealInspectObj <<= xIdlClass;
1837
1838	rtl::Reference< IntrospectionAccessStatic_Impl > pStaticImpl( implInspect( aRealInspectObj ) );
1839	if( pStaticImpl.is() )
1840	xAccess = new ImplIntrospectionAccess( aRealInspectObj, pStaticImpl );
1841	}
1842	}
1843	else
1844	{
1845	rtl::Reference< IntrospectionAccessStatic_Impl > pStaticImpl( implInspect( aToInspectObj ) );
1846	if( pStaticImpl.is() )
1847	xAccess = new ImplIntrospectionAccess( aToInspectObj, pStaticImpl );
1848	}
1849
1850	return xAccess;
1851	}
1852
1853	//-----------------------------------------------------------------------------
1854
1855	// Hashtable fuer Pruefung auf mehrfache Beruecksichtigung von Interfaces
1856	struct hashInterface_Impl
1857	{
1858	size_t operator()(const void* p) const
1859	{
1860	return (size_t)p;
1861	}
1862	};
1863
1864	struct eqInterface_Impl
1865	{
1866	bool operator()(const void* p1, const void* p2) const
1867	{
1868	return ( p1 == p2 );
1869	}
1870	};
1871
1872	typedef boost::unordered_map
1873	<
1874	void*,
1875	void*,
1876	hashInterface_Impl,
1877	eqInterface_Impl
1878	>
1879	CheckedInterfacesMap;
1880
1881
1882
1883	// TODO: Spaeter auslagern
1884	Reference<XIdlClass> TypeToIdlClass( const Type& rType, const Reference< XMultiServiceFactory > & xMgr )
1885	{
1886	static Reference< XIdlReflection > xRefl;
1887
1888	// void als Default-Klasse eintragen
1889	Reference<XIdlClass> xRetClass;
1890	typelib_TypeDescription * pTD = 0;
1891	rType.getDescription( &pTD );
1892	if( pTD )
1893	{
1894	::rtl::OUString sOWName( pTD->pTypeName );
1895	if( !xRefl.is() )
1896	{
1897	xRefl = Reference< XIdlReflection >( xMgr->createInstance( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.reflection.CoreReflection")(&("com.sun.star.reflection.CoreReflection")[0]), ((sal_Int32 )((sizeof ("com.sun.star.reflection.CoreReflection") / sizeof (("com.sun.star.reflection.CoreReflection")[0]))-1)), (((rtl_TextEncoding ) 11))) ), UNO_QUERY );
1898	OSL_ENSURE( xRefl.is(), "### no corereflection!" )do { if (true && (!(xRefl.is()))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "1898" ": "), "%s", "### no corereflection!"); } } while (false);
1899	}
1900	xRetClass = xRefl->forName( sOWName );
1901	}
1902	return xRetClass;
1903	}
1904
1905	// Implementation der Introspection.
1906	rtl::Reference< IntrospectionAccessStatic_Impl > ImplIntrospection::implInspect(const Any& aToInspectObj)
1907	{
1908	MutexGuard aGuard( m_mutex );
1909
1910	// Wenn die Introspection schon disposed ist, wird nur ein leeres Ergebnis geliefert
1911	if( mbDisposed )
1912	return NULL__null;
1913
1914	// Objekt untersuchen
1915	TypeClass eType = aToInspectObj.getValueType().getTypeClass();
1916	if( eType != TypeClass_INTERFACE && eType != TypeClass_STRUCT && eType != TypeClass_EXCEPTION )
1917	return NULL__null;
1918
1919	Reference<XInterface> x;
1920	if( eType == TypeClass_INTERFACE )
1921	{
1922	// Interface aus dem Any besorgen
1923	x = (Reference<XInterface>)aToInspectObj.getValue();
1924	if( !x.is() )
1925	return NULL__null;
1926	}
1927
1928	// Haben wir schon eine Cache-Instanz
1929	if( !mpCache )
1930	mpCache = new IntrospectionAccessCacheMap;
1931	if( !mpTypeProviderCache )
1932	mpTypeProviderCache = new TypeProviderAccessCacheMap;
1933	IntrospectionAccessCacheMap& aCache = *mpCache;
1934	TypeProviderAccessCacheMap& aTPCache = *mpTypeProviderCache;
1935
1936	// Pointer auf ggf. noetige neue IntrospectionAccess-Instanz
1937	rtl::Reference< IntrospectionAccessStatic_Impl > pAccess;
1938
1939	// Pruefen: Ist schon ein passendes Access-Objekt gecached?
1940	Sequence< Reference<XIdlClass> > SupportedClassSeq;
1941	Sequence< Type > SupportedTypesSeq;
1942	Reference<XTypeProvider> xTypeProvider;
1943	Reference<XIdlClass> xImplClass;
1944	Reference<XPropertySetInfo> xPropSetInfo;
1945	Reference<XPropertySet> xPropSet;
1946
1947	// Look for interfaces XTypeProvider and PropertySet
1948	if( eType == TypeClass_INTERFACE )
1949	{
1950	xTypeProvider = Reference<XTypeProvider>::query( x );
1951	if( xTypeProvider.is() )
1952	{
1953	SupportedTypesSeq = xTypeProvider->getTypes();
1954	sal_Int32 nTypeCount = SupportedTypesSeq.getLength();
1955	if( nTypeCount )
1956	{
1957	SupportedClassSeq.realloc( nTypeCount );
1958	Reference<XIdlClass>* pClasses = SupportedClassSeq.getArray();
1959
1960	const Type* pTypes = SupportedTypesSeq.getConstArray();
1961	for( sal_Int32 i = 0 ; i < nTypeCount ; i++ )
1962	{
1963	pClasses[ i ] = TypeToIdlClass( pTypes[ i ], m_xSMgr );
1964	}
1965	// TODO: Caching!
1966	}
1967	}
1968	else
1969	{
1970	xImplClass = TypeToIdlClass( aToInspectObj.getValueType(), m_xSMgr );
1971	SupportedClassSeq.realloc( 1 );
1972	SupportedClassSeq.getArray()[ 0 ] = xImplClass;
1973	}
1974
1975	xPropSet = Reference<XPropertySet>::query( x );
1976	// Jetzt versuchen, das PropertySetInfo zu bekommen
1977	if( xPropSet.is() )
1978	xPropSetInfo = xPropSet->getPropertySetInfo();
1979	}
1980	else
1981	{
1982	xImplClass = TypeToIdlClass( aToInspectObj.getValueType(), m_xSMgr );
1983	}
1984
1985	if( xTypeProvider.is() )
1986	{
1987	Sequence< sal_Int8 > aImpIdSeq = xTypeProvider->getImplementationId();
1988	sal_Int32 nIdLen = aImpIdSeq.getLength();
1989
1990	if( nIdLen )
1991	{
1992	// cache only, if the descriptor class is set
1993	hashTypeProviderKey_Impl aKeySeq( xPropSetInfo, aImpIdSeq );
1994
1995	TypeProviderAccessCacheMap::iterator aIt = aTPCache.find( aKeySeq );
1996	if( aIt == aTPCache.end() )
1997	{
1998	// not found
1999	// Neue Instanz anlegen und unter dem gegebenen Key einfuegen
2000	pAccess = new IntrospectionAccessStatic_Impl( mxCoreReflection );
2001
2002	// Groesse begrenzen, alten Eintrag wieder rausschmeissen
2003	if( mnTPCacheEntryCount > INTROSPECTION_CACHE_MAX_SIZE100 )
2004	{
2005	// Access mit dem kleinsten HitCount suchen
2006	TypeProviderAccessCacheMap::iterator iter = aTPCache.begin();
2007	TypeProviderAccessCacheMap::iterator end = aTPCache.end();
2008	TypeProviderAccessCacheMap::iterator toDelete = iter;
2009	while( iter != end )
2010	{
2011	if( (iter).first.nHitCount < (toDelete).first.nHitCount )
2012	toDelete = iter;
2013	++iter;
2014	}
2015	aTPCache.erase( toDelete );
2016	}
2017	else
2018	mnTPCacheEntryCount++;
2019
2020	// Neuer Eintrage rein in die Table
2021	aKeySeq.nHitCount = 1;
2022	aTPCache[ aKeySeq ] = pAccess;
2023
2024	}
2025	else
2026	{
2027	// Hit-Count erhoehen
2028	(*aIt).first.IncHitCount();
2029	return (*aIt).second;
2030	}
2031	}
2032	}
2033	else if( xImplClass.is() )
2034	{
2035	// cache only, if the descriptor class is set
2036	hashIntrospectionKey_Impl aKeySeq( SupportedClassSeq, xPropSetInfo, xImplClass );
2037
2038	IntrospectionAccessCacheMap::iterator aIt = aCache.find( aKeySeq );
2039	if( aIt == aCache.end() )
2040	{
2041	// not found
2042	// Neue Instanz anlegen und unter dem gegebenen Key einfuegen
2043	pAccess = new IntrospectionAccessStatic_Impl( mxCoreReflection );
2044
2045	// Groesse begrenzen, alten Eintrag wieder rausschmeissen
2046	if( mnCacheEntryCount > INTROSPECTION_CACHE_MAX_SIZE100 )
2047	{
2048	// Access mit dem kleinsten HitCount suchen
2049	IntrospectionAccessCacheMap::iterator iter = aCache.begin();
2050	IntrospectionAccessCacheMap::iterator end = aCache.end();
2051	IntrospectionAccessCacheMap::iterator toDelete = iter;
2052	while( iter != end )
2053	{
2054	if( (iter).first.nHitCount < (toDelete).first.nHitCount )
2055	toDelete = iter;
2056	++iter;
2057	}
2058	aCache.erase( toDelete );
2059	}
2060	else
2061	mnCacheEntryCount++;
2062
2063	// Neuer Eintrage rein in die Table
2064	aKeySeq.nHitCount = 1;
2065	aCache[ aKeySeq ] = pAccess;
2066
2067	}
2068	else
2069	{
2070	// Hit-Count erhoehen
2071	(*aIt).first.IncHitCount();
2072	return (*aIt).second;
2073	}
2074	}
2075
2076	// Kein Access gecached -> neu anlegen
2077	Property* pAllPropArray;
2078	Reference<XInterface>* pInterfaces1;
2079	Reference<XInterface>* pInterfaces2;
2080	sal_Int16* pMapTypeArray;
2081	sal_Int32* pPropertyConceptArray;
2082	sal_Int32 i;
2083
2084	if( !pAccess.is() )
2085	pAccess = new IntrospectionAccessStatic_Impl( mxCoreReflection );
2086
2087	// Referenzen auf wichtige Daten von pAccess
2088	sal_Int32& rPropCount = pAccess->mnPropCount;
2089	IntrospectionNameMap& rPropNameMap = pAccess->maPropertyNameMap;
2090	IntrospectionNameMap& rMethodNameMap = pAccess->maMethodNameMap;
2091	LowerToExactNameMap& rLowerToExactNameMap = pAccess->maLowerToExactNameMap;
2092
2093	// Schon mal Pointer auf das eigene Property-Feld holen
2094	pAllPropArray = pAccess->maAllPropertySeq.getArray();
2095	pInterfaces1 = pAccess->aInterfaceSeq1.getArray();
2096	pInterfaces2 = pAccess->aInterfaceSeq2.getArray();
2097	pMapTypeArray = pAccess->maMapTypeSeq.getArray();
2098	pPropertyConceptArray = pAccess->maPropertyConceptSeq.getArray();
2099
2100	//*************************
2101	//* Analyse vornehmen *
2102	//*************************
2103	if( eType == TypeClass_INTERFACE )
2104	{
2105	// Zunaechst nach speziellen Interfaces suchen, die fuer
2106	// die Introspection von besonderer Bedeutung sind.
2107
2108	// XPropertySet vorhanden?
2109	if( xPropSet.is() && xPropSetInfo.is() )
2110	{
2111	// Gibt es auch ein FastPropertySet?
2112	Reference<XFastPropertySet> xDummy = Reference<XFastPropertySet>::query( x );
2113	sal_Bool bFast = pAccess->mbFastPropSet = xDummy.is();
2114
2115	Sequence<Property> aPropSeq = xPropSetInfo->getProperties();
2116	const Property* pProps = aPropSeq.getConstArray();
2117	sal_Int32 nLen = aPropSeq.getLength();
2118
2119	// Bei FastPropertySet muessen wir uns die Original-Handles merken
2120	if( bFast )
2121	pAccess->mpOrgPropertyHandleArray = new sal_Int32[ nLen ];
2122
2123	for( i = 0 ; i < nLen ; i++ )
2124	{
2125	// Property in eigene Liste uebernehmen
2126	pAccess->checkPropertyArraysSize
2127	( pAllPropArray, pMapTypeArray, pPropertyConceptArray, rPropCount );
2128	Property& rProp = pAllPropArray[ rPropCount ];
2129	rProp = pProps[ i ];
2130
2131	if( bFast )
2132	pAccess->mpOrgPropertyHandleArray[ i ] = rProp.Handle;
2133
2134	// PropCount als Handle fuer das eigene FastPropertySet eintragen
2135	rProp.Handle = rPropCount;
2136
2137	// Art der Property merken
2138	pMapTypeArray[ rPropCount ] = MAP_PROPERTY_SET0;
2139	pPropertyConceptArray[ rPropCount ] = PROPERTYSET;
2140	pAccess->mnPropertySetPropCount++;
2141
2142	// Namen in Hashtable eintragen, wenn nicht schon bekannt
2143	::rtl::OUString aPropName = rProp.Name;
2144
2145	// Haben wir den Namen schon?
2146	IntrospectionNameMap::iterator aIt = rPropNameMap.find( aPropName );
2147	if( aIt == rPropNameMap.end() )
2148	{
2149	// Neuer Eintrag in die Hashtable
2150	rPropNameMap[ aPropName ] = rPropCount;
2151
2152	// Tabelle fuer XExactName pflegen
2153	rLowerToExactNameMap[ toLower( aPropName ) ] = aPropName;
2154	}
2155	else
2156	{
2157	OSL_FAIL(do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2160" ": "), "%s", ( ::rtl::OString( "Introspection: Property \"" ) + ::rtl::OUStringToOString( aPropName, (((rtl_TextEncoding ) 76)) ) + ::rtl::OString( "\" found more than once in PropertySet" ) ).getStr()); } } while (false)
2158	( ::rtl::OString( "Introspection: Property \"" ) +do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2160" ": "), "%s", ( ::rtl::OString( "Introspection: Property \"" ) + ::rtl::OUStringToOString( aPropName, (((rtl_TextEncoding ) 76)) ) + ::rtl::OString( "\" found more than once in PropertySet" ) ).getStr()); } } while (false)
2159	::rtl::OUStringToOString( aPropName, RTL_TEXTENCODING_UTF8 ) +do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2160" ": "), "%s", ( ::rtl::OString( "Introspection: Property \"" ) + ::rtl::OUStringToOString( aPropName, (((rtl_TextEncoding ) 76)) ) + ::rtl::OString( "\" found more than once in PropertySet" ) ).getStr()); } } while (false)
2160	::rtl::OString( "\" found more than once in PropertySet" ) ).getStr() )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2160" ": "), "%s", ( ::rtl::OString( "Introspection: Property \"" ) + ::rtl::OUStringToOString( aPropName, (((rtl_TextEncoding ) 76)) ) + ::rtl::OString( "\" found more than once in PropertySet" ) ).getStr()); } } while (false);
2161	}
2162
2163	// Count pflegen
2164	rPropCount++;
2165	}
2166	}
2167
2168	// Indizes in die Export-Tabellen
2169	sal_Int32 iAllExportedMethod = 0;
2170	sal_Int32 iAllSupportedListener = 0;
2171
2172	// Hashtable fuer Pruefung auf mehrfache Beruecksichtigung von Interfaces
2173	CheckedInterfacesMap aCheckedInterfacesMap;
2174
2175	// Flag, ob XInterface-Methoden erfasst werden sollen
2176	// (das darf nur einmal erfolgen, initial zulassen)
2177	sal_Bool bXInterfaceIsInvalid = sal_False((sal_Bool)0);
2178
2179	// Flag, ob die XInterface-Methoden schon erfasst wurden. Wenn sal_True,
2180	// wird bXInterfaceIsInvalid am Ende der Iface-Schleife aktiviert und
2181	// XInterface-Methoden werden danach abgeklemmt.
2182	sal_Bool bFoundXInterface = sal_False((sal_Bool)0);
2183
2184	sal_Int32 nClassCount = SupportedClassSeq.getLength();
2185	for( sal_Int32 nIdx = 0 ; nIdx < nClassCount; nIdx++ )
2186	{
2187	Reference<XIdlClass> xImplClass2 = SupportedClassSeq.getConstArray()[nIdx];
2188	while( xImplClass2.is() )
2189	{
2190	// Interfaces der Implementation holen
2191	Sequence< Reference<XIdlClass> > aClassSeq = xImplClass2->getInterfaces();
2192	sal_Int32 nIfaceCount = aClassSeq.getLength();
2193
2194	aClassSeq.realloc( nIfaceCount + 1 );
2195	aClassSeq.getArray()[ nIfaceCount ] = xImplClass2;
2196	nIfaceCount++;
2197
2198	const Reference<XIdlClass>* pParamArray = aClassSeq.getConstArray();
2199
2200	for( sal_Int32 j = 0 ; j < nIfaceCount ; j++ )
2201	{
2202	const Reference<XIdlClass>& rxIfaceClass = pParamArray[j];
2203
2204	// Pruefen, ob das Interface schon beruecksichtigt wurde.
2205	XInterface* pIface = ( static_cast< XInterface* >( rxIfaceClass.get() ) );
2206	if( aCheckedInterfacesMap.count( pIface ) > 0 )
2207	{
2208	// Kennen wir schon
2209	continue;
2210	}
2211	else
2212	{
2213	// Sonst eintragen
2214	aCheckedInterfacesMap[ pIface ] = pIface;
2215	}
2216
2217	//********************************************************************
2218
2219	// 2. Fields als Properties registrieren
2220
2221	// Felder holen
2222	Sequence< Reference<XIdlField> > fields = rxIfaceClass->getFields();
2223	const Reference<XIdlField>* pFields = fields.getConstArray();
2224	sal_Int32 nLen = fields.getLength();
2225
2226	for( i = 0 ; i < nLen ; i++ )
2227	{
2228	Reference<XIdlField> xField = pFields[i];
2229	Reference<XIdlClass> xPropType = xField->getType();
2230
2231	// Ist die PropertySequence gross genug?
2232	pAccess->checkPropertyArraysSize
2233	( pAllPropArray, pMapTypeArray, pPropertyConceptArray, rPropCount );
2234
2235	// In eigenes Property-Array eintragen
2236	Property& rProp = pAllPropArray[ rPropCount ];
2237	::rtl::OUString aFieldName = xField->getName();
2238	rProp.Name = aFieldName;
2239	rProp.Handle = rPropCount;
2240	Type aFieldType( xPropType->getTypeClass(), xPropType->getName() );
2241	rProp.Type = aFieldType;
2242	FieldAccessMode eAccessMode = xField->getAccessMode();
2243	rProp.Attributes = (eAccessMode == FieldAccessMode_READONLY \|\|
2244	eAccessMode == FieldAccessMode_CONST)
2245	? READONLY : 0;
2246
2247	// Namen in Hashtable eintragen
2248	::rtl::OUString aPropName = rProp.Name;
2249
2250	// Haben wir den Namen schon?
2251	IntrospectionNameMap::iterator aIt = rPropNameMap.find( aPropName );
2252	if( !( aIt == rPropNameMap.end() ) )
2253	continue;
2254
2255	// Neuer Eintrag in die Hashtable
2256	rPropNameMap[ aPropName ] = rPropCount;
2257
2258	// Tabelle fuer XExactName pflegen
2259	rLowerToExactNameMap[ toLower( aPropName ) ] = aPropName;
2260
2261	// Field merken
2262	pAccess->checkInterfaceArraySize( pAccess->aInterfaceSeq1,
2263	pInterfaces1, rPropCount );
2264	pInterfaces1[ rPropCount ] = xField;
2265
2266	// Art der Property merken
2267	pMapTypeArray[ rPropCount ] = MAP_FIELD1;
2268	pPropertyConceptArray[ rPropCount ] = ATTRIBUTES;
2269	pAccess->mnAttributePropCount++;
2270
2271	// Count pflegen
2272	rPropCount++;
2273	}
2274
2275	//********************************************************************
2276
2277	// 3. Methoden
2278
2279	// Zaehler fuer die gefundenen Listener
2280	sal_Int32 nListenerCount = 0;
2281
2282	// Alle Methoden holen und merken
2283	Sequence< Reference<XIdlMethod> > methods = rxIfaceClass->getMethods();
2284	const Reference<XIdlMethod>* pSourceMethods = methods.getConstArray();
2285	sal_Int32 nSourceMethodCount = methods.getLength();
2286
2287	// 3. a) get/set- und Listener-Methoden suchen
2288
2289	// Feld fuer Infos ueber die Methoden anlegen, damit spaeter leicht die Methoden
2290	// gefunden werden koennen, die nicht im Zusammenhang mit Properties oder Listenern
2291	// stehen. NEU: auch MethodConceptArray initialisieren
2292	MethodType* pMethodTypes = new MethodType[ nSourceMethodCount ];
2293	sal_Int32* pLocalMethodConcepts = new sal_Int32[ nSourceMethodCount ];
2294	for( i = 0 ; i < nSourceMethodCount ; i++ )
2295	{
2296	pMethodTypes[ i ] = STANDARD_METHOD;
2297	pLocalMethodConcepts[ i ] = 0;
2298	}
2299
2300	::rtl::OUString aMethName;
2301	::rtl::OUString aPropName;
2302	::rtl::OUString aStartStr;
2303	for( i = 0 ; i < nSourceMethodCount ; i++ )
2304	{
2305	// Methode ansprechen
2306	const Reference<XIdlMethod>& rxMethod_i = pSourceMethods[i];
2307	sal_Int32& rMethodConcept_i = pLocalMethodConcepts[ i ];
2308
2309	// Namen besorgen
2310	aMethName = rxMethod_i->getName();
2311
2312	// Methoden katalogisieren
2313	// Alle (?) Methoden von XInterface filtern, damit z.B. nicht
2314	// vom Scripting aus acquire oder release gerufen werden kann
2315	if( rxMethod_i->getDeclaringClass()->equals( mxInterfaceClass ) )
2316	{
2317	// XInterface-Methoden sind hiermit einmal beruecksichtigt
2318	bFoundXInterface = sal_True((sal_Bool)1);
2319
2320	if( bXInterfaceIsInvalid )
2321	{
2322	pMethodTypes[ i ] = INVALID_METHOD;
2323	continue;
2324	}
2325	else
2326	{
2327	if( aMethName != ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("queryInterface")(&("queryInterface")[0]), ((sal_Int32)((sizeof ("queryInterface" ) / sizeof (("queryInterface")[0]))-1)), (((rtl_TextEncoding) 11))) )
2328	{
2329	rMethodConcept_i \|= MethodConcept::DANGEROUS;
2330	continue;
2331	}
2332	}
2333	}
2334	else if( rxMethod_i->getDeclaringClass()->equals( mxAggregationClass ) )
2335	{
2336	if( aMethName == "setDelegator" )
2337	{
2338	rMethodConcept_i \|= MethodConcept::DANGEROUS;
2339	continue;
2340	}
2341	}
2342	else if( rxMethod_i->getDeclaringClass()->equals( mxElementAccessClass ) )
2343	{
2344	rMethodConcept_i \|= ( NAMECONTAINER \|
2345	INDEXCONTAINER \|
2346	ENUMERATION );
2347	}
2348	else if( rxMethod_i->getDeclaringClass()->equals( mxNameContainerClass ) \|\|
2349	rxMethod_i->getDeclaringClass()->equals( mxNameAccessClass ) )
2350	{
2351	rMethodConcept_i \|= NAMECONTAINER;
2352	}
2353	else if( rxMethod_i->getDeclaringClass()->equals( mxIndexContainerClass ) \|\|
2354	rxMethod_i->getDeclaringClass()->equals( mxIndexAccessClass ) )
2355	{
2356	rMethodConcept_i \|= INDEXCONTAINER;
2357	}
2358	else if( rxMethod_i->getDeclaringClass()->equals( mxEnumerationAccessClass ) )
2359	{
2360	rMethodConcept_i \|= ENUMERATION;
2361	}
2362
2363	// Wenn der Name zu kurz ist, wird's sowieso nichts
2364	if( aMethName.getLength() <= 3 )
2365	continue;
2366
2367	// Ist es eine get-Methode?
2368	aStartStr = aMethName.copy( 0, 3 );
2369	if( aStartStr == "get" )
2370	{
2371	// Namen der potentiellen Property
2372	aPropName = aMethName.copy( 3 );
2373
2374	// get-Methode darf keinen Parameter haben
2375	Sequence< Reference<XIdlClass> > getParams = rxMethod_i->getParameterTypes();
2376	if( getParams.getLength() > 0 )
2377	{
2378	continue;
2379	}
2380
2381	// Haben wir den Namen schon?
2382	IntrospectionNameMap::iterator aIt = rPropNameMap.find( aPropName );
2383	if( !( aIt == rPropNameMap.end() ) )
2384	{
2385	/* TODO
2386	OSL_TRACE(
2387	String( "Introspection: Property \"" ) +
2388	OOUStringToString( aPropName, CHARSET_SYSTEM ) +
2389	String( "\" found more than once" ) );
2390	*/
2391	continue;
2392	}
2393
2394	// Eine readonly-Property ist es jetzt mindestens schon
2395	rMethodConcept_i \|= PROPERTY;
2396
2397	pMethodTypes[i] = GETSET_METHOD;
2398	Reference<XIdlClass> xGetRetType = rxMethod_i->getReturnType();
2399
2400	// Ist die PropertySequence gross genug?
2401	pAccess->checkPropertyArraysSize
2402	( pAllPropArray, pMapTypeArray, pPropertyConceptArray, rPropCount );
2403
2404	// In eigenes Property-Array eintragen
2405	Property& rProp = pAllPropArray[ rPropCount ];
2406	rProp.Name = aPropName;
2407	rProp.Handle = rPropCount;
2408	rProp.Type = Type( xGetRetType->getTypeClass(), xGetRetType->getName() );
2409	rProp.Attributes = READONLY;
2410
2411	// Neuer Eintrag in die Hashtable
2412	rPropNameMap[ aPropName ] = rPropCount;
2413
2414	// Tabelle fuer XExactName pflegen
2415	rLowerToExactNameMap[ toLower( aPropName ) ] = aPropName;
2416
2417	// get-Methode merken
2418	pAccess->checkInterfaceArraySize( pAccess->aInterfaceSeq1,
2419	pInterfaces1, rPropCount );
2420	pInterfaces1[ rPropCount ] = rxMethod_i;
2421
2422	// Art der Property merken
2423	pMapTypeArray[ rPropCount ] = MAP_GETSET2;
2424	pPropertyConceptArray[ rPropCount ] = METHODS;
2425	pAccess->mnMethodPropCount++;
2426
2427	// Passende set-Methode suchen
2428	sal_Int32 k;
2429	for( k = 0 ; k < nSourceMethodCount ; k++ )
2430	{
2431	// Methode ansprechen
2432	const Reference<XIdlMethod>& rxMethod_k = pSourceMethods[k];
2433
2434	// Nur Methoden nehmen, die nicht schon zugeordnet sind
2435	if( k == i \|\| pMethodTypes[k] != STANDARD_METHOD )
2436	continue;
2437
2438	// Name holen und auswerten
2439	::rtl::OUString aMethName2 = rxMethod_k->getName();
2440	::rtl::OUString aStartStr2 = aMethName2.copy( 0, 3 );
2441	// ACHTUNG: Wegen SDL-Bug NICHT != bei ::rtl::OUString verwenden !!!
2442	if( !( aStartStr2 == "set" ) )
2443	continue;
2444
2445	// Ist es denn der gleiche Name?
2446	::rtl::OUString aPropName2 = aMethName2.copy( 3 );
2447	// ACHTUNG: Wegen SDL-Bug NICHT != bei ::rtl::OUString verwenden !!!
2448	if( !( aPropName == aPropName2 ) )
2449	continue;
2450
2451	// set-Methode muss void returnen
2452	Reference<XIdlClass> xSetRetType = rxMethod_k->getReturnType();
2453	if( xSetRetType->getTypeClass() != TypeClass_VOID )
2454	{
2455	continue;
2456	}
2457
2458	// set-Methode darf nur einen Parameter haben
2459	Sequence< Reference<XIdlClass> > setParams = rxMethod_k->getParameterTypes();
2460	sal_Int32 nParamCount = setParams.getLength();
2461	if( nParamCount != 1 )
2462	{
2463	continue;
2464	}
2465
2466	// Jetzt muss nur noch der return-Typ dem Parameter-Typ entsprechen
2467	const Reference<XIdlClass>* pParamArray2 = setParams.getConstArray();
2468	Reference<XIdlClass> xParamType = pParamArray2[ 0 ];
2469	if( xParamType->equals( xGetRetType ) )
2470	{
2471	pLocalMethodConcepts[ k ] = PROPERTY;
2472
2473	pMethodTypes[k] = GETSET_METHOD;
2474
2475	// ReadOnly-Flag wieder loschen
2476	rProp.Attributes &= ~READONLY;
2477
2478	// set-Methode merken
2479	pAccess->checkInterfaceArraySize( pAccess->aInterfaceSeq2,
2480	pInterfaces2, rPropCount );
2481	pInterfaces2[ rPropCount ] = rxMethod_k;
2482	}
2483	}
2484
2485	// Count pflegen
2486	rPropCount++;
2487	}
2488
2489	// Ist es eine addListener-Methode?
2490	else if( aStartStr == "add" )
2491	{
2492	::rtl::OUString aListenerStr( "Listener" );
2493
2494	// Namen der potentiellen Property
2495	sal_Int32 nStrLen = aMethName.getLength();
2496	sal_Int32 nCopyLen = nStrLen - aListenerStr.getLength();
2497	::rtl::OUString aEndStr = aMethName.copy( nCopyLen > 0 ? nCopyLen : 0 );
2498
2499	// Endet das Teil auf Listener?
2500	// ACHTUNG: Wegen SDL-Bug NICHT != bei ::rtl::OUString verwenden !!!
2501	if( !( aEndStr == aListenerStr ) )
2502	continue;
2503
2504	// Welcher Listener?
2505	::rtl::OUString aListenerName = aMethName.copy( 3, nStrLen - aListenerStr.getLength() - 3 );
2506
2507	// TODO: Hier koennten noch genauere Pruefungen vorgenommen werden
2508	// - Rueckgabe-Typ
2509	// - Anzahl und Art der Parameter
2510
2511
2512	// Passende remove-Methode suchen, sonst gilt's nicht
2513	sal_Int32 k;
2514	for( k = 0 ; k < nSourceMethodCount ; k++ )
2515	{
2516	// Methode ansprechen
2517	const Reference<XIdlMethod>& rxMethod_k = pSourceMethods[k];
2518
2519	// Nur Methoden nehmen, die nicht schon zugeordnet sind
2520	if( k == i \|\| pMethodTypes[k] != STANDARD_METHOD )
2521	continue;
2522
2523	// Name holen und auswerten
2524	::rtl::OUString aMethName2 = rxMethod_k->getName();
2525	sal_Int32 nNameLen = aMethName2.getLength();
2526	sal_Int32 nCopyLen2 = (nNameLen < 6) ? nNameLen : 6;
2527	::rtl::OUString aStartStr2 = aMethName2.copy( 0, nCopyLen2 );
2528	::rtl::OUString aRemoveStr( RTL_CONSTASCII_USTRINGPARAM("remove" )(&("remove")[0]), ((sal_Int32)((sizeof ("remove") / sizeof (("remove")[0]))-1)), (((rtl_TextEncoding) 11)) );
2529	// ACHTUNG: Wegen SDL-Bug NICHT != bei ::rtl::OUString verwenden !!!
2530	if( !( aStartStr2 == aRemoveStr ) )
2531	continue;
2532
2533	// Ist es denn der gleiche Listener?
2534	if( aMethName2.getLength() - aRemoveStr.getLength() <= aListenerStr.getLength() )
2535	continue;
2536	::rtl::OUString aListenerName2 = aMethName2.copy
2537	( 6, aMethName2.getLength() - aRemoveStr.getLength() - aListenerStr.getLength() );
2538	// ACHTUNG: Wegen SDL-Bug NICHT != bei ::rtl::OUString verwenden !!!
2539	if( !( aListenerName == aListenerName2 ) )
2540	continue;
2541
2542	// TODO: Hier koennten noch genauere Pruefungen vorgenommen werden
2543	// - Rueckgabe-Typ
2544	// - Anzahl und Art der Parameter
2545
2546
2547	// Methoden sind als Listener-Schnittstelle erkannt
2548	rMethodConcept_i \|= LISTENER;
2549	pLocalMethodConcepts[ k ] \|= LISTENER;
2550
2551	pMethodTypes[i] = ADD_LISTENER_METHOD;
2552	pMethodTypes[k] = REMOVE_LISTENER_METHOD;
2553	nListenerCount++;
2554	}
2555	}
2556	}
2557
2558
2559	// Jetzt koennen noch SET-Methoden ohne zugehoerige GET-Methode existieren,
2560	// diese muessen zu Write-Only-Properties gemachte werden.
2561	for( i = 0 ; i < nSourceMethodCount ; i++ )
2562	{
2563	// Methode ansprechen
2564	const Reference<XIdlMethod>& rxMethod_i = pSourceMethods[i];
2565
2566	// Nur Methoden nehmen, die nicht schon zugeordnet sind
2567	if( pMethodTypes[i] != STANDARD_METHOD )
2568	continue;
2569
2570	// Namen besorgen
2571	aMethName = rxMethod_i->getName();
2572
2573	// Wenn der Name zu kurz ist, wird's sowieso nichts
2574	if( aMethName.getLength() <= 3 )
2575	continue;
2576
2577	// Ist es eine set-Methode ohne zugehoerige get-Methode?
2578	aStartStr = aMethName.copy( 0, 3 );
2579	if( aStartStr == "set" )
2580	{
2581	// Namen der potentiellen Property
2582	aPropName = aMethName.copy( 3 );
2583
2584	// set-Methode muss void returnen
2585	Reference<XIdlClass> xSetRetType = rxMethod_i->getReturnType();
2586	if( xSetRetType->getTypeClass() != TypeClass_VOID )
2587	{
2588	continue;
2589	}
2590
2591	// set-Methode darf nur einen Parameter haben
2592	Sequence< Reference<XIdlClass> > setParams = rxMethod_i->getParameterTypes();
2593	sal_Int32 nParamCount = setParams.getLength();
2594	if( nParamCount != 1 )
2595	{
2596	continue;
2597	}
2598
2599	// Haben wir den Namen schon?
2600	IntrospectionNameMap::iterator aIt = rPropNameMap.find( aPropName );
2601	if( !( aIt == rPropNameMap.end() ) )
2602	{
2603	/* TODO:
2604	OSL_TRACE(
2605	String( "Introspection: Property \"" ) +
2606	OOUStringToString( aPropName, CHARSET_SYSTEM ) +
2607	String( "\" found more than once" ) );
2608	*/
2609	continue;
2610	}
2611
2612	// Alles klar, es ist eine Write-Only-Property
2613	pLocalMethodConcepts[ i ] = PROPERTY;
2614
2615	pMethodTypes[i] = GETSET_METHOD;
2616	Reference<XIdlClass> xGetRetType = setParams.getConstArray()[0];
2617
2618	// Ist die PropertySequence gross genug?
2619	pAccess->checkPropertyArraysSize
2620	( pAllPropArray, pMapTypeArray, pPropertyConceptArray, rPropCount );
2621
2622	// In eigenes Property-Array eintragen
2623	Property& rProp = pAllPropArray[ rPropCount ];
2624	rProp.Name = aPropName;
2625	rProp.Handle = rPropCount;
2626	rProp.Type = Type( xGetRetType->getTypeClass(), xGetRetType->getName() );
2627	rProp.Attributes = 0; // PROPERTY_WRITEONLY ???
2628
2629	// Neuer Eintrag in die Hashtable
2630	rPropNameMap[ aPropName ] = rPropCount;
2631
2632	// Tabelle fuer XExactName pflegen
2633	rLowerToExactNameMap[ toLower( aPropName ) ] = aPropName;
2634
2635	// set-Methode merken
2636	pAccess->checkInterfaceArraySize( pAccess->aInterfaceSeq2,
2637	pInterfaces2, rPropCount );
2638	pInterfaces2[ rPropCount ] = rxMethod_i;
2639
2640	// Art der Property merken
2641	pMapTypeArray[ rPropCount ] = MAP_SETONLY3;
2642	pPropertyConceptArray[ rPropCount ] = METHODS;
2643	pAccess->mnMethodPropCount++;
2644
2645	// Count pflegen
2646	rPropCount++;
2647	}
2648	}
2649
2650
2651	//********************************************************************
2652
2653	// 4. Methoden in die Gesamt-Sequence uebernehmen
2654
2655	// Wieviele Methoden muessen in die Method-Sequence?
2656	sal_Int32 nExportedMethodCount = 0;
2657	sal_Int32 nSupportedListenerCount = 0;
2658	for( i = 0 ; i < nSourceMethodCount ; i++ )
2659	{
2660	if( pMethodTypes[ i ] != INVALID_METHOD )
2661	{
2662	nExportedMethodCount++;
2663	}
2664	if( pMethodTypes[ i ] == ADD_LISTENER_METHOD )
2665	{
2666	nSupportedListenerCount++;
2667	}
2668	}
2669
2670	// Sequences im Access-Objekt entsprechend aufbohren
2671	pAccess->maAllMethodSeq.realloc( nExportedMethodCount + iAllExportedMethod );
2672	pAccess->maMethodConceptSeq.realloc( nExportedMethodCount + iAllExportedMethod );
2673	pAccess->maSupportedListenerSeq.realloc( nSupportedListenerCount + iAllSupportedListener );
2674
2675	// Methoden reinschreiben
2676	Reference<XIdlMethod>* pDestMethods = pAccess->maAllMethodSeq.getArray();
2677	sal_Int32* pMethodConceptArray = pAccess->maMethodConceptSeq.getArray();
2678	Type* pListenerClassRefs = pAccess->maSupportedListenerSeq.getArray();
2679	for( i = 0 ; i < nSourceMethodCount ; i++ )
2680	{
2681	if( pMethodTypes[ i ] != INVALID_METHOD )
2682	{
2683	// Methode ansprechen
2684	const Reference<XIdlMethod>& rxMethod = pSourceMethods[i];
2685
2686	// Namen in Hashtable eintragen, wenn nicht schon bekannt
2687	::rtl::OUString aMethName2 = rxMethod->getName();
2688	IntrospectionNameMap::iterator aIt = rMethodNameMap.find( aMethName2 );
2689	if( aIt == rMethodNameMap.end() )
2690	{
2691	// Eintragen
2692	rMethodNameMap[ aMethName2 ] = iAllExportedMethod;
2693
2694	// Tabelle fuer XExactName pflegen
2695	rLowerToExactNameMap[ toLower( aMethName2 ) ] = aMethName2;
2696	}
2697	else
2698	{
2699	sal_Int32 iHashResult = (*aIt).second;
2700
2701	Reference<XIdlMethod> xExistingMethod = pDestMethods[ iHashResult ];
2702
2703	Reference< XIdlClass > xExistingMethClass =
2704	xExistingMethod->getDeclaringClass();
2705	Reference< XIdlClass > xNewMethClass = rxMethod->getDeclaringClass();
2706	if( xExistingMethClass->equals( xNewMethClass ) )
2707	continue;
2708	}
2709
2710	pDestMethods[ iAllExportedMethod ] = rxMethod;
2711
2712	// Wenn kein Concept gesetzt wurde, ist die Methode "normal"
2713	sal_Int32& rMethodConcept_i = pLocalMethodConcepts[ i ];
2714	if( !rMethodConcept_i )
2715	rMethodConcept_i = MethodConcept_NORMAL_IMPL0x80000000;
2716	pMethodConceptArray[ iAllExportedMethod ] = rMethodConcept_i;
2717	iAllExportedMethod++;
2718	}
2719	if( pMethodTypes[ i ] == ADD_LISTENER_METHOD )
2720	{
2721	// Klasse des Listeners ermitteln
2722	const Reference<XIdlMethod>& rxMethod = pSourceMethods[i];
2723
2724	// void als Default-Klasse eintragen
2725	Reference<XIdlClass> xListenerClass = TypeToIdlClass( getCppuVoidType(), m_xSMgr );
2726	// ALT: Reference<XIdlClass> xListenerClass = Void_getReflection()->getIdlClass();
2727
2728	// 1. Moeglichkeit: Parameter nach einer Listener-Klasse durchsuchen
2729	// Nachteil: Superklassen muessen rekursiv durchsucht werden
2730	Sequence< Reference<XIdlClass> > aParams = rxMethod->getParameterTypes();
2731	const Reference<XIdlClass>* pParamArray2 = aParams.getConstArray();
2732
2733	Reference<XIdlClass> xEventListenerClass = TypeToIdlClass( getCppuType( (Reference<XEventListener>*) NULL__null ), m_xSMgr );
2734	// ALT: Reference<XIdlClass> xEventListenerClass = XEventListener_getReflection()->getIdlClass();
2735	sal_Int32 nParamCount = aParams.getLength();
2736	sal_Int32 k;
2737	for( k = 0 ; k < nParamCount ; k++ )
2738	{
2739	const Reference<XIdlClass>& rxClass = pParamArray2[k];
2740
2741	// Sind wir von einem Listener abgeleitet?
2742	if( rxClass->equals( xEventListenerClass ) \|\|
2743	isDerivedFrom( rxClass, xEventListenerClass ) )
2744	{
2745	xListenerClass = rxClass;
2746	break;
2747	}
2748	}
2749
2750	// 2. Moeglichkeit: Namen der Methode auswerden
2751	// Nachteil: geht nicht bei Test-Listenern, die es nicht gibt
2752	//aMethName = rxMethod->getName();
2753	//aListenerName = aMethName.Copy( 3, aMethName.Len()-8-3 );
2754	//Reference<XIdlClass> xListenerClass = reflection->forName( aListenerName );
2755	Type aListenerType( TypeClass_INTERFACE, xListenerClass->getName() );
2756	pListenerClassRefs[ iAllSupportedListener ] = aListenerType;
2757	iAllSupportedListener++;
2758	}
2759	}
2760
2761	// Wenn in diesem Durchlauf XInterface-Methoden
2762	// dabei waren, diese zukuenftig ignorieren
2763	if( bFoundXInterface )
2764	bXInterfaceIsInvalid = sal_True((sal_Bool)1);
2765
2766	delete[] pMethodTypes;
2767	delete[] pLocalMethodConcepts;
2768	}
2769
2770	// Super-Klasse(n) vorhanden? Dann dort fortsetzen
2771	Sequence< Reference<XIdlClass> > aSuperClassSeq = xImplClass2->getSuperclasses();
2772
2773	// Zur Zeit wird nur von einer Superklasse ausgegangen
2774	if( aSuperClassSeq.getLength() >= 1 )
2775	{
2776	xImplClass2 = aSuperClassSeq.getConstArray()[0];
2777	OSL_ENSURE( xImplClass2.is(), "super class null" )do { if (true && (!(xImplClass2.is()))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2777" ": "), "%s", "super class null"); } } while (false );
2778	}
2779	else
2780	{
2781	xImplClass2 = NULL__null;
2782	}
2783	}
2784	}
2785
2786	// Anzahl der exportierten Methoden uebernehmen und Sequences anpassen
2787	// (kann abweichen, weil doppelte Methoden erst nach der Ermittlung
2788	// von nExportedMethodCount herausgeworfen werden)
2789	sal_Int32& rMethCount = pAccess->mnMethCount;
2790	rMethCount = iAllExportedMethod;
2791	pAccess->maAllMethodSeq.realloc( rMethCount );
2792	pAccess->maMethodConceptSeq.realloc( rMethCount );
2793
2794	// Groesse der Property-Sequences anpassen
2795	pAccess->maAllPropertySeq.realloc( rPropCount );
2796	pAccess->maPropertyConceptSeq.realloc( rPropCount );
2797	pAccess->maMapTypeSeq.realloc( rPropCount );
2798	}
2799	// Bei structs Fields als Properties registrieren
2800	else //if( eType == TypeClass_STRUCT )
2801	{
2802	// Ist es ein Interface oder eine struct?
2803	//Reference<XIdlClass> xClassRef = aToInspectObj.getReflection()->getIdlClass();
2804	Reference<XIdlClass> xClassRef = TypeToIdlClass( aToInspectObj.getValueType(), m_xSMgr );
2805	if( !xClassRef.is() )
2806	{
2807	OSL_FAIL( "Can't get XIdlClass from Reflection" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/usr/local/src/libreoffice/stoc/source/inspect/introspection.cxx" ":" "2807" ": "), "%s", "Can't get XIdlClass from Reflection" ); } } while (false);
2808	return pAccess;
2809	}
2810
2811	// Felder holen
2812	Sequence< Reference<XIdlField> > fields = xClassRef->getFields();
2813	const Reference<XIdlField>* pFields = fields.getConstArray();
2814	sal_Int32 nLen = fields.getLength();
2815
2816	for( i = 0 ; i < nLen ; i++ )
2817	{
2818	Reference<XIdlField> xField = pFields[i];
2819	Reference<XIdlClass> xPropType = xField->getType();
2820	::rtl::OUString aPropName = xField->getName();
2821
2822	// Ist die PropertySequence gross genug?
2823	pAccess->checkPropertyArraysSize
2824	( pAllPropArray, pMapTypeArray, pPropertyConceptArray, rPropCount );
2825
2826	// In eigenes Property-Array eintragen
2827	Property& rProp = pAllPropArray[ rPropCount ];
2828	rProp.Name = aPropName;
2829	rProp.Handle = rPropCount;
2830	rProp.Type = Type( xPropType->getTypeClass(), xPropType->getName() );
2831	FieldAccessMode eAccessMode = xField->getAccessMode();
2832	rProp.Attributes = (eAccessMode == FieldAccessMode_READONLY \|\|
2833	eAccessMode == FieldAccessMode_CONST)
2834	? READONLY : 0;
2835
2836	//FieldAccessMode eAccessMode = xField->getAccessMode();
2837	//rProp.Attributes = (eAccessMode == FieldAccessMode::READONLY \|\| eAccessMode == CONST)
2838	//? PropertyAttribute::READONLY : 0;
2839
2840	// Namen in Hashtable eintragen
2841	rPropNameMap[ aPropName ] = rPropCount;
2842
2843	// Tabelle fuer XExactName pflegen
2844	rLowerToExactNameMap[ toLower( aPropName ) ] = aPropName;
2845
2846	// Field merken
2847	pAccess->checkInterfaceArraySize( pAccess->aInterfaceSeq1,
2848	pInterfaces1, rPropCount );
2849	pInterfaces1[ rPropCount ] = xField;
2850
2851	// Art der Property merken
2852	pMapTypeArray[ rPropCount ] = MAP_FIELD1;
2853	pPropertyConceptArray[ rPropCount ] = ATTRIBUTES;
2854	pAccess->mnAttributePropCount++;
2855
2856	// Count pflegen
2857	rPropCount++;
2858	}
2859	}
2860
2861	// Property-Sequence auf die richtige Laenge bringen
2862	pAccess->maAllPropertySeq.realloc( pAccess->mnPropCount );
2863
2864	return pAccess;
2865	}
2866
2867	//*************************************************************************
2868	Reference< XInterface > SAL_CALL ImplIntrospection_CreateInstance( const Reference< XMultiServiceFactory > & rSMgr )
2869	throw( RuntimeException )
2870	{
2871	Reference< XInterface > xService = (OWeakObject)(OComponentHelper)new ImplIntrospection( rSMgr );
2872	return xService;
2873	}
2874
2875	}
2876
2877	#ifdef DISABLE_DYNLOADING
2878	#define component_getFactory introspection_component_getFactory
2879	#endif
2880
2881	extern "C"
2882	{
2883	SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) void * SAL_CALL component_getFactory(
2884	const sal_Char * pImplName, void * pServiceManager,
2885	SAL_UNUSED_PARAMETER__attribute__ ((unused)) void * )
2886	{
2887	void * pRet = 0;
2888
2889	if (pServiceManager && rtl_str_compare( pImplName, IMPLEMENTATION_NAME"com.sun.star.comp.stoc.Introspection" ) == 0)
2890	{
2891	Reference< XSingleServiceFactory > xFactory( createOneInstanceFactory(
2892	reinterpret_cast< XMultiServiceFactory * >( pServiceManager ),
2893	::rtl::OUString::createFromAscii( pImplName ),
2894	stoc_inspect::ImplIntrospection_CreateInstance,
2895	stoc_inspect::ImplIntrospection::getSupportedServiceNames_Static() ) );
2896
2897	if (xFactory.is())
2898	{
2899	xFactory->acquire();
2900	pRet = xFactory.get();
2901	}
2902	}
2903
2904	return pRet;
2905	}
2906	}
2907
2908
2909	/* vim:set shiftwidth=4 softtabstop=4 expandtab: */