ACE: CDR_Size.h Source File

00001 // -*- C++ -*-
00002 
00003 //=============================================================================
00004 /**
00005  *  @file   CDR_Size.h
00006  *
00007  *  CDR_Size.h,v 4.3 2006/01/25 13:05:49 jwillemsen Exp
00008  *
00009  *
00010  * ACE Common Data Representation (CDR) size-calculating stream.
00011  *
00012  *
00013  * The current implementation assumes that the host has 1-byte,
00014  * 2-byte and 4-byte integral types, and that it has single
00015  * precision and double precision IEEE floats.
00016  * Those assumptions are pretty good these days, with Crays beign
00017  * the only known exception.
00018  *
00019  *
00020  *  @author Boris Kolpackov <boris@kolpackov.net>
00021  *
00022  */
00023 //=============================================================================
00024 
00025 #ifndef ACE_CDR_SIZE_H
00026 #define ACE_CDR_SIZE_H
00027 
00028 #include /**/ "ace/pre.h"
00029 
00030 #include "ace/CDR_Base.h"
00031 #include "ace/CDR_Stream.h" // for ACE_OutputCDR::from_*
00032 
00033 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00034 # pragma once
00035 #endif /* ACE_LACKS_PRAGMA_ONCE */
00036 
00037 #include "ace/SStringfwd.h"
00038 
00039 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00040 
00041 /**
00042  * @class ACE_SizeCDR
00043  *
00044  * @brief A CDR stream for calculating size of the representation.
00045  *
00046  */
00047 class ACE_Export ACE_SizeCDR
00048 {
00049 public:
00050   /// Default constructor.
00051   ACE_SizeCDR (ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION,
00052                ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION);
00053 
00054   /// Returns @c false if an error has ocurred.
00055   bool good_bit (void) const;
00056 
00057 
00058   /// Reset current size.
00059   void reset (void);
00060 
00061 
00062   /// Return current size.
00063   size_t total_length (void) const;
00064 
00065 
00066   // Return 0 on failure and 1 on success.
00067   //@{ @name Size-calculating pseudo-write operations
00068   ACE_CDR::Boolean write_boolean (ACE_CDR::Boolean x);
00069   ACE_CDR::Boolean write_char (ACE_CDR::Char x);
00070   ACE_CDR::Boolean write_wchar (ACE_CDR::WChar x);
00071   ACE_CDR::Boolean write_octet (ACE_CDR::Octet x);
00072   ACE_CDR::Boolean write_short (ACE_CDR::Short x);
00073   ACE_CDR::Boolean write_ushort (ACE_CDR::UShort x);
00074   ACE_CDR::Boolean write_long (ACE_CDR::Long x);
00075   ACE_CDR::Boolean write_ulong (ACE_CDR::ULong x);
00076   ACE_CDR::Boolean write_longlong (const ACE_CDR::LongLong &x);
00077   ACE_CDR::Boolean write_ulonglong (const ACE_CDR::ULongLong &x);
00078   ACE_CDR::Boolean write_float (ACE_CDR::Float x);
00079   ACE_CDR::Boolean write_double (const ACE_CDR::Double &x);
00080   ACE_CDR::Boolean write_longdouble (const ACE_CDR::LongDouble &x);
00081 
00082   /// For string we offer methods that accept a precomputed length.
00083   ACE_CDR::Boolean write_string (const ACE_CDR::Char *x);
00084   ACE_CDR::Boolean write_string (ACE_CDR::ULong len,
00085                                  const ACE_CDR::Char *x);
00086   ACE_CDR::Boolean write_string (const ACE_CString &x);
00087   ACE_CDR::Boolean write_wstring (const ACE_CDR::WChar *x);
00088   ACE_CDR::Boolean write_wstring (ACE_CDR::ULong length,
00089                                   const ACE_CDR::WChar *x);
00090   //@}
00091 
00092   /// @note the portion written starts at <x> and ends
00093   ///    at <x + length>.
00094   /// The length is *NOT* stored into the CDR stream.
00095   //@{ @name Array write operations
00096   ACE_CDR::Boolean write_boolean_array (const ACE_CDR::Boolean *x,
00097                                         ACE_CDR::ULong length);
00098   ACE_CDR::Boolean write_char_array (const ACE_CDR::Char *x,
00099                                      ACE_CDR::ULong length);
00100   ACE_CDR::Boolean write_wchar_array (const ACE_CDR::WChar* x,
00101                                       ACE_CDR::ULong length);
00102   ACE_CDR::Boolean write_octet_array (const ACE_CDR::Octet* x,
00103                                       ACE_CDR::ULong length);
00104   ACE_CDR::Boolean write_short_array (const ACE_CDR::Short *x,
00105                                       ACE_CDR::ULong length);
00106   ACE_CDR::Boolean write_ushort_array (const ACE_CDR::UShort *x,
00107                                        ACE_CDR::ULong length);
00108   ACE_CDR::Boolean write_long_array (const ACE_CDR::Long *x,
00109                                      ACE_CDR::ULong length);
00110   ACE_CDR::Boolean write_ulong_array (const ACE_CDR::ULong *x,
00111                                       ACE_CDR::ULong length);
00112   ACE_CDR::Boolean write_longlong_array (const ACE_CDR::LongLong* x,
00113                                          ACE_CDR::ULong length);
00114   ACE_CDR::Boolean write_ulonglong_array (const ACE_CDR::ULongLong *x,
00115                                           ACE_CDR::ULong length);
00116   ACE_CDR::Boolean write_float_array (const ACE_CDR::Float *x,
00117                                       ACE_CDR::ULong length);
00118   ACE_CDR::Boolean write_double_array (const ACE_CDR::Double *x,
00119                                        ACE_CDR::ULong length);
00120   ACE_CDR::Boolean write_longdouble_array (const ACE_CDR::LongDouble* x,
00121                                            ACE_CDR::ULong length);
00122 
00123   ///
00124   /// Adjust to <size> and count <size> octets.
00125   void adjust (size_t size);
00126 
00127   /// As above, but now the size and alignment requirements may be
00128   /// different.
00129   void adjust (size_t size,
00130                size_t align);
00131 
00132 private:
00133   /// disallow copying...
00134   ACE_SizeCDR (const ACE_SizeCDR& rhs);
00135   ACE_SizeCDR& operator= (const ACE_SizeCDR& rhs);
00136 
00137   ACE_CDR::Boolean write_1 (const ACE_CDR::Octet *x);
00138   ACE_CDR::Boolean write_2 (const ACE_CDR::UShort *x);
00139   ACE_CDR::Boolean write_4 (const ACE_CDR::ULong *x);
00140   ACE_CDR::Boolean write_8 (const ACE_CDR::ULongLong *x);
00141   ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x);
00142 
00143   /**
00144    * write an array of <length> elements, each of <size> bytes and the
00145    * start aligned at a multiple of <align>. The elements are assumed
00146    * to be packed with the right alignment restrictions.  It is mostly
00147    * designed for buffers of the basic types.
00148    *
00149    * This operation uses <memcpy>; as explained above it is expected
00150    * that using assignment is faster that <memcpy> for one element,
00151    * but for several elements <memcpy> should be more efficient, it
00152    * could be interesting to find the break even point and optimize
00153    * for that case, but that would be too platform dependent.
00154    */
00155   ACE_CDR::Boolean write_array (const void *x,
00156                                 size_t size,
00157                                 size_t align,
00158                                 ACE_CDR::ULong length);
00159 
00160 
00161   ACE_CDR::Boolean write_wchar_array_i (const ACE_CDR::WChar* x,
00162                                         ACE_CDR::ULong length);
00163 
00164 private:
00165   /// Set to false when an error ocurrs.
00166   bool good_bit_;
00167 
00168   /// Current size.
00169   size_t size_;
00170 
00171 protected:
00172   /// GIOP version information
00173   ACE_CDR::Octet major_version_;
00174   ACE_CDR::Octet minor_version_;
00175 };
00176 
00177 // @@ This operator should not be inlined since they force SString.h
00178 //    to be included in this header.
00179 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00180                                                const ACE_CString &x);
00181 
00182 ACE_END_VERSIONED_NAMESPACE_DECL
00183 
00184 #if defined (__ACE_INLINE__)
00185 # include "ace/CDR_Size.inl"
00186 #else /* __ACE_INLINE__ */
00187 
00188 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00189 
00190 // Not used by CORBA or TAO
00191 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00192                                                ACE_CDR::Char x);
00193 
00194 // CDR size-calculating output operators for primitive types
00195 
00196 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00197                                                ACE_CDR::Short x);
00198 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00199                                                ACE_CDR::UShort x);
00200 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00201                                                ACE_CDR::Long x);
00202 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00203                                                ACE_CDR::ULong x);
00204 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00205                                                ACE_CDR::LongLong x);
00206 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00207                                                ACE_CDR::ULongLong x);
00208 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR& ss,
00209                                                ACE_CDR::LongDouble x);
00210 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00211                                                ACE_CDR::Float x);
00212 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00213                                                ACE_CDR::Double x);
00214 
00215 // CDR size-calculating output operator from helper classes
00216 
00217 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00218                                                ACE_OutputCDR::from_boolean x);
00219 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00220                                                ACE_OutputCDR::from_char x);
00221 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00222                                                ACE_OutputCDR::from_wchar x);
00223 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00224                                                ACE_OutputCDR::from_octet x);
00225 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00226                                                ACE_OutputCDR::from_string x);
00227 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00228                                                ACE_OutputCDR::from_wstring x);
00229 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00230                                                const ACE_CDR::Char* x);
00231 extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss,
00232                                                const ACE_CDR::WChar* x);
00233 
00234 ACE_END_VERSIONED_NAMESPACE_DECL
00235 
00236 #endif /* __ACE_INLINE__ */
00237 
00238 
00239 #include /**/ "ace/post.h"
00240 
00241 #endif /* ACE_CDR_SIZE_H */