ACE/ace/CDR_Size.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_string.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 ACE_INLINE
   7 ACE_SizeCDR::ACE_SizeCDR (ACE_CDR::Octet major_version,
   8                           ACE_CDR::Octet minor_version)
   9     : good_bit_ (true),
  10       size_ (0),
  11       major_version_ (major_version),
  12       minor_version_ (minor_version)
  13 {
  14 }
  15
  16 ACE_INLINE bool
  17 ACE_SizeCDR::good_bit () const
  18 {
  19   return this->good_bit_;
  20 }
  21
  22 ACE_INLINE void
  23 ACE_SizeCDR::reset ()
  24 {
  25   this->size_ = 0;
  26 }
  27
  28 ACE_INLINE size_t
  29 ACE_SizeCDR::total_length () const
  30 {
  31   return this->size_;
  32 }
  33
  34
  35 // Encode the CDR stream.
  36
  37 ACE_INLINE ACE_CDR::Boolean
  38 ACE_SizeCDR::write_octet (ACE_CDR::Octet x)
  39 {
  40   return this->write_1 (reinterpret_cast<const ACE_CDR::Octet *> (&x));
  41 }
  42
  43 ACE_INLINE ACE_CDR::Boolean
  44 ACE_SizeCDR::write_boolean (ACE_CDR::Boolean x)
  45 {
  46   return this->write_octet (x ? (ACE_CDR::Octet) 1 : (ACE_CDR::Octet) 0);
  47 }
  48
  49 ACE_INLINE ACE_CDR::Boolean
  50 ACE_SizeCDR::write_char (ACE_CDR::Char x)
  51 {
  52   // Note: translator framework is not supported.
  53   //
  54   return this->write_1 (reinterpret_cast<const ACE_CDR::Octet*> (&x));
  55 }
  56
  57 ACE_INLINE ACE_CDR::Boolean
  58 ACE_SizeCDR::write_short (ACE_CDR::Short x)
  59 {
  60   return this->write_2 (reinterpret_cast<const ACE_CDR::UShort*> (&x));
  61 }
  62
  63 ACE_INLINE ACE_CDR::Boolean
  64 ACE_SizeCDR::write_ushort (ACE_CDR::UShort x)
  65 {
  66   return this->write_2 (reinterpret_cast<const ACE_CDR::UShort*> (&x));
  67 }
  68
  69 ACE_INLINE ACE_CDR::Boolean
  70 ACE_SizeCDR::write_long (ACE_CDR::Long x)
  71 {
  72   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong*> (&x));
  73 }
  74
  75 ACE_INLINE ACE_CDR::Boolean
  76 ACE_SizeCDR::write_ulong (ACE_CDR::ULong x)
  77 {
  78   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong*> (&x));
  79 }
  80
  81 ACE_INLINE ACE_CDR::Boolean
  82 ACE_SizeCDR::write_longlong (const ACE_CDR::LongLong &x)
  83 {
  84   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong*> (&x));
  85 }
  86
  87 ACE_INLINE ACE_CDR::Boolean
  88 ACE_SizeCDR::write_ulonglong (const ACE_CDR::ULongLong &x)
  89 {
  90   const void *temp = &x;
  91   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong *> (temp));
  92 }
  93
  94 ACE_INLINE ACE_CDR::Boolean
  95 ACE_SizeCDR::write_float (ACE_CDR::Float x)
  96 {
  97   const void *temp = &x;
  98   return this->write_4 (reinterpret_cast<const ACE_CDR::ULong *> (temp));
  99 }
 100
 101 ACE_INLINE ACE_CDR::Boolean
 102 ACE_SizeCDR::write_double (const ACE_CDR::Double &x)
 103 {
 104   const void *temp = &x;
 105   return this->write_8 (reinterpret_cast<const ACE_CDR::ULongLong*> (temp));
 106 }
 107
 108 ACE_INLINE ACE_CDR::Boolean
 109 ACE_SizeCDR::write_longdouble (const ACE_CDR::LongDouble &x)
 110 {
 111   const void *temp = &x;
 112   return this->write_16 (reinterpret_cast<const ACE_CDR::LongDouble*> (temp));
 113 }
 114
 115 ACE_INLINE ACE_CDR::Boolean
 116 ACE_SizeCDR::write_fixed (const ACE_CDR::Fixed &x)
 117 {
 118   return this->write_array (&x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN,
 119                             (x.fixed_digits () + 2) / 2);
 120 }
 121
 122 ACE_INLINE ACE_CDR::Boolean
 123 ACE_SizeCDR::write_string (const ACE_CDR::Char *x)
 124 {
 125   if (x != 0)
 126     {
 127       const ACE_CDR::ULong len =
 128         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 129       return this->write_string (len, x);
 130     }
 131   return this->write_string (0, 0);
 132 }
 133
 134 ACE_INLINE ACE_CDR::Boolean
 135 ACE_SizeCDR::write_wstring (const ACE_CDR::WChar *x)
 136 {
 137   if (x != 0)
 138     {
 139       ACE_CDR::ULong len =
 140         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 141       return this->write_wstring (len, x);
 142     }
 143   return this->write_wstring (0, 0);
 144 }
 145
 146 ACE_INLINE ACE_CDR::Boolean
 147 ACE_SizeCDR::write_string (const std::string &x)
 148 {
 149   ACE_CDR::ULong len =
 150     static_cast<ACE_CDR::ULong> (x.size ());
 151   return this->write_string (len,
 152                              x.empty () ? 0 : x.c_str ());
 153 }
 154
 155 ACE_INLINE ACE_CDR::Boolean
 156 ACE_SizeCDR::write_string_view (const std::string_view &x)
 157 {
 158   ACE_CDR::ULong len =
 159     static_cast<ACE_CDR::ULong> (x.size ());
 160   return this->write_string (len,
 161                              x.empty () ? 0 : x.data ());
 162 }
 163
 164 #if !defined(ACE_LACKS_STD_WSTRING)
 165 ACE_INLINE ACE_CDR::Boolean
 166 ACE_SizeCDR::write_wstring (const std::wstring &x)
 167 {
 168   ACE_CDR::ULong len =
 169     static_cast<ACE_CDR::ULong> (x.size ());
 170   return this->write_wstring (len,
 171                               x.empty () ? 0 : x.c_str ());
 172 }
 173 #endif
 174
 175 ACE_INLINE ACE_CDR::Boolean
 176 ACE_SizeCDR::write_char_array (const ACE_CDR::Char *x,
 177                                  ACE_CDR::ULong length)
 178 {
 179   // Note: translator framework is not supported.
 180   //
 181   return this->write_array (x,
 182                             ACE_CDR::OCTET_SIZE,
 183                             ACE_CDR::OCTET_ALIGN,
 184                             length);
 185 }
 186
 187 ACE_INLINE ACE_CDR::Boolean
 188 ACE_SizeCDR::write_wchar_array (const ACE_CDR::WChar* x,
 189                                   ACE_CDR::ULong length)
 190 {
 191   // Note: translator framework is not supported.
 192   //
 193   if (ACE_OutputCDR::wchar_maxbytes () == 0)
 194     {
 195       errno = EACCES;
 196       return (this->good_bit_ = false);
 197     }
 198   if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar))
 199     return this->write_array (x,
 200                               sizeof (ACE_CDR::WChar),
 201                               sizeof (ACE_CDR::WChar) == 2
 202                               ? ACE_CDR::SHORT_ALIGN
 203                               : ACE_CDR::LONG_ALIGN,
 204                               length);
 205   return this->write_wchar_array_i (x,length);
 206 }
 207
 208 ACE_INLINE ACE_CDR::Boolean
 209 ACE_SizeCDR::write_octet_array (const ACE_CDR::Octet* x,
 210                                   ACE_CDR::ULong length)
 211 {
 212   return this->write_array (x,
 213                             ACE_CDR::OCTET_SIZE,
 214                             ACE_CDR::OCTET_ALIGN,
 215                             length);
 216 }
 217
 218 ACE_INLINE ACE_CDR::Boolean
 219 ACE_SizeCDR::write_short_array (const ACE_CDR::Short *x,
 220                                   ACE_CDR::ULong length)
 221 {
 222   return this->write_array (x,
 223                             ACE_CDR::SHORT_SIZE,
 224                             ACE_CDR::SHORT_ALIGN,
 225                             length);
 226 }
 227
 228 ACE_INLINE ACE_CDR::Boolean
 229 ACE_SizeCDR::write_ushort_array (const ACE_CDR::UShort *x,
 230                                  ACE_CDR::ULong length)
 231 {
 232   return this->write_array (x,
 233                             ACE_CDR::SHORT_SIZE,
 234                             ACE_CDR::SHORT_ALIGN,
 235                             length);
 236 }
 237
 238 ACE_INLINE ACE_CDR::Boolean
 239 ACE_SizeCDR::write_long_array (const ACE_CDR::Long *x,
 240                                ACE_CDR::ULong length)
 241 {
 242   return this->write_array (x,
 243                             ACE_CDR::LONG_SIZE,
 244                             ACE_CDR::LONG_ALIGN,
 245                             length);
 246 }
 247
 248 ACE_INLINE ACE_CDR::Boolean
 249 ACE_SizeCDR::write_ulong_array (const ACE_CDR::ULong *x,
 250                                 ACE_CDR::ULong length)
 251 {
 252   return this->write_array (x,
 253                             ACE_CDR::LONG_SIZE,
 254                             ACE_CDR::LONG_ALIGN,
 255                             length);
 256 }
 257
 258 ACE_INLINE ACE_CDR::Boolean
 259 ACE_SizeCDR::write_longlong_array (const ACE_CDR::LongLong *x,
 260                                      ACE_CDR::ULong length)
 261 {
 262   return this->write_array (x,
 263                             ACE_CDR::LONGLONG_SIZE,
 264                             ACE_CDR::LONGLONG_ALIGN,
 265                             length);
 266 }
 267
 268 ACE_INLINE ACE_CDR::Boolean
 269 ACE_SizeCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x,
 270                                       ACE_CDR::ULong length)
 271 {
 272   return this->write_array (x,
 273                             ACE_CDR::LONGLONG_SIZE,
 274                             ACE_CDR::LONGLONG_ALIGN,
 275                             length);
 276 }
 277
 278 ACE_INLINE ACE_CDR::Boolean
 279 ACE_SizeCDR::write_float_array (const ACE_CDR::Float *x,
 280                                   ACE_CDR::ULong length)
 281 {
 282   return this->write_array (x,
 283                             ACE_CDR::LONG_SIZE,
 284                             ACE_CDR::LONG_ALIGN,
 285                             length);
 286 }
 287
 288
 289 ACE_INLINE ACE_CDR::Boolean
 290 ACE_SizeCDR::write_double_array (const ACE_CDR::Double *x,
 291                                    ACE_CDR::ULong length)
 292 {
 293   return this->write_array (x,
 294                             ACE_CDR::LONGLONG_SIZE,
 295                             ACE_CDR::LONGLONG_ALIGN,
 296                             length);
 297 }
 298
 299 ACE_INLINE ACE_CDR::Boolean
 300 ACE_SizeCDR::write_longdouble_array (const ACE_CDR::LongDouble* x,
 301                                        ACE_CDR::ULong length)
 302 {
 303   return this->write_array (x,
 304                             ACE_CDR::LONGDOUBLE_SIZE,
 305                             ACE_CDR::LONGDOUBLE_ALIGN,
 306                             length);
 307 }
 308
 309
 310 // ****************************************************************
 311
 312
 313 ACE_INLINE ACE_CDR::Boolean
 314 operator<< (ACE_SizeCDR &ss, ACE_CDR::Char x)
 315 {
 316   ss.write_char (x);
 317   return ss.good_bit ();
 318 }
 319
 320 ACE_INLINE ACE_CDR::Boolean
 321 operator<< (ACE_SizeCDR &ss, ACE_CDR::Short x)
 322 {
 323   ss.write_short (x);
 324   return ss.good_bit ();
 325 }
 326
 327 ACE_INLINE ACE_CDR::Boolean
 328 operator<< (ACE_SizeCDR &ss, ACE_CDR::UShort x)
 329 {
 330   ss.write_ushort (x);
 331   return ss.good_bit ();
 332 }
 333
 334 ACE_INLINE ACE_CDR::Boolean
 335 operator<< (ACE_SizeCDR &ss, ACE_CDR::Long x)
 336 {
 337   ss.write_long (x);
 338   return ss.good_bit ();
 339 }
 340
 341 ACE_INLINE ACE_CDR::Boolean
 342 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULong x)
 343 {
 344   ss.write_ulong (x);
 345   return ss.good_bit ();
 346 }
 347
 348 ACE_INLINE ACE_CDR::Boolean
 349 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongLong x)
 350 {
 351   ss.write_longlong (x);
 352   return ss.good_bit ();
 353 }
 354
 355 ACE_INLINE ACE_CDR::Boolean
 356 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULongLong x)
 357 {
 358   ss.write_ulonglong (x);
 359   return ss.good_bit ();
 360 }
 361
 362 ACE_INLINE ACE_CDR::Boolean
 363 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongDouble x)
 364 {
 365   ss.write_longdouble (x);
 366   return ss.good_bit ();
 367 }
 368
 369 ACE_INLINE ACE_CDR::Boolean
 370 operator<< (ACE_SizeCDR &ss, ACE_CDR::Float x)
 371 {
 372   ss.write_float (x);
 373   return ss.good_bit ();
 374 }
 375
 376 ACE_INLINE ACE_CDR::Boolean
 377 operator<< (ACE_SizeCDR &ss, ACE_CDR::Double x)
 378 {
 379   ss.write_double (x);
 380   return ss.good_bit ();
 381 }
 382
 383 ACE_INLINE ACE_CDR::Boolean
 384 operator<< (ACE_SizeCDR &ss, const ACE_CDR::Fixed &x)
 385 {
 386   ss.write_fixed (x);
 387   return ss.good_bit ();
 388 }
 389
 390 ACE_INLINE ACE_CDR::Boolean
 391 operator<< (ACE_SizeCDR &ss, const ACE_CDR::Char *x)
 392 {
 393   ss.write_string (x);
 394   return ss.good_bit ();
 395 }
 396
 397 ACE_INLINE ACE_CDR::Boolean
 398 operator<< (ACE_SizeCDR &ss, const ACE_CDR::WChar *x)
 399 {
 400   ss.write_wstring (x);
 401   return ss.good_bit ();
 402 }
 403
 404 ACE_INLINE ACE_CDR::Boolean
 405 operator<< (ACE_SizeCDR &ss, const std::string& x)
 406 {
 407   ss.write_string (x);
 408   return ss.good_bit ();
 409 }
 410
 411 ACE_INLINE ACE_CDR::Boolean
 412 operator<< (ACE_SizeCDR &ss, const std::string_view& x)
 413 {
 414   ss.write_string_view (x);
 415   return ss.good_bit ();
 416 }
 417
 418 #if !defined(ACE_LACKS_STD_WSTRING)
 419 ACE_INLINE ACE_CDR::Boolean
 420 operator<< (ACE_SizeCDR &ss, const std::wstring& x)
 421 {
 422   ss.write_wstring (x);
 423   return ss.good_bit ();
 424 }
 425 #endif
 426
 427 // The following use the helper classes
 428 ACE_INLINE ACE_CDR::Boolean
 429 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_boolean x)
 430 {
 431   ss.write_boolean (x.val_);
 432   return ss.good_bit ();
 433 }
 434
 435 ACE_INLINE ACE_CDR::Boolean
 436 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_char x)
 437 {
 438   ss.write_char (x.val_);
 439   return ss.good_bit ();
 440 }
 441
 442 ACE_INLINE ACE_CDR::Boolean
 443 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wchar x)
 444 {
 445   ss.write_wchar (x.val_);
 446   return ss.good_bit ();
 447 }
 448
 449 ACE_INLINE ACE_CDR::Boolean
 450 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_octet x)
 451 {
 452   ss.write_octet (x.val_);
 453   return ss.good_bit ();
 454 }
 455
 456 ACE_INLINE ACE_CDR::Boolean
 457 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_string x)
 458 {
 459   ACE_CDR::ULong len = 0;
 460
 461   if (x.val_ != 0)
 462     {
 463       len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 464     }
 465
 466   ss.write_string (len, x.val_);
 467   return (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 468 }
 469
 470 ACE_INLINE ACE_CDR::Boolean
 471 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wstring x)
 472 {
 473   ACE_CDR::ULong len = 0;
 474
 475   if (x.val_ != 0)
 476     {
 477         len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 478     }
 479
 480   ss.write_wstring (len, x.val_);
 481   return (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 482 }
 483
 484
 485 ACE_END_VERSIONED_NAMESPACE_DECL