ACE/ace/CDR_Size.cpp

   1 #include "ace/CDR_Size.h"
   2 #include "ace/SString.h"
   3 #include "ace/OS_Memory.h"
   4 #include "ace/Truncate.h"
   5
   6 #if !defined (__ACE_INLINE__)
   7 # include "ace/CDR_Size.inl"
   8 #endif /* ! __ACE_INLINE__ */
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 ACE_CDR::Boolean
  13 ACE_SizeCDR::write_wchar (ACE_CDR::WChar x)
  14 {
  15   // Note: translator framework is not supported.
  16   //
  17   if (ACE_OutputCDR::wchar_maxbytes () == 0)
  18     {
  19       errno = EACCES;
  20       return (this->good_bit_ = false);
  21     }
  22
  23   if (static_cast<ACE_CDR::Short> (major_version_) == 1
  24           && static_cast<ACE_CDR::Short> (minor_version_) == 2)
  25     {
  26       ACE_CDR::Octet len =
  27         static_cast<ACE_CDR::Octet> (ACE_OutputCDR::wchar_maxbytes ());
  28
  29       if (this->write_1 (&len))
  30         {
  31           if (ACE_OutputCDR::wchar_maxbytes () == sizeof(ACE_CDR::WChar))
  32             {
  33               return
  34                 this->write_octet_array (
  35                   reinterpret_cast<const ACE_CDR::Octet*> (&x),
  36                   static_cast<ACE_CDR::ULong> (len));
  37             }
  38           else
  39             {
  40               if (ACE_OutputCDR::wchar_maxbytes () == 2)
  41                 {
  42                   ACE_CDR::Short sx = static_cast<ACE_CDR::Short> (x);
  43                   return
  44                     this->write_octet_array (
  45                       reinterpret_cast<const ACE_CDR::Octet*> (&sx),
  46                       static_cast<ACE_CDR::ULong> (len));
  47                 }
  48               else
  49                 {
  50                   ACE_CDR::Octet ox = static_cast<ACE_CDR::Octet> (x);
  51                   return
  52                     this->write_octet_array (
  53                       reinterpret_cast<const ACE_CDR::Octet*> (&ox),
  54                       static_cast<ACE_CDR::ULong> (len));
  55                 }
  56             }
  57         }
  58     }
  59   else if (static_cast<ACE_CDR::Short> (minor_version_) == 0)
  60     { // wchar is not allowed with GIOP 1.0.
  61       errno = EINVAL;
  62       return (this->good_bit_ = false);
  63     }
  64
  65   if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar))
  66     {
  67       const void *temp = &x;
  68       return this->write_4 (reinterpret_cast<const ACE_CDR::ULong *> (temp));
  69     }
  70   else if (ACE_OutputCDR::wchar_maxbytes () == 2)
  71     {
  72       ACE_CDR::Short sx = static_cast<ACE_CDR::Short> (x);
  73       return this->write_2 (reinterpret_cast<const ACE_CDR::UShort *> (&sx));
  74     }
  75
  76   ACE_CDR::Octet ox = static_cast<ACE_CDR::Octet> (x);
  77   return this->write_1 (reinterpret_cast<const ACE_CDR::Octet *> (&ox));
  78 }
  79
  80 ACE_CDR::Boolean
  81 ACE_SizeCDR::write_string (ACE_CDR::ULong len,
  82                              const ACE_CDR::Char *x)
  83 {
  84   // Note: translator framework is not supported.
  85   //
  86   if (len != 0)
  87     {
  88       if (this->write_ulong (len + 1))
  89         return this->write_char_array (x, len + 1);
  90     }
  91   else
  92     {
  93       // Be nice to programmers: treat nulls as empty strings not
  94       // errors. (OMG-IDL supports languages that don't use the C/C++
  95       // notion of null v. empty strings; nulls aren't part of the OMG-IDL
  96       // string model.)
  97       if (this->write_ulong (1))
  98         return this->write_char (0);
  99     }
 100
 101   return (this->good_bit_ = false);
 102 }
 103
 104 ACE_CDR::Boolean
 105 ACE_SizeCDR::write_string (const ACE_CString &x)
 106 {
 107   // @@ Leave this method in here, not the `.i' file so that we don't
 108   //    have to unnecessarily pull in the `ace/SString.h' header.
 109   return this->write_string (static_cast<ACE_CDR::ULong> (x.length ()),
 110                              x.c_str());
 111 }
 112
 113 ACE_CDR::Boolean
 114 ACE_SizeCDR::write_wstring (ACE_CDR::ULong len,
 115                               const ACE_CDR::WChar *x)
 116 {
 117   // Note: translator framework is not supported.
 118   //
 119   if (ACE_OutputCDR::wchar_maxbytes () == 0)
 120     {
 121       errno = EACCES;
 122       return (this->good_bit_ = false);
 123     }
 124
 125   if (static_cast<ACE_CDR::Short> (this->major_version_) == 1
 126       && static_cast<ACE_CDR::Short> (this->minor_version_) == 2)
 127     {
 128       if (x != 0)
 129         {
 130           //In GIOP 1.2 the length field contains the number of bytes
 131           //the wstring occupies rather than number of wchars
 132           //Taking sizeof might not be a good way! This is a temporary fix.
 133           ACE_CDR::Boolean good_ulong =
 134             this->write_ulong (
 135               ACE_Utils::truncate_cast<ACE_CDR::ULong> (
 136                 ACE_OutputCDR::wchar_maxbytes () * len));
 137
 138           if (good_ulong)
 139             {
 140               return this->write_wchar_array (x, len);
 141             }
 142         }
 143       else
 144         {
 145           //In GIOP 1.2 zero length wstrings are legal
 146           return this->write_ulong (0);
 147         }
 148     }
 149
 150   else
 151     if (x != 0)
 152       {
 153         if (this->write_ulong (len + 1))
 154           return this->write_wchar_array (x, len + 1);
 155       }
 156     else if (this->write_ulong (1))
 157       return this->write_wchar (0);
 158    return (this->good_bit_ = false);
 159 }
 160
 161 ACE_CDR::Boolean
 162 ACE_SizeCDR::write_1 (const ACE_CDR::Octet *)
 163 {
 164   this->adjust (1);
 165   return true;
 166 }
 167
 168 ACE_CDR::Boolean
 169 ACE_SizeCDR::write_2 (const ACE_CDR::UShort *)
 170 {
 171   this->adjust (ACE_CDR::SHORT_SIZE);
 172   return true;
 173 }
 174
 175 ACE_CDR::Boolean
 176 ACE_SizeCDR::write_4 (const ACE_CDR::ULong *)
 177 {
 178   this->adjust (ACE_CDR::LONG_SIZE);
 179   return true;
 180 }
 181
 182 ACE_CDR::Boolean
 183 ACE_SizeCDR::write_8 (const ACE_CDR::ULongLong *)
 184 {
 185   this->adjust (ACE_CDR::LONGLONG_SIZE);
 186   return true;
 187 }
 188
 189 ACE_CDR::Boolean
 190 ACE_SizeCDR::write_16 (const ACE_CDR::LongDouble *)
 191 {
 192   this->adjust (ACE_CDR::LONGDOUBLE_SIZE,
 193                 ACE_CDR::LONGDOUBLE_ALIGN);
 194   return true;
 195 }
 196
 197 ACE_CDR::Boolean
 198 ACE_SizeCDR::write_wchar_array_i (const ACE_CDR::WChar *,
 199                                     ACE_CDR::ULong length)
 200 {
 201   if (length == 0)
 202     return true;
 203
 204   size_t const align = (ACE_OutputCDR::wchar_maxbytes () == 2) ?
 205     ACE_CDR::SHORT_ALIGN :
 206     ACE_CDR::OCTET_ALIGN;
 207
 208   this->adjust (ACE_OutputCDR::wchar_maxbytes () * length, align);
 209   return true;
 210 }
 211
 212
 213 ACE_CDR::Boolean
 214 ACE_SizeCDR::write_array (const void *,
 215                           size_t size,
 216                           size_t align,
 217                           ACE_CDR::ULong length)
 218 {
 219   if (length == 0)
 220     return true;
 221
 222   this->adjust (size * length, align);
 223   return true;
 224 }
 225
 226 ACE_CDR::Boolean
 227 ACE_SizeCDR::write_boolean_array (const ACE_CDR::Boolean*,
 228                                   ACE_CDR::ULong length)
 229 {
 230   this->adjust (length, 1);
 231   return true;
 232 }
 233
 234 void
 235 ACE_SizeCDR::adjust (size_t size)
 236 {
 237   adjust (size, size);
 238 }
 239
 240 void
 241 ACE_SizeCDR::adjust (size_t size,
 242                      size_t align)
 243 {
 244 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 245   const size_t offset = ACE_align_binary (size_, align) - size_;
 246   size_ += offset;
 247 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 248   size_ += size;
 249 }
 250
 251 ACE_CDR::Boolean
 252 operator<< (ACE_SizeCDR &ss, const ACE_CString &x)
 253 {
 254   ss.write_string (x);
 255   return ss.good_bit ();
 256 }
 257
 258 ACE_END_VERSIONED_NAMESPACE_DECL