Context Navigation

corbaiface.mpp@ 27061

Last change on this file since 27061 was 25231, checked in by ak19, 12 years ago
Many changes to get corba working again ever since the addition of RSS support meant that the method get_rss_items needed to be mirrored in the corba code. The corba code was not compiling then and it turned out we needed a later version of Mico's corba implementation (2.3.13 up from 2.3.5). Therefore the current commit not only corrects some errors in the recently added getRssItems() method but includes further changes: 1. namespaced use of iostream functions were required in some mpp files. 2. New types and member variables added to the corbaiface.idl interface file, to mirror the presence of equivalent variables in comtools.h which hadn't been ported over yet. (Such as the complex corba data type equivalent of collectionmetamap used in comtools.h.) This required (de)serialisation methods to be declared and implemented in corbatext_t.h and corbatext_t.mpp. The additional member variables for the corbaColInfoResponse in corbaiface.idl are now also unpacked in corbaproto.mpp along with the rest of the data structure. 3. Having changed from mico version 2.3.5 to 2.3.13 required code to changed to use POA instead of BOA. This also meant that skeleton files were no longer to be generated when running idl over corbaiface.idl. corbaserver inherits from a POA related object now instead of from the skeleton. 4. Makefile.in was updated to reflect these changes (absence of skeleton), includes a target to run IDL over the corbaiface.idl file to generate the necessary helper files, and corrects earlier oversights in updating the corba makefile with the rest of the changes made over time to runtime-src.
Property svn:keywords set to `Author Date Id Revision`
File size: 107.6 KB

Line
1	/*
2	* MICO --- an Open Source CORBA implementation
3	* Copyright (c) 1997-2006 by The Mico Team
4	*
5	* This file was automatically generated. DO NOT EDIT!
6	*/
7
8	#include <corbaiface.h>
9
10
11	using namespace std;
12
13	//--------------------------------------------------------
14	// Implementation of stubs
15	//--------------------------------------------------------
16
17
18	#ifdef HAVE_EXPLICIT_STRUCT_OPS
19	gsdlInterface::corbatext_t::corbatext_t()
20	{
21	}
22
23	gsdlInterface::corbatext_t::corbatext_t( const corbatext_t& _s )
24	{
25	text = ((corbatext_t&)_s).text;
26	encoding = ((corbatext_t&)_s).encoding;
27	length = ((corbatext_t&)_s).length;
28	}
29
30	gsdlInterface::corbatext_t::~corbatext_t()
31	{
32	}
33
34	gsdlInterface::corbatext_t&
35	gsdlInterface::corbatext_t::operator=( const corbatext_t& _s )
36	{
37	text = ((corbatext_t&)_s).text;
38	encoding = ((corbatext_t&)_s).encoding;
39	length = ((corbatext_t&)_s).length;
40	return *this;
41	}
42	#endif
43
44	class _Marshaller_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo {
45	typedef gsdlInterface::corbatext_t _MICO_T;
46	public:
47	~_Marshaller_gsdlInterface_corbatext_t();
48	StaticValueType create () const;
49	void assign (StaticValueType dst, const StaticValueType src) const;
50	void free (StaticValueType) const;
51	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
52	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
53	};
54
55
56	_Marshaller_gsdlInterface_corbatext_t::~_Marshaller_gsdlInterface_corbatext_t()
57	{
58	}
59
60	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const
61	{
62	return (StaticValueType) new _MICO_T;
63	}
64
65	void _Marshaller_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
66	{
67	(_MICO_T) d = (_MICO_T) s;
68	}
69
70	void _Marshaller_gsdlInterface_corbatext_t::free( StaticValueType v ) const
71	{
72	delete (_MICO_T*) v;
73	}
74
75	::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
76	{
77	return
78	dc.struct_begin() &&
79	CORBA::_stcseq_ushort->demarshal( dc, &((_MICO_T*)v)->text ) &&
80	CORBA::_stc_ushort->demarshal( dc, &((_MICO_T*)v)->encoding ) &&
81	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->length ) &&
82	dc.struct_end();
83	}
84
85	void _Marshaller_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
86	{
87	ec.struct_begin();
88	CORBA::_stcseq_ushort->marshal( ec, &((_MICO_T*)v)->text );
89	CORBA::_stc_ushort->marshal( ec, &((_MICO_T*)v)->encoding );
90	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->length );
91	ec.struct_end();
92	}
93
94	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
95
96
97
98	#ifdef HAVE_EXPLICIT_STRUCT_OPS
99	gsdlInterface::corbatext_tmap::corbatext_tmap()
100	{
101	}
102
103	gsdlInterface::corbatext_tmap::corbatext_tmap( const corbatext_tmap& _s )
104	{
105	names = ((corbatext_tmap&)_s).names;
106	values = ((corbatext_tmap&)_s).values;
107	}
108
109	gsdlInterface::corbatext_tmap::~corbatext_tmap()
110	{
111	}
112
113	gsdlInterface::corbatext_tmap&
114	gsdlInterface::corbatext_tmap::operator=( const corbatext_tmap& _s )
115	{
116	names = ((corbatext_tmap&)_s).names;
117	values = ((corbatext_tmap&)_s).values;
118	return *this;
119	}
120	#endif
121
122	class _Marshaller_gsdlInterface_corbatext_tmap : public ::CORBA::StaticTypeInfo {
123	typedef gsdlInterface::corbatext_tmap _MICO_T;
124	public:
125	~_Marshaller_gsdlInterface_corbatext_tmap();
126	StaticValueType create () const;
127	void assign (StaticValueType dst, const StaticValueType src) const;
128	void free (StaticValueType) const;
129	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
130	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
131	};
132
133
134	_Marshaller_gsdlInterface_corbatext_tmap::~_Marshaller_gsdlInterface_corbatext_tmap()
135	{
136	}
137
138	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const
139	{
140	return (StaticValueType) new _MICO_T;
141	}
142
143	void _Marshaller_gsdlInterface_corbatext_tmap::assign( StaticValueType d, const StaticValueType s ) const
144	{
145	(_MICO_T) d = (_MICO_T) s;
146	}
147
148	void _Marshaller_gsdlInterface_corbatext_tmap::free( StaticValueType v ) const
149	{
150	delete (_MICO_T*) v;
151	}
152
153	::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
154	{
155	return
156	dc.struct_begin() &&
157	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
158	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) &&
159	dc.struct_end();
160	}
161
162	void _Marshaller_gsdlInterface_corbatext_tmap::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
163	{
164	ec.struct_begin();
165	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
166	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values );
167	ec.struct_end();
168	}
169
170	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
171
172	#ifdef HAVE_EXPLICIT_STRUCT_OPS
173	gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta()
174	{
175	}
176
177	gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta( const corbatext_tcollectionmeta& _s )
178	{
179	name = ((corbatext_tcollectionmeta&)_s).name;
180	tuples = ((corbatext_tcollectionmeta&)_s).tuples;
181	}
182
183	gsdlInterface::corbatext_tcollectionmeta::~corbatext_tcollectionmeta()
184	{
185	}
186
187	gsdlInterface::corbatext_tcollectionmeta&
188	gsdlInterface::corbatext_tcollectionmeta::operator=( const corbatext_tcollectionmeta& _s )
189	{
190	name = ((corbatext_tcollectionmeta&)_s).name;
191	tuples = ((corbatext_tcollectionmeta&)_s).tuples;
192	return *this;
193	}
194	#endif
195
196	class _Marshaller_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo {
197	typedef gsdlInterface::corbatext_tcollectionmeta _MICO_T;
198	public:
199	~_Marshaller_gsdlInterface_corbatext_tcollectionmeta();
200	StaticValueType create () const;
201	void assign (StaticValueType dst, const StaticValueType src) const;
202	void free (StaticValueType) const;
203	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
204	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
205	};
206
207
208	_Marshaller_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller_gsdlInterface_corbatext_tcollectionmeta()
209	{
210	}
211
212	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tcollectionmeta::create() const
213	{
214	return (StaticValueType) new _MICO_T;
215	}
216
217	void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const
218	{
219	(_MICO_T) d = (_MICO_T) s;
220	}
221
222	void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const
223	{
224	delete (_MICO_T*) v;
225	}
226
227	::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
228	{
229	return
230	dc.struct_begin() &&
231	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
232	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->tuples ) &&
233	dc.struct_end();
234	}
235
236	void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
237	{
238	ec.struct_begin();
239	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
240	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->tuples );
241	ec.struct_end();
242	}
243
244	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta;
245
246
247
248	class _Marshaller_gsdlInterface_corbaComError : public ::CORBA::StaticTypeInfo {
249	typedef gsdlInterface::corbaComError _MICO_T;
250	public:
251	~_Marshaller_gsdlInterface_corbaComError();
252	StaticValueType create () const;
253	void assign (StaticValueType dst, const StaticValueType src) const;
254	void free (StaticValueType) const;
255	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
256	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
257	};
258
259
260	_Marshaller_gsdlInterface_corbaComError::~_Marshaller_gsdlInterface_corbaComError()
261	{
262	}
263
264	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const
265	{
266	return (StaticValueType) new _MICO_T;
267	}
268
269	void _Marshaller_gsdlInterface_corbaComError::assign( StaticValueType d, const StaticValueType s ) const
270	{
271	(_MICO_T) d = (_MICO_T) s;
272	}
273
274	void _Marshaller_gsdlInterface_corbaComError::free( StaticValueType v ) const
275	{
276	delete (_MICO_T*) v;
277	}
278
279	::CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
280	{
281	::CORBA::ULong ul;
282	if( !dc.enumeration( ul ) )
283	return FALSE;
284	(_MICO_T) v = (_MICO_T) ul;
285	return TRUE;
286	}
287
288	void _Marshaller_gsdlInterface_corbaComError::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
289	{
290	ec.enumeration( (::CORBA::ULong) (_MICO_T ) v );
291	}
292
293	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
294
295	#ifdef HAVE_EXPLICIT_STRUCT_OPS
296	gsdlInterface::corbaShortColInfo::corbaShortColInfo()
297	{
298	}
299
300	gsdlInterface::corbaShortColInfo::corbaShortColInfo( const corbaShortColInfo& _s )
301	{
302	name = ((corbaShortColInfo&)_s).name;
303	host = ((corbaShortColInfo&)_s).host;
304	response = ((corbaShortColInfo&)_s).response;
305	}
306
307	gsdlInterface::corbaShortColInfo::~corbaShortColInfo()
308	{
309	}
310
311	gsdlInterface::corbaShortColInfo&
312	gsdlInterface::corbaShortColInfo::operator=( const corbaShortColInfo& _s )
313	{
314	name = ((corbaShortColInfo&)_s).name;
315	host = ((corbaShortColInfo&)_s).host;
316	response = ((corbaShortColInfo&)_s).response;
317	return *this;
318	}
319	#endif
320
321	class _Marshaller_gsdlInterface_corbaShortColInfo : public ::CORBA::StaticTypeInfo {
322	typedef gsdlInterface::corbaShortColInfo _MICO_T;
323	public:
324	~_Marshaller_gsdlInterface_corbaShortColInfo();
325	StaticValueType create () const;
326	void assign (StaticValueType dst, const StaticValueType src) const;
327	void free (StaticValueType) const;
328	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
329	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
330	};
331
332
333	_Marshaller_gsdlInterface_corbaShortColInfo::~_Marshaller_gsdlInterface_corbaShortColInfo()
334	{
335	}
336
337	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const
338	{
339	return (StaticValueType) new _MICO_T;
340	}
341
342	void _Marshaller_gsdlInterface_corbaShortColInfo::assign( StaticValueType d, const StaticValueType s ) const
343	{
344	(_MICO_T) d = (_MICO_T) s;
345	}
346
347	void _Marshaller_gsdlInterface_corbaShortColInfo::free( StaticValueType v ) const
348	{
349	delete (_MICO_T*) v;
350	}
351
352	::CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
353	{
354	return
355	dc.struct_begin() &&
356	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
357	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->host ) &&
358	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->response ) &&
359	dc.struct_end();
360	}
361
362	void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
363	{
364	ec.struct_begin();
365	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
366	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->host );
367	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->response );
368	ec.struct_end();
369	}
370
371	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
372
373	#ifdef HAVE_EXPLICIT_STRUCT_OPS
374	gsdlInterface::corbaColInfoResponse::corbaColInfoResponse()
375	{
376	}
377
378	gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s )
379	{
380	shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
381	useBook = ((corbaColInfoResponse&)_s).useBook;
382	isPublic = ((corbaColInfoResponse&)_s).isPublic;
383	isBeta = ((corbaColInfoResponse&)_s).isBeta;
384	buildDate = ((corbaColInfoResponse&)_s).buildDate;
385	ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
386	languages = ((corbaColInfoResponse&)_s).languages;
387	numDocs = ((corbaColInfoResponse&)_s).numDocs;
388	numWords = ((corbaColInfoResponse&)_s).numWords;
389	numBytes = ((corbaColInfoResponse&)_s).numBytes;
390	collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
391	format = ((corbaColInfoResponse&)_s).format;
392	building = ((corbaColInfoResponse&)_s).building;
393	httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
394	httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
395	receptionist = ((corbaColInfoResponse&)_s).receptionist;
396	isSegmented = ((corbaColInfoResponse&)_s).isSegmented;
397	isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup;
398	ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions;
399	stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes;
400	numSections = ((corbaColInfoResponse&)_s).numSections;
401	collection_macros = ((corbaColInfoResponse&)_s).collection_macros;
402	buildType = ((corbaColInfoResponse&)_s).buildType;
403	infodbType = ((corbaColInfoResponse&)_s).infodbType;
404	authenticate = ((corbaColInfoResponse&)_s).authenticate;
405	auth_group = ((corbaColInfoResponse&)_s).auth_group;
406	public_documents = ((corbaColInfoResponse&)_s).public_documents;
407	private_documents = ((corbaColInfoResponse&)_s).private_documents;
408	dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers;
409	earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp;
410	}
411
412	gsdlInterface::corbaColInfoResponse::~corbaColInfoResponse()
413	{
414	}
415
416	gsdlInterface::corbaColInfoResponse&
417	gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s )
418	{
419	shortInfo = ((corbaColInfoResponse&)_s).shortInfo;
420	useBook = ((corbaColInfoResponse&)_s).useBook;
421	isPublic = ((corbaColInfoResponse&)_s).isPublic;
422	isBeta = ((corbaColInfoResponse&)_s).isBeta;
423	buildDate = ((corbaColInfoResponse&)_s).buildDate;
424	ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
425	languages = ((corbaColInfoResponse&)_s).languages;
426	numDocs = ((corbaColInfoResponse&)_s).numDocs;
427	numWords = ((corbaColInfoResponse&)_s).numWords;
428	numBytes = ((corbaColInfoResponse&)_s).numBytes;
429	collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
430	format = ((corbaColInfoResponse&)_s).format;
431	building = ((corbaColInfoResponse&)_s).building;
432	httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
433	httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
434	receptionist = ((corbaColInfoResponse&)_s).receptionist;
435	isSegmented = ((corbaColInfoResponse&)_s).isSegmented;
436	isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup;
437	ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions;
438	stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes;
439	numSections = ((corbaColInfoResponse&)_s).numSections;
440	collection_macros = ((corbaColInfoResponse&)_s).collection_macros;
441	buildType = ((corbaColInfoResponse&)_s).buildType;
442	infodbType = ((corbaColInfoResponse&)_s).infodbType;
443	authenticate = ((corbaColInfoResponse&)_s).authenticate;
444	auth_group = ((corbaColInfoResponse&)_s).auth_group;
445	public_documents = ((corbaColInfoResponse&)_s).public_documents;
446	private_documents = ((corbaColInfoResponse&)_s).private_documents;
447	dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers;
448	earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp;
449	return *this;
450	}
451	#endif
452
453	class _Marshaller_gsdlInterface_corbaColInfoResponse : public ::CORBA::StaticTypeInfo {
454	typedef gsdlInterface::corbaColInfoResponse _MICO_T;
455	public:
456	~_Marshaller_gsdlInterface_corbaColInfoResponse();
457	StaticValueType create () const;
458	void assign (StaticValueType dst, const StaticValueType src) const;
459	void free (StaticValueType) const;
460	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
461	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
462	};
463
464
465	_Marshaller_gsdlInterface_corbaColInfoResponse::~_Marshaller_gsdlInterface_corbaColInfoResponse()
466	{
467	}
468
469	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const
470	{
471	return (StaticValueType) new _MICO_T;
472	}
473
474	void _Marshaller_gsdlInterface_corbaColInfoResponse::assign( StaticValueType d, const StaticValueType s ) const
475	{
476	(_MICO_T) d = (_MICO_T) s;
477	}
478
479	void _Marshaller_gsdlInterface_corbaColInfoResponse::free( StaticValueType v ) const
480	{
481	delete (_MICO_T*) v;
482	}
483
484	::CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
485	{
486	return
487	dc.struct_begin() &&
488	_marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shortInfo ) &&
489	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->useBook ) &&
490	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) &&
491	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isBeta ) &&
492	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->buildDate ) &&
493	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->ccsCols ) &&
494	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->languages ) &&
495	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
496	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) &&
497	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) &&
498	_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) &&
499	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) &&
500	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) &&
501	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpdomain ) &&
502	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) &&
503	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) &&
504	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isSegmented ) &&
505	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isCollectGroup ) &&
506	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->ccsOptions ) &&
507	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->stemIndexes ) &&
508	CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numSections ) &&
509	_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collection_macros ) &&
510	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->buildType ) &&
511	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->infodbType ) &&
512	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->authenticate ) &&
513	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->auth_group ) &&
514	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->public_documents ) &&
515	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->private_documents ) &&
516	_marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->dynamic_classifiers ) &&
517	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->earliestDatestamp ) &&
518	dc.struct_end();
519	}
520
521	void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
522	{
523	ec.struct_begin();
524	_marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shortInfo );
525	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->useBook );
526	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic );
527	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isBeta );
528	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->buildDate );
529	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->ccsCols );
530	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->languages );
531	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numDocs );
532	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords );
533	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes );
534	_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collectionMeta );
535	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format );
536	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building );
537	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpdomain );
538	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix );
539	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist );
540	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isSegmented );
541	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isCollectGroup );
542	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->ccsOptions );
543	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->stemIndexes );
544	CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numSections );
545	_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collection_macros );
546	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->buildType );
547	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->infodbType );
548	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->authenticate );
549	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->auth_group );
550	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->public_documents );
551	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->private_documents );
552	_marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->dynamic_classifiers );
553	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->earliestDatestamp );
554	ec.struct_end();
555	}
556
557	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
558
559	#ifdef HAVE_EXPLICIT_STRUCT_OPS
560	gsdlInterface::corbaDocRequest::corbaDocRequest()
561	{
562	}
563
564	gsdlInterface::corbaDocRequest::corbaDocRequest( const corbaDocRequest& _s )
565	{
566	OID = ((corbaDocRequest&)_s).OID;
567	docType = ((corbaDocRequest&)_s).docType;
568	docFormat = ((corbaDocRequest&)_s).docFormat;
569	}
570
571	gsdlInterface::corbaDocRequest::~corbaDocRequest()
572	{
573	}
574
575	gsdlInterface::corbaDocRequest&
576	gsdlInterface::corbaDocRequest::operator=( const corbaDocRequest& _s )
577	{
578	OID = ((corbaDocRequest&)_s).OID;
579	docType = ((corbaDocRequest&)_s).docType;
580	docFormat = ((corbaDocRequest&)_s).docFormat;
581	return *this;
582	}
583	#endif
584
585	class _Marshaller_gsdlInterface_corbaDocRequest : public ::CORBA::StaticTypeInfo {
586	typedef gsdlInterface::corbaDocRequest _MICO_T;
587	public:
588	~_Marshaller_gsdlInterface_corbaDocRequest();
589	StaticValueType create () const;
590	void assign (StaticValueType dst, const StaticValueType src) const;
591	void free (StaticValueType) const;
592	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
593	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
594	};
595
596
597	_Marshaller_gsdlInterface_corbaDocRequest::~_Marshaller_gsdlInterface_corbaDocRequest()
598	{
599	}
600
601	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const
602	{
603	return (StaticValueType) new _MICO_T;
604	}
605
606	void _Marshaller_gsdlInterface_corbaDocRequest::assign( StaticValueType d, const StaticValueType s ) const
607	{
608	(_MICO_T) d = (_MICO_T) s;
609	}
610
611	void _Marshaller_gsdlInterface_corbaDocRequest::free( StaticValueType v ) const
612	{
613	delete (_MICO_T*) v;
614	}
615
616	::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
617	{
618	return
619	dc.struct_begin() &&
620	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
621	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docType ) &&
622	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docFormat ) &&
623	dc.struct_end();
624	}
625
626	void _Marshaller_gsdlInterface_corbaDocRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
627	{
628	ec.struct_begin();
629	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
630	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docType );
631	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docFormat );
632	ec.struct_end();
633	}
634
635	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
636
637	#ifdef HAVE_EXPLICIT_STRUCT_OPS
638	gsdlInterface::corbaDocResponse::corbaDocResponse()
639	{
640	}
641
642	gsdlInterface::corbaDocResponse::corbaDocResponse( const corbaDocResponse& _s )
643	{
644	doc = ((corbaDocResponse&)_s).doc;
645	}
646
647	gsdlInterface::corbaDocResponse::~corbaDocResponse()
648	{
649	}
650
651	gsdlInterface::corbaDocResponse&
652	gsdlInterface::corbaDocResponse::operator=( const corbaDocResponse& _s )
653	{
654	doc = ((corbaDocResponse&)_s).doc;
655	return *this;
656	}
657	#endif
658
659	class _Marshaller_gsdlInterface_corbaDocResponse : public ::CORBA::StaticTypeInfo {
660	typedef gsdlInterface::corbaDocResponse _MICO_T;
661	public:
662	~_Marshaller_gsdlInterface_corbaDocResponse();
663	StaticValueType create () const;
664	void assign (StaticValueType dst, const StaticValueType src) const;
665	void free (StaticValueType) const;
666	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
667	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
668	};
669
670
671	_Marshaller_gsdlInterface_corbaDocResponse::~_Marshaller_gsdlInterface_corbaDocResponse()
672	{
673	}
674
675	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const
676	{
677	return (StaticValueType) new _MICO_T;
678	}
679
680	void _Marshaller_gsdlInterface_corbaDocResponse::assign( StaticValueType d, const StaticValueType s ) const
681	{
682	(_MICO_T) d = (_MICO_T) s;
683	}
684
685	void _Marshaller_gsdlInterface_corbaDocResponse::free( StaticValueType v ) const
686	{
687	delete (_MICO_T*) v;
688	}
689
690	::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
691	{
692	return
693	dc.struct_begin() &&
694	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->doc ) &&
695	dc.struct_end();
696	}
697
698	void _Marshaller_gsdlInterface_corbaDocResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
699	{
700	ec.struct_begin();
701	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->doc );
702	ec.struct_end();
703	}
704
705	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
706
707
708	class _Marshaller_gsdlInterface_corbaFilterType : public ::CORBA::StaticTypeInfo {
709	typedef gsdlInterface::corbaFilterType _MICO_T;
710	public:
711	~_Marshaller_gsdlInterface_corbaFilterType();
712	StaticValueType create () const;
713	void assign (StaticValueType dst, const StaticValueType src) const;
714	void free (StaticValueType) const;
715	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
716	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
717	};
718
719
720	_Marshaller_gsdlInterface_corbaFilterType::~_Marshaller_gsdlInterface_corbaFilterType()
721	{
722	}
723
724	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const
725	{
726	return (StaticValueType) new _MICO_T;
727	}
728
729	void _Marshaller_gsdlInterface_corbaFilterType::assign( StaticValueType d, const StaticValueType s ) const
730	{
731	(_MICO_T) d = (_MICO_T) s;
732	}
733
734	void _Marshaller_gsdlInterface_corbaFilterType::free( StaticValueType v ) const
735	{
736	delete (_MICO_T*) v;
737	}
738
739	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
740	{
741	::CORBA::ULong ul;
742	if( !dc.enumeration( ul ) )
743	return FALSE;
744	(_MICO_T) v = (_MICO_T) ul;
745	return TRUE;
746	}
747
748	void _Marshaller_gsdlInterface_corbaFilterType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
749	{
750	ec.enumeration( (::CORBA::ULong) (_MICO_T ) v );
751	}
752
753	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
754
755
756	class _Marshaller_gsdlInterface_corbaFilterRepeatable : public ::CORBA::StaticTypeInfo {
757	typedef gsdlInterface::corbaFilterRepeatable _MICO_T;
758	public:
759	~_Marshaller_gsdlInterface_corbaFilterRepeatable();
760	StaticValueType create () const;
761	void assign (StaticValueType dst, const StaticValueType src) const;
762	void free (StaticValueType) const;
763	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
764	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
765	};
766
767
768	_Marshaller_gsdlInterface_corbaFilterRepeatable::~_Marshaller_gsdlInterface_corbaFilterRepeatable()
769	{
770	}
771
772	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const
773	{
774	return (StaticValueType) new _MICO_T;
775	}
776
777	void _Marshaller_gsdlInterface_corbaFilterRepeatable::assign( StaticValueType d, const StaticValueType s ) const
778	{
779	(_MICO_T) d = (_MICO_T) s;
780	}
781
782	void _Marshaller_gsdlInterface_corbaFilterRepeatable::free( StaticValueType v ) const
783	{
784	delete (_MICO_T*) v;
785	}
786
787	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
788	{
789	::CORBA::ULong ul;
790	if( !dc.enumeration( ul ) )
791	return FALSE;
792	(_MICO_T) v = (_MICO_T) ul;
793	return TRUE;
794	}
795
796	void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
797	{
798	ec.enumeration( (::CORBA::ULong) (_MICO_T ) v );
799	}
800
801	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
802
803	#ifdef HAVE_EXPLICIT_STRUCT_OPS
804	gsdlInterface::corbaFilterOption::corbaFilterOption()
805	{
806	}
807
808	gsdlInterface::corbaFilterOption::corbaFilterOption( const corbaFilterOption& _s )
809	{
810	name = ((corbaFilterOption&)_s).name;
811	type = ((corbaFilterOption&)_s).type;
812	repeatable = ((corbaFilterOption&)_s).repeatable;
813	defaultValue = ((corbaFilterOption&)_s).defaultValue;
814	validValues = ((corbaFilterOption&)_s).validValues;
815	}
816
817	gsdlInterface::corbaFilterOption::~corbaFilterOption()
818	{
819	}
820
821	gsdlInterface::corbaFilterOption&
822	gsdlInterface::corbaFilterOption::operator=( const corbaFilterOption& _s )
823	{
824	name = ((corbaFilterOption&)_s).name;
825	type = ((corbaFilterOption&)_s).type;
826	repeatable = ((corbaFilterOption&)_s).repeatable;
827	defaultValue = ((corbaFilterOption&)_s).defaultValue;
828	validValues = ((corbaFilterOption&)_s).validValues;
829	return *this;
830	}
831	#endif
832
833	class _Marshaller_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo {
834	typedef gsdlInterface::corbaFilterOption _MICO_T;
835	public:
836	~_Marshaller_gsdlInterface_corbaFilterOption();
837	StaticValueType create () const;
838	void assign (StaticValueType dst, const StaticValueType src) const;
839	void free (StaticValueType) const;
840	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
841	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
842	};
843
844
845	_Marshaller_gsdlInterface_corbaFilterOption::~_Marshaller_gsdlInterface_corbaFilterOption()
846	{
847	}
848
849	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const
850	{
851	return (StaticValueType) new _MICO_T;
852	}
853
854	void _Marshaller_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
855	{
856	(_MICO_T) d = (_MICO_T) s;
857	}
858
859	void _Marshaller_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
860	{
861	delete (_MICO_T*) v;
862	}
863
864	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
865	{
866	return
867	dc.struct_begin() &&
868	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
869	_marshaller_gsdlInterface_corbaFilterType->demarshal( dc, &((_MICO_T*)v)->type ) &&
870	_marshaller_gsdlInterface_corbaFilterRepeatable->demarshal( dc, &((_MICO_T*)v)->repeatable ) &&
871	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->defaultValue ) &&
872	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->validValues ) &&
873	dc.struct_end();
874	}
875
876	void _Marshaller_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
877	{
878	ec.struct_begin();
879	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
880	_marshaller_gsdlInterface_corbaFilterType->marshal( ec, &((_MICO_T*)v)->type );
881	_marshaller_gsdlInterface_corbaFilterRepeatable->marshal( ec, &((_MICO_T*)v)->repeatable );
882	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->defaultValue );
883	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->validValues );
884	ec.struct_end();
885	}
886
887	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
888
889
890	#ifdef HAVE_EXPLICIT_STRUCT_OPS
891	gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse()
892	{
893	}
894
895	gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse( const corbaFilterOptionsResponse& _s )
896	{
897	options = ((corbaFilterOptionsResponse&)_s).options;
898	names = ((corbaFilterOptionsResponse&)_s).names;
899	}
900
901	gsdlInterface::corbaFilterOptionsResponse::~corbaFilterOptionsResponse()
902	{
903	}
904
905	gsdlInterface::corbaFilterOptionsResponse&
906	gsdlInterface::corbaFilterOptionsResponse::operator=( const corbaFilterOptionsResponse& _s )
907	{
908	options = ((corbaFilterOptionsResponse&)_s).options;
909	names = ((corbaFilterOptionsResponse&)_s).names;
910	return *this;
911	}
912	#endif
913
914	class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public ::CORBA::StaticTypeInfo {
915	typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T;
916	public:
917	~_Marshaller_gsdlInterface_corbaFilterOptionsResponse();
918	StaticValueType create () const;
919	void assign (StaticValueType dst, const StaticValueType src) const;
920	void free (StaticValueType) const;
921	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
922	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
923	};
924
925
926	_Marshaller_gsdlInterface_corbaFilterOptionsResponse::~_Marshaller_gsdlInterface_corbaFilterOptionsResponse()
927	{
928	}
929
930	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const
931	{
932	return (StaticValueType) new _MICO_T;
933	}
934
935	void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::assign( StaticValueType d, const StaticValueType s ) const
936	{
937	(_MICO_T) d = (_MICO_T) s;
938	}
939
940	void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::free( StaticValueType v ) const
941	{
942	delete (_MICO_T*) v;
943	}
944
945	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
946	{
947	return
948	dc.struct_begin() &&
949	_marshaller__seq_gsdlInterface_corbaFilterOption->demarshal( dc, &((_MICO_T*)v)->options ) &&
950	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
951	dc.struct_end();
952	}
953
954	void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
955	{
956	ec.struct_begin();
957	_marshaller__seq_gsdlInterface_corbaFilterOption->marshal( ec, &((_MICO_T*)v)->options );
958	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
959	ec.struct_end();
960	}
961
962	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
963
964	#ifdef HAVE_EXPLICIT_STRUCT_OPS
965	gsdlInterface::corbaOptionValue::corbaOptionValue()
966	{
967	}
968
969	gsdlInterface::corbaOptionValue::corbaOptionValue( const corbaOptionValue& _s )
970	{
971	name = ((corbaOptionValue&)_s).name;
972	value = ((corbaOptionValue&)_s).value;
973	}
974
975	gsdlInterface::corbaOptionValue::~corbaOptionValue()
976	{
977	}
978
979	gsdlInterface::corbaOptionValue&
980	gsdlInterface::corbaOptionValue::operator=( const corbaOptionValue& _s )
981	{
982	name = ((corbaOptionValue&)_s).name;
983	value = ((corbaOptionValue&)_s).value;
984	return *this;
985	}
986	#endif
987
988	class _Marshaller_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo {
989	typedef gsdlInterface::corbaOptionValue _MICO_T;
990	public:
991	~_Marshaller_gsdlInterface_corbaOptionValue();
992	StaticValueType create () const;
993	void assign (StaticValueType dst, const StaticValueType src) const;
994	void free (StaticValueType) const;
995	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
996	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
997	};
998
999
1000	_Marshaller_gsdlInterface_corbaOptionValue::~_Marshaller_gsdlInterface_corbaOptionValue()
1001	{
1002	}
1003
1004	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const
1005	{
1006	return (StaticValueType) new _MICO_T;
1007	}
1008
1009	void _Marshaller_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
1010	{
1011	(_MICO_T) d = (_MICO_T) s;
1012	}
1013
1014	void _Marshaller_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
1015	{
1016	delete (_MICO_T*) v;
1017	}
1018
1019	::CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1020	{
1021	return
1022	dc.struct_begin() &&
1023	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
1024	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->value ) &&
1025	dc.struct_end();
1026	}
1027
1028	void _Marshaller_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1029	{
1030	ec.struct_begin();
1031	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
1032	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->value );
1033	ec.struct_end();
1034	}
1035
1036	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
1037
1038
1039	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1040	gsdlInterface::corbaFilterRequest::corbaFilterRequest()
1041	{
1042	}
1043
1044	gsdlInterface::corbaFilterRequest::corbaFilterRequest( const corbaFilterRequest& _s )
1045	{
1046	filter = ((corbaFilterRequest&)_s).filter;
1047	filterOptions = ((corbaFilterRequest&)_s).filterOptions;
1048	docSet = ((corbaFilterRequest&)_s).docSet;
1049	filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
1050	requestParams = ((corbaFilterRequest&)_s).requestParams;
1051	refParams = ((corbaFilterRequest&)_s).refParams;
1052	fields = ((corbaFilterRequest&)_s).fields;
1053	getParents = ((corbaFilterRequest&)_s).getParents;
1054	}
1055
1056	gsdlInterface::corbaFilterRequest::~corbaFilterRequest()
1057	{
1058	}
1059
1060	gsdlInterface::corbaFilterRequest&
1061	gsdlInterface::corbaFilterRequest::operator=( const corbaFilterRequest& _s )
1062	{
1063	filter = ((corbaFilterRequest&)_s).filter;
1064	filterOptions = ((corbaFilterRequest&)_s).filterOptions;
1065	docSet = ((corbaFilterRequest&)_s).docSet;
1066	filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
1067	requestParams = ((corbaFilterRequest&)_s).requestParams;
1068	refParams = ((corbaFilterRequest&)_s).refParams;
1069	fields = ((corbaFilterRequest&)_s).fields;
1070	getParents = ((corbaFilterRequest&)_s).getParents;
1071	return *this;
1072	}
1073	#endif
1074
1075	class _Marshaller_gsdlInterface_corbaFilterRequest : public ::CORBA::StaticTypeInfo {
1076	typedef gsdlInterface::corbaFilterRequest _MICO_T;
1077	public:
1078	~_Marshaller_gsdlInterface_corbaFilterRequest();
1079	StaticValueType create () const;
1080	void assign (StaticValueType dst, const StaticValueType src) const;
1081	void free (StaticValueType) const;
1082	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1083	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1084	};
1085
1086
1087	_Marshaller_gsdlInterface_corbaFilterRequest::~_Marshaller_gsdlInterface_corbaFilterRequest()
1088	{
1089	}
1090
1091	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const
1092	{
1093	return (StaticValueType) new _MICO_T;
1094	}
1095
1096	void _Marshaller_gsdlInterface_corbaFilterRequest::assign( StaticValueType d, const StaticValueType s ) const
1097	{
1098	(_MICO_T) d = (_MICO_T) s;
1099	}
1100
1101	void _Marshaller_gsdlInterface_corbaFilterRequest::free( StaticValueType v ) const
1102	{
1103	delete (_MICO_T*) v;
1104	}
1105
1106	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1107	{
1108	return
1109	dc.struct_begin() &&
1110	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->filter ) &&
1111	_marshaller__seq_gsdlInterface_corbaOptionValue->demarshal( dc, &((_MICO_T*)v)->filterOptions ) &&
1112	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docSet ) &&
1113	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->filterResultOptions ) &&
1114	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->requestParams ) &&
1115	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->refParams ) &&
1116	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->fields ) &&
1117	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->getParents ) &&
1118	dc.struct_end();
1119	}
1120
1121	void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1122	{
1123	ec.struct_begin();
1124	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->filter );
1125	_marshaller__seq_gsdlInterface_corbaOptionValue->marshal( ec, &((_MICO_T*)v)->filterOptions );
1126	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docSet );
1127	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->filterResultOptions );
1128	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->requestParams );
1129	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->refParams );
1130	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->fields );
1131	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->getParents );
1132	ec.struct_end();
1133	}
1134
1135	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
1136
1137	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1138	gsdlInterface::corbaTermInfo::corbaTermInfo()
1139	{
1140	}
1141
1142	gsdlInterface::corbaTermInfo::corbaTermInfo( const corbaTermInfo& _s )
1143	{
1144	term = ((corbaTermInfo&)_s).term;
1145	frequency = ((corbaTermInfo&)_s).frequency;
1146	matchTerms = ((corbaTermInfo&)_s).matchTerms;
1147	}
1148
1149	gsdlInterface::corbaTermInfo::~corbaTermInfo()
1150	{
1151	}
1152
1153	gsdlInterface::corbaTermInfo&
1154	gsdlInterface::corbaTermInfo::operator=( const corbaTermInfo& _s )
1155	{
1156	term = ((corbaTermInfo&)_s).term;
1157	frequency = ((corbaTermInfo&)_s).frequency;
1158	matchTerms = ((corbaTermInfo&)_s).matchTerms;
1159	return *this;
1160	}
1161	#endif
1162
1163	class _Marshaller_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo {
1164	typedef gsdlInterface::corbaTermInfo _MICO_T;
1165	public:
1166	~_Marshaller_gsdlInterface_corbaTermInfo();
1167	StaticValueType create () const;
1168	void assign (StaticValueType dst, const StaticValueType src) const;
1169	void free (StaticValueType) const;
1170	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1171	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1172	};
1173
1174
1175	_Marshaller_gsdlInterface_corbaTermInfo::~_Marshaller_gsdlInterface_corbaTermInfo()
1176	{
1177	}
1178
1179	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const
1180	{
1181	return (StaticValueType) new _MICO_T;
1182	}
1183
1184	void _Marshaller_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
1185	{
1186	(_MICO_T) d = (_MICO_T) s;
1187	}
1188
1189	void _Marshaller_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
1190	{
1191	delete (_MICO_T*) v;
1192	}
1193
1194	::CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1195	{
1196	return
1197	dc.struct_begin() &&
1198	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->term ) &&
1199	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->frequency ) &&
1200	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->matchTerms ) &&
1201	dc.struct_end();
1202	}
1203
1204	void _Marshaller_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1205	{
1206	ec.struct_begin();
1207	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->term );
1208	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->frequency );
1209	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->matchTerms );
1210	ec.struct_end();
1211	}
1212
1213	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
1214
1215
1216	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1217	gsdlInterface::corbaMetadataInfo::corbaMetadataInfo()
1218	{
1219	}
1220
1221	gsdlInterface::corbaMetadataInfo::corbaMetadataInfo( const corbaMetadataInfo& _s )
1222	{
1223	params = ((corbaMetadataInfo&)_s).params;
1224	isRef = ((corbaMetadataInfo&)_s).isRef;
1225	values = ((corbaMetadataInfo&)_s).values;
1226	id = ((corbaMetadataInfo&)_s).id;
1227	parentid = ((corbaMetadataInfo&)_s).parentid;
1228	}
1229
1230	gsdlInterface::corbaMetadataInfo::~corbaMetadataInfo()
1231	{
1232	}
1233
1234	gsdlInterface::corbaMetadataInfo&
1235	gsdlInterface::corbaMetadataInfo::operator=( const corbaMetadataInfo& _s )
1236	{
1237	params = ((corbaMetadataInfo&)_s).params;
1238	isRef = ((corbaMetadataInfo&)_s).isRef;
1239	values = ((corbaMetadataInfo&)_s).values;
1240	id = ((corbaMetadataInfo&)_s).id;
1241	parentid = ((corbaMetadataInfo&)_s).parentid;
1242	return *this;
1243	}
1244	#endif
1245
1246	class _Marshaller_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo {
1247	typedef gsdlInterface::corbaMetadataInfo _MICO_T;
1248	public:
1249	~_Marshaller_gsdlInterface_corbaMetadataInfo();
1250	StaticValueType create () const;
1251	void assign (StaticValueType dst, const StaticValueType src) const;
1252	void free (StaticValueType) const;
1253	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1254	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1255	};
1256
1257
1258	_Marshaller_gsdlInterface_corbaMetadataInfo::~_Marshaller_gsdlInterface_corbaMetadataInfo()
1259	{
1260	}
1261
1262	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const
1263	{
1264	return (StaticValueType) new _MICO_T;
1265	}
1266
1267	void _Marshaller_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1268	{
1269	(_MICO_T) d = (_MICO_T) s;
1270	}
1271
1272	void _Marshaller_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1273	{
1274	delete (_MICO_T*) v;
1275	}
1276
1277	::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1278	{
1279	return
1280	dc.struct_begin() &&
1281	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->params ) &&
1282	CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isRef ) &&
1283	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) &&
1284	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->id ) &&
1285	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->parentid ) &&
1286	dc.struct_end();
1287	}
1288
1289	void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1290	{
1291	ec.struct_begin();
1292	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->params );
1293	CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isRef );
1294	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values );
1295	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->id );
1296	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->parentid );
1297	ec.struct_end();
1298	}
1299
1300	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
1301
1302
1303	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1304	gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map()
1305	{
1306	}
1307
1308	gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map( const corbaMetadataInfo_map& _s )
1309	{
1310	names = ((corbaMetadataInfo_map&)_s).names;
1311	values = ((corbaMetadataInfo_map&)_s).values;
1312	}
1313
1314	gsdlInterface::corbaMetadataInfo_map::~corbaMetadataInfo_map()
1315	{
1316	}
1317
1318	gsdlInterface::corbaMetadataInfo_map&
1319	gsdlInterface::corbaMetadataInfo_map::operator=( const corbaMetadataInfo_map& _s )
1320	{
1321	names = ((corbaMetadataInfo_map&)_s).names;
1322	values = ((corbaMetadataInfo_map&)_s).values;
1323	return *this;
1324	}
1325	#endif
1326
1327	class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public ::CORBA::StaticTypeInfo {
1328	typedef gsdlInterface::corbaMetadataInfo_map _MICO_T;
1329	public:
1330	~_Marshaller_gsdlInterface_corbaMetadataInfo_map();
1331	StaticValueType create () const;
1332	void assign (StaticValueType dst, const StaticValueType src) const;
1333	void free (StaticValueType) const;
1334	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1335	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1336	};
1337
1338
1339	_Marshaller_gsdlInterface_corbaMetadataInfo_map::~_Marshaller_gsdlInterface_corbaMetadataInfo_map()
1340	{
1341	}
1342
1343	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const
1344	{
1345	return (StaticValueType) new _MICO_T;
1346	}
1347
1348	void _Marshaller_gsdlInterface_corbaMetadataInfo_map::assign( StaticValueType d, const StaticValueType s ) const
1349	{
1350	(_MICO_T) d = (_MICO_T) s;
1351	}
1352
1353	void _Marshaller_gsdlInterface_corbaMetadataInfo_map::free( StaticValueType v ) const
1354	{
1355	delete (_MICO_T*) v;
1356	}
1357
1358	::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1359	{
1360	return
1361	dc.struct_begin() &&
1362	_marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
1363	_marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->values ) &&
1364	dc.struct_end();
1365	}
1366
1367	void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1368	{
1369	ec.struct_begin();
1370	_marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
1371	_marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->values );
1372	ec.struct_end();
1373	}
1374
1375	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
1376
1377
1378	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1379	gsdlInterface::corbaResultDocInfo::corbaResultDocInfo()
1380	{
1381	}
1382
1383	gsdlInterface::corbaResultDocInfo::corbaResultDocInfo( const corbaResultDocInfo& _s )
1384	{
1385	OID = ((corbaResultDocInfo&)_s).OID;
1386	resultNum = ((corbaResultDocInfo&)_s).resultNum;
1387	ranking = ((corbaResultDocInfo&)_s).ranking;
1388	termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1389	phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1390	docFreq = ((corbaResultDocInfo&)_s).docFreq;
1391	metadata = ((corbaResultDocInfo&)_s).metadata;
1392	classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1393	classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1394	metaparents = ((corbaResultDocInfo&)_s).metaparents;
1395	}
1396
1397	gsdlInterface::corbaResultDocInfo::~corbaResultDocInfo()
1398	{
1399	}
1400
1401	gsdlInterface::corbaResultDocInfo&
1402	gsdlInterface::corbaResultDocInfo::operator=( const corbaResultDocInfo& _s )
1403	{
1404	OID = ((corbaResultDocInfo&)_s).OID;
1405	resultNum = ((corbaResultDocInfo&)_s).resultNum;
1406	ranking = ((corbaResultDocInfo&)_s).ranking;
1407	termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1408	phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1409	docFreq = ((corbaResultDocInfo&)_s).docFreq;
1410	metadata = ((corbaResultDocInfo&)_s).metadata;
1411	classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1412	classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1413	metaparents = ((corbaResultDocInfo&)_s).metaparents;
1414	return *this;
1415	}
1416	#endif
1417
1418	class _Marshaller_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo {
1419	typedef gsdlInterface::corbaResultDocInfo _MICO_T;
1420	public:
1421	~_Marshaller_gsdlInterface_corbaResultDocInfo();
1422	StaticValueType create () const;
1423	void assign (StaticValueType dst, const StaticValueType src) const;
1424	void free (StaticValueType) const;
1425	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1426	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1427	};
1428
1429
1430	_Marshaller_gsdlInterface_corbaResultDocInfo::~_Marshaller_gsdlInterface_corbaResultDocInfo()
1431	{
1432	}
1433
1434	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const
1435	{
1436	return (StaticValueType) new _MICO_T;
1437	}
1438
1439	void _Marshaller_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1440	{
1441	(_MICO_T) d = (_MICO_T) s;
1442	}
1443
1444	void _Marshaller_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1445	{
1446	delete (_MICO_T*) v;
1447	}
1448
1449	::CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1450	{
1451	return
1452	dc.struct_begin() &&
1453	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
1454	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->resultNum ) &&
1455	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->ranking ) &&
1456	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->termsMatched ) &&
1457	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->phraseMatched ) &&
1458	CORBA::_stcseq_long->demarshal( dc, &((_MICO_T*)v)->docFreq ) &&
1459	_marshaller_gsdlInterface_corbaMetadataInfo_map->demarshal( dc, &((_MICO_T*)v)->metadata ) &&
1460	_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->classifierMetadataType ) &&
1461	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->classifierMetadataOffset ) &&
1462	_marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->metaparents ) &&
1463	dc.struct_end();
1464	}
1465
1466	void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1467	{
1468	ec.struct_begin();
1469	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
1470	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->resultNum );
1471	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->ranking );
1472	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->termsMatched );
1473	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->phraseMatched );
1474	CORBA::_stcseq_long->marshal( ec, &((_MICO_T*)v)->docFreq );
1475	_marshaller_gsdlInterface_corbaMetadataInfo_map->marshal( ec, &((_MICO_T*)v)->metadata );
1476	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->classifierMetadataType );
1477	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->classifierMetadataOffset );
1478	_marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->metaparents );
1479	ec.struct_end();
1480	}
1481
1482	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
1483
1484
1485
1486	class _Marshaller_gsdlInterface_corbaIsApprox : public ::CORBA::StaticTypeInfo {
1487	typedef gsdlInterface::corbaIsApprox _MICO_T;
1488	public:
1489	~_Marshaller_gsdlInterface_corbaIsApprox();
1490	StaticValueType create () const;
1491	void assign (StaticValueType dst, const StaticValueType src) const;
1492	void free (StaticValueType) const;
1493	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1494	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1495	};
1496
1497
1498	_Marshaller_gsdlInterface_corbaIsApprox::~_Marshaller_gsdlInterface_corbaIsApprox()
1499	{
1500	}
1501
1502	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const
1503	{
1504	return (StaticValueType) new _MICO_T;
1505	}
1506
1507	void _Marshaller_gsdlInterface_corbaIsApprox::assign( StaticValueType d, const StaticValueType s ) const
1508	{
1509	(_MICO_T) d = (_MICO_T) s;
1510	}
1511
1512	void _Marshaller_gsdlInterface_corbaIsApprox::free( StaticValueType v ) const
1513	{
1514	delete (_MICO_T*) v;
1515	}
1516
1517	::CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1518	{
1519	::CORBA::ULong ul;
1520	if( !dc.enumeration( ul ) )
1521	return FALSE;
1522	(_MICO_T) v = (_MICO_T) ul;
1523	return TRUE;
1524	}
1525
1526	void _Marshaller_gsdlInterface_corbaIsApprox::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1527	{
1528	ec.enumeration( (::CORBA::ULong) (_MICO_T ) v );
1529	}
1530
1531	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
1532
1533	#ifdef HAVE_EXPLICIT_STRUCT_OPS
1534	gsdlInterface::corbaFilterResponse::corbaFilterResponse()
1535	{
1536	}
1537
1538	gsdlInterface::corbaFilterResponse::corbaFilterResponse( const corbaFilterResponse& _s )
1539	{
1540	numDocs = ((corbaFilterResponse&)_s).numDocs;
1541	isApprox = ((corbaFilterResponse&)_s).isApprox;
1542	termInfo = ((corbaFilterResponse&)_s).termInfo;
1543	docInfo = ((corbaFilterResponse&)_s).docInfo;
1544	}
1545
1546	gsdlInterface::corbaFilterResponse::~corbaFilterResponse()
1547	{
1548	}
1549
1550	gsdlInterface::corbaFilterResponse&
1551	gsdlInterface::corbaFilterResponse::operator=( const corbaFilterResponse& _s )
1552	{
1553	numDocs = ((corbaFilterResponse&)_s).numDocs;
1554	isApprox = ((corbaFilterResponse&)_s).isApprox;
1555	termInfo = ((corbaFilterResponse&)_s).termInfo;
1556	docInfo = ((corbaFilterResponse&)_s).docInfo;
1557	return *this;
1558	}
1559	#endif
1560
1561	class _Marshaller_gsdlInterface_corbaFilterResponse : public ::CORBA::StaticTypeInfo {
1562	typedef gsdlInterface::corbaFilterResponse _MICO_T;
1563	public:
1564	~_Marshaller_gsdlInterface_corbaFilterResponse();
1565	StaticValueType create () const;
1566	void assign (StaticValueType dst, const StaticValueType src) const;
1567	void free (StaticValueType) const;
1568	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1569	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1570	};
1571
1572
1573	_Marshaller_gsdlInterface_corbaFilterResponse::~_Marshaller_gsdlInterface_corbaFilterResponse()
1574	{
1575	}
1576
1577	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const
1578	{
1579	return (StaticValueType) new _MICO_T;
1580	}
1581
1582	void _Marshaller_gsdlInterface_corbaFilterResponse::assign( StaticValueType d, const StaticValueType s ) const
1583	{
1584	(_MICO_T) d = (_MICO_T) s;
1585	}
1586
1587	void _Marshaller_gsdlInterface_corbaFilterResponse::free( StaticValueType v ) const
1588	{
1589	delete (_MICO_T*) v;
1590	}
1591
1592	::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1593	{
1594	return
1595	dc.struct_begin() &&
1596	CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
1597	_marshaller_gsdlInterface_corbaIsApprox->demarshal( dc, &((_MICO_T*)v)->isApprox ) &&
1598	_marshaller__seq_gsdlInterface_corbaTermInfo->demarshal( dc, &((_MICO_T*)v)->termInfo ) &&
1599	_marshaller__seq_gsdlInterface_corbaResultDocInfo->demarshal( dc, &((_MICO_T*)v)->docInfo ) &&
1600	dc.struct_end();
1601	}
1602
1603	void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1604	{
1605	ec.struct_begin();
1606	CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->numDocs );
1607	_marshaller_gsdlInterface_corbaIsApprox->marshal( ec, &((_MICO_T*)v)->isApprox );
1608	_marshaller__seq_gsdlInterface_corbaTermInfo->marshal( ec, &((_MICO_T*)v)->termInfo );
1609	_marshaller__seq_gsdlInterface_corbaResultDocInfo->marshal( ec, &((_MICO_T*)v)->docInfo );
1610	ec.struct_end();
1611	}
1612
1613	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
1614
1615
1616	/*
1617	* Base interface for class corbaiface
1618	*/
1619
1620	gsdlInterface::corbaiface::~corbaiface()
1621	{
1622	}
1623
1624	void *
1625	gsdlInterface::corbaiface::_narrow_helper( const char *_repoid )
1626	{
1627	if( strcmp( _repoid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 )
1628	return (void *)this;
1629	return NULL;
1630	}
1631
1632	gsdlInterface::corbaiface_ptr
1633	gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj )
1634	{
1635	gsdlInterface::corbaiface_ptr _o;
1636	if( !CORBA::is_nil( _obj ) ) {
1637	void *_p;
1638	if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" )))
1639	return _duplicate( (gsdlInterface::corbaiface_ptr) _p );
1640	if (!strcmp (_obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0") \|\| _obj->_is_a_remote ("IDL:gsdlInterface/corbaiface:1.0")) {
1641	_o = new gsdlInterface::corbaiface_stub;
1642	_o->CORBA::Object::operator=( *_obj );
1643	return _o;
1644	}
1645	}
1646	return _nil();
1647	}
1648
1649	gsdlInterface::corbaiface_ptr
1650	gsdlInterface::corbaiface::_narrow( CORBA::AbstractBase_ptr _obj )
1651	{
1652	return _narrow (_obj->_to_object());
1653	}
1654
1655	class _Marshaller_gsdlInterface_corbaiface : public ::CORBA::StaticTypeInfo {
1656	typedef gsdlInterface::corbaiface_ptr _MICO_T;
1657	public:
1658	~_Marshaller_gsdlInterface_corbaiface();
1659	StaticValueType create () const;
1660	void assign (StaticValueType dst, const StaticValueType src) const;
1661	void free (StaticValueType) const;
1662	void release (StaticValueType) const;
1663	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
1664	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
1665	};
1666
1667
1668	_Marshaller_gsdlInterface_corbaiface::~_Marshaller_gsdlInterface_corbaiface()
1669	{
1670	}
1671
1672	::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
1673	{
1674	return (StaticValueType) new _MICO_T( 0 );
1675	}
1676
1677	void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
1678	{
1679	(_MICO_T) d = ::gsdlInterface::corbaiface::_duplicate( (_MICO_T) s );
1680	}
1681
1682	void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
1683	{
1684	::CORBA::release( (_MICO_T ) v );
1685	delete (_MICO_T*) v;
1686	}
1687
1688	void _Marshaller_gsdlInterface_corbaiface::release( StaticValueType v ) const
1689	{
1690	::CORBA::release( (_MICO_T ) v );
1691	}
1692
1693	::CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
1694	{
1695	::CORBA::Object_ptr obj;
1696	if (!::CORBA::_stc_Object->demarshal(dc, &obj))
1697	return FALSE;
1698	(_MICO_T ) v = ::gsdlInterface::corbaiface::_narrow( obj );
1699	::CORBA::Boolean ret = ::CORBA::is_nil (obj) \|\| !::CORBA::is_nil ((_MICO_T )v);
1700	::CORBA::release (obj);
1701	return ret;
1702	}
1703
1704	void _Marshaller_gsdlInterface_corbaiface::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
1705	{
1706	::CORBA::Object_ptr obj = (_MICO_T ) v;
1707	::CORBA::_stc_Object->marshal( ec, &obj );
1708	}
1709
1710	::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
1711
1712
1713	/*
1714	* Stub interface for class corbaiface
1715	*/
1716
1717	gsdlInterface::corbaiface_stub::~corbaiface_stub()
1718	{
1719	}
1720
1721	#ifndef MICO_CONF_NO_POA
1722
1723	void *
1724	POA_gsdlInterface::corbaiface::_narrow_helper (const char * repoid)
1725	{
1726	if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
1727	return (void *) this;
1728	}
1729	return NULL;
1730	}
1731
1732	POA_gsdlInterface::corbaiface *
1733	POA_gsdlInterface::corbaiface::_narrow (PortableServer::Servant serv)
1734	{
1735	void * p;
1736	if ((p = serv->_narrow_helper ("IDL:gsdlInterface/corbaiface:1.0")) != NULL) {
1737	serv->_add_ref ();
1738	return (POA_gsdlInterface::corbaiface *) p;
1739	}
1740	return NULL;
1741	}
1742
1743	gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp ()
1744	{
1745	}
1746
1747	gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
1748	: CORBA::Object(*obj), PortableServer::StubBase(poa)
1749	{
1750	}
1751
1752	gsdlInterface::corbaiface_stub_clp::~corbaiface_stub_clp ()
1753	{
1754	}
1755
1756	#endif // MICO_CONF_NO_POA
1757
1758	CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& _par_error )
1759	{
1760	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
1761	CORBA::Boolean _res;
1762	CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1763
1764	CORBA::StaticRequest __req( this, "initialise" );
1765	__req.add_inout_arg( &_sa_error );
1766	__req.set_result( &__res );
1767
1768	__req.invoke();
1769
1770	mico_sii_throw( &__req,
1771	0);
1772	return _res;
1773	}
1774
1775
1776	#ifndef MICO_CONF_NO_POA
1777
1778	CORBA::Boolean
1779	gsdlInterface::corbaiface_stub_clp::initialise( gsdlInterface::corbaComError& _par_error )
1780	{
1781	PortableServer::Servant _serv = _preinvoke ();
1782	if (_serv) {
1783	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
1784	if (_myserv) {
1785	CORBA::Boolean __res;
1786
1787	#ifdef HAVE_EXCEPTIONS
1788	try {
1789	#endif
1790	__res = _myserv->initialise(_par_error);
1791	#ifdef HAVE_EXCEPTIONS
1792	}
1793	catch (...) {
1794	_myserv->_remove_ref();
1795	_postinvoke();
1796	throw;
1797	}
1798	#endif
1799
1800	_myserv->_remove_ref();
1801	_postinvoke ();
1802	return __res;
1803	}
1804	_postinvoke ();
1805	}
1806
1807	return gsdlInterface::corbaiface_stub::initialise(_par_error);
1808	}
1809
1810	#endif // MICO_CONF_NO_POA
1811
1812	void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error )
1813	{
1814	CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key );
1815	CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline );
1816	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
1817	CORBA::StaticRequest __req( this, "configure" );
1818	__req.add_in_arg( &_sa_key );
1819	__req.add_in_arg( &_sa_cfgline );
1820	__req.add_inout_arg( &_sa_error );
1821
1822	__req.invoke();
1823
1824	mico_sii_throw( &__req,
1825	0);
1826	}
1827
1828
1829	#ifndef MICO_CONF_NO_POA
1830
1831	void
1832	gsdlInterface::corbaiface_stub_clp::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error )
1833	{
1834	PortableServer::Servant _serv = _preinvoke ();
1835	if (_serv) {
1836	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
1837	if (_myserv) {
1838	#ifdef HAVE_EXCEPTIONS
1839	try {
1840	#endif
1841	_myserv->configure(_par_key, _par_cfgline, _par_error);
1842	#ifdef HAVE_EXCEPTIONS
1843	}
1844	catch (...) {
1845	_myserv->_remove_ref();
1846	_postinvoke();
1847	throw;
1848	}
1849	#endif
1850
1851	_myserv->_remove_ref();
1852	_postinvoke ();
1853	return;
1854	}
1855	_postinvoke ();
1856	}
1857
1858	gsdlInterface::corbaiface_stub::configure(_par_key, _par_cfgline, _par_error);
1859	}
1860
1861	#endif // MICO_CONF_NO_POA
1862
1863	void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error )
1864	{
1865	CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist );
1866	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
1867	CORBA::StaticRequest __req( this, "collectionList" );
1868	__req.add_inout_arg( &_sa_collist );
1869	__req.add_inout_arg( &_sa_error );
1870
1871	__req.invoke();
1872
1873	mico_sii_throw( &__req,
1874	0);
1875	}
1876
1877
1878	#ifndef MICO_CONF_NO_POA
1879
1880	void
1881	gsdlInterface::corbaiface_stub_clp::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error )
1882	{
1883	PortableServer::Servant _serv = _preinvoke ();
1884	if (_serv) {
1885	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
1886	if (_myserv) {
1887	#ifdef HAVE_EXCEPTIONS
1888	try {
1889	#endif
1890	_myserv->collectionList(_par_collist, _par_error);
1891	#ifdef HAVE_EXCEPTIONS
1892	}
1893	catch (...) {
1894	_myserv->_remove_ref();
1895	_postinvoke();
1896	throw;
1897	}
1898	#endif
1899
1900	_myserv->_remove_ref();
1901	_postinvoke ();
1902	return;
1903	}
1904	_postinvoke ();
1905	}
1906
1907	gsdlInterface::corbaiface_stub::collectionList(_par_collist, _par_error);
1908	}
1909
1910	#endif // MICO_CONF_NO_POA
1911
1912	void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error )
1913	{
1914	CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection );
1915	CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has );
1916	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
1917	CORBA::StaticRequest __req( this, "hasCollection" );
1918	__req.add_in_arg( &_sa_corbaCollection );
1919	__req.add_inout_arg( &_sa_has );
1920	__req.add_inout_arg( &_sa_error );
1921
1922	__req.invoke();
1923
1924	mico_sii_throw( &__req,
1925	0);
1926	}
1927
1928
1929	#ifndef MICO_CONF_NO_POA
1930
1931	void
1932	gsdlInterface::corbaiface_stub_clp::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error )
1933	{
1934	PortableServer::Servant _serv = _preinvoke ();
1935	if (_serv) {
1936	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
1937	if (_myserv) {
1938	#ifdef HAVE_EXCEPTIONS
1939	try {
1940	#endif
1941	_myserv->hasCollection(_par_corbaCollection, _par_has, _par_error);
1942	#ifdef HAVE_EXCEPTIONS
1943	}
1944	catch (...) {
1945	_myserv->_remove_ref();
1946	_postinvoke();
1947	throw;
1948	}
1949	#endif
1950
1951	_myserv->_remove_ref();
1952	_postinvoke ();
1953	return;
1954	}
1955	_postinvoke ();
1956	}
1957
1958	gsdlInterface::corbaiface_stub::hasCollection(_par_corbaCollection, _par_has, _par_error);
1959	}
1960
1961	#endif // MICO_CONF_NO_POA
1962
1963	void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error )
1964	{
1965	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
1966	CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess );
1967	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
1968	CORBA::StaticRequest __req( this, "ping" );
1969	__req.add_in_arg( &_sa_collection );
1970	__req.add_inout_arg( &_sa_wasSuccess );
1971	__req.add_inout_arg( &_sa_error );
1972
1973	__req.invoke();
1974
1975	mico_sii_throw( &__req,
1976	0);
1977	}
1978
1979
1980	#ifndef MICO_CONF_NO_POA
1981
1982	void
1983	gsdlInterface::corbaiface_stub_clp::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error )
1984	{
1985	PortableServer::Servant _serv = _preinvoke ();
1986	if (_serv) {
1987	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
1988	if (_myserv) {
1989	#ifdef HAVE_EXCEPTIONS
1990	try {
1991	#endif
1992	_myserv->ping(_par_collection, _par_wasSuccess, _par_error);
1993	#ifdef HAVE_EXCEPTIONS
1994	}
1995	catch (...) {
1996	_myserv->_remove_ref();
1997	_postinvoke();
1998	throw;
1999	}
2000	#endif
2001
2002	_myserv->_remove_ref();
2003	_postinvoke ();
2004	return;
2005	}
2006	_postinvoke ();
2007	}
2008
2009	gsdlInterface::corbaiface_stub::ping(_par_collection, _par_wasSuccess, _par_error);
2010	}
2011
2012	#endif // MICO_CONF_NO_POA
2013
2014	void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2015	{
2016	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2017	CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request );
2018	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response );
2019	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2020	CORBA::StaticRequest __req( this, "getDocument" );
2021	__req.add_in_arg( &_sa_collection );
2022	__req.add_inout_arg( &_sa_request );
2023	__req.add_inout_arg( &_sa_response );
2024	__req.add_inout_arg( &_sa_error );
2025
2026	__req.invoke();
2027
2028	mico_sii_throw( &__req,
2029	0);
2030	}
2031
2032
2033	#ifndef MICO_CONF_NO_POA
2034
2035	void
2036	gsdlInterface::corbaiface_stub_clp::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2037	{
2038	PortableServer::Servant _serv = _preinvoke ();
2039	if (_serv) {
2040	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2041	if (_myserv) {
2042	#ifdef HAVE_EXCEPTIONS
2043	try {
2044	#endif
2045	_myserv->getDocument(_par_collection, _par_request, _par_response, _par_error);
2046	#ifdef HAVE_EXCEPTIONS
2047	}
2048	catch (...) {
2049	_myserv->_remove_ref();
2050	_postinvoke();
2051	throw;
2052	}
2053	#endif
2054
2055	_myserv->_remove_ref();
2056	_postinvoke ();
2057	return;
2058	}
2059	_postinvoke ();
2060	}
2061
2062	gsdlInterface::corbaiface_stub::getDocument(_par_collection, _par_request, _par_response, _par_error);
2063	}
2064
2065	#endif // MICO_CONF_NO_POA
2066
2067	void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2068	{
2069	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2070	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response );
2071	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2072	CORBA::StaticRequest __req( this, "getCollectInfo" );
2073	__req.add_in_arg( &_sa_collection );
2074	__req.add_inout_arg( &_sa_response );
2075	__req.add_inout_arg( &_sa_error );
2076
2077	__req.invoke();
2078
2079	mico_sii_throw( &__req,
2080	0);
2081	}
2082
2083
2084	#ifndef MICO_CONF_NO_POA
2085
2086	void
2087	gsdlInterface::corbaiface_stub_clp::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2088	{
2089	PortableServer::Servant _serv = _preinvoke ();
2090	if (_serv) {
2091	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2092	if (_myserv) {
2093	#ifdef HAVE_EXCEPTIONS
2094	try {
2095	#endif
2096	_myserv->getCollectInfo(_par_collection, _par_response, _par_error);
2097	#ifdef HAVE_EXCEPTIONS
2098	}
2099	catch (...) {
2100	_myserv->_remove_ref();
2101	_postinvoke();
2102	throw;
2103	}
2104	#endif
2105
2106	_myserv->_remove_ref();
2107	_postinvoke ();
2108	return;
2109	}
2110	_postinvoke ();
2111	}
2112
2113	gsdlInterface::corbaiface_stub::getCollectInfo(_par_collection, _par_response, _par_error);
2114	}
2115
2116	#endif // MICO_CONF_NO_POA
2117
2118	void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error )
2119	{
2120	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2121	CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames );
2122	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2123	CORBA::StaticRequest __req( this, "getFilterInfo" );
2124	__req.add_in_arg( &_sa_collection );
2125	__req.add_inout_arg( &_sa_filterNames );
2126	__req.add_inout_arg( &_sa_error );
2127
2128	__req.invoke();
2129
2130	mico_sii_throw( &__req,
2131	0);
2132	}
2133
2134
2135	#ifndef MICO_CONF_NO_POA
2136
2137	void
2138	gsdlInterface::corbaiface_stub_clp::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error )
2139	{
2140	PortableServer::Servant _serv = _preinvoke ();
2141	if (_serv) {
2142	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2143	if (_myserv) {
2144	#ifdef HAVE_EXCEPTIONS
2145	try {
2146	#endif
2147	_myserv->getFilterInfo(_par_collection, _par_filterNames, _par_error);
2148	#ifdef HAVE_EXCEPTIONS
2149	}
2150	catch (...) {
2151	_myserv->_remove_ref();
2152	_postinvoke();
2153	throw;
2154	}
2155	#endif
2156
2157	_myserv->_remove_ref();
2158	_postinvoke ();
2159	return;
2160	}
2161	_postinvoke ();
2162	}
2163
2164	gsdlInterface::corbaiface_stub::getFilterInfo(_par_collection, _par_filterNames, _par_error);
2165	}
2166
2167	#endif // MICO_CONF_NO_POA
2168
2169	void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2170	{
2171	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2172	CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option );
2173	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response );
2174	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2175	CORBA::StaticRequest __req( this, "getFilterOptions" );
2176	__req.add_in_arg( &_sa_collection );
2177	__req.add_in_arg( &_sa_option );
2178	__req.add_inout_arg( &_sa_response );
2179	__req.add_inout_arg( &_sa_error );
2180
2181	__req.invoke();
2182
2183	mico_sii_throw( &__req,
2184	0);
2185	}
2186
2187
2188	#ifndef MICO_CONF_NO_POA
2189
2190	void
2191	gsdlInterface::corbaiface_stub_clp::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2192	{
2193	PortableServer::Servant _serv = _preinvoke ();
2194	if (_serv) {
2195	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2196	if (_myserv) {
2197	#ifdef HAVE_EXCEPTIONS
2198	try {
2199	#endif
2200	_myserv->getFilterOptions(_par_collection, _par_option, _par_response, _par_error);
2201	#ifdef HAVE_EXCEPTIONS
2202	}
2203	catch (...) {
2204	_myserv->_remove_ref();
2205	_postinvoke();
2206	throw;
2207	}
2208	#endif
2209
2210	_myserv->_remove_ref();
2211	_postinvoke ();
2212	return;
2213	}
2214	_postinvoke ();
2215	}
2216
2217	gsdlInterface::corbaiface_stub::getFilterOptions(_par_collection, _par_option, _par_response, _par_error);
2218	}
2219
2220	#endif // MICO_CONF_NO_POA
2221
2222	void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2223	{
2224	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2225	CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request );
2226	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response );
2227	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2228	CORBA::StaticRequest __req( this, "filter" );
2229	__req.add_in_arg( &_sa_collection );
2230	__req.add_in_arg( &_sa_request );
2231	__req.add_inout_arg( &_sa_response );
2232	__req.add_inout_arg( &_sa_error );
2233
2234	__req.invoke();
2235
2236	mico_sii_throw( &__req,
2237	0);
2238	}
2239
2240
2241	#ifndef MICO_CONF_NO_POA
2242
2243	void
2244	gsdlInterface::corbaiface_stub_clp::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error )
2245	{
2246	PortableServer::Servant _serv = _preinvoke ();
2247	if (_serv) {
2248	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2249	if (_myserv) {
2250	#ifdef HAVE_EXCEPTIONS
2251	try {
2252	#endif
2253	_myserv->filter(_par_collection, _par_request, _par_response, _par_error);
2254	#ifdef HAVE_EXCEPTIONS
2255	}
2256	catch (...) {
2257	_myserv->_remove_ref();
2258	_postinvoke();
2259	throw;
2260	}
2261	#endif
2262
2263	_myserv->_remove_ref();
2264	_postinvoke ();
2265	return;
2266	}
2267	_postinvoke ();
2268	}
2269
2270	gsdlInterface::corbaiface_stub::filter(_par_collection, _par_request, _par_response, _par_error);
2271	}
2272
2273	#endif // MICO_CONF_NO_POA
2274
2275	void gsdlInterface::corbaiface_stub::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error )
2276	{
2277	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2278	CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome );
2279	CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items );
2280	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2281	CORBA::StaticRequest __req( this, "getRssItems" );
2282	__req.add_in_arg( &_sa_collection );
2283	__req.add_in_arg( &_sa_gsdlhome );
2284	__req.add_inout_arg( &_sa_rss_items );
2285	__req.add_inout_arg( &_sa_error );
2286
2287	__req.invoke();
2288
2289	mico_sii_throw( &__req,
2290	0);
2291	}
2292
2293
2294	#ifndef MICO_CONF_NO_POA
2295
2296	void
2297	gsdlInterface::corbaiface_stub_clp::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error )
2298	{
2299	PortableServer::Servant _serv = _preinvoke ();
2300	if (_serv) {
2301	POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv);
2302	if (_myserv) {
2303	#ifdef HAVE_EXCEPTIONS
2304	try {
2305	#endif
2306	_myserv->getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error);
2307	#ifdef HAVE_EXCEPTIONS
2308	}
2309	catch (...) {
2310	_myserv->_remove_ref();
2311	_postinvoke();
2312	throw;
2313	}
2314	#endif
2315
2316	_myserv->_remove_ref();
2317	_postinvoke ();
2318	return;
2319	}
2320	_postinvoke ();
2321	}
2322
2323	gsdlInterface::corbaiface_stub::getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error);
2324	}
2325
2326	#endif // MICO_CONF_NO_POA
2327
2328	class _Marshaller__seq_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo {
2329	typedef SequenceTmpl< gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
2330	public:
2331	~_Marshaller__seq_gsdlInterface_corbatext_t();
2332	StaticValueType create () const;
2333	void assign (StaticValueType dst, const StaticValueType src) const;
2334	void free (StaticValueType) const;
2335	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2336	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2337	};
2338
2339
2340	_Marshaller__seq_gsdlInterface_corbatext_t::~_Marshaller__seq_gsdlInterface_corbatext_t()
2341	{
2342	}
2343
2344	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
2345	{
2346	return (StaticValueType) new _MICO_T;
2347	}
2348
2349	void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
2350	{
2351	(_MICO_T) d = (_MICO_T) s;
2352	}
2353
2354	void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
2355	{
2356	delete (_MICO_T*) v;
2357	}
2358
2359	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2360	{
2361	::CORBA::ULong len;
2362	if( !dc.seq_begin( len ) )
2363	return FALSE;
2364	((_MICO_T *) v)->length( len );
2365	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2366	if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T)v)[i] ) )
2367	return FALSE;
2368	}
2369	return dc.seq_end();
2370	}
2371
2372	void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2373	{
2374	::CORBA::ULong len = ((_MICO_T *) v)->length();
2375	ec.seq_begin( len );
2376	for( ::CORBA::ULong i = 0; i < len; i++ )
2377	_marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T)v)[i] );
2378	ec.seq_end();
2379	}
2380
2381	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
2382
2383	class _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo {
2384	typedef SequenceTmpl< gsdlInterface::corbatext_tcollectionmeta,MICO_TID_DEF> _MICO_T;
2385	public:
2386	~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta();
2387	StaticValueType create () const;
2388	void assign (StaticValueType dst, const StaticValueType src) const;
2389	void free (StaticValueType) const;
2390	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2391	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2392	};
2393
2394
2395	_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta()
2396	{
2397	}
2398
2399	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::create() const
2400	{
2401	return (StaticValueType) new _MICO_T;
2402	}
2403
2404	void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const
2405	{
2406	(_MICO_T) d = (_MICO_T) s;
2407	}
2408
2409	void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const
2410	{
2411	delete (_MICO_T*) v;
2412	}
2413
2414	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2415	{
2416	::CORBA::ULong len;
2417	if( !dc.seq_begin( len ) )
2418	return FALSE;
2419	((_MICO_T *) v)->length( len );
2420	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2421	if( !_marshaller_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T)v)[i] ) )
2422	return FALSE;
2423	}
2424	return dc.seq_end();
2425	}
2426
2427	void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2428	{
2429	::CORBA::ULong len = ((_MICO_T *) v)->length();
2430	ec.seq_begin( len );
2431	for( ::CORBA::ULong i = 0; i < len; i++ )
2432	_marshaller_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T)v)[i] );
2433	ec.seq_end();
2434	}
2435
2436	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;
2437
2438	class _Marshaller__seq_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo {
2439	typedef SequenceTmpl< gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
2440	public:
2441	~_Marshaller__seq_gsdlInterface_corbaFilterOption();
2442	StaticValueType create () const;
2443	void assign (StaticValueType dst, const StaticValueType src) const;
2444	void free (StaticValueType) const;
2445	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2446	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2447	};
2448
2449
2450	_Marshaller__seq_gsdlInterface_corbaFilterOption::~_Marshaller__seq_gsdlInterface_corbaFilterOption()
2451	{
2452	}
2453
2454	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
2455	{
2456	return (StaticValueType) new _MICO_T;
2457	}
2458
2459	void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
2460	{
2461	(_MICO_T) d = (_MICO_T) s;
2462	}
2463
2464	void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
2465	{
2466	delete (_MICO_T*) v;
2467	}
2468
2469	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2470	{
2471	::CORBA::ULong len;
2472	if( !dc.seq_begin( len ) )
2473	return FALSE;
2474	((_MICO_T *) v)->length( len );
2475	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2476	if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &((_MICO_T)v)[i] ) )
2477	return FALSE;
2478	}
2479	return dc.seq_end();
2480	}
2481
2482	void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2483	{
2484	::CORBA::ULong len = ((_MICO_T *) v)->length();
2485	ec.seq_begin( len );
2486	for( ::CORBA::ULong i = 0; i < len; i++ )
2487	_marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &((_MICO_T)v)[i] );
2488	ec.seq_end();
2489	}
2490
2491	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
2492
2493	class _Marshaller__seq_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo {
2494	typedef SequenceTmpl< gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
2495	public:
2496	~_Marshaller__seq_gsdlInterface_corbaOptionValue();
2497	StaticValueType create () const;
2498	void assign (StaticValueType dst, const StaticValueType src) const;
2499	void free (StaticValueType) const;
2500	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2501	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2502	};
2503
2504
2505	_Marshaller__seq_gsdlInterface_corbaOptionValue::~_Marshaller__seq_gsdlInterface_corbaOptionValue()
2506	{
2507	}
2508
2509	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
2510	{
2511	return (StaticValueType) new _MICO_T;
2512	}
2513
2514	void _Marshaller__seq_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
2515	{
2516	(_MICO_T) d = (_MICO_T) s;
2517	}
2518
2519	void _Marshaller__seq_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
2520	{
2521	delete (_MICO_T*) v;
2522	}
2523
2524	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2525	{
2526	::CORBA::ULong len;
2527	if( !dc.seq_begin( len ) )
2528	return FALSE;
2529	((_MICO_T *) v)->length( len );
2530	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2531	if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &((_MICO_T)v)[i] ) )
2532	return FALSE;
2533	}
2534	return dc.seq_end();
2535	}
2536
2537	void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2538	{
2539	::CORBA::ULong len = ((_MICO_T *) v)->length();
2540	ec.seq_begin( len );
2541	for( ::CORBA::ULong i = 0; i < len; i++ )
2542	_marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &((_MICO_T)v)[i] );
2543	ec.seq_end();
2544	}
2545
2546	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
2547
2548	class _Marshaller__seq_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo {
2549	typedef SequenceTmpl< gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
2550	public:
2551	~_Marshaller__seq_gsdlInterface_corbaTermInfo();
2552	StaticValueType create () const;
2553	void assign (StaticValueType dst, const StaticValueType src) const;
2554	void free (StaticValueType) const;
2555	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2556	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2557	};
2558
2559
2560	_Marshaller__seq_gsdlInterface_corbaTermInfo::~_Marshaller__seq_gsdlInterface_corbaTermInfo()
2561	{
2562	}
2563
2564	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
2565	{
2566	return (StaticValueType) new _MICO_T;
2567	}
2568
2569	void _Marshaller__seq_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
2570	{
2571	(_MICO_T) d = (_MICO_T) s;
2572	}
2573
2574	void _Marshaller__seq_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
2575	{
2576	delete (_MICO_T*) v;
2577	}
2578
2579	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2580	{
2581	::CORBA::ULong len;
2582	if( !dc.seq_begin( len ) )
2583	return FALSE;
2584	((_MICO_T *) v)->length( len );
2585	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2586	if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &((_MICO_T)v)[i] ) )
2587	return FALSE;
2588	}
2589	return dc.seq_end();
2590	}
2591
2592	void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2593	{
2594	::CORBA::ULong len = ((_MICO_T *) v)->length();
2595	ec.seq_begin( len );
2596	for( ::CORBA::ULong i = 0; i < len; i++ )
2597	_marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &((_MICO_T)v)[i] );
2598	ec.seq_end();
2599	}
2600
2601	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
2602
2603	class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo {
2604	typedef SequenceTmpl< gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
2605	public:
2606	~_Marshaller__seq_gsdlInterface_corbaMetadataInfo();
2607	StaticValueType create () const;
2608	void assign (StaticValueType dst, const StaticValueType src) const;
2609	void free (StaticValueType) const;
2610	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2611	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2612	};
2613
2614
2615	_Marshaller__seq_gsdlInterface_corbaMetadataInfo::~_Marshaller__seq_gsdlInterface_corbaMetadataInfo()
2616	{
2617	}
2618
2619	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
2620	{
2621	return (StaticValueType) new _MICO_T;
2622	}
2623
2624	void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
2625	{
2626	(_MICO_T) d = (_MICO_T) s;
2627	}
2628
2629	void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
2630	{
2631	delete (_MICO_T*) v;
2632	}
2633
2634	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2635	{
2636	::CORBA::ULong len;
2637	if( !dc.seq_begin( len ) )
2638	return FALSE;
2639	((_MICO_T *) v)->length( len );
2640	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2641	if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T)v)[i] ) )
2642	return FALSE;
2643	}
2644	return dc.seq_end();
2645	}
2646
2647	void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2648	{
2649	::CORBA::ULong len = ((_MICO_T *) v)->length();
2650	ec.seq_begin( len );
2651	for( ::CORBA::ULong i = 0; i < len; i++ )
2652	_marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T)v)[i] );
2653	ec.seq_end();
2654	}
2655
2656	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
2657
2658	class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo {
2659	typedef SequenceTmpl< gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
2660	public:
2661	~_Marshaller__seq_gsdlInterface_corbaResultDocInfo();
2662	StaticValueType create () const;
2663	void assign (StaticValueType dst, const StaticValueType src) const;
2664	void free (StaticValueType) const;
2665	::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const;
2666	void marshal (::CORBA::DataEncoder &, StaticValueType) const;
2667	};
2668
2669
2670	_Marshaller__seq_gsdlInterface_corbaResultDocInfo::~_Marshaller__seq_gsdlInterface_corbaResultDocInfo()
2671	{
2672	}
2673
2674	::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
2675	{
2676	return (StaticValueType) new _MICO_T;
2677	}
2678
2679	void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
2680	{
2681	(_MICO_T) d = (_MICO_T) s;
2682	}
2683
2684	void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
2685	{
2686	delete (_MICO_T*) v;
2687	}
2688
2689	::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const
2690	{
2691	::CORBA::ULong len;
2692	if( !dc.seq_begin( len ) )
2693	return FALSE;
2694	((_MICO_T *) v)->length( len );
2695	for( ::CORBA::ULong i = 0; i < len; i++ ) {
2696	if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &((_MICO_T)v)[i] ) )
2697	return FALSE;
2698	}
2699	return dc.seq_end();
2700	}
2701
2702	void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const
2703	{
2704	::CORBA::ULong len = ((_MICO_T *) v)->length();
2705	ec.seq_begin( len );
2706	for( ::CORBA::ULong i = 0; i < len; i++ )
2707	_marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &((_MICO_T)v)[i] );
2708	ec.seq_end();
2709	}
2710
2711	::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
2712
2713	struct __tc_init_CORBAIFACE {
2714	__tc_init_CORBAIFACE()
2715	{
2716	_marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t;
2717	_marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap;
2718	_marshaller_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller_gsdlInterface_corbatext_tcollectionmeta;
2719	_marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError;
2720	_marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo;
2721	_marshaller_gsdlInterface_corbaColInfoResponse = new _Marshaller_gsdlInterface_corbaColInfoResponse;
2722	_marshaller_gsdlInterface_corbaDocRequest = new _Marshaller_gsdlInterface_corbaDocRequest;
2723	_marshaller_gsdlInterface_corbaDocResponse = new _Marshaller_gsdlInterface_corbaDocResponse;
2724	_marshaller_gsdlInterface_corbaFilterType = new _Marshaller_gsdlInterface_corbaFilterType;
2725	_marshaller_gsdlInterface_corbaFilterRepeatable = new _Marshaller_gsdlInterface_corbaFilterRepeatable;
2726	_marshaller_gsdlInterface_corbaFilterOption = new _Marshaller_gsdlInterface_corbaFilterOption;
2727	_marshaller_gsdlInterface_corbaFilterOptionsResponse = new _Marshaller_gsdlInterface_corbaFilterOptionsResponse;
2728	_marshaller_gsdlInterface_corbaOptionValue = new _Marshaller_gsdlInterface_corbaOptionValue;
2729	_marshaller_gsdlInterface_corbaFilterRequest = new _Marshaller_gsdlInterface_corbaFilterRequest;
2730	_marshaller_gsdlInterface_corbaTermInfo = new _Marshaller_gsdlInterface_corbaTermInfo;
2731	_marshaller_gsdlInterface_corbaMetadataInfo = new _Marshaller_gsdlInterface_corbaMetadataInfo;
2732	_marshaller_gsdlInterface_corbaMetadataInfo_map = new _Marshaller_gsdlInterface_corbaMetadataInfo_map;
2733	_marshaller_gsdlInterface_corbaResultDocInfo = new _Marshaller_gsdlInterface_corbaResultDocInfo;
2734	_marshaller_gsdlInterface_corbaIsApprox = new _Marshaller_gsdlInterface_corbaIsApprox;
2735	_marshaller_gsdlInterface_corbaFilterResponse = new _Marshaller_gsdlInterface_corbaFilterResponse;
2736	_marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface;
2737	_marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t;
2738	_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;
2739	_marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption;
2740	_marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue;
2741	_marshaller__seq_gsdlInterface_corbaTermInfo = new _Marshaller__seq_gsdlInterface_corbaTermInfo;
2742	_marshaller__seq_gsdlInterface_corbaMetadataInfo = new _Marshaller__seq_gsdlInterface_corbaMetadataInfo;
2743	_marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo;
2744	}
2745
2746	~__tc_init_CORBAIFACE()
2747	{
2748	delete static_cast<_Marshaller_gsdlInterface_corbatext_t*>(_marshaller_gsdlInterface_corbatext_t);
2749	delete static_cast<_Marshaller_gsdlInterface_corbatext_tmap*>(_marshaller_gsdlInterface_corbatext_tmap);
2750	delete static_cast<_Marshaller_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller_gsdlInterface_corbatext_tcollectionmeta);
2751	delete static_cast<_Marshaller_gsdlInterface_corbaComError*>(_marshaller_gsdlInterface_corbaComError);
2752	delete static_cast<_Marshaller_gsdlInterface_corbaShortColInfo*>(_marshaller_gsdlInterface_corbaShortColInfo);
2753	delete static_cast<_Marshaller_gsdlInterface_corbaColInfoResponse*>(_marshaller_gsdlInterface_corbaColInfoResponse);
2754	delete static_cast<_Marshaller_gsdlInterface_corbaDocRequest*>(_marshaller_gsdlInterface_corbaDocRequest);
2755	delete static_cast<_Marshaller_gsdlInterface_corbaDocResponse*>(_marshaller_gsdlInterface_corbaDocResponse);
2756	delete static_cast<_Marshaller_gsdlInterface_corbaFilterType*>(_marshaller_gsdlInterface_corbaFilterType);
2757	delete static_cast<_Marshaller_gsdlInterface_corbaFilterRepeatable*>(_marshaller_gsdlInterface_corbaFilterRepeatable);
2758	delete static_cast<_Marshaller_gsdlInterface_corbaFilterOption*>(_marshaller_gsdlInterface_corbaFilterOption);
2759	delete static_cast<_Marshaller_gsdlInterface_corbaFilterOptionsResponse*>(_marshaller_gsdlInterface_corbaFilterOptionsResponse);
2760	delete static_cast<_Marshaller_gsdlInterface_corbaOptionValue*>(_marshaller_gsdlInterface_corbaOptionValue);
2761	delete static_cast<_Marshaller_gsdlInterface_corbaFilterRequest*>(_marshaller_gsdlInterface_corbaFilterRequest);
2762	delete static_cast<_Marshaller_gsdlInterface_corbaTermInfo*>(_marshaller_gsdlInterface_corbaTermInfo);
2763	delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo*>(_marshaller_gsdlInterface_corbaMetadataInfo);
2764	delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo_map*>(_marshaller_gsdlInterface_corbaMetadataInfo_map);
2765	delete static_cast<_Marshaller_gsdlInterface_corbaResultDocInfo*>(_marshaller_gsdlInterface_corbaResultDocInfo);
2766	delete static_cast<_Marshaller_gsdlInterface_corbaIsApprox*>(_marshaller_gsdlInterface_corbaIsApprox);
2767	delete static_cast<_Marshaller_gsdlInterface_corbaFilterResponse*>(_marshaller_gsdlInterface_corbaFilterResponse);
2768	delete static_cast<_Marshaller_gsdlInterface_corbaiface*>(_marshaller_gsdlInterface_corbaiface);
2769	delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_t*>(_marshaller__seq_gsdlInterface_corbatext_t);
2770	delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta);
2771	delete static_cast<_Marshaller__seq_gsdlInterface_corbaFilterOption*>(_marshaller__seq_gsdlInterface_corbaFilterOption);
2772	delete static_cast<_Marshaller__seq_gsdlInterface_corbaOptionValue*>(_marshaller__seq_gsdlInterface_corbaOptionValue);
2773	delete static_cast<_Marshaller__seq_gsdlInterface_corbaTermInfo*>(_marshaller__seq_gsdlInterface_corbaTermInfo);
2774	delete static_cast<_Marshaller__seq_gsdlInterface_corbaMetadataInfo*>(_marshaller__seq_gsdlInterface_corbaMetadataInfo);
2775	delete static_cast<_Marshaller__seq_gsdlInterface_corbaResultDocInfo*>(_marshaller__seq_gsdlInterface_corbaResultDocInfo);
2776	}
2777	};
2778
2779	static __tc_init_CORBAIFACE __init_CORBAIFACE;
2780
2781	//--------------------------------------------------------
2782	// Implementation of skeletons
2783	//--------------------------------------------------------
2784
2785	// PortableServer Skeleton Class for interface gsdlInterface::corbaiface
2786	POA_gsdlInterface::corbaiface::~corbaiface()
2787	{
2788	}
2789
2790	::gsdlInterface::corbaiface_ptr
2791	POA_gsdlInterface::corbaiface::_this ()
2792	{
2793	CORBA::Object_var obj = PortableServer::ServantBase::_this();
2794	return ::gsdlInterface::corbaiface::_narrow (obj);
2795	}
2796
2797	CORBA::Boolean
2798	POA_gsdlInterface::corbaiface::_is_a (const char * repoid)
2799	{
2800	if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) {
2801	return TRUE;
2802	}
2803	return FALSE;
2804	}
2805
2806	CORBA::InterfaceDef_ptr
2807	POA_gsdlInterface::corbaiface::_get_interface ()
2808	{
2809	CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:gsdlInterface/corbaiface:1.0");
2810
2811	if (CORBA::is_nil (ifd)) {
2812	mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO));
2813	}
2814
2815	return ifd;
2816	}
2817
2818	CORBA::RepositoryId
2819	POA_gsdlInterface::corbaiface::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr)
2820	{
2821	return CORBA::string_dup ("IDL:gsdlInterface/corbaiface:1.0");
2822	}
2823
2824	CORBA::Object_ptr
2825	POA_gsdlInterface::corbaiface::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj)
2826	{
2827	return new ::gsdlInterface::corbaiface_stub_clp (poa, obj);
2828	}
2829
2830	bool
2831	POA_gsdlInterface::corbaiface::dispatch (CORBA::StaticServerRequest_ptr __req)
2832	{
2833	#ifdef HAVE_EXCEPTIONS
2834	try {
2835	#endif
2836	switch (mico_string_hash (__req->op_name(), 17)) {
2837	case 0:
2838	if( strcmp( __req->op_name(), "collectionList" ) == 0 ) {
2839	::gsdlInterface::corbatext_tarray _par_collist;
2840	CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist );
2841	::gsdlInterface::corbaComError _par_error;
2842	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2843
2844	__req->add_inout_arg( &_sa_collist );
2845	__req->add_inout_arg( &_sa_error );
2846
2847	if( !__req->read_args() )
2848	return true;
2849
2850	collectionList( _par_collist, _par_error );
2851	__req->write_results();
2852	return true;
2853	}
2854	break;
2855	case 3:
2856	if( strcmp( __req->op_name(), "ping" ) == 0 ) {
2857	::gsdlInterface::corbatext_t _par_collection;
2858	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2859	CORBA::Boolean _par_wasSuccess;
2860	CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess );
2861	::gsdlInterface::corbaComError _par_error;
2862	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2863
2864	__req->add_in_arg( &_sa_collection );
2865	__req->add_inout_arg( &_sa_wasSuccess );
2866	__req->add_inout_arg( &_sa_error );
2867
2868	if( !__req->read_args() )
2869	return true;
2870
2871	ping( _par_collection, _par_wasSuccess, _par_error );
2872	__req->write_results();
2873	return true;
2874	}
2875	break;
2876	case 7:
2877	if( strcmp( __req->op_name(), "filter" ) == 0 ) {
2878	::gsdlInterface::corbatext_t _par_collection;
2879	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2880	::gsdlInterface::corbaFilterRequest _par_request;
2881	CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request );
2882	::gsdlInterface::corbaFilterResponse _par_response;
2883	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response );
2884	::gsdlInterface::corbaComError _par_error;
2885	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2886
2887	__req->add_in_arg( &_sa_collection );
2888	__req->add_in_arg( &_sa_request );
2889	__req->add_inout_arg( &_sa_response );
2890	__req->add_inout_arg( &_sa_error );
2891
2892	if( !__req->read_args() )
2893	return true;
2894
2895	filter( _par_collection, _par_request, _par_response, _par_error );
2896	__req->write_results();
2897	return true;
2898	}
2899	break;
2900	case 8:
2901	if( strcmp( __req->op_name(), "getRssItems" ) == 0 ) {
2902	::gsdlInterface::corbatext_t _par_collection;
2903	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2904	::gsdlInterface::corbatext_t _par_gsdlhome;
2905	CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome );
2906	::gsdlInterface::corbatext_t _par_rss_items;
2907	CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items );
2908	::gsdlInterface::corbaComError _par_error;
2909	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2910
2911	__req->add_in_arg( &_sa_collection );
2912	__req->add_in_arg( &_sa_gsdlhome );
2913	__req->add_inout_arg( &_sa_rss_items );
2914	__req->add_inout_arg( &_sa_error );
2915
2916	if( !__req->read_args() )
2917	return true;
2918
2919	getRssItems( _par_collection, _par_gsdlhome, _par_rss_items, _par_error );
2920	__req->write_results();
2921	return true;
2922	}
2923	break;
2924	case 9:
2925	if( strcmp( __req->op_name(), "getFilterOptions" ) == 0 ) {
2926	::gsdlInterface::corbatext_t _par_collection;
2927	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2928	::gsdlInterface::corbatext_t _par_option;
2929	CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option );
2930	::gsdlInterface::corbaFilterOptionsResponse _par_response;
2931	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response );
2932	::gsdlInterface::corbaComError _par_error;
2933	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2934
2935	__req->add_in_arg( &_sa_collection );
2936	__req->add_in_arg( &_sa_option );
2937	__req->add_inout_arg( &_sa_response );
2938	__req->add_inout_arg( &_sa_error );
2939
2940	if( !__req->read_args() )
2941	return true;
2942
2943	getFilterOptions( _par_collection, _par_option, _par_response, _par_error );
2944	__req->write_results();
2945	return true;
2946	}
2947	break;
2948	case 10:
2949	if( strcmp( __req->op_name(), "getCollectInfo" ) == 0 ) {
2950	::gsdlInterface::corbatext_t _par_collection;
2951	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2952	::gsdlInterface::corbaColInfoResponse _par_response;
2953	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response );
2954	::gsdlInterface::corbaComError _par_error;
2955	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2956
2957	__req->add_in_arg( &_sa_collection );
2958	__req->add_inout_arg( &_sa_response );
2959	__req->add_inout_arg( &_sa_error );
2960
2961	if( !__req->read_args() )
2962	return true;
2963
2964	getCollectInfo( _par_collection, _par_response, _par_error );
2965	__req->write_results();
2966	return true;
2967	}
2968	break;
2969	case 11:
2970	if( strcmp( __req->op_name(), "initialise" ) == 0 ) {
2971	::gsdlInterface::corbaComError _par_error;
2972	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2973
2974	CORBA::Boolean _res;
2975	CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
2976	__req->add_inout_arg( &_sa_error );
2977	__req->set_result( &__res );
2978
2979	if( !__req->read_args() )
2980	return true;
2981
2982	_res = initialise( _par_error );
2983	__req->write_results();
2984	return true;
2985	}
2986	if( strcmp( __req->op_name(), "getFilterInfo" ) == 0 ) {
2987	::gsdlInterface::corbatext_t _par_collection;
2988	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
2989	::gsdlInterface::corbatext_tarray _par_filterNames;
2990	CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames );
2991	::gsdlInterface::corbaComError _par_error;
2992	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
2993
2994	__req->add_in_arg( &_sa_collection );
2995	__req->add_inout_arg( &_sa_filterNames );
2996	__req->add_inout_arg( &_sa_error );
2997
2998	if( !__req->read_args() )
2999	return true;
3000
3001	getFilterInfo( _par_collection, _par_filterNames, _par_error );
3002	__req->write_results();
3003	return true;
3004	}
3005	break;
3006	case 12:
3007	if( strcmp( __req->op_name(), "hasCollection" ) == 0 ) {
3008	::gsdlInterface::corbatext_t _par_corbaCollection;
3009	CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection );
3010	CORBA::Boolean _par_has;
3011	CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has );
3012	::gsdlInterface::corbaComError _par_error;
3013	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
3014
3015	__req->add_in_arg( &_sa_corbaCollection );
3016	__req->add_inout_arg( &_sa_has );
3017	__req->add_inout_arg( &_sa_error );
3018
3019	if( !__req->read_args() )
3020	return true;
3021
3022	hasCollection( _par_corbaCollection, _par_has, _par_error );
3023	__req->write_results();
3024	return true;
3025	}
3026	break;
3027	case 13:
3028	if( strcmp( __req->op_name(), "configure" ) == 0 ) {
3029	::gsdlInterface::corbatext_t _par_key;
3030	CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key );
3031	::gsdlInterface::corbatext_tarray _par_cfgline;
3032	CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline );
3033	::gsdlInterface::corbaComError _par_error;
3034	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
3035
3036	__req->add_in_arg( &_sa_key );
3037	__req->add_in_arg( &_sa_cfgline );
3038	__req->add_inout_arg( &_sa_error );
3039
3040	if( !__req->read_args() )
3041	return true;
3042
3043	configure( _par_key, _par_cfgline, _par_error );
3044	__req->write_results();
3045	return true;
3046	}
3047	if( strcmp( __req->op_name(), "getDocument" ) == 0 ) {
3048	::gsdlInterface::corbatext_t _par_collection;
3049	CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection );
3050	::gsdlInterface::corbaDocRequest _par_request;
3051	CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request );
3052	::gsdlInterface::corbaDocResponse _par_response;
3053	CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response );
3054	::gsdlInterface::corbaComError _par_error;
3055	CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error );
3056
3057	__req->add_in_arg( &_sa_collection );
3058	__req->add_inout_arg( &_sa_request );
3059	__req->add_inout_arg( &_sa_response );
3060	__req->add_inout_arg( &_sa_error );
3061
3062	if( !__req->read_args() )
3063	return true;
3064
3065	getDocument( _par_collection, _par_request, _par_response, _par_error );
3066	__req->write_results();
3067	return true;
3068	}
3069	break;
3070	}
3071	#ifdef HAVE_EXCEPTIONS
3072	} catch( CORBA::SystemException_catch &_ex ) {
3073	__req->set_exception( _ex->_clone() );
3074	__req->write_results();
3075	return true;
3076	} catch( ... ) {
3077	CORBA::UNKNOWN _ex (CORBA::OMGVMCID \| 1, CORBA::COMPLETED_MAYBE);
3078	__req->set_exception (_ex->_clone());
3079	__req->write_results ();
3080	return true;
3081	}
3082	#endif
3083
3084	return false;
3085	}
3086
3087	void
3088	POA_gsdlInterface::corbaiface::invoke (CORBA::StaticServerRequest_ptr __req)
3089	{
3090	if (dispatch (__req)) {
3091	return;
3092	}
3093
3094	CORBA::Exception * ex =
3095	new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO);
3096	__req->set_exception (ex);
3097	__req->write_results();
3098	}
3099

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format