Project

General

Profile

MyServiceC.cpp

n-miyamoto, 10/12/2017 10:28 PM

 
1
// -*- C++ -*-
2
/**
3
 * Code generated by the The ACE ORB (TAO) IDL Compiler v2.4.4
4
 * TAO and the TAO IDL Compiler have been developed by:
5
 *       Center for Distributed Object Computing
6
 *       Washington University
7
 *       St. Louis, MO
8
 *       USA
9
 *       http://www.cs.wustl.edu/~schmidt/doc-center.html
10
 * and
11
 *       Distributed Object Computing Laboratory
12
 *       University of California at Irvine
13
 *       Irvine, CA
14
 *       USA
15
 * and
16
 *       Institute for Software Integrated Systems
17
 *       Vanderbilt University
18
 *       Nashville, TN
19
 *       USA
20
 *       http://www.isis.vanderbilt.edu/
21
 *
22
 * Information about TAO is available at:
23
 *     http://www.dre.vanderbilt.edu/~schmidt/TAO.html
24
 **/
25

    
26
// TAO_IDL - Generated from
27
// be\be_codegen.cpp:366
28

    
29

    
30
#include "MyServiceC.h"
31
#include "tao/AnyTypeCode/Null_RefCount_Policy.h"
32
#include "tao/AnyTypeCode/TypeCode_Constants.h"
33
#include "tao/AnyTypeCode/Alias_TypeCode_Static.h"
34
#include "tao/AnyTypeCode/Objref_TypeCode_Static.h"
35
#include "tao/AnyTypeCode/Sequence_TypeCode_Static.h"
36
#include "tao/AnyTypeCode/String_TypeCode_Static.h"
37
#include "tao/CDR.h"
38
#include "tao/Exception_Data.h"
39
#include "tao/Invocation_Adapter.h"
40
#include "tao/Object_T.h"
41
#include "tao/CDR.h"
42
#include "tao/AnyTypeCode/Any.h"
43
#include "tao/AnyTypeCode/Any_Impl_T.h"
44
#include "tao/AnyTypeCode/Any_Dual_Impl_T.h"
45
#include "ace/OS_NS_string.h"
46

    
47
#if !defined (__ACE_INLINE__)
48
#include "MyServiceC.inl"
49
#endif /* !defined INLINE */
50

    
51
// TAO_IDL - Generated from
52
// be\be_visitor_sequence\sequence_cs.cpp:105
53

    
54
#if !defined (_SIMPLESERVICE_ECHOLIST_CS_)
55
#define _SIMPLESERVICE_ECHOLIST_CS_
56

    
57
SimpleService::EchoList::EchoList (void)
58
{}
59

    
60
SimpleService::EchoList::EchoList (
61
    ::CORBA::ULong max)
62
  : ::TAO::unbounded_basic_string_sequence<char> (max)
63
{}
64

    
65
SimpleService::EchoList::EchoList (
66
    ::CORBA::ULong max,
67
    ::CORBA::ULong length,
68
    ::CORBA::Char * * buffer,
69
    ::CORBA::Boolean release)
70
  : ::TAO::unbounded_basic_string_sequence<char>
71
    (max, length, buffer, release)
72
{}
73

    
74
SimpleService::EchoList::EchoList (
75
    const EchoList &seq)
76
  : ::TAO::unbounded_basic_string_sequence<char> (seq)
77
{}
78

    
79
SimpleService::EchoList::~EchoList (void)
80
{}
81

    
82
void SimpleService::EchoList::_tao_any_destructor (
83
    void * _tao_void_pointer)
84
{
85
  EchoList * _tao_tmp_pointer =
86
    static_cast<EchoList *> (_tao_void_pointer);
87
  delete _tao_tmp_pointer;
88
}
89

    
90
#endif /* end #if !defined */
91

    
92
// TAO_IDL - Generated from
93
// be\be_visitor_typecode\alias_typecode.cpp:49
94

    
95

    
96

    
97
// TAO_IDL - Generated from
98
// be\be_visitor_typecode\typecode_defn.cpp:461
99

    
100

    
101
#ifndef _TAO_TYPECODE_SimpleService_EchoList_GUARD
102
#define _TAO_TYPECODE_SimpleService_EchoList_GUARD
103

    
104
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
105

    
106
namespace TAO
107
{
108
  namespace TypeCode
109
  {
110
    namespace
111
    {
112
      TAO::TypeCode::Sequence< ::CORBA::TypeCode_ptr const *,
113
                              TAO::Null_RefCount_Policy>
114
        SimpleService_EchoList_0 (
115
          ::CORBA::tk_sequence,
116
          &CORBA::_tc_string,
117
          0U);
118
        
119
      ::CORBA::TypeCode_ptr const tc_SimpleService_EchoList_0 =
120
        &SimpleService_EchoList_0;
121
    }
122
  }
123
}
124

    
125
TAO_END_VERSIONED_NAMESPACE_DECL
126

    
127
#endif /* _TAO_TYPECODE_SimpleService_EchoList_GUARD */
128

    
129
static TAO::TypeCode::Alias<char const *,
130
                            ::CORBA::TypeCode_ptr const *,
131
                            TAO::Null_RefCount_Policy>
132
  _tao_tc_SimpleService_EchoList (
133
    ::CORBA::tk_alias,
134
    "IDL:SimpleService/EchoList:1.0",
135
    "EchoList",
136
    &TAO::TypeCode::tc_SimpleService_EchoList_0);
137
  
138

    
139
namespace SimpleService
140
{
141
  ::CORBA::TypeCode_ptr const _tc_EchoList =
142
    &_tao_tc_SimpleService_EchoList;
143
}
144

    
145
// TAO_IDL - Generated from
146
// be\be_visitor_sequence\sequence_cs.cpp:105
147

    
148
#if !defined (_SIMPLESERVICE_VALUELIST_CS_)
149
#define _SIMPLESERVICE_VALUELIST_CS_
150

    
151
SimpleService::ValueList::ValueList (void)
152
{}
153

    
154
SimpleService::ValueList::ValueList (
155
    ::CORBA::ULong max)
156
  : ::TAO::unbounded_value_sequence< ::CORBA::Float> (max)
157
{}
158

    
159
SimpleService::ValueList::ValueList (
160
    ::CORBA::ULong max,
161
    ::CORBA::ULong length,
162
    ::CORBA::Float * buffer,
163
    ::CORBA::Boolean release)
164
  : ::TAO::unbounded_value_sequence< ::CORBA::Float>
165
    (max, length, buffer, release)
166
{}
167

    
168
SimpleService::ValueList::ValueList (
169
    const ValueList &seq)
170
  : ::TAO::unbounded_value_sequence< ::CORBA::Float> (seq)
171
{}
172

    
173
SimpleService::ValueList::~ValueList (void)
174
{}
175

    
176
void SimpleService::ValueList::_tao_any_destructor (
177
    void * _tao_void_pointer)
178
{
179
  ValueList * _tao_tmp_pointer =
180
    static_cast<ValueList *> (_tao_void_pointer);
181
  delete _tao_tmp_pointer;
182
}
183

    
184
#endif /* end #if !defined */
185

    
186
// TAO_IDL - Generated from
187
// be\be_visitor_typecode\alias_typecode.cpp:49
188

    
189

    
190

    
191
// TAO_IDL - Generated from
192
// be\be_visitor_typecode\typecode_defn.cpp:461
193

    
194

    
195
#ifndef _TAO_TYPECODE_SimpleService_ValueList_GUARD
196
#define _TAO_TYPECODE_SimpleService_ValueList_GUARD
197

    
198
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
199

    
200
namespace TAO
201
{
202
  namespace TypeCode
203
  {
204
    namespace
205
    {
206
      TAO::TypeCode::Sequence< ::CORBA::TypeCode_ptr const *,
207
                              TAO::Null_RefCount_Policy>
208
        SimpleService_ValueList_0 (
209
          ::CORBA::tk_sequence,
210
          &CORBA::_tc_float,
211
          0U);
212
        
213
      ::CORBA::TypeCode_ptr const tc_SimpleService_ValueList_0 =
214
        &SimpleService_ValueList_0;
215
    }
216
  }
217
}
218

    
219
TAO_END_VERSIONED_NAMESPACE_DECL
220

    
221
#endif /* _TAO_TYPECODE_SimpleService_ValueList_GUARD */
222

    
223
static TAO::TypeCode::Alias<char const *,
224
                            ::CORBA::TypeCode_ptr const *,
225
                            TAO::Null_RefCount_Policy>
226
  _tao_tc_SimpleService_ValueList (
227
    ::CORBA::tk_alias,
228
    "IDL:SimpleService/ValueList:1.0",
229
    "ValueList",
230
    &TAO::TypeCode::tc_SimpleService_ValueList_0);
231
  
232

    
233
namespace SimpleService
234
{
235
  ::CORBA::TypeCode_ptr const _tc_ValueList =
236
    &_tao_tc_SimpleService_ValueList;
237
}
238

    
239
// TAO_IDL - Generated from
240
// be\be_visitor_interface\interface_cs.cpp:48
241
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
242

    
243
// Traits specializations for SimpleService::MyService.
244

    
245
SimpleService::MyService_ptr
246
TAO::Objref_Traits<SimpleService::MyService>::duplicate (
247
    SimpleService::MyService_ptr p)
248
{
249
  return SimpleService::MyService::_duplicate (p);
250
}
251

    
252
void
253
TAO::Objref_Traits<SimpleService::MyService>::release (
254
    SimpleService::MyService_ptr p)
255
{
256
  ::CORBA::release (p);
257
}
258

    
259
SimpleService::MyService_ptr
260
TAO::Objref_Traits<SimpleService::MyService>::nil (void)
261
{
262
  return SimpleService::MyService::_nil ();
263
}
264

    
265
::CORBA::Boolean
266
TAO::Objref_Traits<SimpleService::MyService>::marshal (
267
    const SimpleService::MyService_ptr p,
268
    TAO_OutputCDR & cdr)
269
{
270
  return ::CORBA::Object::marshal (p, cdr);
271
}
272

    
273
TAO_END_VERSIONED_NAMESPACE_DECL
274

    
275

    
276

    
277
// TAO_IDL - Generated from
278
// be\be_visitor_operation\operation_cs.cpp:88
279

    
280
char *
281
SimpleService::MyService::echo (
282
  const char * msg)
283
{
284
  if (!this->is_evaluated ())
285
    {
286
      ::CORBA::Object::tao_object_initialize (this);
287
    }
288
  
289
  TAO::Arg_Traits< char *>::ret_val _tao_retval;
290
  TAO::Arg_Traits< char *>::in_arg_val _tao_msg (msg);
291

    
292
  TAO::Argument *_the_tao_operation_signature [] =
293
    {
294
      &_tao_retval,
295
      &_tao_msg
296
    };
297

    
298
  TAO::Invocation_Adapter _tao_call (
299
      this,
300
      _the_tao_operation_signature,
301
      2,
302
      "echo",
303
      4,
304
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY
305
      
306
    );
307

    
308
  _tao_call.invoke (0, 0);
309

    
310
  return _tao_retval.retn ();
311
}
312

    
313
// TAO_IDL - Generated from
314
// be\be_visitor_operation\operation_cs.cpp:88
315

    
316
::SimpleService::EchoList *
317
SimpleService::MyService::get_echo_history (
318
  void)
319
{
320
  if (!this->is_evaluated ())
321
    {
322
      ::CORBA::Object::tao_object_initialize (this);
323
    }
324
  
325
  TAO::Arg_Traits< ::SimpleService::EchoList>::ret_val _tao_retval;
326

    
327
  TAO::Argument *_the_tao_operation_signature [] =
328
    {
329
      &_tao_retval
330
    };
331

    
332
  TAO::Invocation_Adapter _tao_call (
333
      this,
334
      _the_tao_operation_signature,
335
      1,
336
      "get_echo_history",
337
      16,
338
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY,
339
      TAO::TAO_TWOWAY_INVOCATION
340
      ,
341
      TAO::TAO_SYNCHRONOUS_INVOCATION,
342
      false
343
    );
344

    
345
  _tao_call.invoke (0, 0);
346

    
347
  return _tao_retval.retn ();
348
}
349

    
350
// TAO_IDL - Generated from
351
// be\be_visitor_operation\operation_cs.cpp:88
352

    
353
void
354
SimpleService::MyService::set_value (
355
  ::CORBA::Float value)
356
{
357
  if (!this->is_evaluated ())
358
    {
359
      ::CORBA::Object::tao_object_initialize (this);
360
    }
361
  
362
  TAO::Arg_Traits< void>::ret_val _tao_retval;
363
  TAO::Arg_Traits< ::CORBA::Float>::in_arg_val _tao_value (value);
364

    
365
  TAO::Argument *_the_tao_operation_signature [] =
366
    {
367
      &_tao_retval,
368
      &_tao_value
369
    };
370

    
371
  TAO::Invocation_Adapter _tao_call (
372
      this,
373
      _the_tao_operation_signature,
374
      2,
375
      "set_value",
376
      9,
377
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY
378
      
379
    );
380

    
381
  _tao_call.invoke (0, 0);
382
}
383

    
384
// TAO_IDL - Generated from
385
// be\be_visitor_operation\operation_cs.cpp:88
386

    
387
::CORBA::Float
388
SimpleService::MyService::get_value (
389
  void)
390
{
391
  if (!this->is_evaluated ())
392
    {
393
      ::CORBA::Object::tao_object_initialize (this);
394
    }
395
  
396
  TAO::Arg_Traits< ::CORBA::Float>::ret_val _tao_retval;
397

    
398
  TAO::Argument *_the_tao_operation_signature [] =
399
    {
400
      &_tao_retval
401
    };
402

    
403
  TAO::Invocation_Adapter _tao_call (
404
      this,
405
      _the_tao_operation_signature,
406
      1,
407
      "get_value",
408
      9,
409
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY,
410
      TAO::TAO_TWOWAY_INVOCATION
411
      ,
412
      TAO::TAO_SYNCHRONOUS_INVOCATION,
413
      false
414
    );
415

    
416
  _tao_call.invoke (0, 0);
417

    
418
  return _tao_retval.retn ();
419
}
420

    
421
// TAO_IDL - Generated from
422
// be\be_visitor_operation\operation_cs.cpp:88
423

    
424
::SimpleService::ValueList *
425
SimpleService::MyService::get_value_history (
426
  void)
427
{
428
  if (!this->is_evaluated ())
429
    {
430
      ::CORBA::Object::tao_object_initialize (this);
431
    }
432
  
433
  TAO::Arg_Traits< ::SimpleService::ValueList>::ret_val _tao_retval;
434

    
435
  TAO::Argument *_the_tao_operation_signature [] =
436
    {
437
      &_tao_retval
438
    };
439

    
440
  TAO::Invocation_Adapter _tao_call (
441
      this,
442
      _the_tao_operation_signature,
443
      1,
444
      "get_value_history",
445
      17,
446
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY,
447
      TAO::TAO_TWOWAY_INVOCATION
448
      ,
449
      TAO::TAO_SYNCHRONOUS_INVOCATION,
450
      false
451
    );
452

    
453
  _tao_call.invoke (0, 0);
454

    
455
  return _tao_retval.retn ();
456
}
457

    
458
SimpleService::MyService::MyService (void)
459
{
460
}
461

    
462
SimpleService::MyService::~MyService (void)
463
{
464
}
465

    
466
void
467
SimpleService::MyService::_tao_any_destructor (void *_tao_void_pointer)
468
{
469
  MyService *_tao_tmp_pointer =
470
    static_cast<MyService *> (_tao_void_pointer);
471
  ::CORBA::release (_tao_tmp_pointer);
472
}
473

    
474
SimpleService::MyService_ptr
475
SimpleService::MyService::_narrow (
476
    ::CORBA::Object_ptr _tao_objref)
477
{
478
  return
479
    TAO::Narrow_Utils<MyService>::narrow (
480
        _tao_objref,
481
        "IDL:SimpleService/MyService:1.0");
482
}
483

    
484
SimpleService::MyService_ptr
485
SimpleService::MyService::_unchecked_narrow (
486
    ::CORBA::Object_ptr _tao_objref)
487
{
488
  return
489
    TAO::Narrow_Utils<MyService>::unchecked_narrow (
490
        _tao_objref);
491
}
492

    
493
SimpleService::MyService_ptr
494
SimpleService::MyService::_nil (void)
495
{
496
  return 0;
497
}
498

    
499
SimpleService::MyService_ptr
500
SimpleService::MyService::_duplicate (MyService_ptr obj)
501
{
502
  if (! ::CORBA::is_nil (obj))
503
    {
504
      obj->_add_ref ();
505
    }
506
  return obj;
507
}
508

    
509
void
510
SimpleService::MyService::_tao_release (MyService_ptr obj)
511
{
512
  ::CORBA::release (obj);
513
}
514

    
515
::CORBA::Boolean
516
SimpleService::MyService::_is_a (const char *value)
517
{
518
  if (
519
      ACE_OS::strcmp (
520
          value,
521
          "IDL:SimpleService/MyService:1.0"
522
        ) == 0 ||
523
      ACE_OS::strcmp (
524
          value,
525
          "IDL:omg.org/CORBA/Object:1.0"
526
        ) == 0
527
    )
528
    {
529
      return true; // success using local knowledge
530
    }
531
  else
532
    {
533
      return this->::CORBA::Object::_is_a (value);
534
    }
535
}
536

    
537
const char* SimpleService::MyService::_interface_repository_id (void) const
538
{
539
  return "IDL:SimpleService/MyService:1.0";
540
}
541

    
542
::CORBA::Boolean
543
SimpleService::MyService::marshal (TAO_OutputCDR &cdr)
544
{
545
  return (cdr << this);
546
}
547

    
548
// TAO_IDL - Generated from
549
// be\be_visitor_typecode\objref_typecode.cpp:70
550

    
551
static TAO::TypeCode::Objref<char const *,
552
                             TAO::Null_RefCount_Policy>
553
  _tao_tc_SimpleService_MyService (
554
    ::CORBA::tk_objref,
555
    "IDL:SimpleService/MyService:1.0",
556
    "MyService");
557
  
558

    
559
namespace SimpleService
560
{
561
  ::CORBA::TypeCode_ptr const _tc_MyService =
562
    &_tao_tc_SimpleService_MyService;
563
}
564

    
565
// TAO_IDL - Generated from
566
// be\be_visitor_sequence\any_op_cs.cpp:45
567

    
568

    
569
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
570

    
571

    
572
TAO_END_VERSIONED_NAMESPACE_DECL
573

    
574

    
575

    
576
#if defined (ACE_ANY_OPS_USE_NAMESPACE)
577

    
578
namespace SimpleService
579
{
580
  
581
  /// Copying insertion.
582
  void operator<<= (
583
      ::CORBA::Any &_tao_any,
584
      const ::SimpleService::EchoList &_tao_elem)
585
  {
586
    TAO::Any_Dual_Impl_T< ::SimpleService::EchoList>::insert_copy (
587
        _tao_any,
588
        ::SimpleService::EchoList::_tao_any_destructor,
589
        ::SimpleService::_tc_EchoList,
590
        _tao_elem);
591
  }
592

    
593
  /// Non-copying insertion.
594
  void operator<<= (
595
      ::CORBA::Any &_tao_any,
596
      ::SimpleService::EchoList *_tao_elem)
597
  {
598
    TAO::Any_Dual_Impl_T< ::SimpleService::EchoList>::insert (
599
        _tao_any,
600
        ::SimpleService::EchoList::_tao_any_destructor,
601
        ::SimpleService::_tc_EchoList,
602
        _tao_elem);
603
  }
604

    
605
  /// Extraction to const pointer.
606
  ::CORBA::Boolean operator>>= (
607
      const ::CORBA::Any &_tao_any,
608
      const ::SimpleService::EchoList *&_tao_elem)
609
  {
610
    return
611
      TAO::Any_Dual_Impl_T< ::SimpleService::EchoList>::extract (
612
          _tao_any,
613
          ::SimpleService::EchoList::_tao_any_destructor,
614
          ::SimpleService::_tc_EchoList,
615
          _tao_elem);
616
  }
617
}
618

    
619
#else
620

    
621

    
622
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
623

    
624

    
625
/// Copying insertion.
626
void operator<<= (
627
    ::CORBA::Any &_tao_any,
628
    const SimpleService::EchoList &_tao_elem)
629
{
630
  TAO::Any_Dual_Impl_T<SimpleService::EchoList>::insert_copy (
631
      _tao_any,
632
      SimpleService::EchoList::_tao_any_destructor,
633
      SimpleService::_tc_EchoList,
634
      _tao_elem);
635
}
636

    
637
/// Non-copying insertion.
638
void operator<<= (
639
    ::CORBA::Any &_tao_any,
640
    SimpleService::EchoList *_tao_elem)
641
{
642
  TAO::Any_Dual_Impl_T<SimpleService::EchoList>::insert (
643
      _tao_any,
644
      SimpleService::EchoList::_tao_any_destructor,
645
      SimpleService::_tc_EchoList,
646
      _tao_elem);
647
}
648

    
649
/// Extraction to const pointer.
650
::CORBA::Boolean operator>>= (
651
    const ::CORBA::Any &_tao_any,
652
    const SimpleService::EchoList *&_tao_elem)
653
{
654
  return
655
    TAO::Any_Dual_Impl_T<SimpleService::EchoList>::extract (
656
        _tao_any,
657
        SimpleService::EchoList::_tao_any_destructor,
658
        SimpleService::_tc_EchoList,
659
        _tao_elem);
660
}
661
TAO_END_VERSIONED_NAMESPACE_DECL
662

    
663

    
664

    
665
#endif
666

    
667
// TAO_IDL - Generated from
668
// be\be_visitor_sequence\any_op_cs.cpp:45
669

    
670

    
671
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
672

    
673

    
674
TAO_END_VERSIONED_NAMESPACE_DECL
675

    
676

    
677

    
678
#if defined (ACE_ANY_OPS_USE_NAMESPACE)
679

    
680
namespace SimpleService
681
{
682
  
683
  /// Copying insertion.
684
  void operator<<= (
685
      ::CORBA::Any &_tao_any,
686
      const ::SimpleService::ValueList &_tao_elem)
687
  {
688
    TAO::Any_Dual_Impl_T< ::SimpleService::ValueList>::insert_copy (
689
        _tao_any,
690
        ::SimpleService::ValueList::_tao_any_destructor,
691
        ::SimpleService::_tc_ValueList,
692
        _tao_elem);
693
  }
694

    
695
  /// Non-copying insertion.
696
  void operator<<= (
697
      ::CORBA::Any &_tao_any,
698
      ::SimpleService::ValueList *_tao_elem)
699
  {
700
    TAO::Any_Dual_Impl_T< ::SimpleService::ValueList>::insert (
701
        _tao_any,
702
        ::SimpleService::ValueList::_tao_any_destructor,
703
        ::SimpleService::_tc_ValueList,
704
        _tao_elem);
705
  }
706

    
707
  /// Extraction to const pointer.
708
  ::CORBA::Boolean operator>>= (
709
      const ::CORBA::Any &_tao_any,
710
      const ::SimpleService::ValueList *&_tao_elem)
711
  {
712
    return
713
      TAO::Any_Dual_Impl_T< ::SimpleService::ValueList>::extract (
714
          _tao_any,
715
          ::SimpleService::ValueList::_tao_any_destructor,
716
          ::SimpleService::_tc_ValueList,
717
          _tao_elem);
718
  }
719
}
720

    
721
#else
722

    
723

    
724
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
725

    
726

    
727
/// Copying insertion.
728
void operator<<= (
729
    ::CORBA::Any &_tao_any,
730
    const SimpleService::ValueList &_tao_elem)
731
{
732
  TAO::Any_Dual_Impl_T<SimpleService::ValueList>::insert_copy (
733
      _tao_any,
734
      SimpleService::ValueList::_tao_any_destructor,
735
      SimpleService::_tc_ValueList,
736
      _tao_elem);
737
}
738

    
739
/// Non-copying insertion.
740
void operator<<= (
741
    ::CORBA::Any &_tao_any,
742
    SimpleService::ValueList *_tao_elem)
743
{
744
  TAO::Any_Dual_Impl_T<SimpleService::ValueList>::insert (
745
      _tao_any,
746
      SimpleService::ValueList::_tao_any_destructor,
747
      SimpleService::_tc_ValueList,
748
      _tao_elem);
749
}
750

    
751
/// Extraction to const pointer.
752
::CORBA::Boolean operator>>= (
753
    const ::CORBA::Any &_tao_any,
754
    const SimpleService::ValueList *&_tao_elem)
755
{
756
  return
757
    TAO::Any_Dual_Impl_T<SimpleService::ValueList>::extract (
758
        _tao_any,
759
        SimpleService::ValueList::_tao_any_destructor,
760
        SimpleService::_tc_ValueList,
761
        _tao_elem);
762
}
763
TAO_END_VERSIONED_NAMESPACE_DECL
764

    
765

    
766

    
767
#endif
768

    
769
// TAO_IDL - Generated from
770
// be\be_visitor_interface\any_op_cs.cpp:38
771
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
772

    
773

    
774

    
775
namespace TAO
776
{
777
  template<>
778
  ::CORBA::Boolean
779
  Any_Impl_T<SimpleService::MyService>::to_object (
780
      ::CORBA::Object_ptr &_tao_elem) const
781
  {
782
    _tao_elem = ::CORBA::Object::_duplicate (this->value_);
783
    return true;
784
  }
785
}
786
TAO_END_VERSIONED_NAMESPACE_DECL
787

    
788

    
789

    
790
#if defined (ACE_ANY_OPS_USE_NAMESPACE)
791

    
792
namespace SimpleService
793
{
794
  
795

    
796
  /// Copying insertion.
797
  void
798
  operator<<= (
799
      ::CORBA::Any &_tao_any,
800
      MyService_ptr _tao_elem)
801
  {
802
    MyService_ptr _tao_objptr =
803
      MyService::_duplicate (_tao_elem);
804
    _tao_any <<= &_tao_objptr;
805
  }
806

    
807
  /// Non-copying insertion.
808
  void
809
  operator<<= (
810
      ::CORBA::Any &_tao_any,
811
      MyService_ptr *_tao_elem)
812
  {
813
    TAO::Any_Impl_T<MyService>::insert (
814
        _tao_any,
815
        MyService::_tao_any_destructor,
816
        _tc_MyService,
817
        *_tao_elem);
818
  }
819

    
820
  ::CORBA::Boolean
821
  operator>>= (
822
      const ::CORBA::Any &_tao_any,
823
      MyService_ptr &_tao_elem)
824
  {
825
    return
826
      TAO::Any_Impl_T<MyService>::extract (
827
          _tao_any,
828
          MyService::_tao_any_destructor,
829
          _tc_MyService,
830
          _tao_elem);
831
  }
832
}
833

    
834
#else
835

    
836
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
837

    
838

    
839

    
840
/// Copying insertion.
841
void
842
operator<<= (
843
    ::CORBA::Any &_tao_any,
844
    SimpleService::MyService_ptr _tao_elem)
845
{
846
  SimpleService::MyService_ptr _tao_objptr =
847
    SimpleService::MyService::_duplicate (_tao_elem);
848
  _tao_any <<= &_tao_objptr;
849
}
850

    
851
/// Non-copying insertion.
852
void
853
operator<<= (
854
    ::CORBA::Any &_tao_any,
855
    SimpleService::MyService_ptr *_tao_elem)
856
{
857
  TAO::Any_Impl_T<SimpleService::MyService>::insert (
858
      _tao_any,
859
      SimpleService::MyService::_tao_any_destructor,
860
      SimpleService::_tc_MyService,
861
      *_tao_elem);
862
}
863

    
864
::CORBA::Boolean
865
operator>>= (
866
    const ::CORBA::Any &_tao_any,
867
    SimpleService::MyService_ptr &_tao_elem)
868
{
869
  return
870
    TAO::Any_Impl_T<SimpleService::MyService>::extract (
871
        _tao_any,
872
        SimpleService::MyService::_tao_any_destructor,
873
        SimpleService::_tc_MyService,
874
        _tao_elem);
875
}
876

    
877
TAO_END_VERSIONED_NAMESPACE_DECL
878

    
879

    
880

    
881
#endif
882

    
883
// TAO_IDL - Generated from
884
// be\be_visitor_sequence\cdr_op_cs.cpp:93
885
#if !defined _TAO_CDR_OP_SimpleService_EchoList_CPP_
886
#define _TAO_CDR_OP_SimpleService_EchoList_CPP_
887

    
888
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
889

    
890
::CORBA::Boolean operator<< (
891
    TAO_OutputCDR &strm,
892
    const SimpleService::EchoList &_tao_sequence)
893
{
894
  return TAO::marshal_sequence(strm, _tao_sequence);
895
}
896

    
897
::CORBA::Boolean operator>> (
898
    TAO_InputCDR &strm,
899
    SimpleService::EchoList &_tao_sequence)
900
{
901
  return TAO::demarshal_sequence(strm, _tao_sequence);
902
}
903

    
904

    
905
TAO_END_VERSIONED_NAMESPACE_DECL
906

    
907
#endif /* _TAO_CDR_OP_SimpleService_EchoList_CPP_ */
908

    
909
// TAO_IDL - Generated from
910
// be\be_visitor_sequence\cdr_op_cs.cpp:93
911
#if !defined _TAO_CDR_OP_SimpleService_ValueList_CPP_
912
#define _TAO_CDR_OP_SimpleService_ValueList_CPP_
913

    
914
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
915

    
916
::CORBA::Boolean operator<< (
917
    TAO_OutputCDR &strm,
918
    const SimpleService::ValueList &_tao_sequence)
919
{
920
  return TAO::marshal_sequence(strm, _tao_sequence);
921
}
922

    
923
::CORBA::Boolean operator>> (
924
    TAO_InputCDR &strm,
925
    SimpleService::ValueList &_tao_sequence)
926
{
927
  return TAO::demarshal_sequence(strm, _tao_sequence);
928
}
929

    
930

    
931
TAO_END_VERSIONED_NAMESPACE_DECL
932

    
933
#endif /* _TAO_CDR_OP_SimpleService_ValueList_CPP_ */
934

    
935
// TAO_IDL - Generated from
936
// be\be_visitor_interface\cdr_op_cs.cpp:51
937

    
938
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
939

    
940
::CORBA::Boolean operator<< (
941
    TAO_OutputCDR &strm,
942
    const SimpleService::MyService_ptr _tao_objref)
943
{
944
  ::CORBA::Object_ptr _tao_corba_obj = _tao_objref;
945
  return (strm << _tao_corba_obj);
946
}
947

    
948
::CORBA::Boolean operator>> (
949
    TAO_InputCDR &strm,
950
    SimpleService::MyService_ptr &_tao_objref)
951
{
952
  ::CORBA::Object_var obj;
953

    
954
  if (!(strm >> obj.inout ()))
955
    {
956
      return false;
957
    }
958
  
959
  typedef ::SimpleService::MyService RHS_SCOPED_NAME;
960

    
961
  // Narrow to the right type.
962
  _tao_objref =
963
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (obj.in ());
964
    
965
  return true;
966
}
967

    
968
TAO_END_VERSIONED_NAMESPACE_DECL
969

    
970

    
971