TAO/tao/Object_Argument_T.h

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