TAO: Fixed_Array_Argument

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