source: main/tags/2.53/gsdl/lib/corbaiface.mpp@ 32727

Last change on this file since 32727 was 2261, checked in by say1, 23 years ago

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