source: branches/corba/gsdl/lib/corbaiface.mpp@ 1074

Last change on this file since 1074 was 1074, checked in by cs025, 24 years ago

Corba improvements; tidied client initialisation in corbaproto and also
added a number of changes to the main trunk which somehow had not made
it into the corba branch via update before its instantiation.

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