TAO/tao/AnyTypeCode/Marshal.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Marshal.h
   6  *
   7  *   Classes that marshal various IDL data types.
   8  *
   9  *  @author  Aniruddha S. Gokhale
  10  */
  11 //=============================================================================
  12
  13
  14 #ifndef TAO_MARSHAL_H
  15 #define TAO_MARSHAL_H
  16
  17 #include /**/ "ace/pre.h"
  18
  19 #include "tao/Basic_Types.h"
  20
  21 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  22 # pragma once
  23 #endif /* ACE_LACKS_PRAGMA_ONCE */
  24
  25 #include "tao/AnyTypeCode/TAO_AnyTypeCode_Export.h"
  26
  27 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  28
  29 namespace CORBA
  30 {
  31   class TypeCode;
  32   typedef TypeCode *TypeCode_ptr;
  33 }
  34
  35 class TAO_OutputCDR;
  36 class TAO_InputCDR;
  37
  38 // = Forward declarations.
  39 class TAO_Marshal_Object;
  40 class TAO_Marshal_Primitive;
  41 class TAO_Marshal_Any;
  42 class TAO_Marshal_TypeCode;
  43 class TAO_Marshal_Principal;
  44 class TAO_Marshal_ObjRef;
  45 class TAO_Marshal_Struct;
  46 class TAO_Marshal_Union;
  47 class TAO_Marshal_String;
  48 class TAO_Marshal_Sequence;
  49 class TAO_Marshal_Array;
  50 class TAO_Marshal_Alias;
  51 class TAO_Marshal_Except;
  52 class TAO_Marshal_WString;
  53 class TAO_Marshal_Value;
  54
  55 namespace TAO
  56 {
  57   enum traverse_status
  58     {
  59       TRAVERSE_STOP,
  60       TRAVERSE_CONTINUE
  61     };
  62 }
  63
  64 /**
  65  * @class TAO_Marshal_Object
  66  *
  67  * @brief TAO_Marshal_Object
  68  *
  69  * The Marshaling object that provides a common interface to the
  70  * CDR object for marshaling different IDL data types
  71  * Provides a set of virtual methods for appending and skipping
  72  * data over a CDR stream.
  73  */
  74 class TAO_AnyTypeCode_Export TAO_Marshal_Object
  75 {
  76 public:
  77   /// constructor
  78   TAO_Marshal_Object ();
  79
  80   /// destructor
  81   virtual ~TAO_Marshal_Object ();
  82
  83   /// skip entry point, it allocates the right kind of Marshal_Object
  84   /// and invokes skip on it.
  85   static TAO::traverse_status perform_skip (CORBA::TypeCode_ptr tc,
  86                                             TAO_InputCDR *context);
  87
  88   /// skip operation
  89   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
  90                                      TAO_InputCDR *context) = 0;
  91
  92   /// append entry point, it allocates the right kind of Marshal_Object
  93   /// and invokes skip on it.
  94   static TAO::traverse_status perform_append (CORBA::TypeCode_ptr tc,
  95                                               TAO_InputCDR *src,
  96                                               TAO_OutputCDR *dest);
  97
  98   /// append operation
  99   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 100                                        TAO_InputCDR *src,
 101                                        TAO_OutputCDR *dest) = 0;
 102 };
 103
 104 /**
 105  * @class TAO_Marshal_Primitive:
 106  *
 107  * @brief TAO_Marshal_Primitive
 108  *
 109  * marshaling primitives
 110  */
 111 class TAO_AnyTypeCode_Export TAO_Marshal_Primitive: public TAO_Marshal_Object
 112 {
 113 public:
 114   TAO_Marshal_Primitive ();
 115
 116   /// skip operation
 117   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 118                                      TAO_InputCDR *context);
 119
 120   /// append operation
 121   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 122                                        TAO_InputCDR *src,
 123                                        TAO_OutputCDR *dest);
 124 };
 125
 126 /**
 127  * @class TAO_Marshal_Any:
 128  *
 129  * @brief TAO_Marshal_Any
 130  *
 131  * Marshal an Any
 132  */
 133 class TAO_AnyTypeCode_Export TAO_Marshal_Any: public TAO_Marshal_Object
 134 {
 135 public:
 136   TAO_Marshal_Any ();
 137
 138   /// skip operation
 139   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 140                                      TAO_InputCDR *context);
 141
 142   /// append operation
 143   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 144                                        TAO_InputCDR *src,
 145                                        TAO_OutputCDR *dest);
 146 };
 147
 148 /**
 149  * @class TAO_Marshal_TypeCode
 150  *
 151  * @brief TAO_Marshal_TypeCode
 152  *
 153  * marshal a typecode
 154  */
 155 class TAO_AnyTypeCode_Export TAO_Marshal_TypeCode: public TAO_Marshal_Object
 156 {
 157 public:
 158   TAO_Marshal_TypeCode ();
 159
 160   /// skip operation
 161   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 162                                      TAO_InputCDR *context);
 163
 164   /// append operation
 165   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 166                                        TAO_InputCDR *src,
 167                                        TAO_OutputCDR *dest);
 168 };
 169
 170 /**
 171  * @class TAO_Marshal_Principal
 172  *
 173  * @brief TAO_Marshal_Principal
 174  *
 175  * marshal a principal
 176  */
 177 class TAO_AnyTypeCode_Export TAO_Marshal_Principal: public TAO_Marshal_Object
 178 {
 179 public:
 180   TAO_Marshal_Principal ();
 181
 182   /// skip operation
 183   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 184                                      TAO_InputCDR *context);
 185
 186   /// append operation
 187   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 188                                        TAO_InputCDR *src,
 189                                        TAO_OutputCDR *dest);
 190 };
 191
 192 /**
 193  * @class TAO_Marshal_ObjRef
 194  *
 195  * @brief TAO_Marshal_ObjRef
 196  *
 197  * marshal an object reference
 198  */
 199 class TAO_AnyTypeCode_Export TAO_Marshal_ObjRef: public TAO_Marshal_Object
 200 {
 201 public:
 202   TAO_Marshal_ObjRef ();
 203
 204   /// skip operation
 205   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 206                                      TAO_InputCDR *context);
 207
 208   /// append operation
 209   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 210                                        TAO_InputCDR *src,
 211                                        TAO_OutputCDR *dest);
 212 };
 213
 214 /**
 215  * @class TAO_Marshal_Struct
 216  *
 217  * @brief TAO_Marshal_Struct
 218  *
 219  * marshal a struct
 220  */
 221 class TAO_AnyTypeCode_Export TAO_Marshal_Struct : public TAO_Marshal_Object
 222 {
 223 public:
 224   TAO_Marshal_Struct ();
 225
 226   /// skip operation
 227   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 228                                      TAO_InputCDR *context);
 229
 230   /// append operation
 231   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 232                                        TAO_InputCDR *src,
 233                                        TAO_OutputCDR *dest);
 234 };
 235
 236 /**
 237  * @class TAO_Marshal_Union
 238  *
 239  * @brief TAO_Marshal_Union
 240  *
 241  * marshal a union
 242  */
 243 class TAO_AnyTypeCode_Export TAO_Marshal_Union: public TAO_Marshal_Object
 244 {
 245 public:
 246   TAO_Marshal_Union ();
 247
 248   /// skip operation
 249   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 250                                      TAO_InputCDR *context);
 251
 252   /// append operation
 253   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 254                                        TAO_InputCDR *src,
 255                                        TAO_OutputCDR *dest);
 256 };
 257
 258 /**
 259  * @class TAO_Marshal_String
 260  *
 261  * @brief TAO_Marshal_String
 262  *
 263  * marshal a string
 264  */
 265 class TAO_AnyTypeCode_Export TAO_Marshal_String: public TAO_Marshal_Object
 266 {
 267 public:
 268   TAO_Marshal_String ();
 269
 270   /// skip operation
 271   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 272                                      TAO_InputCDR *context);
 273
 274   /// append operation
 275   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 276                                        TAO_InputCDR *src,
 277                                        TAO_OutputCDR *dest);
 278 };
 279
 280 /**
 281  * @class TAO_Marshal_Sequence
 282  *
 283  * @brief TAO_Marshal_Sequence
 284  *
 285  * marshal a sequence
 286  */
 287 class TAO_AnyTypeCode_Export TAO_Marshal_Sequence: public TAO_Marshal_Object
 288 {
 289 public:
 290   TAO_Marshal_Sequence ();
 291
 292   /// skip operation
 293   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 294                                      TAO_InputCDR *context);
 295
 296   /// append operation
 297   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 298                                        TAO_InputCDR *src,
 299                                        TAO_OutputCDR *dest);
 300 };
 301
 302 /**
 303  * @class TAO_Marshal_Array
 304  *
 305  * @brief TAO_Marshal_Array
 306  *
 307  * marshal an array
 308  */
 309 class TAO_AnyTypeCode_Export TAO_Marshal_Array: public TAO_Marshal_Object
 310 {
 311 public:
 312   TAO_Marshal_Array ();
 313
 314   /// skip operation
 315   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 316                                      TAO_InputCDR *context);
 317
 318   /// append operation
 319   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 320                                        TAO_InputCDR *src,
 321                                        TAO_OutputCDR *dest);
 322 };
 323
 324 /**
 325  * @class TAO_Marshal_Alias
 326  *
 327  * @brief TAO_Marshal_Alias
 328  *
 329  * marshal an alias
 330  */
 331 class TAO_AnyTypeCode_Export TAO_Marshal_Alias: public TAO_Marshal_Object
 332 {
 333 public:
 334   TAO_Marshal_Alias ();
 335
 336   /// skip operation
 337   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 338                                      TAO_InputCDR *context);
 339
 340   /// append operation
 341   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 342                                        TAO_InputCDR *src,
 343                                        TAO_OutputCDR *dest);
 344 };
 345
 346 /**
 347  * @class TAO_Marshal_Except
 348  *
 349  * @brief TAO_Marshal_Except
 350  *
 351  * marshal an exception
 352  */
 353 class TAO_AnyTypeCode_Export TAO_Marshal_Except: public TAO_Marshal_Object
 354 {
 355 public:
 356   TAO_Marshal_Except ();
 357
 358   /// skip operation
 359   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 360                                      TAO_InputCDR *context);
 361
 362   /// append operation
 363   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 364                                        TAO_InputCDR *src,
 365                                        TAO_OutputCDR *dest);
 366 };
 367
 368 /**
 369  * @class TAO_Marshal_WString
 370  *
 371  * @brief TAO_Marshal_WString
 372  *
 373  * marshal a wide string
 374  */
 375 class TAO_AnyTypeCode_Export TAO_Marshal_WString : public TAO_Marshal_Object
 376 {
 377 public:
 378   TAO_Marshal_WString ();
 379
 380   /// skip operation
 381   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 382                                      TAO_InputCDR *context);
 383
 384   /// append operation
 385   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 386                                        TAO_InputCDR *src,
 387                                        TAO_OutputCDR *dest);
 388 };
 389
 390 /**
 391  * @class TAO_Marshal_Value
 392  *
 393  * @brief TAO_Marshal_Value
 394  *
 395  * marshal a valuetype
 396  */
 397 class TAO_AnyTypeCode_Export TAO_Marshal_Value: public TAO_Marshal_Object
 398 {
 399 public:
 400   TAO_Marshal_Value ();
 401
 402   /// skip operation
 403   virtual TAO::traverse_status skip (CORBA::TypeCode_ptr tc,
 404                                      TAO_InputCDR *context);
 405
 406   /// append operation
 407   virtual TAO::traverse_status append (CORBA::TypeCode_ptr tc,
 408                                        TAO_InputCDR *src,
 409                                        TAO_OutputCDR *dest);
 410
 411 private:
 412   CORBA::Boolean nested_processing_;
 413 };
 414
 415 TAO_END_VERSIONED_NAMESPACE_DECL
 416
 417 #if defined (__ACE_INLINE__)
 418 # include "tao/AnyTypeCode/Marshal.inl"
 419 #endif /* __ACE_INLINE__ */
 420
 421 #include /**/ "ace/post.h"
 422 #endif /* TAO_MARSHAL_H */