TAO: Fixed_Size_Argument

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file    Fixed_Size_Argument_T.h
00006  *
00007  *  $Id: Fixed_Size_Argument_T.h 90586 2010-06-14 13:48:01Z parsons $
00008  *
00009  *  @authors Jeff Parsons and Carlos O'Ryan
00010  */
00011 //=============================================================================
00012 
00013 #ifndef TAO_FIXED_SIZE_ARGUMENT_T_H
00014 #define TAO_FIXED_SIZE_ARGUMENT_T_H
00015 
00016 #include /**/ "ace/pre.h"
00017 #include "tao/Argument.h"
00018 
00019 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00020 # pragma once
00021 #endif /* ACE_LACKS_PRAGMA_ONCE */
00022 
00023 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
00024 
00025 namespace TAO
00026 {
00027   /**
00028    * @class In_Fixed_Size_Argument_T
00029    *
00030    * @brief Template class for IN stub argument of fixed size IDL types.
00031    *
00032    */
00033   template<typename S,
00034            template <typename> class Insert_Policy>
00035   class In_Fixed_Size_Argument_T : public InArgument
00036   {
00037   public:
00038     In_Fixed_Size_Argument_T (S const & x);
00039 
00040     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
00041 #if TAO_HAS_INTERCEPTORS == 1
00042     virtual void interceptor_value (CORBA::Any *any) const;
00043 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00044     S const & arg (void) const;
00045 
00046   protected:
00047     S const * x_;
00048   };
00049 
00050   /**
00051    * @class In_Fixed_Size_Clonable_Argument_T
00052    *
00053    * @brief Template class for IN stub argument of fixed size IDL types.
00054    *
00055    */
00056   template<typename S,
00057            template <typename> class Insert_Policy>
00058   class In_Fixed_Size_Clonable_Argument_T :
00059           public In_Fixed_Size_Argument_T<S, Insert_Policy>
00060   {
00061   public:
00062     In_Fixed_Size_Clonable_Argument_T (S const & x);
00063     virtual ~In_Fixed_Size_Clonable_Argument_T (void);
00064 
00065     virtual Argument* clone (void);
00066 
00067   private:
00068     bool is_clone_;
00069   };
00070 
00071   /**
00072    * @class Inout_Fixed_Size_Argument_T
00073    *
00074    * @brief Template class for INOUT stub argument of fixed size IDL types.
00075    *
00076    */
00077   template<typename S,
00078            template <typename> class Insert_Policy>
00079   class Inout_Fixed_Size_Argument_T : public InoutArgument
00080   {
00081   public:
00082     Inout_Fixed_Size_Argument_T (S & x);
00083 
00084     virtual CORBA::Boolean marshal (TAO_OutputCDR &cdr);
00085     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
00086 #if TAO_HAS_INTERCEPTORS == 1
00087     virtual void interceptor_value (CORBA::Any *any) const;
00088 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00089     S & arg (void);
00090 
00091   private:
00092     S * x_;
00093   };
00094 
00095   /**
00096    * @class Out_Fixed_Size_Argument_T
00097    *
00098    * @brief Template class for OUT stub argument of fixed size IDL types.
00099    *
00100    */
00101   template<typename S,
00102            template <typename> class Insert_Policy>
00103   class Out_Fixed_Size_Argument_T : public OutArgument
00104   {
00105   public:
00106     Out_Fixed_Size_Argument_T (S & x);
00107 
00108     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
00109 #if TAO_HAS_INTERCEPTORS == 1
00110     virtual void interceptor_value (CORBA::Any *any) const;
00111 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00112     S & arg (void);
00113 
00114   private:
00115     S & x_;
00116   };
00117 
00118   /**
00119    * @class Ret_Fixed_Size_Argument_T
00120    *
00121    * @brief Template class for return stub value of fixed size IDL types.
00122    *
00123    */
00124   template<typename S,
00125            template <typename> class Insert_Policy>
00126   class Ret_Fixed_Size_Argument_T : public RetArgument
00127   {
00128   public:
00129     Ret_Fixed_Size_Argument_T (void);
00130 
00131     virtual CORBA::Boolean demarshal (TAO_InputCDR &);
00132 #if TAO_HAS_INTERCEPTORS == 1
00133     virtual void interceptor_value (CORBA::Any *any) const;
00134 #endif /* TAO_HAS_INTERCEPTORS == 1 */
00135     S & arg (void);
00136     S excp (void);
00137     S retn (void);
00138 
00139   protected:
00140     S x_;
00141   };
00142 
00143   /**
00144    * @struct Fixed_Size_Arg_Traits_T
00145    *
00146    * @brief Template class for argument traits of fixed size IDL types.
00147    *
00148    */
00149   template<typename T,
00150            template <typename> class Insert_Policy>
00151   struct Fixed_Size_Arg_Traits_T
00152   {
00153     typedef T                                            ret_type;
00154     typedef T const &                                    in_type;
00155     typedef T &                                          inout_type;
00156     typedef T &                                          out_type;
00157 
00158     typedef In_Fixed_Size_Argument_T<T,Insert_Policy>    in_arg_val;
00159     typedef In_Fixed_Size_Clonable_Argument_T<T,Insert_Policy>
00160                                                          in_clonable_arg_val;
00161     typedef Inout_Fixed_Size_Argument_T<T,Insert_Policy> inout_arg_val;
00162     typedef Out_Fixed_Size_Argument_T<T,Insert_Policy>   out_arg_val;
00163     typedef Ret_Fixed_Size_Argument_T<T,Insert_Policy>   ret_val;
00164   };
00165 }
00166 
00167 TAO_END_VERSIONED_NAMESPACE_DECL
00168 
00169 #if defined (__ACE_INLINE__)
00170 #include "tao/Fixed_Size_Argument_T.inl"
00171 #endif /* __ACE_INLINE__ */
00172 
00173 #if defined (ACE_TEMPLATES_REQUIRE_SOURCE)
00174 #include "tao/Fixed_Size_Argument_T.cpp"
00175 #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
00176 
00177 #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA)
00178 #pragma implementation ("Fixed_Size_Argument_T.cpp")
00179 #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
00180 
00181 #include /**/ "ace/post.h"
00182 
00183 #endif /* TAO_FIXED_SIZE_ARGUMENT_T_H */