TAO/tao/Basic_Argument_T.h

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