TAO/tao/Vector_Argument_T.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Vector_Argument_T.h
   6  *
   7  *  @author Jeff Parsons
   8  */
   9 //=============================================================================
  10
  11 #ifndef TAO_VECTOR_ARGUMENT_T_H
  12 #define TAO_VECTOR_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_Vector_Argument_T
  28    *
  29    * @brief Template class for IN stub argument of
  30    * unbounded sequence IDL types.
  31    *
  32    */
  33   template<typename S,
  34            template <typename> class Insert_Policy>
  35   class In_Vector_Argument_T : public InArgument
  36   {
  37   public:
  38     In_Vector_Argument_T (S const & x);
  39
  40     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
  41 #if TAO_HAS_INTERCEPTORS == 1
  42     virtual void interceptor_value (CORBA::Any *any) const;
  43 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  44     S const & arg () const;
  45
  46   protected:
  47     S const & x_;
  48   };
  49
  50   /**
  51    * @class In_Vector_Clonable_Argument_T
  52    *
  53    * @brief Template class for IN stub argument of
  54    * unbounded sequence IDL types.
  55    *
  56    */
  57   template<typename S,
  58            template <typename> class Insert_Policy>
  59   class In_Vector_Clonable_Argument_T :
  60           public In_Vector_Argument_T<S, Insert_Policy>
  61   {
  62   public:
  63     In_Vector_Clonable_Argument_T (S const & x);
  64     virtual ~In_Vector_Clonable_Argument_T ();
  65
  66     virtual Argument* clone ();
  67
  68   private:
  69     bool is_clone_;
  70   };
  71
  72   /**
  73    * @class Inout_Vector_Argument_T
  74    *
  75    * @brief Template class for INOUT stub argument of
  76    * unbounded sequence IDL types.
  77    *
  78    */
  79   template<typename S,
  80            template <typename> class Insert_Policy>
  81   class Inout_Vector_Argument_T : public InoutArgument
  82   {
  83   public:
  84     Inout_Vector_Argument_T (S & x);
  85
  86     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
  87     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
  88 #if TAO_HAS_INTERCEPTORS == 1
  89     virtual void interceptor_value (CORBA::Any *any) const;
  90 #endif /* TAO_HAS_INTERCEPTORS == 1 */
  91     S & arg ();
  92
  93   private:
  94     S & x_;
  95   };
  96
  97   /**
  98    * @class Out_Vector_Argument_T
  99    *
 100    * @brief Template class for OUT stub argument of
 101    * unbounded sequence IDL types.
 102    *
 103    */
 104   template<typename S,
 105            template <typename> class Insert_Policy>
 106   class Out_Vector_Argument_T : public OutArgument
 107   {
 108   public:
 109     Out_Vector_Argument_T (S & x);
 110
 111     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
 112 #if TAO_HAS_INTERCEPTORS == 1
 113     virtual void interceptor_value (CORBA::Any *any) const;
 114 #endif /* TAO_HAS_INTERCEPTORS == 1 */
 115     S & arg ();
 116
 117   private:
 118     S & x_;
 119   };
 120
 121   /**
 122    * @class Ret_Vector_Argument_T
 123    *
 124    * @brief Template class for return stub value of fixed size IDL types.
 125    *
 126    */
 127   template<typename S,
 128            template <typename> class Insert_Policy>
 129   class Ret_Vector_Argument_T : public RetArgument
 130   {
 131   public:
 132     Ret_Vector_Argument_T ();
 133
 134     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
 135 #if TAO_HAS_INTERCEPTORS == 1
 136     virtual void interceptor_value (CORBA::Any *any) const;
 137 #endif /* TAO_HAS_INTERCEPTORS == 1 */
 138     S & arg ();
 139
 140     S excp ();
 141     S retn ();
 142
 143   protected:
 144     S x_;
 145   };
 146
 147   /**
 148    * @struct Vector_Arg_Traits_T
 149    *
 150    * @brief Template class for stub argument traits of
 151    *  sequence IDL types, when the STL mapping is used by
 152    *  the IDL compiler. The ret_type and out_type typedefs
 153    *  are different from Vector_Arg_Traits_T.
 154    *
 155    */
 156   template<typename T,
 157            template <typename> class Insert_Policy>
 158   struct Vector_Arg_Traits_T
 159   {
 160     typedef T                                           ret_type;
 161     typedef T const &                                   in_type;
 162     typedef T &                                         inout_type;
 163     typedef T &                                         out_type;
 164
 165     typedef In_Vector_Argument_T<T, Insert_Policy>    in_arg_val;
 166     typedef In_Vector_Clonable_Argument_T<T, Insert_Policy>
 167                                                         in_clonable_arg_val;
 168     typedef Inout_Vector_Argument_T<T, Insert_Policy> inout_arg_val;
 169     typedef Out_Vector_Argument_T<T, Insert_Policy>   out_arg_val;
 170     typedef Ret_Vector_Argument_T<T, Insert_Policy>   ret_val;
 171   };
 172 }
 173
 174 TAO_END_VERSIONED_NAMESPACE_DECL
 175
 176 #if defined (__ACE_INLINE__)
 177 #include "tao/Vector_Argument_T.inl"
 178 #endif /* __ACE_INLINE__ */
 179
 180 #include "tao/Vector_Argument_T.cpp"
 181
 182 #include /**/ "ace/post.h"
 183
 184 #endif /* TAO_VECTOR_ARGUMENT_T_H */