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 #if !defined(ACE_LACKS_STD_WSTRING)
 156 ACE_INLINE ACE_CDR::Boolean
 157 ACE_SizeCDR::write_wstring (const std::wstring &x)
 158 {
 159   ACE_CDR::ULong len =
 160     static_cast<ACE_CDR::ULong> (x.size ());
 161   return this->write_wstring (len,
 162                               x.empty () ? 0 : x.c_str ());
 163 }
 164 #endif
 165
 166 ACE_INLINE ACE_CDR::Boolean
 167 ACE_SizeCDR::write_char_array (const ACE_CDR::Char *x,
 168                                  ACE_CDR::ULong length)
 169 {
 170   // Note: translator framework is not supported.
 171   //
 172   return this->write_array (x,
 173                             ACE_CDR::OCTET_SIZE,
 174                             ACE_CDR::OCTET_ALIGN,
 175                             length);
 176 }
 177
 178 ACE_INLINE ACE_CDR::Boolean
 179 ACE_SizeCDR::write_wchar_array (const ACE_CDR::WChar* x,
 180                                   ACE_CDR::ULong length)
 181 {
 182   // Note: translator framework is not supported.
 183   //
 184   if (ACE_OutputCDR::wchar_maxbytes () == 0)
 185     {
 186       errno = EACCES;
 187       return (this->good_bit_ = false);
 188     }
 189   if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar))
 190     return this->write_array (x,
 191                               sizeof (ACE_CDR::WChar),
 192                               sizeof (ACE_CDR::WChar) == 2
 193                               ? ACE_CDR::SHORT_ALIGN
 194                               : ACE_CDR::LONG_ALIGN,
 195                               length);
 196   return this->write_wchar_array_i (x,length);
 197 }
 198
 199 ACE_INLINE ACE_CDR::Boolean
 200 ACE_SizeCDR::write_octet_array (const ACE_CDR::Octet* x,
 201                                   ACE_CDR::ULong length)
 202 {
 203   return this->write_array (x,
 204                             ACE_CDR::OCTET_SIZE,
 205                             ACE_CDR::OCTET_ALIGN,
 206                             length);
 207 }
 208
 209 ACE_INLINE ACE_CDR::Boolean
 210 ACE_SizeCDR::write_short_array (const ACE_CDR::Short *x,
 211                                   ACE_CDR::ULong length)
 212 {
 213   return this->write_array (x,
 214                             ACE_CDR::SHORT_SIZE,
 215                             ACE_CDR::SHORT_ALIGN,
 216                             length);
 217 }
 218
 219 ACE_INLINE ACE_CDR::Boolean
 220 ACE_SizeCDR::write_ushort_array (const ACE_CDR::UShort *x,
 221                                  ACE_CDR::ULong length)
 222 {
 223   return this->write_array (x,
 224                             ACE_CDR::SHORT_SIZE,
 225                             ACE_CDR::SHORT_ALIGN,
 226                             length);
 227 }
 228
 229 ACE_INLINE ACE_CDR::Boolean
 230 ACE_SizeCDR::write_long_array (const ACE_CDR::Long *x,
 231                                ACE_CDR::ULong length)
 232 {
 233   return this->write_array (x,
 234                             ACE_CDR::LONG_SIZE,
 235                             ACE_CDR::LONG_ALIGN,
 236                             length);
 237 }
 238
 239 ACE_INLINE ACE_CDR::Boolean
 240 ACE_SizeCDR::write_ulong_array (const ACE_CDR::ULong *x,
 241                                 ACE_CDR::ULong length)
 242 {
 243   return this->write_array (x,
 244                             ACE_CDR::LONG_SIZE,
 245                             ACE_CDR::LONG_ALIGN,
 246                             length);
 247 }
 248
 249 ACE_INLINE ACE_CDR::Boolean
 250 ACE_SizeCDR::write_longlong_array (const ACE_CDR::LongLong *x,
 251                                      ACE_CDR::ULong length)
 252 {
 253   return this->write_array (x,
 254                             ACE_CDR::LONGLONG_SIZE,
 255                             ACE_CDR::LONGLONG_ALIGN,
 256                             length);
 257 }
 258
 259 ACE_INLINE ACE_CDR::Boolean
 260 ACE_SizeCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x,
 261                                       ACE_CDR::ULong length)
 262 {
 263   return this->write_array (x,
 264                             ACE_CDR::LONGLONG_SIZE,
 265                             ACE_CDR::LONGLONG_ALIGN,
 266                             length);
 267 }
 268
 269 ACE_INLINE ACE_CDR::Boolean
 270 ACE_SizeCDR::write_float_array (const ACE_CDR::Float *x,
 271                                   ACE_CDR::ULong length)
 272 {
 273   return this->write_array (x,
 274                             ACE_CDR::LONG_SIZE,
 275                             ACE_CDR::LONG_ALIGN,
 276                             length);
 277 }
 278
 279
 280 ACE_INLINE ACE_CDR::Boolean
 281 ACE_SizeCDR::write_double_array (const ACE_CDR::Double *x,
 282                                    ACE_CDR::ULong length)
 283 {
 284   return this->write_array (x,
 285                             ACE_CDR::LONGLONG_SIZE,
 286                             ACE_CDR::LONGLONG_ALIGN,
 287                             length);
 288 }
 289
 290 ACE_INLINE ACE_CDR::Boolean
 291 ACE_SizeCDR::write_longdouble_array (const ACE_CDR::LongDouble* x,
 292                                        ACE_CDR::ULong length)
 293 {
 294   return this->write_array (x,
 295                             ACE_CDR::LONGDOUBLE_SIZE,
 296                             ACE_CDR::LONGDOUBLE_ALIGN,
 297                             length);
 298 }
 299
 300
 301 // ****************************************************************
 302
 303
 304 ACE_INLINE ACE_CDR::Boolean
 305 operator<< (ACE_SizeCDR &ss, ACE_CDR::Char x)
 306 {
 307   ss.write_char (x);
 308   return ss.good_bit ();
 309 }
 310
 311 ACE_INLINE ACE_CDR::Boolean
 312 operator<< (ACE_SizeCDR &ss, ACE_CDR::Short x)
 313 {
 314   ss.write_short (x);
 315   return ss.good_bit ();
 316 }
 317
 318 ACE_INLINE ACE_CDR::Boolean
 319 operator<< (ACE_SizeCDR &ss, ACE_CDR::UShort x)
 320 {
 321   ss.write_ushort (x);
 322   return ss.good_bit ();
 323 }
 324
 325 ACE_INLINE ACE_CDR::Boolean
 326 operator<< (ACE_SizeCDR &ss, ACE_CDR::Long x)
 327 {
 328   ss.write_long (x);
 329   return ss.good_bit ();
 330 }
 331
 332 ACE_INLINE ACE_CDR::Boolean
 333 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULong x)
 334 {
 335   ss.write_ulong (x);
 336   return ss.good_bit ();
 337 }
 338
 339 ACE_INLINE ACE_CDR::Boolean
 340 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongLong x)
 341 {
 342   ss.write_longlong (x);
 343   return ss.good_bit ();
 344 }
 345
 346 ACE_INLINE ACE_CDR::Boolean
 347 operator<< (ACE_SizeCDR &ss, ACE_CDR::ULongLong x)
 348 {
 349   ss.write_ulonglong (x);
 350   return ss.good_bit ();
 351 }
 352
 353 ACE_INLINE ACE_CDR::Boolean
 354 operator<< (ACE_SizeCDR &ss, ACE_CDR::LongDouble x)
 355 {
 356   ss.write_longdouble (x);
 357   return ss.good_bit ();
 358 }
 359
 360 ACE_INLINE ACE_CDR::Boolean
 361 operator<< (ACE_SizeCDR &ss, ACE_CDR::Float x)
 362 {
 363   ss.write_float (x);
 364   return ss.good_bit ();
 365 }
 366
 367 ACE_INLINE ACE_CDR::Boolean
 368 operator<< (ACE_SizeCDR &ss, ACE_CDR::Double x)
 369 {
 370   ss.write_double (x);
 371   return ss.good_bit ();
 372 }
 373
 374 ACE_INLINE ACE_CDR::Boolean
 375 operator<< (ACE_SizeCDR &ss, const ACE_CDR::Fixed &x)
 376 {
 377   ss.write_fixed (x);
 378   return ss.good_bit ();
 379 }
 380
 381 ACE_INLINE ACE_CDR::Boolean
 382 operator<< (ACE_SizeCDR &ss, const ACE_CDR::Char *x)
 383 {
 384   ss.write_string (x);
 385   return ss.good_bit ();
 386 }
 387
 388 ACE_INLINE ACE_CDR::Boolean
 389 operator<< (ACE_SizeCDR &ss, const ACE_CDR::WChar *x)
 390 {
 391   ss.write_wstring (x);
 392   return ss.good_bit ();
 393 }
 394
 395 ACE_INLINE ACE_CDR::Boolean
 396 operator<< (ACE_SizeCDR &ss, const std::string& x)
 397 {
 398   ss.write_string (x);
 399   return ss.good_bit ();
 400 }
 401
 402 #if !defined(ACE_LACKS_STD_WSTRING)
 403 ACE_INLINE ACE_CDR::Boolean
 404 operator<< (ACE_SizeCDR &ss, const std::wstring& x)
 405 {
 406   ss.write_wstring (x);
 407   return ss.good_bit ();
 408 }
 409 #endif
 410
 411 // The following use the helper classes
 412 ACE_INLINE ACE_CDR::Boolean
 413 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_boolean x)
 414 {
 415   ss.write_boolean (x.val_);
 416   return ss.good_bit ();
 417 }
 418
 419 ACE_INLINE ACE_CDR::Boolean
 420 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_char x)
 421 {
 422   ss.write_char (x.val_);
 423   return ss.good_bit ();
 424 }
 425
 426 ACE_INLINE ACE_CDR::Boolean
 427 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wchar x)
 428 {
 429   ss.write_wchar (x.val_);
 430   return ss.good_bit ();
 431 }
 432
 433 ACE_INLINE ACE_CDR::Boolean
 434 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_octet x)
 435 {
 436   ss.write_octet (x.val_);
 437   return ss.good_bit ();
 438 }
 439
 440 ACE_INLINE ACE_CDR::Boolean
 441 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_string x)
 442 {
 443   ACE_CDR::ULong len = 0;
 444
 445   if (x.val_ != 0)
 446     {
 447       len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 448     }
 449
 450   ss.write_string (len, x.val_);
 451   return (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 452 }
 453
 454 ACE_INLINE ACE_CDR::Boolean
 455 operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wstring x)
 456 {
 457   ACE_CDR::ULong len = 0;
 458
 459   if (x.val_ != 0)
 460     {
 461         len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
 462     }
 463
 464   ss.write_wstring (len, x.val_);
 465   return (ss.good_bit () && (!x.bound_ || len <= x.bound_));
 466 }
 467
 468
 469 ACE_END_VERSIONED_NAMESPACE_DECL