source: trunk/gsdl/lib/corbaiface.mpp@ 2173

Last change on this file since 2173 was 2126, checked in by say1, 23 years ago

corba updates
  • Property svn:keywords set to Author Date Id Revision
File size: 68.0 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 *_rid )
1389{
1390 if( strcmp( _rid, "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 ( _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( gsdlInterface::corbaComError& error )
1437{
1438 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1439 CORBA::Boolean _res;
1440 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1441
1442 CORBA::StaticRequest __req( this, "initialise" );
1443 __req.add_inout_arg( &_error );
1444 __req.set_result( &__res );
1445
1446 __req.invoke();
1447
1448 mico_sii_throw( &__req,
1449 0);
1450 return _res;
1451}
1452
1453
1454void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& key, const gsdlInterface::corbatext_tarray& cfgline, gsdlInterface::corbaComError& error )
1455{
1456 CORBA::StaticAny _key( _marshaller_gsdlInterface_corbatext_t, &key );
1457 CORBA::StaticAny _cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &cfgline );
1458 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1459 CORBA::StaticRequest __req( this, "configure" );
1460 __req.add_in_arg( &_key );
1461 __req.add_in_arg( &_cfgline );
1462 __req.add_inout_arg( &_error );
1463
1464 __req.invoke();
1465
1466 mico_sii_throw( &__req,
1467 0);
1468}
1469
1470
1471void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& collist, gsdlInterface::corbaComError& error )
1472{
1473 CORBA::StaticAny _collist( _marshaller__seq_gsdlInterface_corbatext_t, &collist );
1474 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1475 CORBA::StaticRequest __req( this, "collectionList" );
1476 __req.add_inout_arg( &_collist );
1477 __req.add_inout_arg( &_error );
1478
1479 __req.invoke();
1480
1481 mico_sii_throw( &__req,
1482 0);
1483}
1484
1485
1486void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, gsdlInterface::corbaComError& error )
1487{
1488 CORBA::StaticAny _corbaCollection( _marshaller_gsdlInterface_corbatext_t, &corbaCollection );
1489 CORBA::StaticAny _has( CORBA::_stc_boolean, &has );
1490 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1491 CORBA::StaticRequest __req( this, "hasCollection" );
1492 __req.add_in_arg( &_corbaCollection );
1493 __req.add_inout_arg( &_has );
1494 __req.add_inout_arg( &_error );
1495
1496 __req.invoke();
1497
1498 mico_sii_throw( &__req,
1499 0);
1500}
1501
1502
1503CORBA::Boolean gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaComError& error )
1504{
1505 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1506 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1507 CORBA::Boolean _res;
1508 CORBA::StaticAny __res( CORBA::_stc_boolean, &_res );
1509
1510 CORBA::StaticRequest __req( this, "ping" );
1511 __req.add_in_arg( &_collection );
1512 __req.add_inout_arg( &_error );
1513 __req.set_result( &__res );
1514
1515 __req.invoke();
1516
1517 mico_sii_throw( &__req,
1518 0);
1519 return _res;
1520}
1521
1522
1523void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaDocRequest& request, gsdlInterface::corbaDocResponse& response, gsdlInterface::corbaComError& error )
1524{
1525 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1526 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaDocRequest, &request );
1527 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaDocResponse, &response );
1528 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1529 CORBA::StaticRequest __req( this, "getDocument" );
1530 __req.add_in_arg( &_collection );
1531 __req.add_inout_arg( &_request );
1532 __req.add_inout_arg( &_response );
1533 __req.add_inout_arg( &_error );
1534
1535 __req.invoke();
1536
1537 mico_sii_throw( &__req,
1538 0);
1539}
1540
1541
1542void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbaColInfoResponse& response, gsdlInterface::corbaComError& error )
1543{
1544 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1545 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaColInfoResponse, &response );
1546 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1547 CORBA::StaticRequest __req( this, "getCollectInfo" );
1548 __req.add_in_arg( &_collection );
1549 __req.add_inout_arg( &_response );
1550 __req.add_inout_arg( &_error );
1551
1552 __req.invoke();
1553
1554 mico_sii_throw( &__req,
1555 0);
1556}
1557
1558
1559void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& collection, gsdlInterface::corbatext_tarray& filterNames, gsdlInterface::corbaComError& error )
1560{
1561 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1562 CORBA::StaticAny _filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &filterNames );
1563 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1564 CORBA::StaticRequest __req( this, "getFilterInfo" );
1565 __req.add_in_arg( &_collection );
1566 __req.add_inout_arg( &_filterNames );
1567 __req.add_inout_arg( &_error );
1568
1569 __req.invoke();
1570
1571 mico_sii_throw( &__req,
1572 0);
1573}
1574
1575
1576void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbatext_t& option, gsdlInterface::corbaFilterOptionsResponse& response, gsdlInterface::corbaComError& error )
1577{
1578 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1579 CORBA::StaticAny _option( _marshaller_gsdlInterface_corbatext_t, &option );
1580 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &response );
1581 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1582 CORBA::StaticRequest __req( this, "getFilterOptions" );
1583 __req.add_in_arg( &_collection );
1584 __req.add_in_arg( &_option );
1585 __req.add_inout_arg( &_response );
1586 __req.add_inout_arg( &_error );
1587
1588 __req.invoke();
1589
1590 mico_sii_throw( &__req,
1591 0);
1592}
1593
1594
1595void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& collection, const gsdlInterface::corbaFilterRequest& request, gsdlInterface::corbaFilterResponse& response, gsdlInterface::corbaComError& error )
1596{
1597 CORBA::StaticAny _collection( _marshaller_gsdlInterface_corbatext_t, &collection );
1598 CORBA::StaticAny _request( _marshaller_gsdlInterface_corbaFilterRequest, &request );
1599 CORBA::StaticAny _response( _marshaller_gsdlInterface_corbaFilterResponse, &response );
1600 CORBA::StaticAny _error( _marshaller_gsdlInterface_corbaComError, &error );
1601 CORBA::StaticRequest __req( this, "filter" );
1602 __req.add_in_arg( &_collection );
1603 __req.add_in_arg( &_request );
1604 __req.add_inout_arg( &_response );
1605 __req.add_inout_arg( &_error );
1606
1607 __req.invoke();
1608
1609 mico_sii_throw( &__req,
1610 0);
1611}
1612
1613
1614#ifdef HAVE_NAMESPACE
1615namespace gsdlInterface { vector<CORBA::Narrow_proto> * corbaiface::_narrow_helpers; }
1616#else
1617vector<CORBA::Narrow_proto> * gsdlInterface::corbaiface::_narrow_helpers;
1618#endif
1619
1620class _Marshaller_gsdlInterface_corbaiface : public CORBA::StaticTypeInfo {
1621 typedef gsdlInterface::corbaiface_ptr _MICO_T;
1622 public:
1623 StaticValueType create () const;
1624 void assign (StaticValueType dst, const StaticValueType src) const;
1625 void free (StaticValueType) const;
1626 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1627 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1628};
1629
1630
1631CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const
1632{
1633 return (StaticValueType) new _MICO_T( 0 );
1634}
1635
1636void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const
1637{
1638 *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s );
1639}
1640
1641void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const
1642{
1643 CORBA::release( *(_MICO_T *) v );
1644 delete (_MICO_T*) v;
1645}
1646
1647CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1648{
1649 CORBA::Object_ptr obj;
1650 if (!CORBA::_stc_Object->demarshal(dc, &obj))
1651 return FALSE;
1652 *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj );
1653 CORBA::Boolean ret = CORBA::is_nil (obj) || !CORBA::is_nil (*(_MICO_T *)v);
1654 CORBA::release (obj);
1655 return ret;
1656}
1657
1658void _Marshaller_gsdlInterface_corbaiface::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1659{
1660 CORBA::Object_ptr obj = *(_MICO_T *) v;
1661 CORBA::_stc_Object->marshal( ec, &obj );
1662}
1663
1664CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;
1665
1666class _Marshaller__seq_gsdlInterface_corbatext_t : public CORBA::StaticTypeInfo {
1667 typedef SequenceTmpl<gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T;
1668 public:
1669 StaticValueType create () const;
1670 void assign (StaticValueType dst, const StaticValueType src) const;
1671 void free (StaticValueType) const;
1672 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1673 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1674};
1675
1676
1677CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const
1678{
1679 return (StaticValueType) new _MICO_T;
1680}
1681
1682void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const
1683{
1684 *(_MICO_T*) d = *(_MICO_T*) s;
1685}
1686
1687void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const
1688{
1689 delete (_MICO_T*) v;
1690}
1691
1692CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1693{
1694 CORBA::ULong len;
1695 if( !dc.seq_begin( len ) )
1696 return FALSE;
1697 ((_MICO_T *) v)->length( len );
1698 for( CORBA::ULong i = 0; i < len; i++ ) {
1699 if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1700 return FALSE;
1701 }
1702 return dc.seq_end();
1703}
1704
1705void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1706{
1707 CORBA::ULong len = ((_MICO_T *) v)->length();
1708 ec.seq_begin( len );
1709 for( CORBA::ULong i = 0; i < len; i++ )
1710 _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] );
1711 ec.seq_end();
1712}
1713
1714CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;
1715
1716class _Marshaller__seq_gsdlInterface_corbaFilterOption : public CORBA::StaticTypeInfo {
1717 typedef SequenceTmpl<gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T;
1718 public:
1719 StaticValueType create () const;
1720 void assign (StaticValueType dst, const StaticValueType src) const;
1721 void free (StaticValueType) const;
1722 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1723 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1724};
1725
1726
1727CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const
1728{
1729 return (StaticValueType) new _MICO_T;
1730}
1731
1732void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const
1733{
1734 *(_MICO_T*) d = *(_MICO_T*) s;
1735}
1736
1737void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const
1738{
1739 delete (_MICO_T*) v;
1740}
1741
1742CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1743{
1744 CORBA::ULong len;
1745 if( !dc.seq_begin( len ) )
1746 return FALSE;
1747 ((_MICO_T *) v)->length( len );
1748 for( CORBA::ULong i = 0; i < len; i++ ) {
1749 if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1750 return FALSE;
1751 }
1752 return dc.seq_end();
1753}
1754
1755void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1756{
1757 CORBA::ULong len = ((_MICO_T *) v)->length();
1758 ec.seq_begin( len );
1759 for( CORBA::ULong i = 0; i < len; i++ )
1760 _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] );
1761 ec.seq_end();
1762}
1763
1764CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;
1765
1766class _Marshaller__seq_gsdlInterface_corbaOptionValue : public CORBA::StaticTypeInfo {
1767 typedef SequenceTmpl<gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T;
1768 public:
1769 StaticValueType create () const;
1770 void assign (StaticValueType dst, const StaticValueType src) const;
1771 void free (StaticValueType) const;
1772 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1773 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1774};
1775
1776
1777CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const
1778{
1779 return (StaticValueType) new _MICO_T;
1780}
1781
1782void _Marshaller__seq_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const
1783{
1784 *(_MICO_T*) d = *(_MICO_T*) s;
1785}
1786
1787void _Marshaller__seq_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const
1788{
1789 delete (_MICO_T*) v;
1790}
1791
1792CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1793{
1794 CORBA::ULong len;
1795 if( !dc.seq_begin( len ) )
1796 return FALSE;
1797 ((_MICO_T *) v)->length( len );
1798 for( CORBA::ULong i = 0; i < len; i++ ) {
1799 if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1800 return FALSE;
1801 }
1802 return dc.seq_end();
1803}
1804
1805void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1806{
1807 CORBA::ULong len = ((_MICO_T *) v)->length();
1808 ec.seq_begin( len );
1809 for( CORBA::ULong i = 0; i < len; i++ )
1810 _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] );
1811 ec.seq_end();
1812}
1813
1814CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;
1815
1816class _Marshaller__seq_gsdlInterface_corbaTermInfo : public CORBA::StaticTypeInfo {
1817 typedef SequenceTmpl<gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T;
1818 public:
1819 StaticValueType create () const;
1820 void assign (StaticValueType dst, const StaticValueType src) const;
1821 void free (StaticValueType) const;
1822 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1823 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1824};
1825
1826
1827CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const
1828{
1829 return (StaticValueType) new _MICO_T;
1830}
1831
1832void _Marshaller__seq_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const
1833{
1834 *(_MICO_T*) d = *(_MICO_T*) s;
1835}
1836
1837void _Marshaller__seq_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const
1838{
1839 delete (_MICO_T*) v;
1840}
1841
1842CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1843{
1844 CORBA::ULong len;
1845 if( !dc.seq_begin( len ) )
1846 return FALSE;
1847 ((_MICO_T *) v)->length( len );
1848 for( CORBA::ULong i = 0; i < len; i++ ) {
1849 if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1850 return FALSE;
1851 }
1852 return dc.seq_end();
1853}
1854
1855void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1856{
1857 CORBA::ULong len = ((_MICO_T *) v)->length();
1858 ec.seq_begin( len );
1859 for( CORBA::ULong i = 0; i < len; i++ )
1860 _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1861 ec.seq_end();
1862}
1863
1864CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;
1865
1866class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public CORBA::StaticTypeInfo {
1867 typedef SequenceTmpl<gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T;
1868 public:
1869 StaticValueType create () const;
1870 void assign (StaticValueType dst, const StaticValueType src) const;
1871 void free (StaticValueType) const;
1872 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1873 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1874};
1875
1876
1877CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const
1878{
1879 return (StaticValueType) new _MICO_T;
1880}
1881
1882void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const
1883{
1884 *(_MICO_T*) d = *(_MICO_T*) s;
1885}
1886
1887void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const
1888{
1889 delete (_MICO_T*) v;
1890}
1891
1892CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1893{
1894 CORBA::ULong len;
1895 if( !dc.seq_begin( len ) )
1896 return FALSE;
1897 ((_MICO_T *) v)->length( len );
1898 for( CORBA::ULong i = 0; i < len; i++ ) {
1899 if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1900 return FALSE;
1901 }
1902 return dc.seq_end();
1903}
1904
1905void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1906{
1907 CORBA::ULong len = ((_MICO_T *) v)->length();
1908 ec.seq_begin( len );
1909 for( CORBA::ULong i = 0; i < len; i++ )
1910 _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1911 ec.seq_end();
1912}
1913
1914CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;
1915
1916class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public CORBA::StaticTypeInfo {
1917 typedef SequenceTmpl<gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T;
1918 public:
1919 StaticValueType create () const;
1920 void assign (StaticValueType dst, const StaticValueType src) const;
1921 void free (StaticValueType) const;
1922 CORBA::Boolean demarshal (CORBA::DataDecoder&, StaticValueType) const;
1923 void marshal (CORBA::DataEncoder &, StaticValueType) const;
1924};
1925
1926
1927CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const
1928{
1929 return (StaticValueType) new _MICO_T;
1930}
1931
1932void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const
1933{
1934 *(_MICO_T*) d = *(_MICO_T*) s;
1935}
1936
1937void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const
1938{
1939 delete (_MICO_T*) v;
1940}
1941
1942CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( CORBA::DataDecoder &dc, StaticValueType v ) const
1943{
1944 CORBA::ULong len;
1945 if( !dc.seq_begin( len ) )
1946 return FALSE;
1947 ((_MICO_T *) v)->length( len );
1948 for( CORBA::ULong i = 0; i < len; i++ ) {
1949 if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) )
1950 return FALSE;
1951 }
1952 return dc.seq_end();
1953}
1954
1955void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( CORBA::DataEncoder &ec, StaticValueType v ) const
1956{
1957 CORBA::ULong len = ((_MICO_T *) v)->length();
1958 ec.seq_begin( len );
1959 for( CORBA::ULong i = 0; i < len; i++ )
1960 _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] );
1961 ec.seq_end();
1962}
1963
1964CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;
1965
1966struct __tc_init_CORBAIFACE {
1967 __tc_init_CORBAIFACE()
1968 {
1969 _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t;
1970 _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap;
1971 _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError;
1972 _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo;
1973 _marshaller_gsdlInterface_corbaColInfoResponse = new _Marshaller_gsdlInterface_corbaColInfoResponse;
1974 _marshaller_gsdlInterface_corbaDocRequest = new _Marshaller_gsdlInterface_corbaDocRequest;
1975 _marshaller_gsdlInterface_corbaDocResponse = new _Marshaller_gsdlInterface_corbaDocResponse;
1976 _marshaller_gsdlInterface_corbaFilterType = new _Marshaller_gsdlInterface_corbaFilterType;
1977 _marshaller_gsdlInterface_corbaFilterRepeatable = new _Marshaller_gsdlInterface_corbaFilterRepeatable;
1978 _marshaller_gsdlInterface_corbaFilterOption = new _Marshaller_gsdlInterface_corbaFilterOption;
1979 _marshaller_gsdlInterface_corbaFilterOptionsResponse = new _Marshaller_gsdlInterface_corbaFilterOptionsResponse;
1980 _marshaller_gsdlInterface_corbaOptionValue = new _Marshaller_gsdlInterface_corbaOptionValue;
1981 _marshaller_gsdlInterface_corbaFilterRequest = new _Marshaller_gsdlInterface_corbaFilterRequest;
1982 _marshaller_gsdlInterface_corbaTermInfo = new _Marshaller_gsdlInterface_corbaTermInfo;
1983 _marshaller_gsdlInterface_corbaMetadataInfo = new _Marshaller_gsdlInterface_corbaMetadataInfo;
1984 _marshaller_gsdlInterface_corbaMetadataInfo_map = new _Marshaller_gsdlInterface_corbaMetadataInfo_map;
1985 _marshaller_gsdlInterface_corbaResultDocInfo = new _Marshaller_gsdlInterface_corbaResultDocInfo;
1986 _marshaller_gsdlInterface_corbaIsApprox = new _Marshaller_gsdlInterface_corbaIsApprox;
1987 _marshaller_gsdlInterface_corbaFilterResponse = new _Marshaller_gsdlInterface_corbaFilterResponse;
1988 _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface;
1989 _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t;
1990 _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption;
1991 _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue;
1992 _marshaller__seq_gsdlInterface_corbaTermInfo = new _Marshaller__seq_gsdlInterface_corbaTermInfo;
1993 _marshaller__seq_gsdlInterface_corbaMetadataInfo = new _Marshaller__seq_gsdlInterface_corbaMetadataInfo;
1994 _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo;
1995 }
1996};
1997
1998static __tc_init_CORBAIFACE __init_CORBAIFACE;
1999
Note: See TracBrowser for help on using the repository browser.