TAO/tao/Var_Array_Argument_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Var_Array_Argument_T.h
   6  *
   7  *  @authors Jeff Parsons and Carlos O'Ryan
   8  */
   9 //=============================================================================
  10
  11 #ifndef TAO_VAR_ARRAY_ARGUMENT_T_H
  12 #define TAO_VAR_ARRAY_ARGUMENT_T_H
  13
  14 #include /**/ "ace/pre.h"
  15
  16 #include "tao/Argument.h"
  17
  18 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  19 # pragma once
  20 #endif /* ACE_LACKS_PRAGMA_ONCE */
  21
  22 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  23
  24 namespace TAO
  25 {
  26   /**
  27    * @class In_Var_Array_Argument_T
  28    *
  29    * @brief IN stub argument of variable size element array.
  30    *
  31    */
  32   template<typename S_forany,
  33            template <typename> class Insert_Policy>
  34   class In_Var_Array_Argument_T : public InArgument
  35   {
  36   public:
  37     In_Var_Array_Argument_T (const typename S_forany::_slice_type * x);
  38
  39     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
  40 #if TAO_HAS_INTERCEPTORS == 1
  41     virtual void interceptor_value (CORBA::Any *any) const;
  42 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  43     typename S_forany::_slice_type const * arg () const;
  44
  45   protected:
  46     S_forany x_;
  47   };
  48
  49   /**
  50    * @class In_Var_Array_Clonable_Argument_T
  51    *
  52    * @brief IN stub argument of variable size element array.
  53    *
  54    */
  55   template<typename S_forany,
  56            template <typename> class Insert_Policy>
  57   class In_Var_Array_Clonable_Argument_T :
  58           public In_Var_Array_Argument_T<S_forany, Insert_Policy>
  59   {
  60   public:
  61     In_Var_Array_Clonable_Argument_T (const typename S_forany::_slice_type * x);
  62     virtual ~In_Var_Array_Clonable_Argument_T ();
  63
  64     virtual Argument* clone ();
  65
  66   private:
  67     bool is_clone_;
  68   };
  69
  70   /**
  71    * @class Inout_Var_Array_Argument_T
  72    *
  73    * @brief INOUT stub argument of variable size element array.
  74    *
  75    */
  76   template<typename S_forany,
  77            template <typename> class Insert_Policy>
  78   class Inout_Var_Array_Argument_T : public InoutArgument
  79   {
  80   public:
  81     Inout_Var_Array_Argument_T (typename S_forany::_slice_type *&x);
  82
  83     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
  84     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
  85 #if TAO_HAS_INTERCEPTORS == 1
  86     virtual void interceptor_value (CORBA::Any *any) const;
  87 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  88     typename S_forany::_slice_type * arg ();
  89
  90   private:
  91     S_forany x_;
  92   };
  93
  94   /**
  95    * @class Out_Var_Array_Argument_T
  96    *
  97    * @brief OUT stub argument of variable size element array.
  98    *
  99    */
 100   template<typename S_out,
 101            typename S_forany,
 102            template <typename> class Insert_Policy>
 103   class Out_Var_Array_Argument_T : public OutArgument
 104   {
 105   public:
 106     Out_Var_Array_Argument_T (S_out x);
 107
 108     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
 109 #if TAO_HAS_INTERCEPTORS == 1
 110     virtual void interceptor_value (CORBA::Any *any) const;
 111 #endif /* TAO_HAS_INTERCEPTORS == 1 */
 112     typename S_forany::_slice_type *& arg ();
 113
 114   private:
 115     typename S_forany::_slice_type *& x_;
 116   };
 117
 118   /**
 119    * @class Ret_Var_Array_Argument_T
 120    *
 121    * @brief Return stub value of variable size element array.
 122    *
 123    */
 124   template<typename S_var,
 125            typename S_forany,
 126            template <typename> class Insert_Policy>
 127   class Ret_Var_Array_Argument_T : public RetArgument
 128   {
 129   public:
 130     Ret_Var_Array_Argument_T ();
 131
 132     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
 133 #if TAO_HAS_INTERCEPTORS == 1
 134     virtual void interceptor_value (CORBA::Any *any) const;
 135 #endif /* TAO_HAS_INTERCEPTORS == 1 */
 136     typename S_forany::_slice_type *& arg ();
 137
 138     typename S_forany::_slice_type * excp ();
 139     typename S_forany::_slice_type * retn ();
 140
 141   private:
 142     S_var x_;
 143   };
 144
 145   /**
 146    * @struct Var_Array_Arg_Traits_T
 147    *
 148    * @brief Argument traits of variable size element array.
 149    *
 150    */
 151   template<typename T_out,
 152            typename T_forany,
 153            template <typename> class Insert_Policy>
 154   struct Var_Array_Arg_Traits_T
 155   {
 156     typedef typename T_forany::_slice_type *            ret_type;
 157     typedef const typename T_forany::_array_type        in_type;
 158     typedef typename T_forany::_array_type              inout_type;
 159     typedef T_out                                       out_type;
 160
 161     typedef In_Var_Array_Argument_T<T_forany,
 162                                     Insert_Policy>      in_arg_val;
 163     typedef In_Var_Array_Clonable_Argument_T<T_forany,
 164                                              Insert_Policy>
 165                                                         in_clonable_arg_val;
 166     typedef Inout_Var_Array_Argument_T<T_forany,
 167                                        Insert_Policy>   inout_arg_val;
 168     typedef Out_Var_Array_Argument_T<T_out,
 169                                      T_forany,
 170                                      Insert_Policy>     out_arg_val;
 171     typedef Ret_Var_Array_Argument_T<typename T_out::_var_type,
 172                                      T_forany,
 173                                      Insert_Policy>     ret_val;
 174   };
 175 }
 176
 177 TAO_END_VERSIONED_NAMESPACE_DECL
 178
 179 #if defined (__ACE_INLINE__)
 180 #include "tao/Var_Array_Argument_T.inl"
 181 #endif /* __ACE_INLINE__ */
 182
 183 #include "tao/Var_Array_Argument_T.cpp"
 184
 185 #include /**/ "ace/post.h"
 186
 187 #endif /* TAO_VAR_ARRAY_ARGUMENT_T_H */