source: tags/gsdl-2_30d-distribution/gsdl/lib/corbaiface.mpp@ 2308

Last change on this file since 2308 was 1860, checked in by cs025, 23 years ago

Included CORBA branch for first time
  • Property svn:keywords set to Author Date Id Revision
File size: 76.1 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 isPublic = ((corbaColInfoResponse&)_s).isPublic;
284 isBeta = ((corbaColInfoResponse&)_s).isBeta;
285 buildDate = ((corbaColInfoResponse&)_s).buildDate;
286 ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
287 languages = ((corbaColInfoResponse&)_s).languages;
288 numDocs = ((corbaColInfoResponse&)_s).numDocs;
289 numWords = ((corbaColInfoResponse&)_s).numWords;
290 numBytes = ((corbaColInfoResponse&)_s).numBytes;
291 collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
292 format = ((corbaColInfoResponse&)_s).format;
293 building = ((corbaColInfoResponse&)_s).building;
294 httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
295 httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
296 receptionist = ((corbaColInfoResponse&)_s).receptionist;
297}
298
299gsdlInterface::corbaColInfoResponse::~corbaColInfoResponse()
300{
301}
302
303gsdlInterface::corbaColInfoResponse&
304gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s )
305{
306 shoftInfo = ((corbaColInfoResponse&)_s).shoftInfo;
307 isPublic = ((corbaColInfoResponse&)_s).isPublic;
308 isBeta = ((corbaColInfoResponse&)_s).isBeta;
309 buildDate = ((corbaColInfoResponse&)_s).buildDate;
310 ccsCols = ((corbaColInfoResponse&)_s).ccsCols;
311 languages = ((corbaColInfoResponse&)_s).languages;
312 numDocs = ((corbaColInfoResponse&)_s).numDocs;
313 numWords = ((corbaColInfoResponse&)_s).numWords;
314 numBytes = ((corbaColInfoResponse&)_s).numBytes;
315 collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta;
316 format = ((corbaColInfoResponse&)_s).format;
317 building = ((corbaColInfoResponse&)_s).building;
318 httpdomain = ((corbaColInfoResponse&)_s).httpdomain;
319 httpprefix = ((corbaColInfoResponse&)_s).httpprefix;
320 receptionist = ((corbaColInfoResponse&)_s).receptionist;
321 return *this;
322}
323#endif
324
325class _Marshaller_gsdlInterface_corbaColInfoResponse : public CORBA::StaticTypeInfo {
326 typedef gsdlInterface::corbaColInfoResponse _MICO_T;
327 public:
328 StaticValueType create () const;
329 void assign (StaticValueType dst, const StaticValueType src) const;
330 void free (StaticValueType) const;
331 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
332 void marshal (CORBA::DataEncoder &, StaticValueType) const;
333};
334
335
336CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const
337{
338 return (StaticValueType) new _MICO_T;
339}
340
341void _Marshaller_gsdlInterface_corbaColInfoResponse::assign( StaticValueType d, const StaticValueType s ) const
342{
343 *(_MICO_T*) d = *(_MICO_T*) s;
344}
345
346void _Marshaller_gsdlInterface_corbaColInfoResponse::free( StaticValueType v ) const
347{
348 delete (_MICO_T*) v;
349}
350
351CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
352{
353 return
354 dc.struct_begin() &&
355 _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shoftInfo ) &&
356 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) &&
357 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isBeta ) &&
358 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->buildDate ) &&
359 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->ccsCols ) &&
360 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->languages ) &&
361 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
362 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) &&
363 CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) &&
364 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) &&
365 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) &&
366 _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) &&
367 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpdomain ) &&
368 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) &&
369 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) &&
370 dc.struct_end();
371}
372
373void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
374{
375 ec.struct_begin();
376 _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shoftInfo );
377 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic );
378 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isBeta );
379 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->buildDate );
380 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->ccsCols );
381 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->languages );
382 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numDocs );
383 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords );
384 CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes );
385 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->collectionMeta );
386 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format );
387 _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building );
388 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpdomain );
389 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix );
390 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist );
391 ec.struct_end();
392}
393
394CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;
395
396#ifdef HAVE_EXPLICIT_STRUCT_OPS
397gsdlInterface::corbaDocRequest::corbaDocRequest()
398{
399}
400
401gsdlInterface::corbaDocRequest::corbaDocRequest( const corbaDocRequest& _s )
402{
403 OID = ((corbaDocRequest&)_s).OID;
404 docType = ((corbaDocRequest&)_s).docType;
405 docFormat = ((corbaDocRequest&)_s).docFormat;
406}
407
408gsdlInterface::corbaDocRequest::~corbaDocRequest()
409{
410}
411
412gsdlInterface::corbaDocRequest&
413gsdlInterface::corbaDocRequest::operator=( const corbaDocRequest& _s )
414{
415 OID = ((corbaDocRequest&)_s).OID;
416 docType = ((corbaDocRequest&)_s).docType;
417 docFormat = ((corbaDocRequest&)_s).docFormat;
418 return *this;
419}
420#endif
421
422class _Marshaller_gsdlInterface_corbaDocRequest : public CORBA::StaticTypeInfo {
423 typedef gsdlInterface::corbaDocRequest _MICO_T;
424 public:
425 StaticValueType create () const;
426 void assign (StaticValueType dst, const StaticValueType src) const;
427 void free (StaticValueType) const;
428 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
429 void marshal (CORBA::DataEncoder &, StaticValueType) const;
430};
431
432
433CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const
434{
435 return (StaticValueType) new _MICO_T;
436}
437
438void _Marshaller_gsdlInterface_corbaDocRequest::assign( StaticValueType d, const StaticValueType s ) const
439{
440 *(_MICO_T*) d = *(_MICO_T*) s;
441}
442
443void _Marshaller_gsdlInterface_corbaDocRequest::free( StaticValueType v ) const
444{
445 delete (_MICO_T*) v;
446}
447
448CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
449{
450 return
451 dc.struct_begin() &&
452 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
453 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docType ) &&
454 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docFormat ) &&
455 dc.struct_end();
456}
457
458void _Marshaller_gsdlInterface_corbaDocRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
459{
460 ec.struct_begin();
461 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
462 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docType );
463 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docFormat );
464 ec.struct_end();
465}
466
467CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;
468
469#ifdef HAVE_EXPLICIT_STRUCT_OPS
470gsdlInterface::corbaDocResponse::corbaDocResponse()
471{
472}
473
474gsdlInterface::corbaDocResponse::corbaDocResponse( const corbaDocResponse& _s )
475{
476 doc = ((corbaDocResponse&)_s).doc;
477}
478
479gsdlInterface::corbaDocResponse::~corbaDocResponse()
480{
481}
482
483gsdlInterface::corbaDocResponse&
484gsdlInterface::corbaDocResponse::operator=( const corbaDocResponse& _s )
485{
486 doc = ((corbaDocResponse&)_s).doc;
487 return *this;
488}
489#endif
490
491class _Marshaller_gsdlInterface_corbaDocResponse : public CORBA::StaticTypeInfo {
492 typedef gsdlInterface::corbaDocResponse _MICO_T;
493 public:
494 StaticValueType create () const;
495 void assign (StaticValueType dst, const StaticValueType src) const;
496 void free (StaticValueType) const;
497 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
498 void marshal (CORBA::DataEncoder &, StaticValueType) const;
499};
500
501
502CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const
503{
504 return (StaticValueType) new _MICO_T;
505}
506
507void _Marshaller_gsdlInterface_corbaDocResponse::assign( StaticValueType d, const StaticValueType s ) const
508{
509 *(_MICO_T*) d = *(_MICO_T*) s;
510}
511
512void _Marshaller_gsdlInterface_corbaDocResponse::free( StaticValueType v ) const
513{
514 delete (_MICO_T*) v;
515}
516
517CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
518{
519 return
520 dc.struct_begin() &&
521 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->doc ) &&
522 dc.struct_end();
523}
524
525void _Marshaller_gsdlInterface_corbaDocResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
526{
527 ec.struct_begin();
528 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->doc );
529 ec.struct_end();
530}
531
532CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;
533
534
535class _Marshaller_gsdlInterface_corbaFilterType : public CORBA::StaticTypeInfo {
536 typedef gsdlInterface::corbaFilterType _MICO_T;
537 public:
538 StaticValueType create () const;
539 void assign (StaticValueType dst, const StaticValueType src) const;
540 void free (StaticValueType) const;
541 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
542 void marshal (CORBA::DataEncoder &, StaticValueType) const;
543};
544
545
546CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const
547{
548 return (StaticValueType) new _MICO_T;
549}
550
551void _Marshaller_gsdlInterface_corbaFilterType::assign( StaticValueType d, const StaticValueType s ) const
552{
553 *(_MICO_T*) d = *(_MICO_T*) s;
554}
555
556void _Marshaller_gsdlInterface_corbaFilterType::free( StaticValueType v ) const
557{
558 delete (_MICO_T*) v;
559}
560
561CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
562{
563 CORBA::ULong ul;
564 if( !dc.enumeration( ul ) )
565 return FALSE;
566 *(_MICO_T*) v = (_MICO_T) ul;
567 return TRUE;
568}
569
570void _Marshaller_gsdlInterface_corbaFilterType::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
571{
572 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
573}
574
575CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;
576
577
578class _Marshaller_gsdlInterface_corbaFilterRepeatable : public CORBA::StaticTypeInfo {
579 typedef gsdlInterface::corbaFilterRepeatable _MICO_T;
580 public:
581 StaticValueType create () const;
582 void assign (StaticValueType dst, const StaticValueType src) const;
583 void free (StaticValueType) const;
584 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
585 void marshal (CORBA::DataEncoder &, StaticValueType) const;
586};
587
588
589CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const
590{
591 return (StaticValueType) new _MICO_T;
592}
593
594void _Marshaller_gsdlInterface_corbaFilterRepeatable::assign( StaticValueType d, const StaticValueType s ) const
595{
596 *(_MICO_T*) d = *(_MICO_T*) s;
597}
598
599void _Marshaller_gsdlInterface_corbaFilterRepeatable::free( StaticValueType v ) const
600{
601 delete (_MICO_T*) v;
602}
603
604CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
605{
606 CORBA::ULong ul;
607 if( !dc.enumeration( ul ) )
608 return FALSE;
609 *(_MICO_T*) v = (_MICO_T) ul;
610 return TRUE;
611}
612
613void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
614{
615 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
616}
617
618CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;
619
620#ifdef HAVE_EXPLICIT_STRUCT_OPS
621gsdlInterface::corbaFilterOption::corbaFilterOption()
622{
623}
624
625gsdlInterface::corbaFilterOption::corbaFilterOption( const corbaFilterOption& _s )
626{
627 name = ((corbaFilterOption&)_s).name;
628 type = ((corbaFilterOption&)_s).type;
629 repeatable = ((corbaFilterOption&)_s).repeatable;
630 defaultValue = ((corbaFilterOption&)_s).defaultValue;
631 validValues = ((corbaFilterOption&)_s).validValues;
632}
633
634gsdlInterface::corbaFilterOption::~corbaFilterOption()
635{
636}
637
638gsdlInterface::corbaFilterOption&
639gsdlInterface::corbaFilterOption::operator=( const corbaFilterOption& _s )
640{
641 name = ((corbaFilterOption&)_s).name;
642 type = ((corbaFilterOption&)_s).type;
643 repeatable = ((corbaFilterOption&)_s).repeatable;
644 defaultValue = ((corbaFilterOption&)_s).defaultValue;
645 validValues = ((corbaFilterOption&)_s).validValues;
646 return *this;
647}
648#endif
649
650class _Marshaller_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
651 typedef gsdlInterface::corbaFilterOption _MICO_T;
652 public:
653 StaticValueType create () const;
654 void assign (StaticValueType dst, const StaticValueType src) const;
655 void free (StaticValueType) const;
656 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
657 void marshal (CORBA::DataEncoder &, StaticValueType) const;
658};
659
660
661CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const
662{
663 return (StaticValueType) new _MICO_T;
664}
665
666void _Marshaller_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
667{
668 *(_MICO_T*) d = *(_MICO_T*) s;
669}
670
671void _Marshaller_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
672{
673 delete (_MICO_T*) v;
674}
675
676CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
677{
678 return
679 dc.struct_begin() &&
680 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
681 _marshaller_gsdlInterface_corbaFilterType->demarshal( dc, &((_MICO_T*)v)->type ) &&
682 _marshaller_gsdlInterface_corbaFilterRepeatable->demarshal( dc, &((_MICO_T*)v)->repeatable ) &&
683 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->defaultValue ) &&
684 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->validValues ) &&
685 dc.struct_end();
686}
687
688void _Marshaller_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
689{
690 ec.struct_begin();
691 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
692 _marshaller_gsdlInterface_corbaFilterType->marshal( ec, &((_MICO_T*)v)->type );
693 _marshaller_gsdlInterface_corbaFilterRepeatable->marshal( ec, &((_MICO_T*)v)->repeatable );
694 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->defaultValue );
695 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->validValues );
696 ec.struct_end();
697}
698
699CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;
700
701
702#ifdef HAVE_EXPLICIT_STRUCT_OPS
703gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse()
704{
705}
706
707gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse( const corbaFilterOptionsResponse& _s )
708{
709 options = ((corbaFilterOptionsResponse&)_s).options;
710 names = ((corbaFilterOptionsResponse&)_s).names;
711}
712
713gsdlInterface::corbaFilterOptionsResponse::~corbaFilterOptionsResponse()
714{
715}
716
717gsdlInterface::corbaFilterOptionsResponse&
718gsdlInterface::corbaFilterOptionsResponse::operator=( const corbaFilterOptionsResponse& _s )
719{
720 options = ((corbaFilterOptionsResponse&)_s).options;
721 names = ((corbaFilterOptionsResponse&)_s).names;
722 return *this;
723}
724#endif
725
726class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public CORBA::StaticTypeInfo {
727 typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T;
728 public:
729 StaticValueType create () const;
730 void assign (StaticValueType dst, const StaticValueType src) const;
731 void free (StaticValueType) const;
732 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
733 void marshal (CORBA::DataEncoder &, StaticValueType) const;
734};
735
736
737CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const
738{
739 return (StaticValueType) new _MICO_T;
740}
741
742void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::assign( StaticValueType d, const StaticValueType s ) const
743{
744 *(_MICO_T*) d = *(_MICO_T*) s;
745}
746
747void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::free( StaticValueType v ) const
748{
749 delete (_MICO_T*) v;
750}
751
752CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
753{
754 return
755 dc.struct_begin() &&
756 _marshaller__seq_gsdlInterface_corbaFilterOption->demarshal( dc, &((_MICO_T*)v)->options ) &&
757 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
758 dc.struct_end();
759}
760
761void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
762{
763 ec.struct_begin();
764 _marshaller__seq_gsdlInterface_corbaFilterOption->marshal( ec, &((_MICO_T*)v)->options );
765 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
766 ec.struct_end();
767}
768
769CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;
770
771#ifdef HAVE_EXPLICIT_STRUCT_OPS
772gsdlInterface::corbaOptionValue::corbaOptionValue()
773{
774}
775
776gsdlInterface::corbaOptionValue::corbaOptionValue( const corbaOptionValue& _s )
777{
778 name = ((corbaOptionValue&)_s).name;
779 value = ((corbaOptionValue&)_s).value;
780}
781
782gsdlInterface::corbaOptionValue::~corbaOptionValue()
783{
784}
785
786gsdlInterface::corbaOptionValue&
787gsdlInterface::corbaOptionValue::operator=( const corbaOptionValue& _s )
788{
789 name = ((corbaOptionValue&)_s).name;
790 value = ((corbaOptionValue&)_s).value;
791 return *this;
792}
793#endif
794
795class _Marshaller_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
796 typedef gsdlInterface::corbaOptionValue _MICO_T;
797 public:
798 StaticValueType create () const;
799 void assign (StaticValueType dst, const StaticValueType src) const;
800 void free (StaticValueType) const;
801 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
802 void marshal (CORBA::DataEncoder &, StaticValueType) const;
803};
804
805
806CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const
807{
808 return (StaticValueType) new _MICO_T;
809}
810
811void _Marshaller_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
812{
813 *(_MICO_T*) d = *(_MICO_T*) s;
814}
815
816void _Marshaller_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
817{
818 delete (_MICO_T*) v;
819}
820
821CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
822{
823 return
824 dc.struct_begin() &&
825 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) &&
826 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->value ) &&
827 dc.struct_end();
828}
829
830void _Marshaller_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
831{
832 ec.struct_begin();
833 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name );
834 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->value );
835 ec.struct_end();
836}
837
838CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;
839
840
841#ifdef HAVE_EXPLICIT_STRUCT_OPS
842gsdlInterface::corbaFilterRequest::corbaFilterRequest()
843{
844}
845
846gsdlInterface::corbaFilterRequest::corbaFilterRequest( const corbaFilterRequest& _s )
847{
848 filter = ((corbaFilterRequest&)_s).filter;
849 filterOptions = ((corbaFilterRequest&)_s).filterOptions;
850 docSet = ((corbaFilterRequest&)_s).docSet;
851 filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
852 requestParams = ((corbaFilterRequest&)_s).requestParams;
853 refParams = ((corbaFilterRequest&)_s).refParams;
854 fields = ((corbaFilterRequest&)_s).fields;
855 getParents = ((corbaFilterRequest&)_s).getParents;
856}
857
858gsdlInterface::corbaFilterRequest::~corbaFilterRequest()
859{
860}
861
862gsdlInterface::corbaFilterRequest&
863gsdlInterface::corbaFilterRequest::operator=( const corbaFilterRequest& _s )
864{
865 filter = ((corbaFilterRequest&)_s).filter;
866 filterOptions = ((corbaFilterRequest&)_s).filterOptions;
867 docSet = ((corbaFilterRequest&)_s).docSet;
868 filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions;
869 requestParams = ((corbaFilterRequest&)_s).requestParams;
870 refParams = ((corbaFilterRequest&)_s).refParams;
871 fields = ((corbaFilterRequest&)_s).fields;
872 getParents = ((corbaFilterRequest&)_s).getParents;
873 return *this;
874}
875#endif
876
877class _Marshaller_gsdlInterface_corbaFilterRequest : public CORBA::StaticTypeInfo {
878 typedef gsdlInterface::corbaFilterRequest _MICO_T;
879 public:
880 StaticValueType create () const;
881 void assign (StaticValueType dst, const StaticValueType src) const;
882 void free (StaticValueType) const;
883 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
884 void marshal (CORBA::DataEncoder &, StaticValueType) const;
885};
886
887
888CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const
889{
890 return (StaticValueType) new _MICO_T;
891}
892
893void _Marshaller_gsdlInterface_corbaFilterRequest::assign( StaticValueType d, const StaticValueType s ) const
894{
895 *(_MICO_T*) d = *(_MICO_T*) s;
896}
897
898void _Marshaller_gsdlInterface_corbaFilterRequest::free( StaticValueType v ) const
899{
900 delete (_MICO_T*) v;
901}
902
903CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
904{
905 return
906 dc.struct_begin() &&
907 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->filter ) &&
908 _marshaller__seq_gsdlInterface_corbaOptionValue->demarshal( dc, &((_MICO_T*)v)->filterOptions ) &&
909 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docSet ) &&
910 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->filterResultOptions ) &&
911 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->requestParams ) &&
912 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->refParams ) &&
913 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->fields ) &&
914 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->getParents ) &&
915 dc.struct_end();
916}
917
918void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
919{
920 ec.struct_begin();
921 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->filter );
922 _marshaller__seq_gsdlInterface_corbaOptionValue->marshal( ec, &((_MICO_T*)v)->filterOptions );
923 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docSet );
924 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->filterResultOptions );
925 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->requestParams );
926 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->refParams );
927 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->fields );
928 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->getParents );
929 ec.struct_end();
930}
931
932CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;
933
934#ifdef HAVE_EXPLICIT_STRUCT_OPS
935gsdlInterface::corbaTermInfo::corbaTermInfo()
936{
937}
938
939gsdlInterface::corbaTermInfo::corbaTermInfo( const corbaTermInfo& _s )
940{
941 term = ((corbaTermInfo&)_s).term;
942 frequency = ((corbaTermInfo&)_s).frequency;
943 matchTerms = ((corbaTermInfo&)_s).matchTerms;
944}
945
946gsdlInterface::corbaTermInfo::~corbaTermInfo()
947{
948}
949
950gsdlInterface::corbaTermInfo&
951gsdlInterface::corbaTermInfo::operator=( const corbaTermInfo& _s )
952{
953 term = ((corbaTermInfo&)_s).term;
954 frequency = ((corbaTermInfo&)_s).frequency;
955 matchTerms = ((corbaTermInfo&)_s).matchTerms;
956 return *this;
957}
958#endif
959
960class _Marshaller_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
961 typedef gsdlInterface::corbaTermInfo _MICO_T;
962 public:
963 StaticValueType create () const;
964 void assign (StaticValueType dst, const StaticValueType src) const;
965 void free (StaticValueType) const;
966 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
967 void marshal (CORBA::DataEncoder &, StaticValueType) const;
968};
969
970
971CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const
972{
973 return (StaticValueType) new _MICO_T;
974}
975
976void _Marshaller_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
977{
978 *(_MICO_T*) d = *(_MICO_T*) s;
979}
980
981void _Marshaller_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
982{
983 delete (_MICO_T*) v;
984}
985
986CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
987{
988 return
989 dc.struct_begin() &&
990 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->term ) &&
991 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->frequency ) &&
992 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->matchTerms ) &&
993 dc.struct_end();
994}
995
996void _Marshaller_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
997{
998 ec.struct_begin();
999 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->term );
1000 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->frequency );
1001 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->matchTerms );
1002 ec.struct_end();
1003}
1004
1005CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;
1006
1007
1008#ifdef HAVE_EXPLICIT_STRUCT_OPS
1009gsdlInterface::corbaMetadataInfo::corbaMetadataInfo()
1010{
1011}
1012
1013gsdlInterface::corbaMetadataInfo::corbaMetadataInfo( const corbaMetadataInfo& _s )
1014{
1015 params = ((corbaMetadataInfo&)_s).params;
1016 isRef = ((corbaMetadataInfo&)_s).isRef;
1017 values = ((corbaMetadataInfo&)_s).values;
1018 id = ((corbaMetadataInfo&)_s).id;
1019 parentid = ((corbaMetadataInfo&)_s).parentid;
1020}
1021
1022gsdlInterface::corbaMetadataInfo::~corbaMetadataInfo()
1023{
1024}
1025
1026gsdlInterface::corbaMetadataInfo&
1027gsdlInterface::corbaMetadataInfo::operator=( const corbaMetadataInfo& _s )
1028{
1029 params = ((corbaMetadataInfo&)_s).params;
1030 isRef = ((corbaMetadataInfo&)_s).isRef;
1031 values = ((corbaMetadataInfo&)_s).values;
1032 id = ((corbaMetadataInfo&)_s).id;
1033 parentid = ((corbaMetadataInfo&)_s).parentid;
1034 return *this;
1035}
1036#endif
1037
1038class _Marshaller_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
1039 typedef gsdlInterface::corbaMetadataInfo _MICO_T;
1040 public:
1041 StaticValueType create () const;
1042 void assign (StaticValueType dst, const StaticValueType src) const;
1043 void free (StaticValueType) const;
1044 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1045 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1046};
1047
1048
1049CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const
1050{
1051 return (StaticValueType) new _MICO_T;
1052}
1053
1054void _Marshaller_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1055{
1056 *(_MICO_T*) d = *(_MICO_T*) s;
1057}
1058
1059void _Marshaller_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1060{
1061 delete (_MICO_T*) v;
1062}
1063
1064CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1065{
1066 return
1067 dc.struct_begin() &&
1068 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->params ) &&
1069 CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isRef ) &&
1070 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) &&
1071 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->id ) &&
1072 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->parentid ) &&
1073 dc.struct_end();
1074}
1075
1076void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1077{
1078 ec.struct_begin();
1079 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->params );
1080 CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isRef );
1081 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values );
1082 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->id );
1083 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->parentid );
1084 ec.struct_end();
1085}
1086
1087CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;
1088
1089
1090#ifdef HAVE_EXPLICIT_STRUCT_OPS
1091gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map()
1092{
1093}
1094
1095gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map( const corbaMetadataInfo_map& _s )
1096{
1097 names = ((corbaMetadataInfo_map&)_s).names;
1098 values = ((corbaMetadataInfo_map&)_s).values;
1099}
1100
1101gsdlInterface::corbaMetadataInfo_map::~corbaMetadataInfo_map()
1102{
1103}
1104
1105gsdlInterface::corbaMetadataInfo_map&
1106gsdlInterface::corbaMetadataInfo_map::operator=( const corbaMetadataInfo_map& _s )
1107{
1108 names = ((corbaMetadataInfo_map&)_s).names;
1109 values = ((corbaMetadataInfo_map&)_s).values;
1110 return *this;
1111}
1112#endif
1113
1114class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public CORBA::StaticTypeInfo {
1115 typedef gsdlInterface::corbaMetadataInfo_map _MICO_T;
1116 public:
1117 StaticValueType create () const;
1118 void assign (StaticValueType dst, const StaticValueType src) const;
1119 void free (StaticValueType) const;
1120 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1121 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1122};
1123
1124
1125CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const
1126{
1127 return (StaticValueType) new _MICO_T;
1128}
1129
1130void _Marshaller_gsdlInterface_corbaMetadataInfo_map::assign( StaticValueType d, const StaticValueType s ) const
1131{
1132 *(_MICO_T*) d = *(_MICO_T*) s;
1133}
1134
1135void _Marshaller_gsdlInterface_corbaMetadataInfo_map::free( StaticValueType v ) const
1136{
1137 delete (_MICO_T*) v;
1138}
1139
1140CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1141{
1142 return
1143 dc.struct_begin() &&
1144 _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) &&
1145 _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->values ) &&
1146 dc.struct_end();
1147}
1148
1149void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1150{
1151 ec.struct_begin();
1152 _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names );
1153 _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->values );
1154 ec.struct_end();
1155}
1156
1157CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;
1158
1159
1160#ifdef HAVE_EXPLICIT_STRUCT_OPS
1161gsdlInterface::corbaResultDocInfo::corbaResultDocInfo()
1162{
1163}
1164
1165gsdlInterface::corbaResultDocInfo::corbaResultDocInfo( const corbaResultDocInfo& _s )
1166{
1167 OID = ((corbaResultDocInfo&)_s).OID;
1168 resultNum = ((corbaResultDocInfo&)_s).resultNum;
1169 ranking = ((corbaResultDocInfo&)_s).ranking;
1170 termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1171 phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1172 docFreq = ((corbaResultDocInfo&)_s).docFreq;
1173 metadata = ((corbaResultDocInfo&)_s).metadata;
1174 classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1175 classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1176 metaparents = ((corbaResultDocInfo&)_s).metaparents;
1177}
1178
1179gsdlInterface::corbaResultDocInfo::~corbaResultDocInfo()
1180{
1181}
1182
1183gsdlInterface::corbaResultDocInfo&
1184gsdlInterface::corbaResultDocInfo::operator=( const corbaResultDocInfo& _s )
1185{
1186 OID = ((corbaResultDocInfo&)_s).OID;
1187 resultNum = ((corbaResultDocInfo&)_s).resultNum;
1188 ranking = ((corbaResultDocInfo&)_s).ranking;
1189 termsMatched = ((corbaResultDocInfo&)_s).termsMatched;
1190 phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched;
1191 docFreq = ((corbaResultDocInfo&)_s).docFreq;
1192 metadata = ((corbaResultDocInfo&)_s).metadata;
1193 classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType;
1194 classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset;
1195 metaparents = ((corbaResultDocInfo&)_s).metaparents;
1196 return *this;
1197}
1198#endif
1199
1200class _Marshaller_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
1201 typedef gsdlInterface::corbaResultDocInfo _MICO_T;
1202 public:
1203 StaticValueType create () const;
1204 void assign (StaticValueType dst, const StaticValueType src) const;
1205 void free (StaticValueType) const;
1206 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1207 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1208};
1209
1210
1211CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const
1212{
1213 return (StaticValueType) new _MICO_T;
1214}
1215
1216void _Marshaller_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1217{
1218 *(_MICO_T*) d = *(_MICO_T*) s;
1219}
1220
1221void _Marshaller_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1222{
1223 delete (_MICO_T*) v;
1224}
1225
1226CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1227{
1228 return
1229 dc.struct_begin() &&
1230 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) &&
1231 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->resultNum ) &&
1232 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->ranking ) &&
1233 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->termsMatched ) &&
1234 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->phraseMatched ) &&
1235 CORBA::_stcseq_long->demarshal( dc, &((_MICO_T*)v)->docFreq ) &&
1236 _marshaller_gsdlInterface_corbaMetadataInfo_map->demarshal( dc, &((_MICO_T*)v)->metadata ) &&
1237 _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->classifierMetadataType ) &&
1238 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->classifierMetadataOffset ) &&
1239 _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->metaparents ) &&
1240 dc.struct_end();
1241}
1242
1243void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1244{
1245 ec.struct_begin();
1246 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID );
1247 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->resultNum );
1248 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->ranking );
1249 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->termsMatched );
1250 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->phraseMatched );
1251 CORBA::_stcseq_long->marshal( ec, &((_MICO_T*)v)->docFreq );
1252 _marshaller_gsdlInterface_corbaMetadataInfo_map->marshal( ec, &((_MICO_T*)v)->metadata );
1253 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->classifierMetadataType );
1254 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->classifierMetadataOffset );
1255 _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->metaparents );
1256 ec.struct_end();
1257}
1258
1259CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;
1260
1261
1262
1263class _Marshaller_gsdlInterface_corbaIsApprox : public CORBA::StaticTypeInfo {
1264 typedef gsdlInterface::corbaIsApprox _MICO_T;
1265 public:
1266 StaticValueType create () const;
1267 void assign (StaticValueType dst, const StaticValueType src) const;
1268 void free (StaticValueType) const;
1269 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1270 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1271};
1272
1273
1274CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const
1275{
1276 return (StaticValueType) new _MICO_T;
1277}
1278
1279void _Marshaller_gsdlInterface_corbaIsApprox::assign( StaticValueType d, const StaticValueType s ) const
1280{
1281 *(_MICO_T*) d = *(_MICO_T*) s;
1282}
1283
1284void _Marshaller_gsdlInterface_corbaIsApprox::free( StaticValueType v ) const
1285{
1286 delete (_MICO_T*) v;
1287}
1288
1289CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1290{
1291 CORBA::ULong ul;
1292 if( !dc.enumeration( ul ) )
1293 return FALSE;
1294 *(_MICO_T*) v = (_MICO_T) ul;
1295 return TRUE;
1296}
1297
1298void _Marshaller_gsdlInterface_corbaIsApprox::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1299{
1300 ec.enumeration( (CORBA::ULong) *(_MICO_T *) v );
1301}
1302
1303CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;
1304
1305#ifdef HAVE_EXPLICIT_STRUCT_OPS
1306gsdlInterface::corbaFilterResponse::corbaFilterResponse()
1307{
1308}
1309
1310gsdlInterface::corbaFilterResponse::corbaFilterResponse( const corbaFilterResponse& _s )
1311{
1312 numDocs = ((corbaFilterResponse&)_s).numDocs;
1313 isApprox = ((corbaFilterResponse&)_s).isApprox;
1314 termInfo = ((corbaFilterResponse&)_s).termInfo;
1315 docInfo = ((corbaFilterResponse&)_s).docInfo;
1316}
1317
1318gsdlInterface::corbaFilterResponse::~corbaFilterResponse()
1319{
1320}
1321
1322gsdlInterface::corbaFilterResponse&
1323gsdlInterface::corbaFilterResponse::operator=( const corbaFilterResponse& _s )
1324{
1325 numDocs = ((corbaFilterResponse&)_s).numDocs;
1326 isApprox = ((corbaFilterResponse&)_s).isApprox;
1327 termInfo = ((corbaFilterResponse&)_s).termInfo;
1328 docInfo = ((corbaFilterResponse&)_s).docInfo;
1329 return *this;
1330}
1331#endif
1332
1333class _Marshaller_gsdlInterface_corbaFilterResponse : public CORBA::StaticTypeInfo {
1334 typedef gsdlInterface::corbaFilterResponse _MICO_T;
1335 public:
1336 StaticValueType create () const;
1337 void assign (StaticValueType dst, const StaticValueType src) const;
1338 void free (StaticValueType) const;
1339 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1340 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1341};
1342
1343
1344CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const
1345{
1346 return (StaticValueType) new _MICO_T;
1347}
1348
1349void _Marshaller_gsdlInterface_corbaFilterResponse::assign( StaticValueType d, const StaticValueType s ) const
1350{
1351 *(_MICO_T*) d = *(_MICO_T*) s;
1352}
1353
1354void _Marshaller_gsdlInterface_corbaFilterResponse::free( StaticValueType v ) const
1355{
1356 delete (_MICO_T*) v;
1357}
1358
1359CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1360{
1361 return
1362 dc.struct_begin() &&
1363 CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->numDocs ) &&
1364 _marshaller_gsdlInterface_corbaIsApprox->demarshal( dc, &((_MICO_T*)v)->isApprox ) &&
1365 _marshaller__seq_gsdlInterface_corbaTermInfo->demarshal( dc, &((_MICO_T*)v)->termInfo ) &&
1366 _marshaller__seq_gsdlInterface_corbaResultDocInfo->demarshal( dc, &((_MICO_T*)v)->docInfo ) &&
1367 dc.struct_end();
1368}
1369
1370void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1371{
1372 ec.struct_begin();
1373 CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->numDocs );
1374 _marshaller_gsdlInterface_corbaIsApprox->marshal( ec, &((_MICO_T*)v)->isApprox );
1375 _marshaller__seq_gsdlInterface_corbaTermInfo->marshal( ec, &((_MICO_T*)v)->termInfo );
1376 _marshaller__seq_gsdlInterface_corbaResultDocInfo->marshal( ec, &((_MICO_T*)v)->docInfo );
1377 ec.struct_end();
1378}
1379
1380CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;
1381
1382
1383// Stub interface corbaiface
1384gsdlInterface::corbaiface::~corbaiface()
1385{
1386}
1387
1388void *gsdlInterface::corbaiface::_narrow_helper( const char *_repoid )
1389{
1390 if( strcmp( _repoid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 )
1391 return (void *)this;
1392 return NULL;
1393}
1394
1395bool gsdlInterface::corbaiface::_narrow_helper2( CORBA::Object_ptr _obj )
1396{
1397 if( strcmp( _obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0" ) == 0) {
1398 return true;
1399 }
1400 for( vector<CORBA::Narrow_proto>::size_type _i = 0;
1401 _narrow_helpers && _i < _narrow_helpers->size(); _i++ ) {
1402 bool _res = (*(*_narrow_helpers)[ _i ])( _obj );
1403 if( _res )
1404 return true;
1405 }
1406 return false;
1407}
1408
1409gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj )
1410{
1411 gsdlInterface::corbaiface_ptr _o;
1412 if( !CORBA::is_nil( _obj ) ) {
1413 void *_p;
1414 if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" )))
1415 return _duplicate( (gsdlInterface::corbaiface_ptr) _p );
1416 if( _narrow_helper2( _obj ) ||
1417 ( !strlen (_obj->_repoid()) && _obj->_is_a_remote( "IDL:gsdlInterface/corbaiface:1.0" ) ) ) {
1418 _o = new gsdlInterface::corbaiface_stub;
1419 _o->MICO_SCOPE(CORBA,Object::operator=)( *_obj );
1420 return _o;
1421 }
1422 }
1423 return _nil();
1424}
1425
1426gsdlInterface::corbaiface_ptr
1427gsdlInterface::corbaiface::_narrow( CORBA::AbstractBase_ptr _obj )
1428{
1429 return _narrow (_obj->_to_object());
1430}
1431
1432gsdlInterface::corbaiface_stub::~corbaiface_stub()
1433{
1434}
1435
1436CORBA::Boolean gsdlInterface::corbaiface_stub::initialise()
1437{
1438 CORBA::Boolean _res;
1439 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1440
1441 CORBA::StaticRequest __req( this, "initialise" );
1442 __req.set_result( &__res );
1443
1444 __req.invoke();
1445
1446 mico_sii_throw( &__req,
1447 0);
1448 return _res;
1449}
1450
1451
1452void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline )
1453{
1454 CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
1455 CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
1456 CORBA::StaticRequest __req( this, "configure" );
1457 __req.add_in_arg( &_key );
1458 __req.add_in_arg( &_cfgline );
1459
1460 __req.invoke();
1461
1462 mico_sii_throw( &__req,
1463 0);
1464}
1465
1466
1467void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist )
1468{
1469 CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
1470 CORBA::StaticRequest __req( this, "collectionList" );
1471 __req.add_inout_arg( &_collist );
1472
1473 __req.invoke();
1474
1475 mico_sii_throw( &__req,
1476 0);
1477}
1478
1479
1480void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
1481{
1482 CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
1483 CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
1484 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1485 CORBA::StaticRequest __req( this, "hasCollection" );
1486 __req.add_in_arg( &_corbaCollection );
1487 __req.add_inout_arg( &_has );
1488 __req.add_inout_arg( &_error );
1489
1490 __req.invoke();
1491
1492 mico_sii_throw( &__req,
1493 0);
1494}
1495
1496
1497CORBA::Boolean gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error )
1498{
1499 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1500 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1501 CORBA::Boolean _res;
1502 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1503
1504 CORBA::StaticRequest __req( this, "ping" );
1505 __req.add_in_arg( &_collection );
1506 __req.add_inout_arg( &_error );
1507 __req.set_result( &__res );
1508
1509 __req.invoke();
1510
1511 mico_sii_throw( &__req,
1512 0);
1513 return _res;
1514}
1515
1516
1517void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
1518{
1519 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1520 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
1521 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
1522 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1523 CORBA::StaticRequest __req( this, "getDocument" );
1524 __req.add_in_arg( &_collection );
1525 __req.add_inout_arg( &_request );
1526 __req.add_inout_arg( &_response );
1527 __req.add_inout_arg( &_error );
1528
1529 __req.invoke();
1530
1531 mico_sii_throw( &__req,
1532 0);
1533}
1534
1535
1536void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
1537{
1538 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1539 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
1540 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1541 CORBA::StaticRequest __req( this, "getCollectInfo" );
1542 __req.add_in_arg( &_collection );
1543 __req.add_inout_arg( &_response );
1544 __req.add_inout_arg( &_error );
1545
1546 __req.invoke();
1547
1548 mico_sii_throw( &__req,
1549 0);
1550}
1551
1552
1553void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
1554{
1555 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1556 CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
1557 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1558 CORBA::StaticRequest __req( this, "getFilterInfo" );
1559 __req.add_in_arg( &_collection );
1560 __req.add_inout_arg( &_filterNames );
1561 __req.add_inout_arg( &_error );
1562
1563 __req.invoke();
1564
1565 mico_sii_throw( &__req,
1566 0);
1567}
1568
1569
1570void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
1571{
1572 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1573 CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
1574 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
1575 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1576 CORBA::StaticRequest __req( this, "getFilterOptions" );
1577 __req.add_in_arg( &_collection );
1578 __req.add_in_arg( &_option );
1579 __req.add_inout_arg( &_response );
1580 __req.add_inout_arg( &_error );
1581
1582 __req.invoke();
1583
1584 mico_sii_throw( &__req,
1585 0);
1586}
1587
1588
1589void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
1590{
1591 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1592 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
1593 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
1594 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1595 CORBA::StaticRequest __req( this, "filter" );
1596 __req.add_in_arg( &_collection );
1597 __req.add_in_arg( &_request );
1598 __req.add_inout_arg( &_response );
1599 __req.add_inout_arg( &_error );
1600
1601 __req.invoke();
1602
1603 mico_sii_throw( &__req,
1604 0);
1605}
1606
1607
1608#ifdef HAVE_NAMESPACE
1609namespace gsdlInterface { vector<CORBA::Narrow_proto> * corbaiface::_narrow_helpers; };
1610#else
1611vector<CORBA::Narrow_proto> * gsdlInterface::corbaiface::_narrow_helpers;
1612#endif
1613
1614class _Marshaller_gsdlInterface_corbaiface : public CORBA::StaticTypeInfo {
1615 typedef gsdlInterface::corbaiface_ptr _MICO_T;
1616 public:
1617 StaticValueType create () const;
1618 void assign (StaticValueType dst, const StaticValueType src) const;
1619 void free (StaticValueType) const;
1620 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1621 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1622};
1623
1624
1625CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
1626{
1627 return (StaticValueType) new _MICO_T( 0 );
1628}
1629
1630void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
1631{
1632 *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s );
1633}
1634
1635void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
1636{
1637 CORBA::release( *(_MICO_T *) v );
1638 delete (_MICO_T*) v;
1639}
1640
1641CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1642{
1643 CORBA::Object_ptr obj;
1644 if (!CORBA::_stc_Object->demarshal(dc, &obj))
1645 return FALSE;
1646 *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj );
1647 CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v);
1648 CORBA::release (obj);
1649 return ret;
1650}
1651
1652void _Marshaller_gsdlInterface_corbaiface::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1653{
1654 CORBA::Object_ptr obj = *(_MICO_T *) v;
1655 CORBA::_stc_Object->marshal( ec, &obj );
1656}
1657
1658CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
1659
1660class _Marshaller__seq_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
1661 typedef SequenceTmpl<gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
1662 public:
1663 StaticValueType create () const;
1664 void assign (StaticValueType dst, const StaticValueType src) const;
1665 void free (StaticValueType) const;
1666 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1667 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1668};
1669
1670
1671CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
1672{
1673 return (StaticValueType) new _MICO_T;
1674}
1675
1676void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
1677{
1678 *(_MICO_T*) d = *(_MICO_T*) s;
1679}
1680
1681void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
1682{
1683 delete (_MICO_T*) v;
1684}
1685
1686CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1687{
1688 CORBA::ULong len;
1689 if( !dc.seq_begin( len ) )
1690 return FALSE;
1691 ((_MICO_T *) v)->length( len );
1692 for( CORBA::ULong i = 0; i < len; i++ ) {
1693 if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1694 return FALSE;
1695 }
1696 return dc.seq_end();
1697}
1698
1699void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1700{
1701 CORBA::ULong len = ((_MICO_T *) v)->length();
1702 ec.seq_begin( len );
1703 for( CORBA::ULong i = 0; i < len; i++ )
1704 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] );
1705 ec.seq_end();
1706}
1707
1708CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
1709
1710class _Marshaller__seq_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
1711 typedef SequenceTmpl<gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
1712 public:
1713 StaticValueType create () const;
1714 void assign (StaticValueType dst, const StaticValueType src) const;
1715 void free (StaticValueType) const;
1716 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1717 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1718};
1719
1720
1721CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
1722{
1723 return (StaticValueType) new _MICO_T;
1724}
1725
1726void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
1727{
1728 *(_MICO_T*) d = *(_MICO_T*) s;
1729}
1730
1731void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
1732{
1733 delete (_MICO_T*) v;
1734}
1735
1736CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1737{
1738 CORBA::ULong len;
1739 if( !dc.seq_begin( len ) )
1740 return FALSE;
1741 ((_MICO_T *) v)->length( len );
1742 for( CORBA::ULong i = 0; i < len; i++ ) {
1743 if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1744 return FALSE;
1745 }
1746 return dc.seq_end();
1747}
1748
1749void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1750{
1751 CORBA::ULong len = ((_MICO_T *) v)->length();
1752 ec.seq_begin( len );
1753 for( CORBA::ULong i = 0; i < len; i++ )
1754 _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] );
1755 ec.seq_end();
1756}
1757
1758CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
1759
1760class _Marshaller__seq_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
1761 typedef SequenceTmpl<gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
1762 public:
1763 StaticValueType create () const;
1764 void assign (StaticValueType dst, const StaticValueType src) const;
1765 void free (StaticValueType) const;
1766 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1767 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1768};
1769
1770
1771CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
1772{
1773 return (StaticValueType) new _MICO_T;
1774}
1775
1776void _Marshaller__seq_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
1777{
1778 *(_MICO_T*) d = *(_MICO_T*) s;
1779}
1780
1781void _Marshaller__seq_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
1782{
1783 delete (_MICO_T*) v;
1784}
1785
1786CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1787{
1788 CORBA::ULong len;
1789 if( !dc.seq_begin( len ) )
1790 return FALSE;
1791 ((_MICO_T *) v)->length( len );
1792 for( CORBA::ULong i = 0; i < len; i++ ) {
1793 if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1794 return FALSE;
1795 }
1796 return dc.seq_end();
1797}
1798
1799void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1800{
1801 CORBA::ULong len = ((_MICO_T *) v)->length();
1802 ec.seq_begin( len );
1803 for( CORBA::ULong i = 0; i < len; i++ )
1804 _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] );
1805 ec.seq_end();
1806}
1807
1808CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
1809
1810class _Marshaller__seq_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
1811 typedef SequenceTmpl<gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
1812 public:
1813 StaticValueType create () const;
1814 void assign (StaticValueType dst, const StaticValueType src) const;
1815 void free (StaticValueType) const;
1816 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1817 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1818};
1819
1820
1821CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
1822{
1823 return (StaticValueType) new _MICO_T;
1824}
1825
1826void _Marshaller__seq_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
1827{
1828 *(_MICO_T*) d = *(_MICO_T*) s;
1829}
1830
1831void _Marshaller__seq_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
1832{
1833 delete (_MICO_T*) v;
1834}
1835
1836CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1837{
1838 CORBA::ULong len;
1839 if( !dc.seq_begin( len ) )
1840 return FALSE;
1841 ((_MICO_T *) v)->length( len );
1842 for( CORBA::ULong i = 0; i < len; i++ ) {
1843 if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1844 return FALSE;
1845 }
1846 return dc.seq_end();
1847}
1848
1849void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1850{
1851 CORBA::ULong len = ((_MICO_T *) v)->length();
1852 ec.seq_begin( len );
1853 for( CORBA::ULong i = 0; i < len; i++ )
1854 _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1855 ec.seq_end();
1856}
1857
1858CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
1859
1860class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
1861 typedef SequenceTmpl<gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
1862 public:
1863 StaticValueType create () const;
1864 void assign (StaticValueType dst, const StaticValueType src) const;
1865 void free (StaticValueType) const;
1866 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1867 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1868};
1869
1870
1871CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
1872{
1873 return (StaticValueType) new _MICO_T;
1874}
1875
1876void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1877{
1878 *(_MICO_T*) d = *(_MICO_T*) s;
1879}
1880
1881void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1882{
1883 delete (_MICO_T*) v;
1884}
1885
1886CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1887{
1888 CORBA::ULong len;
1889 if( !dc.seq_begin( len ) )
1890 return FALSE;
1891 ((_MICO_T *) v)->length( len );
1892 for( CORBA::ULong i = 0; i < len; i++ ) {
1893 if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1894 return FALSE;
1895 }
1896 return dc.seq_end();
1897}
1898
1899void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1900{
1901 CORBA::ULong len = ((_MICO_T *) v)->length();
1902 ec.seq_begin( len );
1903 for( CORBA::ULong i = 0; i < len; i++ )
1904 _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1905 ec.seq_end();
1906}
1907
1908CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
1909
1910class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
1911 typedef SequenceTmpl<gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
1912 public:
1913 StaticValueType create () const;
1914 void assign (StaticValueType dst, const StaticValueType src) const;
1915 void free (StaticValueType) const;
1916 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1917 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1918};
1919
1920
1921CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
1922{
1923 return (StaticValueType) new _MICO_T;
1924}
1925
1926void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1927{
1928 *(_MICO_T*) d = *(_MICO_T*) s;
1929}
1930
1931void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1932{
1933 delete (_MICO_T*) v;
1934}
1935
1936CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1937{
1938 CORBA::ULong len;
1939 if( !dc.seq_begin( len ) )
1940 return FALSE;
1941 ((_MICO_T *) v)->length( len );
1942 for( CORBA::ULong i = 0; i < len; i++ ) {
1943 if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1944 return FALSE;
1945 }
1946 return dc.seq_end();
1947}
1948
1949void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1950{
1951 CORBA::ULong len = ((_MICO_T *) v)->length();
1952 ec.seq_begin( len );
1953 for( CORBA::ULong i = 0; i < len; i++ )
1954 _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1955 ec.seq_end();
1956}
1957
1958CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
1959
1960struct __tc_init_CORBAIFACE {
1961 __tc_init_CORBAIFACE()
1962 {
1963 _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t;
1964 _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap;
1965 _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError;
1966 _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo;
1967 _marshaller_gsdlInterface_corbaColInfoResponse = new _Marshaller_gsdlInterface_corbaColInfoResponse;
1968 _marshaller_gsdlInterface_corbaDocRequest = new _Marshaller_gsdlInterface_corbaDocRequest;
1969 _marshaller_gsdlInterface_corbaDocResponse = new _Marshaller_gsdlInterface_corbaDocResponse;
1970 _marshaller_gsdlInterface_corbaFilterType = new _Marshaller_gsdlInterface_corbaFilterType;
1971 _marshaller_gsdlInterface_corbaFilterRepeatable = new _Marshaller_gsdlInterface_corbaFilterRepeatable;
1972 _marshaller_gsdlInterface_corbaFilterOption = new _Marshaller_gsdlInterface_corbaFilterOption;
1973 _marshaller_gsdlInterface_corbaFilterOptionsResponse = new _Marshaller_gsdlInterface_corbaFilterOptionsResponse;
1974 _marshaller_gsdlInterface_corbaOptionValue = new _Marshaller_gsdlInterface_corbaOptionValue;
1975 _marshaller_gsdlInterface_corbaFilterRequest = new _Marshaller_gsdlInterface_corbaFilterRequest;
1976 _marshaller_gsdlInterface_corbaTermInfo = new _Marshaller_gsdlInterface_corbaTermInfo;
1977 _marshaller_gsdlInterface_corbaMetadataInfo = new _Marshaller_gsdlInterface_corbaMetadataInfo;
1978 _marshaller_gsdlInterface_corbaMetadataInfo_map = new _Marshaller_gsdlInterface_corbaMetadataInfo_map;
1979 _marshaller_gsdlInterface_corbaResultDocInfo = new _Marshaller_gsdlInterface_corbaResultDocInfo;
1980 _marshaller_gsdlInterface_corbaIsApprox = new _Marshaller_gsdlInterface_corbaIsApprox;
1981 _marshaller_gsdlInterface_corbaFilterResponse = new _Marshaller_gsdlInterface_corbaFilterResponse;
1982 _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface;
1983 _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t;
1984 _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption;
1985 _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue;
1986 _marshaller__seq_gsdlInterface_corbaTermInfo = new _Marshaller__seq_gsdlInterface_corbaTermInfo;
1987 _marshaller__seq_gsdlInterface_corbaMetadataInfo = new _Marshaller__seq_gsdlInterface_corbaMetadataInfo;
1988 _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo;
1989 }
1990};
1991
1992static __tc_init_CORBAIFACE __init_CORBAIFACE;
1993
1994//--------------------------------------------------------
1995// Implementation of skeletons
1996//--------------------------------------------------------
1997
1998gsdlInterface::corbaiface_skel::corbaiface_skel( const CORBA::BOA::ReferenceData &_id )
1999{
2000 CORBA::ImplementationDef_var _impl =
2001 _find_impl( "IDL:gsdlInterface/corbaiface:1.0", "corbaiface" );
2002 assert( !CORBA::is_nil( _impl ) );
2003 _create_ref( _id,
2004 CORBA::InterfaceDef::_nil(),
2005 _impl,
2006 "IDL:gsdlInterface/corbaiface:1.0" );
2007 register_dispatcher( new StaticInterfaceDispatcherWrapper<corbaiface_skel>( this ) );
2008}
2009
2010gsdlInterface::corbaiface_skel::corbaiface_skel( CORBA::Object_ptr _obj )
2011{
2012 CORBA::ImplementationDef_var _impl =
2013 _find_impl( "IDL:gsdlInterface/corbaiface:1.0", "corbaiface" );
2014 assert( !CORBA::is_nil( _impl ) );
2015 _restore_ref( _obj,
2016 CORBA::BOA::ReferenceData(),
2017 CORBA::InterfaceDef::_nil(),
2018 _impl );
2019 register_dispatcher( new StaticInterfaceDispatcherWrapper<corbaiface_skel>( this ) );
2020}
2021
2022gsdlInterface::corbaiface_skel::~corbaiface_skel()
2023{
2024}
2025
2026bool gsdlInterface::corbaiface_skel::dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment & /*_env*/ )
2027{
2028 #ifdef HAVE_EXCEPTIONS
2029 try {
2030 #endif
2031 extern CORBA::ULong mico_string_hash (const char *, CORBA::ULong);
2032 switch (mico_string_hash (_req->op_name(), 17)) {
2033 case 0:
2034 if( strcmp( _req->op_name(), "collectionList" ) == 0 ) {
2035 corbatext_tarray collist;
2036 CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
2037
2038 _req->add_inout_arg( &_collist );
2039
2040 if( !_req->read_args() )
2041 return true;
2042
2043 collectionList( collist );
2044 _req->write_results();
2045 return true;
2046 }
2047 break;
2048 case 3:
2049 if( strcmp( _req->op_name(), "ping" ) == 0 ) {
2050 corbatext_t collection;
2051 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2052 corbaComError error;
2053 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2054
2055 CORBA::Boolean _res;
2056 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
2057 _req->add_in_arg( &_collection );
2058 _req->add_inout_arg( &_error );
2059 _req->set_result( &__res );
2060
2061 if( !_req->read_args() )
2062 return true;
2063
2064 _res = ping( collection, error );
2065 _req->write_results();
2066 return true;
2067 }
2068 break;
2069 case 7:
2070 if( strcmp( _req->op_name(), "filter" ) == 0 ) {
2071 corbatext_t collection;
2072 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2073 corbaFilterRequest request;
2074 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
2075 corbaFilterResponse response;
2076 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
2077 corbaComError error;
2078 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2079
2080 _req->add_in_arg( &_collection );
2081 _req->add_in_arg( &_request );
2082 _req->add_inout_arg( &_response );
2083 _req->add_inout_arg( &_error );
2084
2085 if( !_req->read_args() )
2086 return true;
2087
2088 filter( collection, request, response, error );
2089 _req->write_results();
2090 return true;
2091 }
2092 break;
2093 case 9:
2094 if( strcmp( _req->op_name(), "getFilterOptions" ) == 0 ) {
2095 corbatext_t collection;
2096 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2097 corbatext_t option;
2098 CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
2099 corbaFilterOptionsResponse response;
2100 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
2101 corbaComError error;
2102 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2103
2104 _req->add_in_arg( &_collection );
2105 _req->add_in_arg( &_option );
2106 _req->add_inout_arg( &_response );
2107 _req->add_inout_arg( &_error );
2108
2109 if( !_req->read_args() )
2110 return true;
2111
2112 getFilterOptions( collection, option, response, error );
2113 _req->write_results();
2114 return true;
2115 }
2116 break;
2117 case 10:
2118 if( strcmp( _req->op_name(), "getCollectInfo" ) == 0 ) {
2119 corbatext_t collection;
2120 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2121 corbaColInfoResponse response;
2122 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
2123 corbaComError error;
2124 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2125
2126 _req->add_in_arg( &_collection );
2127 _req->add_inout_arg( &_response );
2128 _req->add_inout_arg( &_error );
2129
2130 if( !_req->read_args() )
2131 return true;
2132
2133 getCollectInfo( collection, response, error );
2134 _req->write_results();
2135 return true;
2136 }
2137 break;
2138 case 11:
2139 if( strcmp( _req->op_name(), "initialise" ) == 0 ) {
2140 CORBA::Boolean _res;
2141 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
2142 _req->set_result( &__res );
2143
2144 if( !_req->read_args() )
2145 return true;
2146
2147 _res = initialise();
2148 _req->write_results();
2149 return true;
2150 }
2151 if( strcmp( _req->op_name(), "getFilterInfo" ) == 0 ) {
2152 corbatext_t collection;
2153 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2154 corbatext_tarray filterNames;
2155 CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
2156 corbaComError error;
2157 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2158
2159 _req->add_in_arg( &_collection );
2160 _req->add_inout_arg( &_filterNames );
2161 _req->add_inout_arg( &_error );
2162
2163 if( !_req->read_args() )
2164 return true;
2165
2166 getFilterInfo( collection, filterNames, error );
2167 _req->write_results();
2168 return true;
2169 }
2170 break;
2171 case 12:
2172 if( strcmp( _req->op_name(), "hasCollection" ) == 0 ) {
2173 corbatext_t corbaCollection;
2174 CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
2175 CORBA::Boolean has;
2176 CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
2177 corbaComError error;
2178 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2179
2180 _req->add_in_arg( &_corbaCollection );
2181 _req->add_inout_arg( &_has );
2182 _req->add_inout_arg( &_error );
2183
2184 if( !_req->read_args() )
2185 return true;
2186
2187 hasCollection( corbaCollection, has, error );
2188 _req->write_results();
2189 return true;
2190 }
2191 break;
2192 case 13:
2193 if( strcmp( _req->op_name(), "configure" ) == 0 ) {
2194 corbatext_t key;
2195 CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
2196 corbatext_tarray cfgline;
2197 CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
2198
2199 _req->add_in_arg( &_key );
2200 _req->add_in_arg( &_cfgline );
2201
2202 if( !_req->read_args() )
2203 return true;
2204
2205 configure( key, cfgline );
2206 _req->write_results();
2207 return true;
2208 }
2209 if( strcmp( _req->op_name(), "getDocument" ) == 0 ) {
2210 corbatext_t collection;
2211 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
2212 corbaDocRequest request;
2213 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
2214 corbaDocResponse response;
2215 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
2216 corbaComError error;
2217 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
2218
2219 _req->add_in_arg( &_collection );
2220 _req->add_inout_arg( &_request );
2221 _req->add_inout_arg( &_response );
2222 _req->add_inout_arg( &_error );
2223
2224 if( !_req->read_args() )
2225 return true;
2226
2227 getDocument( collection, request, response, error );
2228 _req->write_results();
2229 return true;
2230 }
2231 break;
2232 }
2233 #ifdef HAVE_EXCEPTIONS
2234 } catch( CORBA::SystemException_catch &_ex ) {
2235 _req->set_exception( _ex->_clone() );
2236 _req->write_results();
2237 return true;
2238 } catch( ... ) {
2239 assert( 0 );
2240 return true;
2241 }
2242 #endif
2243 return false;
2244}
2245
2246gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface_skel::_this()
2247{
2248 return gsdlInterface::corbaiface::_duplicate( this );
2249}
2250
Note: See TracBrowser for help on using the repository browser.