TAO/tao/VarOut_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    VarOut_T.h
   6  *
   7  *  @author Jeff Parsons
   8  */
   9 //=============================================================================
  10
  11 #ifndef TAO_VAROUT_T_H
  12 #define TAO_VAROUT_T_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include /**/ "tao/Versioned_Namespace.h"
  17
  18 #include "ace/OS_Memory.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 /**
  27  * @class TAO_Var_Base_T
  28  *
  29  * @brief Parametrized implementation of _var base class for structs,
  30  * unions and exceptions.
  31  */
  32 template<typename T>
  33 class TAO_Var_Base_T
  34 {
  35 public:
  36   TAO_Var_Base_T ();
  37   TAO_Var_Base_T (T *);
  38   TAO_Var_Base_T (const TAO_Var_Base_T<T> &);
  39
  40   ~TAO_Var_Base_T ();
  41
  42   T * operator-> ();
  43   const T * operator-> () const;
  44
  45   typedef const T &   _in_type;
  46   typedef       T &   _inout_type;
  47
  48   // Common mapping for fixed and variable size types.
  49   _in_type      in () const;
  50   _inout_type   inout ();
  51
  52   // TAO extension.
  53   T * ptr () const;
  54   operator T *& ();
  55
  56 protected:
  57   T * ptr_;
  58 };
  59
  60 /**
  61  * @class TAO_Fixed_Var_T
  62  *
  63  * @brief Parametrized implementation of _var class for structs, unions,
  64  * and exceptions with members of fixed size.
  65  */
  66 template<typename T>
  67 class TAO_Fixed_Var_T : public TAO_Var_Base_T<T>
  68 {
  69 public:
  70   TAO_Fixed_Var_T ();
  71   TAO_Fixed_Var_T (T *);
  72   TAO_Fixed_Var_T (const TAO_Fixed_Var_T<T> &);
  73
  74   // Fixed-size types only.
  75   TAO_Fixed_Var_T (const T &);
  76
  77   TAO_Fixed_Var_T & operator= (T *);
  78   TAO_Fixed_Var_T & operator= (const TAO_Fixed_Var_T<T> &);
  79
  80   // Fixed-size types only.
  81   TAO_Fixed_Var_T & operator= (const T &);
  82
  83   operator const T & () const;
  84   operator T & ();
  85   operator T & () const;
  86
  87   typedef T &   _out_type;
  88   typedef T     _retn_type;
  89
  90   // Mapping for fixed size types.
  91   _out_type     out ();
  92   _retn_type    _retn ();
  93 };
  94
  95 /**
  96  * @class TAO_Var_Var_T
  97  *
  98  * @brief Parametrized implementation of _var class for structs, unions,
  99  * and exceptions with members of variable size.
 100  */
 101 template<typename T>
 102 class TAO_Var_Var_T : public TAO_Var_Base_T<T>
 103 {
 104 public:
 105   TAO_Var_Var_T ();
 106   TAO_Var_Var_T (T *);
 107   TAO_Var_Var_T (const TAO_Var_Var_T<T> &);
 108
 109   TAO_Var_Var_T & operator= (T *);
 110   TAO_Var_Var_T & operator= (const TAO_Var_Var_T<T> &);
 111
 112   operator const T & () const;
 113   operator T & ();
 114   operator T & () const;
 115
 116   typedef T *&  _out_type;
 117   typedef T *   _retn_type;
 118
 119   // Mapping for variable size types.
 120   _out_type     out ();
 121   _retn_type    _retn ();
 122 };
 123
 124 /**
 125  * @class TAO_Out_T
 126  *
 127  * @brief Parametrized implementation of _out class for structs, unions
 128  * and exceptions..
 129  */
 130 template<typename T>
 131 class TAO_Out_T
 132 {
 133 public:
 134   typedef typename T::_var_type T_var;
 135
 136   TAO_Out_T (T *&);
 137   TAO_Out_T (T_var &);
 138   TAO_Out_T (const TAO_Out_T<T> &);
 139
 140   TAO_Out_T &operator= (const TAO_Out_T<T> &);
 141   TAO_Out_T &operator= (T *);
 142
 143   operator T *& ();
 144   T *& ptr ();
 145   T * operator-> ();
 146
 147 private:
 148   T *& ptr_;
 149
 150   /// Assignment from T_var not allowed.
 151   void operator= (const T_var &);
 152 };
 153
 154 TAO_END_VERSIONED_NAMESPACE_DECL
 155
 156 #if defined (__ACE_INLINE__)
 157 #include "tao/VarOut_T.inl"
 158 #endif /* __ACE_INLINE__ */
 159
 160 #include "tao/VarOut_T.cpp"
 161
 162 #include /**/ "ace/post.h"
 163
 164 #endif /* TAO_VAROUT_T_H */