source: main/trunk/greenstone2/runtime-src/src/corba/corbaiface.mpp@ 24874

Last change on this file since 24874 was 15463, checked in by mdewsnip, 16 years ago

Moved all the CORBA stuff from lib into src/corba, to prevent it from uglying up the core code.
  • Property svn:keywords set to Author Date Id Revision
File size: 68.3 KB
Line 
1/*
2 * MICO --- a free CORBA implementation
3 * Copyright (C) 1997-98 Kay Roemer & Arno Puder
4 *
5 * This file was automatically generated. DO NOT EDIT!
6 */
7
8#include "corbaiface.h"
9
10//--------------------------------------------------------
11// Implementation of stubs
12//--------------------------------------------------------
13
14
15#ifdef HAVE_EXPLICIT_STRUCT_OPS
16gsdlInterface::corbatext_t::corbatext_t()
17{
18}
19
20gsdlInterface::corbatext_t::corbatext_t( const corbatext_t& _s )
21{
22 text = ((corbatext_t&)_s).text;
23 encoding = ((corbatext_t&)_s).encoding;
24 length = ((corbatext_t&)_s).length;
25}
26
27gsdlInterface::corbatext_t::~corbatext_t()
28{
29}
30
31gsdlInterface::corbatext_t&
32gsdlInterface::corbatext_t::operator=( const corbatext_t& _s )
33{
34 text = ((corbatext_t&)_s).text;
35 encoding = ((corbatext_t&)_s).encoding;
36 length = ((corbatext_t&)_s).length;
37 return *this;
38}
39#endif
40
41class _Marshaller_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
42 typedef gsdlInterface::corbatext_t _MICO_T;
43 public:
44 StaticValueType create () const;
45 void assign (StaticValueType dst, const StaticValueType src) const;
46 void free (StaticValueType) const;
47 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
48 void marshal (CORBA::DataEncoder &, StaticValueType) const;
49};
50
51
52CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const
53{
54 return (StaticValueType) new _MICO_T;
55}
56
57void _Marshaller_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
58{
59 *(_MICO_T*) d = *(_MICO_T*) s;
60}
61
62void _Marshaller_gsdlInterface_corbatext_t::free( StaticValueType v ) const
63{
64 delete (_MICO_T*) v;
65}
66
67CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
68{
69 return
70 dc.struct_begin() &&
71 CORBA::_stcseq_ushort->demarshal( dc, &((_MICO_T*)v)->text ) &&
72 CORBA::_stc_ushort->demarshal( dc, &((_MICO_T*)v)->encoding ) &&
73 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->length ) &&
74 dc.struct_end();
75}
76
77void _Marshaller_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
78{
79 ec.struct_begin();
80 CORBA::_stcseq_ushort->marshal( ec, &((_MICO_T*)v)->text );
81 CORBA::_stc_ushort->marshal( ec, &((_MICO_T*)v)->encoding );
82 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->length );
83 ec.struct_end();
84}
85
86CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;
87
88
89
90#ifdef HAVE_EXPLICIT_STRUCT_OPS
91gsdlInterface::corbatext_tmap::corbatext_tmap()
92{
93}
94
95gsdlInterface::corbatext_tmap::corbatext_tmap( const corbatext_tmap& _s )
96{
97 names = ((corbatext_tmap&)_s).names;
98 values = ((corbatext_tmap&)_s).values;
99}
100
101gsdlInterface::corbatext_tmap::~corbatext_tmap()
102{
103}
104
105gsdlInterface::corbatext_tmap&
106gsdlInterface::corbatext_tmap::operator=( const corbatext_tmap& _s )
107{
108 names = ((corbatext_tmap&)_s).names;
109 values = ((corbatext_tmap&)_s).values;
110 return *this;
111}
112#endif
113
114class _Marshaller_gsdlInterface_corbatext_tmap : public CORBA::StaticTypeInfo {
115 typedef gsdlInterface::corbatext_tmap _MICO_T;
116 public:
117 StaticValueType create () const;
118 void assign (StaticValueType dst, const StaticValueType src) const;
119 void free (StaticValueType) const;
120 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
121 void marshal (CORBA::DataEncoder &, StaticValueType) const;
122};
123
124
125CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const
126{
127 return (StaticValueType) new _MICO_T;
128}
129
130void _Marshaller_gsdlInterface_corbatext_tmap::assign( StaticValueType d, const StaticValueType s ) const
131{
132 *(_MICO_T*) d = *(_MICO_T*) s;
133}
134
135void _Marshaller_gsdlInterface_corbatext_tmap::free( StaticValueType v ) const
136{
137 delete (_MICO_T*) v;
138}
139
140CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
141{
142 return
143 dc.struct_begin() &&
144 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
145 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) &&
146 dc.struct_end();
147}
148
149void _Marshaller_gsdlInterface_corbatext_tmap::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
150{
151 ec.struct_begin();
152 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
153 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values );
154 ec.struct_end();
155}
156
157CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;
158
159
160class _Marshaller_gsdlInterface_corbaComError : public CORBA::StaticTypeInfo {
161 typedef gsdlInterface::corbaComError _MICO_T;
162 public:
163 StaticValueType create () const;
164 void assign (StaticValueType dst, const StaticValueType src) const;
165 void free (StaticValueType) const;
166 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
167 void marshal (CORBA::DataEncoder &, StaticValueType) const;
168};
169
170
171CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const
172{
173 return (StaticValueType) new _MICO_T;
174}
175
176void _Marshaller_gsdlInterface_corbaComError::assign( StaticValueType d, const StaticValueType s ) const
177{
178 *(_MICO_T*) d = *(_MICO_T*) s;
179}
180
181void _Marshaller_gsdlInterface_corbaComError::free( StaticValueType v ) const
182{
183 delete (_MICO_T*) v;
184}
185
186CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
187{
188 CORBA::ULong ul;
189 if( !dc.enumeration( ul ) )
190 return FALSE;
191 *(_MICO_T*) v = (_MICO_T) ul;
192 return TRUE;
193}
194
195void _Marshaller_gsdlInterface_corbaComError::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
196{
197 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
198}
199
200CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;
201
202#ifdef HAVE_EXPLICIT_STRUCT_OPS
203gsdlInterface::corbaShortColInfo::corbaShortColInfo()
204{
205}
206
207gsdlInterface::corbaShortColInfo::corbaShortColInfo( const corbaShortColInfo& _s )
208{
209 name = ((corbaShortColInfo&)_s).name;
210 host = ((corbaShortColInfo&)_s).host;
211 response = ((corbaShortColInfo&)_s).response;
212}
213
214gsdlInterface::corbaShortColInfo::~corbaShortColInfo()
215{
216}
217
218gsdlInterface::corbaShortColInfo&
219gsdlInterface::corbaShortColInfo::operator=( const corbaShortColInfo& _s )
220{
221 name = ((corbaShortColInfo&)_s).name;
222 host = ((corbaShortColInfo&)_s).host;
223 response = ((corbaShortColInfo&)_s).response;
224 return *this;
225}
226#endif
227
228class _Marshaller_gsdlInterface_corbaShortColInfo : public CORBA::StaticTypeInfo {
229 typedef gsdlInterface::corbaShortColInfo _MICO_T;
230 public:
231 StaticValueType create () const;
232 void assign (StaticValueType dst, const StaticValueType src) const;
233 void free (StaticValueType) const;
234 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
235 void marshal (CORBA::DataEncoder &, StaticValueType) const;
236};
237
238
239CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const
240{
241 return (StaticValueType) new _MICO_T;
242}
243
244void _Marshaller_gsdlInterface_corbaShortColInfo::assign( StaticValueType d, const StaticValueType s ) const
245{
246 *(_MICO_T*) d = *(_MICO_T*) s;
247}
248
249void _Marshaller_gsdlInterface_corbaShortColInfo::free( StaticValueType v ) const
250{
251 delete (_MICO_T*) v;
252}
253
254CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
255{
256 return
257 dc.struct_begin() &&
258 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
259 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->host ) &&
260 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->response ) &&
261 dc.struct_end();
262}
263
264void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
265{
266 ec.struct_begin();
267 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
268 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->host );
269 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->response );
270 ec.struct_end();
271}
272
273CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;
274
275#ifdef HAVE_EXPLICIT_STRUCT_OPS
276gsdlInterface::corbaColInfoResponse::corbaColInfoResponse()
277{
278}
279
280gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s )
281{
282 shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
283 useBook = ((corbaColInfoResponse&)_s).useBook;
284 isPublic = ((corbaColInfoResponse&)_s).isPublic;
285 isBeta = ((corbaColInfoResponse&)_s).isBeta;
286 buildDate = ((corbaColInfoResponse&)_s).buildDate;
287 ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
288 languages = ((corbaColInfoResponse&)_s).languages;
289 numDocs = ((corbaColInfoResponse&)_s).numDocs;
290 numWords = ((corbaColInfoResponse&)_s).numWords;
291 numBytes = ((corbaColInfoResponse&)_s).numBytes;
292 collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
293 format = ((corbaColInfoResponse&)_s).format;
294 building = ((corbaColInfoResponse&)_s).building;
295 httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
296 httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
297 receptionist = ((corbaColInfoResponse&)_s).receptionist;
298}
299
300gsdlInterface::corbaColInfoResponse::~corbaColInfoResponse()
301{
302}
303
304gsdlInterface::corbaColInfoResponse&
305gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s )
306{
307 shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
308 useBook = ((corbaColInfoResponse&)_s).useBook;
309 isPublic = ((corbaColInfoResponse&)_s).isPublic;
310 isBeta = ((corbaColInfoResponse&)_s).isBeta;
311 buildDate = ((corbaColInfoResponse&)_s).buildDate;
312 ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
313 languages = ((corbaColInfoResponse&)_s).languages;
314 numDocs = ((corbaColInfoResponse&)_s).numDocs;
315 numWords = ((corbaColInfoResponse&)_s).numWords;
316 numBytes = ((corbaColInfoResponse&)_s).numBytes;
317 collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
318 format = ((corbaColInfoResponse&)_s).format;
319 building = ((corbaColInfoResponse&)_s).building;
320 httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
321 httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
322 receptionist = ((corbaColInfoResponse&)_s).receptionist;
323 return *this;
324}
325#endif
326
327class _Marshaller_gsdlInterface_corbaColInfoResponse : public CORBA::StaticTypeInfo {
328 typedef gsdlInterface::corbaColInfoResponse _MICO_T;
329 public:
330 StaticValueType create () const;
331 void assign (StaticValueType dst, const StaticValueType src) const;
332 void free (StaticValueType) const;
333 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
334 void marshal (CORBA::DataEncoder &, StaticValueType) const;
335};
336
337
338CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const
339{
340 return (StaticValueType) new _MICO_T;
341}
342
343void _Marshaller_gsdlInterface_corbaColInfoResponse::assign( StaticValueType d, const StaticValueType s ) const
344{
345 *(_MICO_T*) d = *(_MICO_T*) s;
346}
347
348void _Marshaller_gsdlInterface_corbaColInfoResponse::free( StaticValueType v ) const
349{
350 delete (_MICO_T*) v;
351}
352
353CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
354{
355 return
356 dc.struct_begin() &&
357 _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shoftInfo ) &&
358 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->useBook ) &&
359 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) &&
360 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isBeta ) &&
361 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->buildDate ) &&
362 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->ccsCols ) &&
363 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->languages ) &&
364 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
365 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) &&
366 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) &&
367 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) &&
368 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) &&
369 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) &&
370 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpdomain ) &&
371 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) &&
372 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) &&
373 dc.struct_end();
374}
375
376void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
377{
378 ec.struct_begin();
379 _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shoftInfo );
380 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->useBook );
381 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic );
382 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isBeta );
383 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->buildDate );
384 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->ccsCols );
385 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->languages );
386 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numDocs );
387 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords );
388 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes );
389 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->collectionMeta );
390 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format );
391 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building );
392 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpdomain );
393 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix );
394 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist );
395 ec.struct_end();
396}
397
398CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
399
400#ifdef HAVE_EXPLICIT_STRUCT_OPS
401gsdlInterface::corbaDocRequest::corbaDocRequest()
402{
403}
404
405gsdlInterface::corbaDocRequest::corbaDocRequest( const corbaDocRequest& _s )
406{
407 OID = ((corbaDocRequest&)_s).OID;
408 docType = ((corbaDocRequest&)_s).docType;
409 docFormat = ((corbaDocRequest&)_s).docFormat;
410}
411
412gsdlInterface::corbaDocRequest::~corbaDocRequest()
413{
414}
415
416gsdlInterface::corbaDocRequest&
417gsdlInterface::corbaDocRequest::operator=( const corbaDocRequest& _s )
418{
419 OID = ((corbaDocRequest&)_s).OID;
420 docType = ((corbaDocRequest&)_s).docType;
421 docFormat = ((corbaDocRequest&)_s).docFormat;
422 return *this;
423}
424#endif
425
426class _Marshaller_gsdlInterface_corbaDocRequest : public CORBA::StaticTypeInfo {
427 typedef gsdlInterface::corbaDocRequest _MICO_T;
428 public:
429 StaticValueType create () const;
430 void assign (StaticValueType dst, const StaticValueType src) const;
431 void free (StaticValueType) const;
432 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
433 void marshal (CORBA::DataEncoder &, StaticValueType) const;
434};
435
436
437CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const
438{
439 return (StaticValueType) new _MICO_T;
440}
441
442void _Marshaller_gsdlInterface_corbaDocRequest::assign( StaticValueType d, const StaticValueType s ) const
443{
444 *(_MICO_T*) d = *(_MICO_T*) s;
445}
446
447void _Marshaller_gsdlInterface_corbaDocRequest::free( StaticValueType v ) const
448{
449 delete (_MICO_T*) v;
450}
451
452CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
453{
454 return
455 dc.struct_begin() &&
456 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
457 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docType ) &&
458 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docFormat ) &&
459 dc.struct_end();
460}
461
462void _Marshaller_gsdlInterface_corbaDocRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
463{
464 ec.struct_begin();
465 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
466 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docType );
467 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docFormat );
468 ec.struct_end();
469}
470
471CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
472
473#ifdef HAVE_EXPLICIT_STRUCT_OPS
474gsdlInterface::corbaDocResponse::corbaDocResponse()
475{
476}
477
478gsdlInterface::corbaDocResponse::corbaDocResponse( const corbaDocResponse& _s )
479{
480 doc = ((corbaDocResponse&)_s).doc;
481}
482
483gsdlInterface::corbaDocResponse::~corbaDocResponse()
484{
485}
486
487gsdlInterface::corbaDocResponse&
488gsdlInterface::corbaDocResponse::operator=( const corbaDocResponse& _s )
489{
490 doc = ((corbaDocResponse&)_s).doc;
491 return *this;
492}
493#endif
494
495class _Marshaller_gsdlInterface_corbaDocResponse : public CORBA::StaticTypeInfo {
496 typedef gsdlInterface::corbaDocResponse _MICO_T;
497 public:
498 StaticValueType create () const;
499 void assign (StaticValueType dst, const StaticValueType src) const;
500 void free (StaticValueType) const;
501 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
502 void marshal (CORBA::DataEncoder &, StaticValueType) const;
503};
504
505
506CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const
507{
508 return (StaticValueType) new _MICO_T;
509}
510
511void _Marshaller_gsdlInterface_corbaDocResponse::assign( StaticValueType d, const StaticValueType s ) const
512{
513 *(_MICO_T*) d = *(_MICO_T*) s;
514}
515
516void _Marshaller_gsdlInterface_corbaDocResponse::free( StaticValueType v ) const
517{
518 delete (_MICO_T*) v;
519}
520
521CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
522{
523 return
524 dc.struct_begin() &&
525 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->doc ) &&
526 dc.struct_end();
527}
528
529void _Marshaller_gsdlInterface_corbaDocResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
530{
531 ec.struct_begin();
532 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->doc );
533 ec.struct_end();
534}
535
536CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
537
538
539class _Marshaller_gsdlInterface_corbaFilterType : public CORBA::StaticTypeInfo {
540 typedef gsdlInterface::corbaFilterType _MICO_T;
541 public:
542 StaticValueType create () const;
543 void assign (StaticValueType dst, const StaticValueType src) const;
544 void free (StaticValueType) const;
545 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
546 void marshal (CORBA::DataEncoder &, StaticValueType) const;
547};
548
549
550CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const
551{
552 return (StaticValueType) new _MICO_T;
553}
554
555void _Marshaller_gsdlInterface_corbaFilterType::assign( StaticValueType d, const StaticValueType s ) const
556{
557 *(_MICO_T*) d = *(_MICO_T*) s;
558}
559
560void _Marshaller_gsdlInterface_corbaFilterType::free( StaticValueType v ) const
561{
562 delete (_MICO_T*) v;
563}
564
565CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
566{
567 CORBA::ULong ul;
568 if( !dc.enumeration( ul ) )
569 return FALSE;
570 *(_MICO_T*) v = (_MICO_T) ul;
571 return TRUE;
572}
573
574void _Marshaller_gsdlInterface_corbaFilterType::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
575{
576 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
577}
578
579CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
580
581
582class _Marshaller_gsdlInterface_corbaFilterRepeatable : public CORBA::StaticTypeInfo {
583 typedef gsdlInterface::corbaFilterRepeatable _MICO_T;
584 public:
585 StaticValueType create () const;
586 void assign (StaticValueType dst, const StaticValueType src) const;
587 void free (StaticValueType) const;
588 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
589 void marshal (CORBA::DataEncoder &, StaticValueType) const;
590};
591
592
593CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const
594{
595 return (StaticValueType) new _MICO_T;
596}
597
598void _Marshaller_gsdlInterface_corbaFilterRepeatable::assign( StaticValueType d, const StaticValueType s ) const
599{
600 *(_MICO_T*) d = *(_MICO_T*) s;
601}
602
603void _Marshaller_gsdlInterface_corbaFilterRepeatable::free( StaticValueType v ) const
604{
605 delete (_MICO_T*) v;
606}
607
608CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
609{
610 CORBA::ULong ul;
611 if( !dc.enumeration( ul ) )
612 return FALSE;
613 *(_MICO_T*) v = (_MICO_T) ul;
614 return TRUE;
615}
616
617void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
618{
619 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
620}
621
622CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
623
624#ifdef HAVE_EXPLICIT_STRUCT_OPS
625gsdlInterface::corbaFilterOption::corbaFilterOption()
626{
627}
628
629gsdlInterface::corbaFilterOption::corbaFilterOption( const corbaFilterOption& _s )
630{
631 name = ((corbaFilterOption&)_s).name;
632 type = ((corbaFilterOption&)_s).type;
633 repeatable = ((corbaFilterOption&)_s).repeatable;
634 defaultValue = ((corbaFilterOption&)_s).defaultValue;
635 validValues = ((corbaFilterOption&)_s).validValues;
636}
637
638gsdlInterface::corbaFilterOption::~corbaFilterOption()
639{
640}
641
642gsdlInterface::corbaFilterOption&
643gsdlInterface::corbaFilterOption::operator=( const corbaFilterOption& _s )
644{
645 name = ((corbaFilterOption&)_s).name;
646 type = ((corbaFilterOption&)_s).type;
647 repeatable = ((corbaFilterOption&)_s).repeatable;
648 defaultValue = ((corbaFilterOption&)_s).defaultValue;
649 validValues = ((corbaFilterOption&)_s).validValues;
650 return *this;
651}
652#endif
653
654class _Marshaller_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
655 typedef gsdlInterface::corbaFilterOption _MICO_T;
656 public:
657 StaticValueType create () const;
658 void assign (StaticValueType dst, const StaticValueType src) const;
659 void free (StaticValueType) const;
660 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
661 void marshal (CORBA::DataEncoder &, StaticValueType) const;
662};
663
664
665CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const
666{
667 return (StaticValueType) new _MICO_T;
668}
669
670void _Marshaller_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
671{
672 *(_MICO_T*) d = *(_MICO_T*) s;
673}
674
675void _Marshaller_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
676{
677 delete (_MICO_T*) v;
678}
679
680CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
681{
682 return
683 dc.struct_begin() &&
684 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
685 _marshaller_gsdlInterface_corbaFilterType->demarshal( dc, &((_MICO_T*)v)->type ) &&
686 _marshaller_gsdlInterface_corbaFilterRepeatable->demarshal( dc, &((_MICO_T*)v)->repeatable ) &&
687 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->defaultValue ) &&
688 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->validValues ) &&
689 dc.struct_end();
690}
691
692void _Marshaller_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
693{
694 ec.struct_begin();
695 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
696 _marshaller_gsdlInterface_corbaFilterType->marshal( ec, &((_MICO_T*)v)->type );
697 _marshaller_gsdlInterface_corbaFilterRepeatable->marshal( ec, &((_MICO_T*)v)->repeatable );
698 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->defaultValue );
699 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->validValues );
700 ec.struct_end();
701}
702
703CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
704
705
706#ifdef HAVE_EXPLICIT_STRUCT_OPS
707gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse()
708{
709}
710
711gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse( const corbaFilterOptionsResponse& _s )
712{
713 options = ((corbaFilterOptionsResponse&)_s).options;
714 names = ((corbaFilterOptionsResponse&)_s).names;
715}
716
717gsdlInterface::corbaFilterOptionsResponse::~corbaFilterOptionsResponse()
718{
719}
720
721gsdlInterface::corbaFilterOptionsResponse&
722gsdlInterface::corbaFilterOptionsResponse::operator=( const corbaFilterOptionsResponse& _s )
723{
724 options = ((corbaFilterOptionsResponse&)_s).options;
725 names = ((corbaFilterOptionsResponse&)_s).names;
726 return *this;
727}
728#endif
729
730class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public CORBA::StaticTypeInfo {
731 typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T;
732 public:
733 StaticValueType create () const;
734 void assign (StaticValueType dst, const StaticValueType src) const;
735 void free (StaticValueType) const;
736 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
737 void marshal (CORBA::DataEncoder &, StaticValueType) const;
738};
739
740
741CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const
742{
743 return (StaticValueType) new _MICO_T;
744}
745
746void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::assign( StaticValueType d, const StaticValueType s ) const
747{
748 *(_MICO_T*) d = *(_MICO_T*) s;
749}
750
751void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::free( StaticValueType v ) const
752{
753 delete (_MICO_T*) v;
754}
755
756CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
757{
758 return
759 dc.struct_begin() &&
760 _marshaller__seq_gsdlInterface_corbaFilterOption->demarshal( dc, &((_MICO_T*)v)->options ) &&
761 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
762 dc.struct_end();
763}
764
765void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
766{
767 ec.struct_begin();
768 _marshaller__seq_gsdlInterface_corbaFilterOption->marshal( ec, &((_MICO_T*)v)->options );
769 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
770 ec.struct_end();
771}
772
773CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
774
775#ifdef HAVE_EXPLICIT_STRUCT_OPS
776gsdlInterface::corbaOptionValue::corbaOptionValue()
777{
778}
779
780gsdlInterface::corbaOptionValue::corbaOptionValue( const corbaOptionValue& _s )
781{
782 name = ((corbaOptionValue&)_s).name;
783 value = ((corbaOptionValue&)_s).value;
784}
785
786gsdlInterface::corbaOptionValue::~corbaOptionValue()
787{
788}
789
790gsdlInterface::corbaOptionValue&
791gsdlInterface::corbaOptionValue::operator=( const corbaOptionValue& _s )
792{
793 name = ((corbaOptionValue&)_s).name;
794 value = ((corbaOptionValue&)_s).value;
795 return *this;
796}
797#endif
798
799class _Marshaller_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
800 typedef gsdlInterface::corbaOptionValue _MICO_T;
801 public:
802 StaticValueType create () const;
803 void assign (StaticValueType dst, const StaticValueType src) const;
804 void free (StaticValueType) const;
805 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
806 void marshal (CORBA::DataEncoder &, StaticValueType) const;
807};
808
809
810CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const
811{
812 return (StaticValueType) new _MICO_T;
813}
814
815void _Marshaller_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
816{
817 *(_MICO_T*) d = *(_MICO_T*) s;
818}
819
820void _Marshaller_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
821{
822 delete (_MICO_T*) v;
823}
824
825CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
826{
827 return
828 dc.struct_begin() &&
829 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
830 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->value ) &&
831 dc.struct_end();
832}
833
834void _Marshaller_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
835{
836 ec.struct_begin();
837 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
838 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->value );
839 ec.struct_end();
840}
841
842CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
843
844
845#ifdef HAVE_EXPLICIT_STRUCT_OPS
846gsdlInterface::corbaFilterRequest::corbaFilterRequest()
847{
848}
849
850gsdlInterface::corbaFilterRequest::corbaFilterRequest( const corbaFilterRequest& _s )
851{
852 filter = ((corbaFilterRequest&)_s).filter;
853 filterOptions = ((corbaFilterRequest&)_s).filterOptions;
854 docSet = ((corbaFilterRequest&)_s).docSet;
855 filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
856 requestParams = ((corbaFilterRequest&)_s).requestParams;
857 refParams = ((corbaFilterRequest&)_s).refParams;
858 fields = ((corbaFilterRequest&)_s).fields;
859 getParents = ((corbaFilterRequest&)_s).getParents;
860}
861
862gsdlInterface::corbaFilterRequest::~corbaFilterRequest()
863{
864}
865
866gsdlInterface::corbaFilterRequest&
867gsdlInterface::corbaFilterRequest::operator=( const corbaFilterRequest& _s )
868{
869 filter = ((corbaFilterRequest&)_s).filter;
870 filterOptions = ((corbaFilterRequest&)_s).filterOptions;
871 docSet = ((corbaFilterRequest&)_s).docSet;
872 filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
873 requestParams = ((corbaFilterRequest&)_s).requestParams;
874 refParams = ((corbaFilterRequest&)_s).refParams;
875 fields = ((corbaFilterRequest&)_s).fields;
876 getParents = ((corbaFilterRequest&)_s).getParents;
877 return *this;
878}
879#endif
880
881class _Marshaller_gsdlInterface_corbaFilterRequest : public CORBA::StaticTypeInfo {
882 typedef gsdlInterface::corbaFilterRequest _MICO_T;
883 public:
884 StaticValueType create () const;
885 void assign (StaticValueType dst, const StaticValueType src) const;
886 void free (StaticValueType) const;
887 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
888 void marshal (CORBA::DataEncoder &, StaticValueType) const;
889};
890
891
892CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const
893{
894 return (StaticValueType) new _MICO_T;
895}
896
897void _Marshaller_gsdlInterface_corbaFilterRequest::assign( StaticValueType d, const StaticValueType s ) const
898{
899 *(_MICO_T*) d = *(_MICO_T*) s;
900}
901
902void _Marshaller_gsdlInterface_corbaFilterRequest::free( StaticValueType v ) const
903{
904 delete (_MICO_T*) v;
905}
906
907CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
908{
909 return
910 dc.struct_begin() &&
911 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->filter ) &&
912 _marshaller__seq_gsdlInterface_corbaOptionValue->demarshal( dc, &((_MICO_T*)v)->filterOptions ) &&
913 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docSet ) &&
914 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->filterResultOptions ) &&
915 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->requestParams ) &&
916 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->refParams ) &&
917 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->fields ) &&
918 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->getParents ) &&
919 dc.struct_end();
920}
921
922void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
923{
924 ec.struct_begin();
925 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->filter );
926 _marshaller__seq_gsdlInterface_corbaOptionValue->marshal( ec, &((_MICO_T*)v)->filterOptions );
927 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docSet );
928 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->filterResultOptions );
929 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->requestParams );
930 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->refParams );
931 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->fields );
932 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->getParents );
933 ec.struct_end();
934}
935
936CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
937
938#ifdef HAVE_EXPLICIT_STRUCT_OPS
939gsdlInterface::corbaTermInfo::corbaTermInfo()
940{
941}
942
943gsdlInterface::corbaTermInfo::corbaTermInfo( const corbaTermInfo& _s )
944{
945 term = ((corbaTermInfo&)_s).term;
946 frequency = ((corbaTermInfo&)_s).frequency;
947 matchTerms = ((corbaTermInfo&)_s).matchTerms;
948}
949
950gsdlInterface::corbaTermInfo::~corbaTermInfo()
951{
952}
953
954gsdlInterface::corbaTermInfo&
955gsdlInterface::corbaTermInfo::operator=( const corbaTermInfo& _s )
956{
957 term = ((corbaTermInfo&)_s).term;
958 frequency = ((corbaTermInfo&)_s).frequency;
959 matchTerms = ((corbaTermInfo&)_s).matchTerms;
960 return *this;
961}
962#endif
963
964class _Marshaller_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
965 typedef gsdlInterface::corbaTermInfo _MICO_T;
966 public:
967 StaticValueType create () const;
968 void assign (StaticValueType dst, const StaticValueType src) const;
969 void free (StaticValueType) const;
970 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
971 void marshal (CORBA::DataEncoder &, StaticValueType) const;
972};
973
974
975CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const
976{
977 return (StaticValueType) new _MICO_T;
978}
979
980void _Marshaller_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
981{
982 *(_MICO_T*) d = *(_MICO_T*) s;
983}
984
985void _Marshaller_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
986{
987 delete (_MICO_T*) v;
988}
989
990CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
991{
992 return
993 dc.struct_begin() &&
994 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->term ) &&
995 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->frequency ) &&
996 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->matchTerms ) &&
997 dc.struct_end();
998}
999
1000void _Marshaller_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1001{
1002 ec.struct_begin();
1003 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->term );
1004 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->frequency );
1005 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->matchTerms );
1006 ec.struct_end();
1007}
1008
1009CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
1010
1011
1012#ifdef HAVE_EXPLICIT_STRUCT_OPS
1013gsdlInterface::corbaMetadataInfo::corbaMetadataInfo()
1014{
1015}
1016
1017gsdlInterface::corbaMetadataInfo::corbaMetadataInfo( const corbaMetadataInfo& _s )
1018{
1019 params = ((corbaMetadataInfo&)_s).params;
1020 isRef = ((corbaMetadataInfo&)_s).isRef;
1021 values = ((corbaMetadataInfo&)_s).values;
1022 id = ((corbaMetadataInfo&)_s).id;
1023 parentid = ((corbaMetadataInfo&)_s).parentid;
1024}
1025
1026gsdlInterface::corbaMetadataInfo::~corbaMetadataInfo()
1027{
1028}
1029
1030gsdlInterface::corbaMetadataInfo&
1031gsdlInterface::corbaMetadataInfo::operator=( const corbaMetadataInfo& _s )
1032{
1033 params = ((corbaMetadataInfo&)_s).params;
1034 isRef = ((corbaMetadataInfo&)_s).isRef;
1035 values = ((corbaMetadataInfo&)_s).values;
1036 id = ((corbaMetadataInfo&)_s).id;
1037 parentid = ((corbaMetadataInfo&)_s).parentid;
1038 return *this;
1039}
1040#endif
1041
1042class _Marshaller_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
1043 typedef gsdlInterface::corbaMetadataInfo _MICO_T;
1044 public:
1045 StaticValueType create () const;
1046 void assign (StaticValueType dst, const StaticValueType src) const;
1047 void free (StaticValueType) const;
1048 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1049 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1050};
1051
1052
1053CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const
1054{
1055 return (StaticValueType) new _MICO_T;
1056}
1057
1058void _Marshaller_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1059{
1060 *(_MICO_T*) d = *(_MICO_T*) s;
1061}
1062
1063void _Marshaller_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1064{
1065 delete (_MICO_T*) v;
1066}
1067
1068CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1069{
1070 return
1071 dc.struct_begin() &&
1072 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->params ) &&
1073 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isRef ) &&
1074 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) &&
1075 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->id ) &&
1076 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->parentid ) &&
1077 dc.struct_end();
1078}
1079
1080void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1081{
1082 ec.struct_begin();
1083 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->params );
1084 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isRef );
1085 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values );
1086 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->id );
1087 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->parentid );
1088 ec.struct_end();
1089}
1090
1091CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
1092
1093
1094#ifdef HAVE_EXPLICIT_STRUCT_OPS
1095gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map()
1096{
1097}
1098
1099gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map( const corbaMetadataInfo_map& _s )
1100{
1101 names = ((corbaMetadataInfo_map&)_s).names;
1102 values = ((corbaMetadataInfo_map&)_s).values;
1103}
1104
1105gsdlInterface::corbaMetadataInfo_map::~corbaMetadataInfo_map()
1106{
1107}
1108
1109gsdlInterface::corbaMetadataInfo_map&
1110gsdlInterface::corbaMetadataInfo_map::operator=( const corbaMetadataInfo_map& _s )
1111{
1112 names = ((corbaMetadataInfo_map&)_s).names;
1113 values = ((corbaMetadataInfo_map&)_s).values;
1114 return *this;
1115}
1116#endif
1117
1118class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public CORBA::StaticTypeInfo {
1119 typedef gsdlInterface::corbaMetadataInfo_map _MICO_T;
1120 public:
1121 StaticValueType create () const;
1122 void assign (StaticValueType dst, const StaticValueType src) const;
1123 void free (StaticValueType) const;
1124 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1125 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1126};
1127
1128
1129CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const
1130{
1131 return (StaticValueType) new _MICO_T;
1132}
1133
1134void _Marshaller_gsdlInterface_corbaMetadataInfo_map::assign( StaticValueType d, const StaticValueType s ) const
1135{
1136 *(_MICO_T*) d = *(_MICO_T*) s;
1137}
1138
1139void _Marshaller_gsdlInterface_corbaMetadataInfo_map::free( StaticValueType v ) const
1140{
1141 delete (_MICO_T*) v;
1142}
1143
1144CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1145{
1146 return
1147 dc.struct_begin() &&
1148 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
1149 _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->values ) &&
1150 dc.struct_end();
1151}
1152
1153void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1154{
1155 ec.struct_begin();
1156 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
1157 _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->values );
1158 ec.struct_end();
1159}
1160
1161CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
1162
1163
1164#ifdef HAVE_EXPLICIT_STRUCT_OPS
1165gsdlInterface::corbaResultDocInfo::corbaResultDocInfo()
1166{
1167}
1168
1169gsdlInterface::corbaResultDocInfo::corbaResultDocInfo( const corbaResultDocInfo& _s )
1170{
1171 OID = ((corbaResultDocInfo&)_s).OID;
1172 resultNum = ((corbaResultDocInfo&)_s).resultNum;
1173 ranking = ((corbaResultDocInfo&)_s).ranking;
1174 termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1175 phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1176 docFreq = ((corbaResultDocInfo&)_s).docFreq;
1177 metadata = ((corbaResultDocInfo&)_s).metadata;
1178 classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1179 classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1180 metaparents = ((corbaResultDocInfo&)_s).metaparents;
1181}
1182
1183gsdlInterface::corbaResultDocInfo::~corbaResultDocInfo()
1184{
1185}
1186
1187gsdlInterface::corbaResultDocInfo&
1188gsdlInterface::corbaResultDocInfo::operator=( const corbaResultDocInfo& _s )
1189{
1190 OID = ((corbaResultDocInfo&)_s).OID;
1191 resultNum = ((corbaResultDocInfo&)_s).resultNum;
1192 ranking = ((corbaResultDocInfo&)_s).ranking;
1193 termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1194 phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1195 docFreq = ((corbaResultDocInfo&)_s).docFreq;
1196 metadata = ((corbaResultDocInfo&)_s).metadata;
1197 classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1198 classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1199 metaparents = ((corbaResultDocInfo&)_s).metaparents;
1200 return *this;
1201}
1202#endif
1203
1204class _Marshaller_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
1205 typedef gsdlInterface::corbaResultDocInfo _MICO_T;
1206 public:
1207 StaticValueType create () const;
1208 void assign (StaticValueType dst, const StaticValueType src) const;
1209 void free (StaticValueType) const;
1210 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1211 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1212};
1213
1214
1215CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const
1216{
1217 return (StaticValueType) new _MICO_T;
1218}
1219
1220void _Marshaller_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1221{
1222 *(_MICO_T*) d = *(_MICO_T*) s;
1223}
1224
1225void _Marshaller_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1226{
1227 delete (_MICO_T*) v;
1228}
1229
1230CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1231{
1232 return
1233 dc.struct_begin() &&
1234 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
1235 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->resultNum ) &&
1236 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->ranking ) &&
1237 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->termsMatched ) &&
1238 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->phraseMatched ) &&
1239 CORBA::_stcseq_long->demarshal( dc, &((_MICO_T*)v)->docFreq ) &&
1240 _marshaller_gsdlInterface_corbaMetadataInfo_map->demarshal( dc, &((_MICO_T*)v)->metadata ) &&
1241 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->classifierMetadataType ) &&
1242 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->classifierMetadataOffset ) &&
1243 _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->metaparents ) &&
1244 dc.struct_end();
1245}
1246
1247void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1248{
1249 ec.struct_begin();
1250 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
1251 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->resultNum );
1252 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->ranking );
1253 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->termsMatched );
1254 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->phraseMatched );
1255 CORBA::_stcseq_long->marshal( ec, &((_MICO_T*)v)->docFreq );
1256 _marshaller_gsdlInterface_corbaMetadataInfo_map->marshal( ec, &((_MICO_T*)v)->metadata );
1257 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->classifierMetadataType );
1258 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->classifierMetadataOffset );
1259 _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->metaparents );
1260 ec.struct_end();
1261}
1262
1263CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
1264
1265
1266
1267class _Marshaller_gsdlInterface_corbaIsApprox : public CORBA::StaticTypeInfo {
1268 typedef gsdlInterface::corbaIsApprox _MICO_T;
1269 public:
1270 StaticValueType create () const;
1271 void assign (StaticValueType dst, const StaticValueType src) const;
1272 void free (StaticValueType) const;
1273 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1274 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1275};
1276
1277
1278CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const
1279{
1280 return (StaticValueType) new _MICO_T;
1281}
1282
1283void _Marshaller_gsdlInterface_corbaIsApprox::assign( StaticValueType d, const StaticValueType s ) const
1284{
1285 *(_MICO_T*) d = *(_MICO_T*) s;
1286}
1287
1288void _Marshaller_gsdlInterface_corbaIsApprox::free( StaticValueType v ) const
1289{
1290 delete (_MICO_T*) v;
1291}
1292
1293CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1294{
1295 CORBA::ULong ul;
1296 if( !dc.enumeration( ul ) )
1297 return FALSE;
1298 *(_MICO_T*) v = (_MICO_T) ul;
1299 return TRUE;
1300}
1301
1302void _Marshaller_gsdlInterface_corbaIsApprox::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1303{
1304 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
1305}
1306
1307CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
1308
1309#ifdef HAVE_EXPLICIT_STRUCT_OPS
1310gsdlInterface::corbaFilterResponse::corbaFilterResponse()
1311{
1312}
1313
1314gsdlInterface::corbaFilterResponse::corbaFilterResponse( const corbaFilterResponse& _s )
1315{
1316 numDocs = ((corbaFilterResponse&)_s).numDocs;
1317 isApprox = ((corbaFilterResponse&)_s).isApprox;
1318 termInfo = ((corbaFilterResponse&)_s).termInfo;
1319 docInfo = ((corbaFilterResponse&)_s).docInfo;
1320}
1321
1322gsdlInterface::corbaFilterResponse::~corbaFilterResponse()
1323{
1324}
1325
1326gsdlInterface::corbaFilterResponse&
1327gsdlInterface::corbaFilterResponse::operator=( const corbaFilterResponse& _s )
1328{
1329 numDocs = ((corbaFilterResponse&)_s).numDocs;
1330 isApprox = ((corbaFilterResponse&)_s).isApprox;
1331 termInfo = ((corbaFilterResponse&)_s).termInfo;
1332 docInfo = ((corbaFilterResponse&)_s).docInfo;
1333 return *this;
1334}
1335#endif
1336
1337class _Marshaller_gsdlInterface_corbaFilterResponse : public CORBA::StaticTypeInfo {
1338 typedef gsdlInterface::corbaFilterResponse _MICO_T;
1339 public:
1340 StaticValueType create () const;
1341 void assign (StaticValueType dst, const StaticValueType src) const;
1342 void free (StaticValueType) const;
1343 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1344 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1345};
1346
1347
1348CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const
1349{
1350 return (StaticValueType) new _MICO_T;
1351}
1352
1353void _Marshaller_gsdlInterface_corbaFilterResponse::assign( StaticValueType d, const StaticValueType s ) const
1354{
1355 *(_MICO_T*) d = *(_MICO_T*) s;
1356}
1357
1358void _Marshaller_gsdlInterface_corbaFilterResponse::free( StaticValueType v ) const
1359{
1360 delete (_MICO_T*) v;
1361}
1362
1363CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1364{
1365 return
1366 dc.struct_begin() &&
1367 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
1368 _marshaller_gsdlInterface_corbaIsApprox->demarshal( dc, &((_MICO_T*)v)->isApprox ) &&
1369 _marshaller__seq_gsdlInterface_corbaTermInfo->demarshal( dc, &((_MICO_T*)v)->termInfo ) &&
1370 _marshaller__seq_gsdlInterface_corbaResultDocInfo->demarshal( dc, &((_MICO_T*)v)->docInfo ) &&
1371 dc.struct_end();
1372}
1373
1374void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1375{
1376 ec.struct_begin();
1377 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->numDocs );
1378 _marshaller_gsdlInterface_corbaIsApprox->marshal( ec, &((_MICO_T*)v)->isApprox );
1379 _marshaller__seq_gsdlInterface_corbaTermInfo->marshal( ec, &((_MICO_T*)v)->termInfo );
1380 _marshaller__seq_gsdlInterface_corbaResultDocInfo->marshal( ec, &((_MICO_T*)v)->docInfo );
1381 ec.struct_end();
1382}
1383
1384CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
1385
1386
1387// Stub interface corbaiface
1388gsdlInterface::corbaiface::~corbaiface()
1389{
1390}
1391
1392void *gsdlInterface::corbaiface::_narrow_helper( const char *_rid )
1393{
1394 if( strcmp( _rid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 )
1395 return (void *)this;
1396 return NULL;
1397}
1398
1399bool gsdlInterface::corbaiface::_narrow_helper2( CORBA::Object_ptr _obj )
1400{
1401 if( strcmp( _obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0" ) == 0) {
1402 return true;
1403 }
1404 for( vector<CORBA::Narrow_proto>::size_type _i = 0;
1405 _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
1406 bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
1407 if( _res )
1408 return true;
1409 }
1410 return false;
1411}
1412
1413gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj )
1414{
1415 gsdlInterface::corbaiface_ptr _o;
1416 if( !CORBA::is_nil( _obj ) ) {
1417 void *_p;
1418 if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" )))
1419 return _duplicate( (gsdlInterface::corbaiface_ptr) _p );
1420 if( _narrow_helper2( _obj ) ||
1421 ( _obj->_is_a_remote( "IDL:gsdlInterface/corbaiface:1.0" ) ) ) {
1422 _o = new gsdlInterface::corbaiface_stub;
1423 _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
1424 return _o;
1425 }
1426 }
1427 return _nil();
1428}
1429
1430gsdlInterface::corbaiface_ptr
1431gsdlInterface::corbaiface::_narrow( CORBA::AbstractBase_ptr _obj )
1432{
1433 return _narrow (_obj->_to_object());
1434}
1435
1436gsdlInterface::corbaiface_stub::~corbaiface_stub()
1437{
1438}
1439
1440CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& error )
1441{
1442 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1443 CORBA::Boolean _res;
1444 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1445
1446 CORBA::StaticRequest __req( this, "initialise" );
1447 __req.add_inout_arg( &_error );
1448 __req.set_result( &__res );
1449
1450 __req.invoke();
1451
1452 mico_sii_throw( &__req,
1453 0);
1454 return _res;
1455}
1456
1457
1458void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error )
1459{
1460 CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
1461 CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
1462 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1463 CORBA::StaticRequest __req( this, "configure" );
1464 __req.add_in_arg( &_key );
1465 __req.add_in_arg( &_cfgline );
1466 __req.add_inout_arg( &_error );
1467
1468 __req.invoke();
1469
1470 mico_sii_throw( &__req,
1471 0);
1472}
1473
1474
1475void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error )
1476{
1477 CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
1478 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1479 CORBA::StaticRequest __req( this, "collectionList" );
1480 __req.add_inout_arg( &_collist );
1481 __req.add_inout_arg( &_error );
1482
1483 __req.invoke();
1484
1485 mico_sii_throw( &__req,
1486 0);
1487}
1488
1489
1490void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
1491{
1492 CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
1493 CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
1494 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1495 CORBA::StaticRequest __req( this, "hasCollection" );
1496 __req.add_in_arg( &_corbaCollection );
1497 __req.add_inout_arg( &_has );
1498 __req.add_inout_arg( &_error );
1499
1500 __req.invoke();
1501
1502 mico_sii_throw( &__req,
1503 0);
1504}
1505
1506
1507void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, gsdlInterface::corbaComError& error )
1508{
1509 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1510 CORBA::StaticAny _wasSuccess( CORBA::_stc_boolean, &wasSuccess );
1511 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1512 CORBA::StaticRequest __req( this, "ping" );
1513 __req.add_in_arg( &_collection );
1514 __req.add_inout_arg( &_wasSuccess );
1515 __req.add_inout_arg( &_error );
1516
1517 __req.invoke();
1518
1519 mico_sii_throw( &__req,
1520 0);
1521}
1522
1523
1524void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
1525{
1526 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1527 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
1528 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
1529 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1530 CORBA::StaticRequest __req( this, "getDocument" );
1531 __req.add_in_arg( &_collection );
1532 __req.add_inout_arg( &_request );
1533 __req.add_inout_arg( &_response );
1534 __req.add_inout_arg( &_error );
1535
1536 __req.invoke();
1537
1538 mico_sii_throw( &__req,
1539 0);
1540}
1541
1542
1543void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
1544{
1545 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1546 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
1547 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1548 CORBA::StaticRequest __req( this, "getCollectInfo" );
1549 __req.add_in_arg( &_collection );
1550 __req.add_inout_arg( &_response );
1551 __req.add_inout_arg( &_error );
1552
1553 __req.invoke();
1554
1555 mico_sii_throw( &__req,
1556 0);
1557}
1558
1559
1560void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
1561{
1562 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1563 CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
1564 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1565 CORBA::StaticRequest __req( this, "getFilterInfo" );
1566 __req.add_in_arg( &_collection );
1567 __req.add_inout_arg( &_filterNames );
1568 __req.add_inout_arg( &_error );
1569
1570 __req.invoke();
1571
1572 mico_sii_throw( &__req,
1573 0);
1574}
1575
1576
1577void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
1578{
1579 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1580 CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
1581 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
1582 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1583 CORBA::StaticRequest __req( this, "getFilterOptions" );
1584 __req.add_in_arg( &_collection );
1585 __req.add_in_arg( &_option );
1586 __req.add_inout_arg( &_response );
1587 __req.add_inout_arg( &_error );
1588
1589 __req.invoke();
1590
1591 mico_sii_throw( &__req,
1592 0);
1593}
1594
1595
1596void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
1597{
1598 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1599 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
1600 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
1601 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1602 CORBA::StaticRequest __req( this, "filter" );
1603 __req.add_in_arg( &_collection );
1604 __req.add_in_arg( &_request );
1605 __req.add_inout_arg( &_response );
1606 __req.add_inout_arg( &_error );
1607
1608 __req.invoke();
1609
1610 mico_sii_throw( &__req,
1611 0);
1612}
1613
1614
1615#ifdef HAVE_NAMESPACE
1616namespace gsdlInterface { vector<CORBA::Narrow_proto> * corbaiface::_narrow_helpers; }
1617#else
1618vector<CORBA::Narrow_proto> * gsdlInterface::corbaiface::_narrow_helpers;
1619#endif
1620
1621class _Marshaller_gsdlInterface_corbaiface : public CORBA::StaticTypeInfo {
1622 typedef gsdlInterface::corbaiface_ptr _MICO_T;
1623 public:
1624 StaticValueType create () const;
1625 void assign (StaticValueType dst, const StaticValueType src) const;
1626 void free (StaticValueType) const;
1627 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1628 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1629};
1630
1631
1632CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
1633{
1634 return (StaticValueType) new _MICO_T( 0 );
1635}
1636
1637void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
1638{
1639 *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s );
1640}
1641
1642void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
1643{
1644 CORBA::release( *(_MICO_T *) v );
1645 delete (_MICO_T*) v;
1646}
1647
1648CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1649{
1650 CORBA::Object_ptr obj;
1651 if (!CORBA::_stc_Object->demarshal(dc, &obj))
1652 return FALSE;
1653 *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj );
1654 CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v);
1655 CORBA::release (obj);
1656 return ret;
1657}
1658
1659void _Marshaller_gsdlInterface_corbaiface::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1660{
1661 CORBA::Object_ptr obj = *(_MICO_T *) v;
1662 CORBA::_stc_Object->marshal( ec, &obj );
1663}
1664
1665CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
1666
1667class _Marshaller__seq_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
1668 typedef SequenceTmpl<gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
1669 public:
1670 StaticValueType create () const;
1671 void assign (StaticValueType dst, const StaticValueType src) const;
1672 void free (StaticValueType) const;
1673 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1674 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1675};
1676
1677
1678CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
1679{
1680 return (StaticValueType) new _MICO_T;
1681}
1682
1683void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
1684{
1685 *(_MICO_T*) d = *(_MICO_T*) s;
1686}
1687
1688void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
1689{
1690 delete (_MICO_T*) v;
1691}
1692
1693CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1694{
1695 CORBA::ULong len;
1696 if( !dc.seq_begin( len ) )
1697 return FALSE;
1698 ((_MICO_T *) v)->length( len );
1699 for( CORBA::ULong i = 0; i < len; i++ ) {
1700 if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1701 return FALSE;
1702 }
1703 return dc.seq_end();
1704}
1705
1706void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1707{
1708 CORBA::ULong len = ((_MICO_T *) v)->length();
1709 ec.seq_begin( len );
1710 for( CORBA::ULong i = 0; i < len; i++ )
1711 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] );
1712 ec.seq_end();
1713}
1714
1715CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
1716
1717class _Marshaller__seq_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
1718 typedef SequenceTmpl<gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
1719 public:
1720 StaticValueType create () const;
1721 void assign (StaticValueType dst, const StaticValueType src) const;
1722 void free (StaticValueType) const;
1723 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1724 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1725};
1726
1727
1728CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
1729{
1730 return (StaticValueType) new _MICO_T;
1731}
1732
1733void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
1734{
1735 *(_MICO_T*) d = *(_MICO_T*) s;
1736}
1737
1738void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
1739{
1740 delete (_MICO_T*) v;
1741}
1742
1743CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1744{
1745 CORBA::ULong len;
1746 if( !dc.seq_begin( len ) )
1747 return FALSE;
1748 ((_MICO_T *) v)->length( len );
1749 for( CORBA::ULong i = 0; i < len; i++ ) {
1750 if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1751 return FALSE;
1752 }
1753 return dc.seq_end();
1754}
1755
1756void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1757{
1758 CORBA::ULong len = ((_MICO_T *) v)->length();
1759 ec.seq_begin( len );
1760 for( CORBA::ULong i = 0; i < len; i++ )
1761 _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] );
1762 ec.seq_end();
1763}
1764
1765CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
1766
1767class _Marshaller__seq_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
1768 typedef SequenceTmpl<gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
1769 public:
1770 StaticValueType create () const;
1771 void assign (StaticValueType dst, const StaticValueType src) const;
1772 void free (StaticValueType) const;
1773 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1774 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1775};
1776
1777
1778CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
1779{
1780 return (StaticValueType) new _MICO_T;
1781}
1782
1783void _Marshaller__seq_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
1784{
1785 *(_MICO_T*) d = *(_MICO_T*) s;
1786}
1787
1788void _Marshaller__seq_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
1789{
1790 delete (_MICO_T*) v;
1791}
1792
1793CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1794{
1795 CORBA::ULong len;
1796 if( !dc.seq_begin( len ) )
1797 return FALSE;
1798 ((_MICO_T *) v)->length( len );
1799 for( CORBA::ULong i = 0; i < len; i++ ) {
1800 if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1801 return FALSE;
1802 }
1803 return dc.seq_end();
1804}
1805
1806void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1807{
1808 CORBA::ULong len = ((_MICO_T *) v)->length();
1809 ec.seq_begin( len );
1810 for( CORBA::ULong i = 0; i < len; i++ )
1811 _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] );
1812 ec.seq_end();
1813}
1814
1815CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
1816
1817class _Marshaller__seq_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
1818 typedef SequenceTmpl<gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
1819 public:
1820 StaticValueType create () const;
1821 void assign (StaticValueType dst, const StaticValueType src) const;
1822 void free (StaticValueType) const;
1823 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1824 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1825};
1826
1827
1828CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
1829{
1830 return (StaticValueType) new _MICO_T;
1831}
1832
1833void _Marshaller__seq_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
1834{
1835 *(_MICO_T*) d = *(_MICO_T*) s;
1836}
1837
1838void _Marshaller__seq_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
1839{
1840 delete (_MICO_T*) v;
1841}
1842
1843CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1844{
1845 CORBA::ULong len;
1846 if( !dc.seq_begin( len ) )
1847 return FALSE;
1848 ((_MICO_T *) v)->length( len );
1849 for( CORBA::ULong i = 0; i < len; i++ ) {
1850 if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1851 return FALSE;
1852 }
1853 return dc.seq_end();
1854}
1855
1856void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1857{
1858 CORBA::ULong len = ((_MICO_T *) v)->length();
1859 ec.seq_begin( len );
1860 for( CORBA::ULong i = 0; i < len; i++ )
1861 _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1862 ec.seq_end();
1863}
1864
1865CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
1866
1867class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
1868 typedef SequenceTmpl<gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
1869 public:
1870 StaticValueType create () const;
1871 void assign (StaticValueType dst, const StaticValueType src) const;
1872 void free (StaticValueType) const;
1873 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1874 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1875};
1876
1877
1878CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
1879{
1880 return (StaticValueType) new _MICO_T;
1881}
1882
1883void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1884{
1885 *(_MICO_T*) d = *(_MICO_T*) s;
1886}
1887
1888void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1889{
1890 delete (_MICO_T*) v;
1891}
1892
1893CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1894{
1895 CORBA::ULong len;
1896 if( !dc.seq_begin( len ) )
1897 return FALSE;
1898 ((_MICO_T *) v)->length( len );
1899 for( CORBA::ULong i = 0; i < len; i++ ) {
1900 if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1901 return FALSE;
1902 }
1903 return dc.seq_end();
1904}
1905
1906void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1907{
1908 CORBA::ULong len = ((_MICO_T *) v)->length();
1909 ec.seq_begin( len );
1910 for( CORBA::ULong i = 0; i < len; i++ )
1911 _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1912 ec.seq_end();
1913}
1914
1915CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
1916
1917class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
1918 typedef SequenceTmpl<gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
1919 public:
1920 StaticValueType create () const;
1921 void assign (StaticValueType dst, const StaticValueType src) const;
1922 void free (StaticValueType) const;
1923 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1924 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1925};
1926
1927
1928CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
1929{
1930 return (StaticValueType) new _MICO_T;
1931}
1932
1933void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1934{
1935 *(_MICO_T*) d = *(_MICO_T*) s;
1936}
1937
1938void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1939{
1940 delete (_MICO_T*) v;
1941}
1942
1943CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1944{
1945 CORBA::ULong len;
1946 if( !dc.seq_begin( len ) )
1947 return FALSE;
1948 ((_MICO_T *) v)->length( len );
1949 for( CORBA::ULong i = 0; i < len; i++ ) {
1950 if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1951 return FALSE;
1952 }
1953 return dc.seq_end();
1954}
1955
1956void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1957{
1958 CORBA::ULong len = ((_MICO_T *) v)->length();
1959 ec.seq_begin( len );
1960 for( CORBA::ULong i = 0; i < len; i++ )
1961 _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1962 ec.seq_end();
1963}
1964
1965CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
1966
1967struct __tc_init_CORBAIFACE {
1968 __tc_init_CORBAIFACE()
1969 {
1970 _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t;
1971 _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap;
1972 _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError;
1973 _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo;
1974 _marshaller_gsdlInterface_corbaColInfoResponse = new _Marshaller_gsdlInterface_corbaColInfoResponse;
1975 _marshaller_gsdlInterface_corbaDocRequest = new _Marshaller_gsdlInterface_corbaDocRequest;
1976 _marshaller_gsdlInterface_corbaDocResponse = new _Marshaller_gsdlInterface_corbaDocResponse;
1977 _marshaller_gsdlInterface_corbaFilterType = new _Marshaller_gsdlInterface_corbaFilterType;
1978 _marshaller_gsdlInterface_corbaFilterRepeatable = new _Marshaller_gsdlInterface_corbaFilterRepeatable;
1979 _marshaller_gsdlInterface_corbaFilterOption = new _Marshaller_gsdlInterface_corbaFilterOption;
1980 _marshaller_gsdlInterface_corbaFilterOptionsResponse = new _Marshaller_gsdlInterface_corbaFilterOptionsResponse;
1981 _marshaller_gsdlInterface_corbaOptionValue = new _Marshaller_gsdlInterface_corbaOptionValue;
1982 _marshaller_gsdlInterface_corbaFilterRequest = new _Marshaller_gsdlInterface_corbaFilterRequest;
1983 _marshaller_gsdlInterface_corbaTermInfo = new _Marshaller_gsdlInterface_corbaTermInfo;
1984 _marshaller_gsdlInterface_corbaMetadataInfo = new _Marshaller_gsdlInterface_corbaMetadataInfo;
1985 _marshaller_gsdlInterface_corbaMetadataInfo_map = new _Marshaller_gsdlInterface_corbaMetadataInfo_map;
1986 _marshaller_gsdlInterface_corbaResultDocInfo = new _Marshaller_gsdlInterface_corbaResultDocInfo;
1987 _marshaller_gsdlInterface_corbaIsApprox = new _Marshaller_gsdlInterface_corbaIsApprox;
1988 _marshaller_gsdlInterface_corbaFilterResponse = new _Marshaller_gsdlInterface_corbaFilterResponse;
1989 _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface;
1990 _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t;
1991 _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption;
1992 _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue;
1993 _marshaller__seq_gsdlInterface_corbaTermInfo = new _Marshaller__seq_gsdlInterface_corbaTermInfo;
1994 _marshaller__seq_gsdlInterface_corbaMetadataInfo = new _Marshaller__seq_gsdlInterface_corbaMetadataInfo;
1995 _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo;
1996 }
1997};
1998
1999static __tc_init_CORBAIFACE __init_CORBAIFACE;
2000
Note: See TracBrowser for help on using the repository browser.