← Back to branch summary

~ubuntu-branches/ubuntu/breezy/ace/breezy

« back to all changes in this revision

Viewing changes to TAO/tao/append.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad, Benjamin Montgomery, Adam Conrad
  • Date: 2005-09-18 22:51:38 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge) (0.1.2 woody)
  • Revision ID: james.westby@ubuntu.com-20050918225138-seav22q6fyylb536
Tags: 5.4.7-3ubuntu1
[ Benjamin Montgomery ]
* Added a patch for amd64 and powerpc that disables the compiler
  option -fvisibility-inlines-hidden

[ Adam Conrad ]
* Added DPATCH_OPTION_CPP=1 to debian/patches/00options to make
  Benjamin's above changes work correctly with dpatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
TAO/tao/append.cpp
1
 
// append.cpp,v 1.52 2003/10/28 18:29:21 bala Exp
2
 
 
3
 
// ============================================================================
4
 
//
5
 
// = LIBRARY
6
 
//     TAO
7
 
//
8
 
// = FILENAME
9
 
//     append.cpp
10
 
//
11
 
// = DESCRIPTION
12
 
//     Appends a CDR stream to another CDR stream. Due to the
13
 
//     stringent alignment requirements, it is not possible to simply
14
 
//     append or memcpy. Instead we go thru the same CDR encoding rules
15
 
//
16
 
// = AUTHOR
17
 
//     Copyright 1994-1995 by Sun Microsystems Inc.
18
 
//     and Aniruddha Gokhale
19
 
//
20
 
// ============================================================================
21
 
 
22
 
#include "Environment.h"
23
 
#include "debug.h"
24
 
#include "Valuetype_Adapter.h"
25
 
#include "ORB_Core.h"
26
 
#include "Typecode.h"
27
 
#include "Marshal.h"
28
 
#include "Any.h"
29
 
#include "ace/Dynamic_Service.h"
30
 
 
31
 
ACE_RCSID (tao,
32
 
           append,
33
 
           "append.cpp,v 1.52 2003/10/28 18:29:21 bala Exp")
34
 
 
35
 
// Encode instances of arbitrary data types based only on typecode.
36
 
// "data" points to the data type; if it's not a primitve data type,
37
 
// the TypeCode interpreter is used to recursively encode its
38
 
// components.  "context" is the marshaling stream on which to encode
39
 
// the data value.
40
 
 
41
 
TAO::traverse_status
42
 
TAO_Marshal_Primitive::append (CORBA::TypeCode_ptr tc,
43
 
                               TAO_InputCDR *src,
44
 
                               TAO_OutputCDR *dest
45
 
                               ACE_ENV_ARG_DECL)
46
 
{
47
 
  CORBA::Boolean continue_append = 1;
48
 
  TAO::traverse_status retval =
49
 
    TAO::TRAVERSE_CONTINUE; // status of encode operation
50
 
 
51
 
  switch (tc->kind_)
52
 
    {
53
 
    case CORBA::tk_null:
54
 
    case CORBA::tk_void:
55
 
      break;
56
 
    case CORBA::tk_short:
57
 
    case CORBA::tk_ushort:
58
 
      continue_append = dest->append_short (*src);
59
 
      break;
60
 
    case CORBA::tk_long:
61
 
    case CORBA::tk_ulong:
62
 
    case CORBA::tk_float:
63
 
    case CORBA::tk_enum:
64
 
      continue_append = dest->append_long (*src);
65
 
      break;
66
 
    case CORBA::tk_double:
67
 
    case CORBA::tk_longlong:
68
 
    case CORBA::tk_ulonglong:
69
 
      continue_append = dest->append_double (*src);
70
 
      break;
71
 
    case CORBA::tk_boolean:
72
 
      continue_append = dest->append_boolean (*src);
73
 
      break;
74
 
    case CORBA::tk_char:
75
 
    case CORBA::tk_octet:
76
 
      continue_append = dest->append_octet (*src);
77
 
      break;
78
 
    case CORBA::tk_longdouble:
79
 
      continue_append = dest->append_longdouble (*src);
80
 
      break;
81
 
    case CORBA::tk_wchar:
82
 
      continue_append = dest->append_wchar (*src);
83
 
      break;
84
 
    default:
85
 
      retval = TAO::TRAVERSE_STOP;
86
 
      // we are not a primitive type
87
 
    }
88
 
 
89
 
  if (retval == TAO::TRAVERSE_CONTINUE
90
 
      && continue_append == 1)
91
 
    return TAO::TRAVERSE_CONTINUE;
92
 
 
93
 
  if (TAO_debug_level > 0)
94
 
    ACE_DEBUG ((
95
 
        LM_DEBUG,
96
 
        ACE_TEXT ("TAO_Marshal_Primitive::append detected error\n")
97
 
      ));
98
 
 
99
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
100
 
                                    CORBA::COMPLETED_MAYBE),
101
 
                    TAO::TRAVERSE_STOP);
102
 
}
103
 
 
104
 
TAO::traverse_status
105
 
TAO_Marshal_Any::append (CORBA::TypeCode_ptr,
106
 
                         TAO_InputCDR *src,
107
 
                         TAO_OutputCDR *dest
108
 
                         ACE_ENV_ARG_DECL)
109
 
{
110
 
  // Typecode of the element that makes the Any.
111
 
  CORBA::TypeCode_var elem_tc;
112
 
 
113
 
  if (!(*src >> elem_tc.inout ()))
114
 
    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
115
 
                                      CORBA::COMPLETED_MAYBE),
116
 
                      TAO::TRAVERSE_STOP);
117
 
 
118
 
  if (!(*dest << elem_tc.in ()))
119
 
    ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
120
 
                                      CORBA::COMPLETED_MAYBE),
121
 
                      TAO::TRAVERSE_STOP);
122
 
 
123
 
  // append the data
124
 
  TAO::traverse_status retval =
125
 
    TAO_Marshal_Object::perform_append (elem_tc.in (),
126
 
                                        src,
127
 
                                        dest
128
 
                                         ACE_ENV_ARG_PARAMETER);
129
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
130
 
 
131
 
  if (retval != TAO::TRAVERSE_CONTINUE)
132
 
    {
133
 
      if (TAO_debug_level > 0)
134
 
        ACE_DEBUG ((LM_DEBUG,
135
 
                    ACE_TEXT ("TAO_Marshal_Any::append detected error\n")));
136
 
 
137
 
      ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
138
 
                                        CORBA::COMPLETED_MAYBE),
139
 
                        TAO::TRAVERSE_STOP);
140
 
    }
141
 
 
142
 
  return retval;
143
 
}
144
 
 
145
 
TAO::traverse_status
146
 
TAO_Marshal_TypeCode::append (CORBA::TypeCode_ptr,
147
 
                              TAO_InputCDR *src,
148
 
                              TAO_OutputCDR *dest
149
 
                              ACE_ENV_ARG_DECL)
150
 
{
151
 
  CORBA::Boolean continue_append = 1;
152
 
  TAO::traverse_status retval =
153
 
    TAO::TRAVERSE_CONTINUE;
154
 
  CORBA::ULong kind;
155
 
 
156
 
  // Decode the "kind" field of the typecode from the src for further
157
 
  // use. However, also write it back into the destination
158
 
  continue_append = (CORBA::Boolean) (src->read_ulong (kind)
159
 
                                      ? dest->write_ulong (kind)
160
 
                                      : 0);
161
 
 
162
 
  if (continue_append == 1)
163
 
    {
164
 
      // Typecodes with empty parameter lists all have preallocated
165
 
      // constants.  We use those to reduce memory consumption and
166
 
      // heap access ... also, to speed things up!
167
 
      if ((kind < CORBA::TC_KIND_COUNT)
168
 
          || (kind == ~0u))
169
 
        {
170
 
          // Either a non-constant typecode or an indirected typecode.
171
 
          switch (kind)
172
 
            {
173
 
              // Need special handling for all kinds of typecodes that
174
 
              // have nonempty parameter lists ...
175
 
            default:
176
 
              // nothing to de done
177
 
              break;
178
 
            case CORBA::tk_string:
179
 
            case CORBA::tk_wstring:
180
 
              {
181
 
                // read and write the bounds
182
 
                retval =
183
 
                  TAO_Marshal_Object::perform_append (CORBA::_tc_long,
184
 
                                                      src,
185
 
                                                      dest
186
 
                                                       ACE_ENV_ARG_PARAMETER);
187
 
                ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
188
 
              }
189
 
            break;
190
 
 
191
 
            // Indirected typecodes, illegal at "top level"
192
 
            case ~0u:
193
 
              {
194
 
                // read and write the negative offset
195
 
                retval =
196
 
                  TAO_Marshal_Object::perform_append (CORBA::_tc_long,
197
 
                                                      src,
198
 
                                                      dest
199
 
                                                       ACE_ENV_ARG_PARAMETER);
200
 
                ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
201
 
              }
202
 
            break;
203
 
 
204
 
            // The rest have "complex" parameter lists that are
205
 
            // encoded as bulk octets ...
206
 
            case CORBA::tk_objref:
207
 
            case CORBA::tk_struct:
208
 
            case CORBA::tk_union:
209
 
            case CORBA::tk_enum:
210
 
            case CORBA::tk_sequence:
211
 
            case CORBA::tk_array:
212
 
            case CORBA::tk_alias:
213
 
            case CORBA::tk_except:
214
 
            case CORBA::tk_value:
215
 
            case CORBA::tk_value_box:
216
 
            case CORBA::tk_native:
217
 
            case CORBA::tk_abstract_interface:
218
 
            case CORBA::tk_local_interface:
219
 
            case CORBA::tk_component:
220
 
            case CORBA::tk_home:
221
 
            case CORBA::tk_event:
222
 
              {
223
 
                // write the encapsulation i.e., octet sequence
224
 
                retval =
225
 
                  TAO_Marshal_Object::perform_append (TC_opaque,
226
 
                                                      src,
227
 
                                                      dest
228
 
                                                      ACE_ENV_ARG_PARAMETER);
229
 
                ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
230
 
              }
231
 
            } // end of switch
232
 
        }
233
 
      else // bad kind_ value to be decoded
234
 
        {
235
 
          if (TAO_debug_level > 0)
236
 
            {
237
 
              ACE_DEBUG ((LM_DEBUG,
238
 
                          ACE_TEXT ("TAO_Marshal_TypeCode: ")
239
 
                          ACE_TEXT ("Bad kind_ value in CDR stream\n")));
240
 
            }
241
 
 
242
 
          ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
243
 
                            TAO::TRAVERSE_STOP);
244
 
        }
245
 
    }
246
 
 
247
 
  if (continue_append == 1 && retval == TAO::TRAVERSE_CONTINUE)
248
 
    {
249
 
      return TAO::TRAVERSE_CONTINUE;
250
 
    }
251
 
 
252
 
  if (TAO_debug_level > 0)
253
 
    {
254
 
      ACE_DEBUG ((LM_DEBUG,
255
 
                  ACE_TEXT ("TAO_Marshal_TypeCode::append detected error\n")));
256
 
    }
257
 
 
258
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
259
 
                                    CORBA::COMPLETED_MAYBE),
260
 
                    TAO::TRAVERSE_STOP);
261
 
}
262
 
 
263
 
TAO::traverse_status
264
 
TAO_Marshal_Principal::append (CORBA::TypeCode_ptr,
265
 
                               TAO_InputCDR *src,
266
 
                               TAO_OutputCDR *dest
267
 
                               ACE_ENV_ARG_DECL)
268
 
{
269
 
  // write the octet sequence representing the Principal
270
 
  return TAO_Marshal_Object::perform_append (TC_opaque,
271
 
                                             src,
272
 
                                             dest
273
 
                                              ACE_ENV_ARG_PARAMETER);
274
 
}
275
 
 
276
 
TAO::traverse_status
277
 
TAO_Marshal_ObjRef::append (CORBA::TypeCode_ptr,
278
 
                            TAO_InputCDR *src,
279
 
                            TAO_OutputCDR *dest
280
 
                            ACE_ENV_ARG_DECL)
281
 
{
282
 
  CORBA::Boolean continue_append = 1;
283
 
 
284
 
  // First, append the type hint. This will be the type_id encoded in an
285
 
  // object reference.
286
 
  dest->append_string (*src);
287
 
 
288
 
  // Read the profiles, discarding all until an IIOP profile comes by.
289
 
  // Once we see an IIOP profile, ignore any further ones.
290
 
  //
291
 
  // XXX this will need to change someday to let different protocol
292
 
  // code be accessed, not just IIOP.  Protocol modules will be
293
 
  // dynamically loaded from shared libraries via ORB_init (), and we
294
 
  // just need to be able to access such preloaded libraries here as
295
 
  // we unmarshal objrefs.
296
 
 
297
 
  CORBA::ULong profiles = 0;
298
 
 
299
 
  // get the count of profiles that follow. This will tell us the
300
 
  // length of the sequence
301
 
  continue_append = (CORBA::Boolean) (src->read_ulong (profiles)
302
 
                                      ? dest->write_ulong (profiles)
303
 
                                      : 0);
304
 
 
305
 
  // No profiles means a NIL objref.
306
 
  while (profiles-- != 0 && continue_append)
307
 
    {
308
 
      CORBA::ULong tag = 0;
309
 
 
310
 
      // get the profile ID tag
311
 
      if ((continue_append = (CORBA::Boolean) (src->read_ulong (tag)
312
 
                                               ? dest->write_ulong (tag)
313
 
                                               : 0))  == 0)
314
 
        continue;
315
 
 
316
 
      CORBA::ULong length = 0;
317
 
      if ((continue_append = (CORBA::Boolean) (src->read_ulong (length)
318
 
                              ? dest->write_ulong (length)
319
 
                              : 0)) == 0)
320
 
        continue;
321
 
 
322
 
      // @@ This can be optimized! Pre-allocating on the destination
323
 
      //    and then copying directly into that.
324
 
      CORBA::Octet* body = 0;
325
 
      ACE_NEW_RETURN (body,
326
 
                      CORBA::Octet[length],
327
 
                      TAO::TRAVERSE_STOP);
328
 
      continue_append =
329
 
        (CORBA::Boolean) (src->read_octet_array (body, length)
330
 
                          ? dest->write_octet_array (body, length)
331
 
                          : 0);
332
 
      delete [] body;
333
 
    }
334
 
 
335
 
  if (continue_append == 1)
336
 
    return TAO::TRAVERSE_CONTINUE;
337
 
 
338
 
  if (TAO_debug_level > 0)
339
 
    ACE_DEBUG ((
340
 
        LM_DEBUG,
341
 
        ACE_TEXT ("TAO_Marshal_ObjRef::append detected error\n")
342
 
      ));
343
 
 
344
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
345
 
                                    CORBA::COMPLETED_MAYBE),
346
 
                    TAO::TRAVERSE_STOP);
347
 
}
348
 
 
349
 
TAO::traverse_status
350
 
TAO_Marshal_Struct::append (CORBA::TypeCode_ptr  tc,
351
 
                            TAO_InputCDR *src,
352
 
                            TAO_OutputCDR *dest
353
 
                            ACE_ENV_ARG_DECL)
354
 
{
355
 
  TAO::traverse_status retval =
356
 
    TAO::TRAVERSE_CONTINUE;
357
 
  CORBA::TypeCode_var param;
358
 
 
359
 
  // Number of fields in the struct.
360
 
  int member_count = tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
361
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
362
 
 
363
 
  for (int i = 0;
364
 
       i < member_count && retval == TAO::TRAVERSE_CONTINUE;
365
 
       i++)
366
 
    {
367
 
      // get member type
368
 
      param = tc->member_type (i ACE_ENV_ARG_PARAMETER);
369
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
370
 
 
371
 
      retval =
372
 
        TAO_Marshal_Object::perform_append (param.in (),
373
 
                                            src,
374
 
                                            dest
375
 
                                             ACE_ENV_ARG_PARAMETER);
376
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
377
 
    }
378
 
 
379
 
  if (retval == TAO::TRAVERSE_CONTINUE)
380
 
    return TAO::TRAVERSE_CONTINUE;
381
 
 
382
 
  if (TAO_debug_level > 0)
383
 
    ACE_DEBUG ((LM_DEBUG,
384
 
                ACE_TEXT ("TAO_Marshal_Struct::append detected error\n")));
385
 
 
386
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
387
 
                                    CORBA::COMPLETED_MAYBE),
388
 
                    TAO::TRAVERSE_STOP);
389
 
}
390
 
 
391
 
TAO::traverse_status
392
 
TAO_Marshal_Union::append (CORBA::TypeCode_ptr tc,
393
 
                           TAO_InputCDR *src,
394
 
                           TAO_OutputCDR *dest
395
 
                           ACE_ENV_ARG_DECL)
396
 
{
397
 
  CORBA::TypeCode_var discrim_tc =
398
 
    tc->discriminator_type (ACE_ENV_SINGLE_ARG_PARAMETER);
399
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
400
 
 
401
 
  CORBA::ULong kind =
402
 
    discrim_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
403
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
404
 
 
405
 
  // Save the discriminator value in a temporary variable...
406
 
  CORBA::Short short_v;
407
 
  CORBA::UShort ushort_v;
408
 
  CORBA::Long long_v;
409
 
  CORBA::ULong ulong_v;
410
 
  CORBA::ULong enum_v;
411
 
  CORBA::Char char_v;
412
 
  CORBA::WChar wchar_v;
413
 
  CORBA::Boolean boolean_v;
414
 
 
415
 
  switch (kind)
416
 
    {
417
 
    case CORBA::tk_short:
418
 
      {
419
 
        if (!src->read_short (short_v)
420
 
            || !dest->write_short (short_v))
421
 
          return TAO::TRAVERSE_STOP;
422
 
      }
423
 
      break;
424
 
 
425
 
    case CORBA::tk_ushort:
426
 
      {
427
 
        if (!src->read_ushort (ushort_v)
428
 
            || !dest->write_ushort (ushort_v))
429
 
          return TAO::TRAVERSE_STOP;
430
 
      }
431
 
      break;
432
 
 
433
 
    case CORBA::tk_long:
434
 
      {
435
 
        if (!src->read_long (long_v)
436
 
            || !dest->write_long (long_v))
437
 
          return TAO::TRAVERSE_STOP;
438
 
      }
439
 
      break;
440
 
 
441
 
    case CORBA::tk_ulong:
442
 
      {
443
 
        if (!src->read_ulong (ulong_v)
444
 
            || !dest->write_ulong (ulong_v))
445
 
          return TAO::TRAVERSE_STOP;
446
 
      }
447
 
      break;
448
 
 
449
 
    case CORBA::tk_enum:
450
 
      {
451
 
        if (!src->read_ulong (enum_v)
452
 
            || !dest->write_ulong (enum_v))
453
 
          return TAO::TRAVERSE_STOP;
454
 
      }
455
 
      break;
456
 
 
457
 
    case CORBA::tk_char:
458
 
      {
459
 
        if (!src->read_char (char_v)
460
 
            || !dest->write_char (char_v))
461
 
          return TAO::TRAVERSE_STOP;
462
 
      }
463
 
      break;
464
 
 
465
 
    case CORBA::tk_wchar:
466
 
      {
467
 
        if (!src->read_wchar (wchar_v)
468
 
            || !dest->write_wchar (wchar_v))
469
 
          return TAO::TRAVERSE_STOP;
470
 
      }
471
 
      break;
472
 
 
473
 
    case CORBA::tk_boolean:
474
 
      {
475
 
        if (!src->read_boolean (boolean_v)
476
 
            || !dest->write_boolean (boolean_v))
477
 
          return TAO::TRAVERSE_STOP;
478
 
      }
479
 
      break;
480
 
 
481
 
    default:
482
 
      return TAO::TRAVERSE_STOP;
483
 
    }
484
 
 
485
 
  CORBA::ULong member_count =
486
 
    tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
487
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
488
 
 
489
 
  const CORBA::ULong null_member = ~ACE_static_cast (CORBA::ULong, 0U);
490
 
 
491
 
  CORBA::ULong current_member = null_member;
492
 
  CORBA::ULong default_member = null_member;
493
 
 
494
 
  for (CORBA::ULong i = 0;
495
 
       i != member_count && current_member == null_member;
496
 
       ++i)
497
 
    {
498
 
      CORBA::Any_var any = tc->member_label (i
499
 
                                             ACE_ENV_ARG_PARAMETER);
500
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
501
 
 
502
 
      CORBA::Octet o;
503
 
 
504
 
      if ((any >>= CORBA::Any::to_octet (o)) && o == 0)
505
 
        {
506
 
          CORBA::ULong default_index =
507
 
            tc->default_index (ACE_ENV_SINGLE_ARG_PARAMETER);
508
 
          ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
509
 
 
510
 
          if (i != default_index)
511
 
            ACE_THROW_RETURN (CORBA::BAD_TYPECODE (),
512
 
                              TAO::TRAVERSE_STOP);
513
 
          // Found the default branch, save its position and continue
514
 
          // trying to find the current value...
515
 
          default_member = i;
516
 
          continue;
517
 
        }
518
 
 
519
 
      switch (kind)
520
 
        {
521
 
        case CORBA::tk_short:
522
 
          {
523
 
            CORBA::Short d;
524
 
            if ((any >>= d) && d == short_v)
525
 
              current_member = i;
526
 
          }
527
 
          break;
528
 
 
529
 
        case CORBA::tk_ushort:
530
 
          {
531
 
            CORBA::UShort d;
532
 
            if ((any >>= d) && d == ushort_v)
533
 
              current_member = i;
534
 
          }
535
 
          break;
536
 
 
537
 
        case CORBA::tk_long:
538
 
          {
539
 
            CORBA::Long d;
540
 
            if ((any >>= d) && d == long_v)
541
 
              current_member = i;
542
 
          }
543
 
          break;
544
 
 
545
 
        case CORBA::tk_ulong:
546
 
          {
547
 
            CORBA::ULong d;
548
 
            if ((any >>= d) && d == ulong_v)
549
 
              current_member = i;
550
 
          }
551
 
          break;
552
 
 
553
 
        case CORBA::tk_enum:
554
 
          {
555
 
            ACE_Message_Block *mb = any->_tao_get_cdr ();
556
 
 
557
 
            if (mb != 0)
558
 
              {
559
 
                CORBA::ULong d = 0;
560
 
                TAO_InputCDR cdr (mb->data_block (),
561
 
                                  ACE_Message_Block::DONT_DELETE,
562
 
                                  mb->rd_ptr () - mb->base (),
563
 
                                  mb->wr_ptr () - mb->base (),
564
 
                                  ACE_CDR_BYTE_ORDER,
565
 
                                  TAO_DEF_GIOP_MAJOR,
566
 
                                  TAO_DEF_GIOP_MINOR);
567
 
                cdr.read_ulong (d);
568
 
 
569
 
                if (d == enum_v)
570
 
                  {
571
 
                    current_member = i;
572
 
                  }
573
 
              }
574
 
            else
575
 
              {
576
 
                const CORBA::ULong *d =
577
 
                  ACE_reinterpret_cast (const CORBA::ULong *,
578
 
                                        any->value ());
579
 
                if (*d == enum_v)
580
 
                  {
581
 
                    current_member = i;
582
 
                  }
583
 
              }
584
 
          }
585
 
          break;
586
 
 
587
 
        case CORBA::tk_char:
588
 
          {
589
 
            CORBA::Char d;
590
 
            if ((any >>= CORBA::Any::to_char (d)) && d == char_v)
591
 
              current_member = i;
592
 
          }
593
 
          break;
594
 
 
595
 
        case CORBA::tk_wchar:
596
 
          {
597
 
            CORBA::WChar d;
598
 
            if ((any >>= CORBA::Any::to_wchar (d)) && d == wchar_v)
599
 
              current_member = i;
600
 
          }
601
 
          break;
602
 
 
603
 
        case CORBA::tk_boolean:
604
 
          {
605
 
            CORBA::Boolean d;
606
 
            if ((any >>= CORBA::Any::to_boolean (d)) && d == boolean_v)
607
 
              current_member = i;
608
 
          }
609
 
          break;
610
 
 
611
 
        default:
612
 
          return TAO::TRAVERSE_STOP;
613
 
        }
614
 
    }
615
 
 
616
 
  if (current_member == null_member)
617
 
    {
618
 
      // Cannot find the current member, check if there is a
619
 
      // default...
620
 
      if (default_member != null_member)
621
 
        {
622
 
          // Good, use the default to append...
623
 
          CORBA::TypeCode_var member_tc =
624
 
            tc->member_type (default_member ACE_ENV_ARG_PARAMETER);
625
 
          ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
626
 
          return TAO_Marshal_Object::perform_append (member_tc.in (),
627
 
                                                     src,
628
 
                                                     dest
629
 
                                                      ACE_ENV_ARG_PARAMETER);
630
 
        }
631
 
 
632
 
      // If we're here, we have an implicit default case, and we
633
 
      // should just return without appending anything, since no
634
 
      // union member was marshaled in the first place.
635
 
      return TAO::TRAVERSE_CONTINUE;
636
 
    }
637
 
 
638
 
  // If we found the member successfully then just use that one...
639
 
  CORBA::TypeCode_var member_tc =
640
 
    tc->member_type (current_member ACE_ENV_ARG_PARAMETER);
641
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
642
 
  return TAO_Marshal_Object::perform_append (member_tc.in (),
643
 
                                             src,
644
 
                                             dest
645
 
                                              ACE_ENV_ARG_PARAMETER);
646
 
}
647
 
 
648
 
TAO::traverse_status
649
 
TAO_Marshal_String::append (CORBA::TypeCode_ptr,
650
 
                            TAO_InputCDR *src,
651
 
                            TAO_OutputCDR *dest
652
 
                            ACE_ENV_ARG_DECL)
653
 
{
654
 
  CORBA::Boolean continue_append = 1;
655
 
 
656
 
  // On decode, omit the check against specified string bounds, and
657
 
  // cope with illegal "zero length" strings (all lengths on the wire
658
 
  // must include a NUL).
659
 
  //
660
 
  // This is on the principle of being gracious in what we accept; we
661
 
  // don't generate messages that fail to comply with protocol specs,
662
 
  // but we will accept them when it's clear how to do so.
663
 
 
664
 
  continue_append = dest->append_string (*src);
665
 
  if (continue_append == 1)
666
 
    return TAO::TRAVERSE_CONTINUE;
667
 
 
668
 
  if (TAO_debug_level > 0)
669
 
    ACE_DEBUG ((LM_DEBUG,
670
 
                ACE_TEXT ("TAO_Marshal_TypeCode::append detected error\n")));
671
 
 
672
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
673
 
                                    CORBA::COMPLETED_MAYBE),
674
 
                    TAO::TRAVERSE_STOP);
675
 
}
676
 
 
677
 
TAO::traverse_status
678
 
TAO_Marshal_Sequence::append (CORBA::TypeCode_ptr  tc,
679
 
                              TAO_InputCDR *src,
680
 
                              TAO_OutputCDR *dest
681
 
                              ACE_ENV_ARG_DECL)
682
 
{
683
 
  // Size of element.
684
 
  CORBA::ULong bounds;
685
 
 
686
 
  // First unmarshal the sequence length ... we trust it to be right
687
 
  // here, on the "be gracious in what you accept" principle.  We
688
 
  // don't generate illegal sequences (i.e. length > bounds).
689
 
 
690
 
  CORBA::Boolean continue_append =
691
 
    (CORBA::Boolean) (src->read_ulong (bounds)
692
 
                      ? dest->write_ulong (bounds)
693
 
                      : 0);
694
 
 
695
 
  if (!continue_append)
696
 
    {
697
 
      ACE_DEBUG ((
698
 
          LM_DEBUG,
699
 
          ACE_TEXT ("TAO_Marshal_Sequence::append detected error\n")
700
 
        ));
701
 
      ACE_THROW_RETURN (CORBA::MARSHAL (),
702
 
                        TAO::TRAVERSE_STOP);
703
 
    }
704
 
 
705
 
  if (bounds == 0)
706
 
    {
707
 
      return TAO::TRAVERSE_CONTINUE;
708
 
    }
709
 
 
710
 
  if (continue_append)
711
 
    {
712
 
      // Get element typecode.
713
 
      CORBA::TypeCode_var tc2 =
714
 
        tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
715
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
716
 
 
717
 
      TAO::traverse_status retval =
718
 
        TAO::TRAVERSE_CONTINUE;
719
 
 
720
 
      CORBA::TCKind kind = tc2->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
721
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
722
 
 
723
 
      switch (kind)
724
 
        {
725
 
        case CORBA::tk_octet:
726
 
          {
727
 
            char* buf;
728
 
            if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
729
 
                              ACE_CDR::OCTET_ALIGN, buf) == 0)
730
 
              {
731
 
                if (src->read_octet_array ((ACE_CDR::Octet*)buf, bounds) == 0)
732
 
                  retval = TAO::TRAVERSE_STOP;
733
 
              }
734
 
          }
735
 
          break;
736
 
        case CORBA::tk_boolean:
737
 
          {
738
 
            char* buf;
739
 
            if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
740
 
                              ACE_CDR::OCTET_ALIGN, buf) == 0)
741
 
              {
742
 
                if (src->read_boolean_array ((ACE_CDR::Boolean*)buf, bounds) == 0)
743
 
                  retval = TAO::TRAVERSE_STOP;
744
 
              }
745
 
          }
746
 
          break;
747
 
        case CORBA::tk_char:
748
 
          {
749
 
            char* buf;
750
 
            if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
751
 
                              ACE_CDR::OCTET_ALIGN, buf) == 0)
752
 
              {
753
 
                if (src->read_char_array ((ACE_CDR::Char*)buf, bounds) == 0)
754
 
                  retval = TAO::TRAVERSE_STOP;
755
 
              }
756
 
          }
757
 
          break;
758
 
        case CORBA::tk_short:
759
 
          {
760
 
            char* buf;
761
 
            if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
762
 
                              ACE_CDR::SHORT_ALIGN, buf) == 0)
763
 
              {
764
 
                if (src->read_short_array ((ACE_CDR::Short*)buf, bounds) == 0)
765
 
                  retval = TAO::TRAVERSE_STOP;
766
 
              }
767
 
          }
768
 
          break;
769
 
        case CORBA::tk_ushort:
770
 
          {
771
 
            char* buf;
772
 
            if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
773
 
                              ACE_CDR::SHORT_ALIGN, buf) == 0)
774
 
              {
775
 
                if (src->read_ushort_array ((ACE_CDR::UShort*)buf, bounds) == 0)
776
 
                  retval = TAO::TRAVERSE_STOP;
777
 
              }
778
 
          }
779
 
          break;
780
 
        case CORBA::tk_wchar:
781
 
          {
782
 
            char* buf;
783
 
            if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
784
 
                              ACE_CDR::SHORT_ALIGN, buf) == 0)
785
 
              {
786
 
                if (src->read_wchar_array ((ACE_CDR::WChar*)buf, bounds) == 0)
787
 
                  retval = TAO::TRAVERSE_STOP;
788
 
              }
789
 
          }
790
 
          break;
791
 
        case CORBA::tk_long:
792
 
          {
793
 
            char* buf;
794
 
            if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
795
 
                              ACE_CDR::LONG_ALIGN, buf) == 0)
796
 
              {
797
 
                if (src->read_long_array ((ACE_CDR::Long*)buf, bounds) == 0)
798
 
                  retval = TAO::TRAVERSE_STOP;
799
 
              }
800
 
          }
801
 
          break;
802
 
        case CORBA::tk_ulong:
803
 
          {
804
 
            char* buf;
805
 
            if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
806
 
                              ACE_CDR::LONG_ALIGN, buf) == 0)
807
 
              {
808
 
                if (src->read_ulong_array ((ACE_CDR::ULong*)buf, bounds) == 0)
809
 
                  retval = TAO::TRAVERSE_STOP;
810
 
              }
811
 
          }
812
 
          break;
813
 
        case CORBA::tk_float:
814
 
          {
815
 
            char* buf;
816
 
            if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
817
 
                              ACE_CDR::LONG_ALIGN, buf) == 0)
818
 
              {
819
 
                if (src->read_float_array ((ACE_CDR::Float*)buf, bounds) == 0)
820
 
                  retval = TAO::TRAVERSE_STOP;
821
 
              }
822
 
          }
823
 
          break;
824
 
        case CORBA::tk_double:
825
 
          {
826
 
            char* buf;
827
 
            if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
828
 
                              ACE_CDR::LONGLONG_ALIGN, buf) == 0)
829
 
              {
830
 
                if (src->read_double_array ((ACE_CDR::Double*)buf, bounds) == 0)
831
 
                  retval = TAO::TRAVERSE_STOP;
832
 
              }
833
 
          }
834
 
          break;
835
 
        case CORBA::tk_longlong:
836
 
          {
837
 
            char* buf;
838
 
            if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
839
 
                              ACE_CDR::LONGLONG_ALIGN, buf) == 0)
840
 
              {
841
 
                if (src->read_longlong_array ((ACE_CDR::LongLong*)buf, bounds) == 0)
842
 
                  retval = TAO::TRAVERSE_STOP;
843
 
              }
844
 
          }
845
 
          break;
846
 
        case CORBA::tk_ulonglong:
847
 
          {
848
 
            char* buf;
849
 
            if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
850
 
                              ACE_CDR::LONGLONG_ALIGN, buf) == 0)
851
 
              {
852
 
                if (src->read_ulonglong_array ((ACE_CDR::ULongLong*)buf, bounds) == 0)
853
 
                  retval = TAO::TRAVERSE_STOP;
854
 
              }
855
 
          }
856
 
          break;
857
 
        case CORBA::tk_longdouble:
858
 
          {
859
 
            char* buf;
860
 
            if (dest->adjust (ACE_CDR::LONGDOUBLE_SIZE * bounds,
861
 
                              ACE_CDR::LONGDOUBLE_ALIGN, buf) == 0)
862
 
              {
863
 
                if (src->read_longdouble_array ((ACE_CDR::LongDouble*)buf, bounds) == 0)
864
 
                  retval = TAO::TRAVERSE_STOP;
865
 
              }
866
 
          }
867
 
          break;
868
 
 
869
 
        default:
870
 
          while (bounds-- && retval == TAO::TRAVERSE_CONTINUE)
871
 
            {
872
 
              retval = TAO_Marshal_Object::perform_append (tc2.in (),
873
 
                                                           src,
874
 
                                                           dest
875
 
                                                            ACE_ENV_ARG_PARAMETER);
876
 
              ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
877
 
            }
878
 
          break;
879
 
        }// end of switch
880
 
 
881
 
      if (retval == TAO::TRAVERSE_CONTINUE)
882
 
        return TAO::TRAVERSE_CONTINUE;
883
 
    }
884
 
  // error exit
885
 
  if (TAO_debug_level > 0)
886
 
    ACE_DEBUG ((
887
 
        LM_DEBUG,
888
 
        ACE_TEXT ("marshaling TAO_Marshal_Sequence::append detected error\n")
889
 
      ));
890
 
 
891
 
  ACE_THROW_RETURN (CORBA::MARSHAL (),
892
 
                    TAO::TRAVERSE_STOP);
893
 
}
894
 
 
895
 
TAO::traverse_status
896
 
TAO_Marshal_Array::append (CORBA::TypeCode_ptr  tc,
897
 
                           TAO_InputCDR *src,
898
 
                           TAO_OutputCDR *dest
899
 
                           ACE_ENV_ARG_DECL)
900
 
{
901
 
  // retrieve the bounds of the array
902
 
  CORBA::ULong bounds = tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
903
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
904
 
 
905
 
  // get element typecode
906
 
  CORBA::TypeCode_var tc2 = tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
907
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
908
 
 
909
 
  // For CORBA basic types, the copy can be optimized
910
 
  CORBA::TCKind kind = tc2->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
911
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
912
 
 
913
 
  // Return status.
914
 
  TAO::traverse_status retval =
915
 
    TAO::TRAVERSE_CONTINUE;
916
 
 
917
 
  switch (kind)
918
 
    {
919
 
    case CORBA::tk_octet:
920
 
      {
921
 
        char* buf;
922
 
        if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
923
 
                          ACE_CDR::OCTET_ALIGN, buf) == 0)
924
 
          {
925
 
            if (src->read_octet_array ((ACE_CDR::Octet*)buf, bounds) == 0)
926
 
              retval = TAO::TRAVERSE_STOP;
927
 
          }
928
 
      }
929
 
      break;
930
 
    case CORBA::tk_boolean:
931
 
      {
932
 
        char* buf;
933
 
        if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
934
 
                          ACE_CDR::OCTET_ALIGN, buf) == 0)
935
 
          {
936
 
            if (src->read_boolean_array ((ACE_CDR::Boolean*)buf, bounds) == 0)
937
 
              retval = TAO::TRAVERSE_STOP;
938
 
          }
939
 
      }
940
 
      break;
941
 
    case CORBA::tk_char:
942
 
      {
943
 
        char* buf;
944
 
        if (dest->adjust (ACE_CDR::OCTET_SIZE * bounds,
945
 
                          ACE_CDR::OCTET_ALIGN, buf) == 0)
946
 
          {
947
 
            if (src->read_char_array ((ACE_CDR::Char*)buf, bounds) == 0)
948
 
              retval = TAO::TRAVERSE_STOP;
949
 
          }
950
 
      }
951
 
      break;
952
 
    case CORBA::tk_short:
953
 
      {
954
 
        char* buf;
955
 
        if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
956
 
                          ACE_CDR::SHORT_ALIGN, buf) == 0)
957
 
          {
958
 
            if (src->read_short_array ((ACE_CDR::Short*)buf, bounds) == 0)
959
 
              retval = TAO::TRAVERSE_STOP;
960
 
          }
961
 
      }
962
 
      break;
963
 
    case CORBA::tk_ushort:
964
 
      {
965
 
        char* buf;
966
 
        if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
967
 
                          ACE_CDR::SHORT_ALIGN, buf) == 0)
968
 
          {
969
 
            if (src->read_ushort_array ((ACE_CDR::UShort*)buf, bounds) == 0)
970
 
              retval = TAO::TRAVERSE_STOP;
971
 
          }
972
 
      }
973
 
      break;
974
 
    case CORBA::tk_wchar:
975
 
      {
976
 
        char* buf;
977
 
        if (dest->adjust (ACE_CDR::SHORT_SIZE * bounds,
978
 
                          ACE_CDR::SHORT_ALIGN, buf) == 0)
979
 
          {
980
 
            if (src->read_wchar_array ((ACE_CDR::WChar*)buf, bounds) == 0)
981
 
              retval = TAO::TRAVERSE_STOP;
982
 
          }
983
 
      }
984
 
      break;
985
 
    case CORBA::tk_long:
986
 
      {
987
 
        char* buf;
988
 
        if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
989
 
                          ACE_CDR::LONG_ALIGN, buf) == 0)
990
 
          {
991
 
            if (src->read_long_array ((ACE_CDR::Long*)buf, bounds) == 0)
992
 
              retval = TAO::TRAVERSE_STOP;
993
 
          }
994
 
      }
995
 
      break;
996
 
    case CORBA::tk_ulong:
997
 
      {
998
 
        char* buf;
999
 
        if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
1000
 
                          ACE_CDR::LONG_ALIGN, buf) == 0)
1001
 
          {
1002
 
            if (src->read_ulong_array ((ACE_CDR::ULong*)buf, bounds) == 0)
1003
 
              retval = TAO::TRAVERSE_STOP;
1004
 
          }
1005
 
      }
1006
 
      break;
1007
 
    case CORBA::tk_float:
1008
 
      {
1009
 
        char* buf;
1010
 
        if (dest->adjust (ACE_CDR::LONG_SIZE * bounds,
1011
 
                          ACE_CDR::LONG_ALIGN, buf) == 0)
1012
 
          {
1013
 
            if (src->read_float_array ((ACE_CDR::Float*)buf, bounds) == 0)
1014
 
              retval = TAO::TRAVERSE_STOP;
1015
 
          }
1016
 
      }
1017
 
      break;
1018
 
    case CORBA::tk_double:
1019
 
      {
1020
 
        char* buf;
1021
 
        if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
1022
 
                          ACE_CDR::LONGLONG_ALIGN, buf) == 0)
1023
 
          {
1024
 
            if (src->read_double_array ((ACE_CDR::Double*)buf, bounds) == 0)
1025
 
              retval = TAO::TRAVERSE_STOP;
1026
 
          }
1027
 
      }
1028
 
      break;
1029
 
    case CORBA::tk_longlong:
1030
 
      {
1031
 
        char* buf;
1032
 
        if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
1033
 
                          ACE_CDR::LONGLONG_ALIGN, buf) == 0)
1034
 
          {
1035
 
            if (src->read_longlong_array ((ACE_CDR::LongLong*)buf, bounds) == 0)
1036
 
              retval = TAO::TRAVERSE_STOP;
1037
 
          }
1038
 
      }
1039
 
      break;
1040
 
    case CORBA::tk_ulonglong:
1041
 
      {
1042
 
        char* buf;
1043
 
        if (dest->adjust (ACE_CDR::LONGLONG_SIZE * bounds,
1044
 
                          ACE_CDR::LONGLONG_ALIGN, buf) == 0)
1045
 
          {
1046
 
            if (src->read_ulonglong_array ((ACE_CDR::ULongLong*)buf, bounds) == 0)
1047
 
              retval = TAO::TRAVERSE_STOP;
1048
 
          }
1049
 
      }
1050
 
      break;
1051
 
    case CORBA::tk_longdouble:
1052
 
      {
1053
 
        char* buf;
1054
 
        if (dest->adjust (ACE_CDR::LONGDOUBLE_SIZE * bounds,
1055
 
                          ACE_CDR::LONGDOUBLE_ALIGN, buf) == 0)
1056
 
          {
1057
 
            if (src->read_longdouble_array ((ACE_CDR::LongDouble*)buf, bounds) == 0)
1058
 
              retval = TAO::TRAVERSE_STOP;
1059
 
          }
1060
 
      }
1061
 
      break;
1062
 
    default:
1063
 
      while (bounds-- && retval == TAO::TRAVERSE_CONTINUE)
1064
 
        {
1065
 
          retval = TAO_Marshal_Object::perform_append (tc2.in (),
1066
 
                                                       src,
1067
 
                                                       dest
1068
 
                                                        ACE_ENV_ARG_PARAMETER);
1069
 
          ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1070
 
        }
1071
 
      break;
1072
 
    }// end of switch
1073
 
 
1074
 
  if (retval == TAO::TRAVERSE_CONTINUE)
1075
 
    return retval;
1076
 
 
1077
 
  // error exit
1078
 
  if (TAO_debug_level > 0)
1079
 
    ACE_DEBUG ((LM_DEBUG,
1080
 
                ACE_TEXT ("TAO_Marshal_Sequence::append detected error\n")));
1081
 
 
1082
 
  ACE_THROW_RETURN (CORBA::MARSHAL (),
1083
 
                    TAO::TRAVERSE_STOP);
1084
 
}
1085
 
 
1086
 
TAO::traverse_status
1087
 
TAO_Marshal_Alias::append (CORBA::TypeCode_ptr  tc,
1088
 
                           TAO_InputCDR *src,
1089
 
                           TAO_OutputCDR *dest
1090
 
                           ACE_ENV_ARG_DECL)
1091
 
{
1092
 
  // Typecode of the aliased type.
1093
 
  CORBA::TypeCode_var tc2;
1094
 
  CORBA::Boolean continue_append = 1;
1095
 
 
1096
 
  // Status of decode operation.
1097
 
  TAO::traverse_status retval =
1098
 
    TAO::TRAVERSE_CONTINUE;
1099
 
 
1100
 
  tc2 = tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
1101
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1102
 
 
1103
 
  retval = TAO_Marshal_Object::perform_append (tc2.in (),
1104
 
                                               src,
1105
 
                                               dest
1106
 
                                                ACE_ENV_ARG_PARAMETER);
1107
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1108
 
 
1109
 
  if (retval == TAO::TRAVERSE_CONTINUE
1110
 
      && continue_append == 1)
1111
 
    return TAO::TRAVERSE_CONTINUE;
1112
 
 
1113
 
  if (TAO_debug_level > 0)
1114
 
    ACE_DEBUG ((LM_DEBUG,
1115
 
                ACE_TEXT ("TAO_Marshal_Alias::append detected error\n")));
1116
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
1117
 
                                    CORBA::COMPLETED_MAYBE),
1118
 
                    TAO::TRAVERSE_STOP);
1119
 
}
1120
 
 
1121
 
// Decode exception For exceptions, the "hidden" type ID near the
1122
 
// front of the on-wire representation was previously unmarshaled and
1123
 
// mapped to the "tc" typcode we're using to traverse the memory ...
1124
 
// at the same time its vtable, refcount, and other state was
1125
 
// established.
1126
 
//
1127
 
// NOTE: This is asymmetric with respect to encoding exceptions.
1128
 
TAO::traverse_status
1129
 
TAO_Marshal_Except::append (CORBA::TypeCode_ptr  tc,
1130
 
                            TAO_InputCDR *src,
1131
 
                            TAO_OutputCDR *dest
1132
 
                            ACE_ENV_ARG_DECL)
1133
 
{
1134
 
  TAO::traverse_status retval =
1135
 
    TAO::TRAVERSE_CONTINUE;
1136
 
  CORBA::Boolean continue_append = 1;
1137
 
  CORBA::TypeCode_var param;
1138
 
 
1139
 
  // first append the RepositoryID
1140
 
  continue_append = dest->append_string (*src);
1141
 
 
1142
 
  // Number of fields in the struct.
1143
 
  int member_count = tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
1144
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1145
 
 
1146
 
  for (int i = 0; i < member_count
1147
 
         && retval == TAO::TRAVERSE_CONTINUE
1148
 
         && continue_append == 1; i++)
1149
 
    {
1150
 
      param = tc->member_type (i ACE_ENV_ARG_PARAMETER);
1151
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1152
 
 
1153
 
      retval = TAO_Marshal_Object::perform_append (param.in (),
1154
 
                                                   src,
1155
 
                                                   dest
1156
 
                                                    ACE_ENV_ARG_PARAMETER);
1157
 
    }
1158
 
 
1159
 
  if (retval == TAO::TRAVERSE_CONTINUE
1160
 
      && continue_append == 1)
1161
 
    return TAO::TRAVERSE_CONTINUE;
1162
 
 
1163
 
  if (TAO_debug_level > 0)
1164
 
    ACE_DEBUG ((LM_DEBUG,
1165
 
                ACE_TEXT ("TAO_Marshal_Except::append detected error\n")));
1166
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
1167
 
                                    CORBA::COMPLETED_MAYBE),
1168
 
                    TAO::TRAVERSE_STOP);
1169
 
}
1170
 
 
1171
 
TAO::traverse_status
1172
 
TAO_Marshal_WString::append (CORBA::TypeCode_ptr,
1173
 
                             TAO_InputCDR *src,
1174
 
                             TAO_OutputCDR *dest
1175
 
                             ACE_ENV_ARG_DECL)
1176
 
{
1177
 
  CORBA::Boolean continue_append = 1;
1178
 
 
1179
 
  // On decode, omit the check against specified wstring bounds, and
1180
 
  // cope with illegal "zero length" strings (all lengths on the wire
1181
 
  // must include a NUL).
1182
 
  //
1183
 
  // This is on the principle of being gracious in what we accept; we
1184
 
  // don't generate messages that fail to comply with protocol specs,
1185
 
  // but we will accept them when it's clear how to do so.
1186
 
 
1187
 
  continue_append = dest->append_wstring (*src);
1188
 
 
1189
 
  if (continue_append == 1)
1190
 
    return TAO::TRAVERSE_CONTINUE;
1191
 
 
1192
 
  if (TAO_debug_level > 0)
1193
 
    ACE_DEBUG ((LM_DEBUG,
1194
 
                ACE_TEXT ("TAO_Marshal_WString::append detected error\n")));
1195
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
1196
 
                                    CORBA::COMPLETED_MAYBE),
1197
 
                    TAO::TRAVERSE_STOP);
1198
 
}
1199
 
 
1200
 
TAO::traverse_status
1201
 
TAO_Marshal_Value::append (CORBA::TypeCode_ptr  tc,
1202
 
                           TAO_InputCDR *src,
1203
 
                           TAO_OutputCDR *dest
1204
 
                           ACE_ENV_ARG_DECL)
1205
 
{
1206
 
  TAO::traverse_status retval =
1207
 
    TAO::TRAVERSE_CONTINUE;
1208
 
  CORBA::TypeCode_var param;
1209
 
 
1210
 
  // Use the same method to append our base valuetype.
1211
 
  // To achive this we'll need to distinguish between
1212
 
  // first-time/nested appends so that we won't attempt to
1213
 
  // append rep_id several times.
1214
 
  //
1215
 
  if (nested_processing_ == 0)
1216
 
    {
1217
 
      nested_processing_ = 1;
1218
 
 
1219
 
      CORBA::ULong value_tag;
1220
 
 
1221
 
      if (!src->read_ulong (value_tag) ||
1222
 
          !dest->write_ulong (value_tag))
1223
 
        {
1224
 
          return TAO::TRAVERSE_STOP;
1225
 
        }
1226
 
 
1227
 
      TAO_Valuetype_Adapter *adapter =
1228
 
        ACE_Dynamic_Service<TAO_Valuetype_Adapter>::instance (
1229
 
            TAO_ORB_Core::valuetype_adapter_name ()
1230
 
          );
1231
 
 
1232
 
      if (adapter == 0)
1233
 
        {
1234
 
          ACE_THROW_RETURN (CORBA::INTERNAL (),
1235
 
                            TAO::TRAVERSE_STOP);
1236
 
        }
1237
 
 
1238
 
      if (value_tag == 0) // Null value type pointer.
1239
 
        {
1240
 
          //We are done.
1241
 
          return retval;
1242
 
        }
1243
 
      else if (value_tag & adapter->type_info_single ())
1244
 
        {
1245
 
          // Append repository id which is of type string.
1246
 
          dest->append_string (*src);
1247
 
        }
1248
 
      else
1249
 
        {
1250
 
          //@@ boris: VT CDR
1251
 
          return TAO::TRAVERSE_STOP;
1252
 
        }
1253
 
    }
1254
 
 
1255
 
  // Handle our base valuetype if any.
1256
 
  param = tc->concrete_base_type (ACE_ENV_SINGLE_ARG_PARAMETER);
1257
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1258
 
 
1259
 
  if (param->kind () != CORBA::tk_null)
1260
 
    {
1261
 
      retval = this->append (param.in (),
1262
 
                             src,
1263
 
                             dest
1264
 
                             ACE_ENV_ARG_PARAMETER);
1265
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1266
 
 
1267
 
      if (retval != TAO::TRAVERSE_CONTINUE)
1268
 
        {
1269
 
          return retval;
1270
 
        }
1271
 
    }
1272
 
 
1273
 
  // Number of fields in the struct.
1274
 
  int member_count = tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
1275
 
  ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1276
 
 
1277
 
  for (int i = 0;
1278
 
       i < member_count && retval == TAO::TRAVERSE_CONTINUE;
1279
 
       i++)
1280
 
    {
1281
 
      // get member type
1282
 
      param = tc->member_type (i ACE_ENV_ARG_PARAMETER);
1283
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1284
 
 
1285
 
      retval =
1286
 
        TAO_Marshal_Object::perform_append (param.in (),
1287
 
                                            src,
1288
 
                                            dest
1289
 
                                             ACE_ENV_ARG_PARAMETER);
1290
 
      ACE_CHECK_RETURN (TAO::TRAVERSE_STOP);
1291
 
    }
1292
 
 
1293
 
  if (retval == TAO::TRAVERSE_CONTINUE)
1294
 
    return TAO::TRAVERSE_CONTINUE;
1295
 
 
1296
 
  if (TAO_debug_level > 0)
1297
 
    ACE_DEBUG ((LM_DEBUG,
1298
 
                ACE_TEXT ("TAO_Marshal_Value::append detected error\n")));
1299
 
 
1300
 
  ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE,
1301
 
                                    CORBA::COMPLETED_MAYBE),
1302
 
                    TAO::TRAVERSE_STOP);
1303
 
}