TAO/tao/AnyTypeCode/Marshal.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    Marshal.cpp
   5  *
   6  *  Implements the Marshal_Object class and the factory
   7  *  The original encoder and decoder code now appears in files encode.cpp and
   8  *  decode.cpp
   9  *
  10  *  @author Aniruddha S. Gokhale
  11  *  @author Copyright 1994-1995 by Sun Microsystems Inc.
  12  */
  13 //=============================================================================
  14
  15 #include "tao/AnyTypeCode/Marshal.h"
  16 #include "tao/AnyTypeCode/TypeCode.h"
  17
  18 #if !defined (__ACE_INLINE__)
  19 # include "tao/AnyTypeCode/Marshal.inl"
  20 #endif /* ! __ACE_INLINE__ */
  21
  22 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  23
  24 TAO_Marshal_Object::~TAO_Marshal_Object ()
  25 {
  26 }
  27
  28 TAO::traverse_status
  29 TAO_Marshal_Object::perform_skip (CORBA::TypeCode_ptr tc, TAO_InputCDR *stream)
  30 {
  31   CORBA::ULong const kind = tc->kind ();
  32
  33   switch (kind)
  34     {
  35     default:
  36     case CORBA::tk_fixed:
  37     case CORBA::tk_native:
  38     case CORBA::tk_abstract_interface:
  39     case CORBA::tk_component:
  40     case CORBA::tk_home:
  41       // @@ We don't know how to handle any of them yet.
  42       return TAO::TRAVERSE_STOP;
  43
  44     case CORBA::tk_null:
  45     case CORBA::tk_void:
  46     case CORBA::tk_short:
  47     case CORBA::tk_long:
  48     case CORBA::tk_ushort:
  49     case CORBA::tk_ulong:
  50     case CORBA::tk_float:
  51     case CORBA::tk_double:
  52     case CORBA::tk_boolean:
  53     case CORBA::tk_char:
  54     case CORBA::tk_octet:
  55     case CORBA::tk_longlong:
  56     case CORBA::tk_ulonglong:
  57     case CORBA::tk_longdouble:
  58     case CORBA::tk_wchar:
  59     case CORBA::tk_enum:
  60       {
  61         TAO_Marshal_Primitive marshal;
  62         return marshal.skip (tc, stream);
  63       }
  64
  65     case CORBA::tk_any:
  66       {
  67         TAO_Marshal_Any marshal;
  68         return marshal.skip (tc, stream);
  69       }
  70     case CORBA::tk_TypeCode:
  71       {
  72         TAO_Marshal_TypeCode marshal;
  73         return marshal.skip (tc, stream);
  74       }
  75     case CORBA::tk_Principal:
  76       {
  77         TAO_Marshal_Principal marshal;
  78         return marshal.skip (tc, stream);
  79       }
  80     case CORBA::tk_objref:
  81       {
  82         TAO_Marshal_ObjRef marshal;
  83         return marshal.skip (tc, stream);
  84       }
  85     case CORBA::tk_struct:
  86       {
  87         TAO_Marshal_Struct marshal;
  88         return marshal.skip (tc, stream);
  89       }
  90     case CORBA::tk_union:
  91       {
  92         TAO_Marshal_Union marshal;
  93         return marshal.skip (tc, stream);
  94       }
  95     case CORBA::tk_string:
  96       {
  97         TAO_Marshal_String marshal;
  98         return marshal.skip (tc, stream);
  99       }
 100     case CORBA::tk_sequence:
 101       {
 102         TAO_Marshal_Sequence marshal;
 103         return marshal.skip (tc, stream);
 104       }
 105     case CORBA::tk_array:
 106       {
 107         TAO_Marshal_Array marshal;
 108         return marshal.skip (tc, stream);
 109       }
 110     case CORBA::tk_alias:
 111       {
 112         TAO_Marshal_Alias marshal;
 113         return marshal.skip (tc, stream);
 114       }
 115     case CORBA::tk_except:
 116       {
 117         TAO_Marshal_Except marshal;
 118         return marshal.skip (tc, stream);
 119       }
 120     case CORBA::tk_wstring:
 121       {
 122         TAO_Marshal_WString marshal;
 123         return marshal.skip (tc, stream);
 124       }
 125     case CORBA::tk_value_box:
 126     case CORBA::tk_value:
 127     case CORBA::tk_event:
 128       {
 129         TAO_Marshal_Value marshal;
 130         return marshal.skip (tc, stream);
 131       }
 132     }
 133 }
 134
 135 TAO::traverse_status
 136 TAO_Marshal_Object::perform_append (CORBA::TypeCode_ptr tc,
 137                                     TAO_InputCDR *src,
 138                                     TAO_OutputCDR *dest)
 139 {
 140   CORBA::ULong kind = tc->kind ();
 141
 142   switch (kind)
 143     {
 144     default:
 145     case CORBA::tk_fixed:
 146     case CORBA::tk_native:
 147     case CORBA::tk_abstract_interface:
 148     case CORBA::tk_component:
 149     case CORBA::tk_home:
 150       // @@ We don't know how to handle any of them yet.
 151       return TAO::TRAVERSE_STOP;
 152
 153     case CORBA::tk_null:
 154     case CORBA::tk_void:
 155     case CORBA::tk_short:
 156     case CORBA::tk_long:
 157     case CORBA::tk_ushort:
 158     case CORBA::tk_ulong:
 159     case CORBA::tk_float:
 160     case CORBA::tk_double:
 161     case CORBA::tk_boolean:
 162     case CORBA::tk_char:
 163     case CORBA::tk_octet:
 164     case CORBA::tk_longlong:
 165     case CORBA::tk_ulonglong:
 166     case CORBA::tk_longdouble:
 167     case CORBA::tk_wchar:
 168     case CORBA::tk_enum:
 169       {
 170         TAO_Marshal_Primitive marshal;
 171         return marshal.append (tc, src, dest);
 172       }
 173
 174     case CORBA::tk_any:
 175       {
 176         TAO_Marshal_Any marshal;
 177         return marshal.append (tc, src, dest);
 178       }
 179     case CORBA::tk_TypeCode:
 180       {
 181         TAO_Marshal_TypeCode marshal;
 182         return marshal.append (tc, src, dest);
 183       }
 184     case CORBA::tk_Principal:
 185       {
 186         TAO_Marshal_Principal marshal;
 187         return marshal.append (tc, src, dest);
 188       }
 189     case CORBA::tk_objref:
 190       {
 191         TAO_Marshal_ObjRef marshal;
 192         return marshal.append (tc, src, dest);
 193       }
 194     case CORBA::tk_struct:
 195       {
 196         TAO_Marshal_Struct marshal;
 197         return marshal.append (tc, src, dest);
 198       }
 199     case CORBA::tk_union:
 200       {
 201         TAO_Marshal_Union marshal;
 202         return marshal.append (tc, src, dest);
 203       }
 204     case CORBA::tk_string:
 205       {
 206         TAO_Marshal_String marshal;
 207         return marshal.append (tc, src, dest);
 208       }
 209     case CORBA::tk_sequence:
 210       {
 211         TAO_Marshal_Sequence marshal;
 212         return marshal.append (tc, src, dest);
 213       }
 214     case CORBA::tk_array:
 215       {
 216         TAO_Marshal_Array marshal;
 217         return marshal.append (tc, src, dest);
 218       }
 219     case CORBA::tk_alias:
 220       {
 221         TAO_Marshal_Alias marshal;
 222         return marshal.append (tc, src, dest);
 223       }
 224     case CORBA::tk_except:
 225       {
 226         TAO_Marshal_Except marshal;
 227         return marshal.append (tc, src, dest);
 228       }
 229     case CORBA::tk_wstring:
 230       {
 231         TAO_Marshal_WString marshal;
 232         return marshal.append (tc, src, dest);
 233       }
 234     case CORBA::tk_value_box:
 235     case CORBA::tk_value:
 236     case CORBA::tk_event:
 237       {
 238         TAO_Marshal_Value marshal;
 239         return marshal.append (tc, src, dest);
 240       }
 241     }
 242 }
 243
 244 TAO_END_VERSIONED_NAMESPACE_DECL