ACE/ace/CDR_Stream.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_string.h"
   3 #include "ace/OS_Memory.h"
   4
   5 // ****************************************************************
   6
   7 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   8
   9 // implementing the special types
  10 ACE_INLINE
  11 ACE_OutputCDR::from_boolean::from_boolean (ACE_CDR::Boolean b)
  12   : val_ (b)
  13 {
  14 }
  15
  16 ACE_INLINE
  17 ACE_InputCDR::to_boolean::to_boolean (ACE_CDR::Boolean &b)
  18   : ref_ (b)
  19 {
  20 }
  21
  22 ACE_INLINE
  23 ACE_OutputCDR::from_octet::from_octet (ACE_CDR::Octet o)
  24   : val_ (o)
  25 {
  26 }
  27
  28 ACE_INLINE
  29 ACE_InputCDR::to_octet::to_octet (ACE_CDR::Octet &o)
  30   : ref_ (o)
  31 {
  32 }
  33
  34 ACE_INLINE
  35 ACE_OutputCDR::from_char::from_char (ACE_CDR::Char c)
  36   : val_ (c)
  37 {
  38 }
  39
  40 ACE_INLINE
  41 ACE_InputCDR::to_char::to_char (ACE_CDR::Char &c)
  42   : ref_ (c)
  43 {
  44 }
  45
  46 ACE_INLINE
  47 ACE_OutputCDR::from_wchar::from_wchar (ACE_CDR::WChar wc)
  48   : val_ (wc)
  49 {
  50 }
  51
  52 ACE_INLINE
  53 ACE_InputCDR::to_wchar::to_wchar (ACE_CDR::WChar &wc)
  54   : ref_ (wc)
  55 {
  56 }
  57
  58 ACE_INLINE
  59 ACE_OutputCDR::from_string::from_string (ACE_CDR::Char *s,
  60                                          ACE_CDR::ULong b,
  61                                          ACE_CDR::Boolean nocopy)
  62   : val_ (s),
  63     bound_ (b),
  64     nocopy_ (nocopy)
  65 {
  66 }
  67
  68 ACE_INLINE
  69 ACE_OutputCDR::from_string::from_string (const ACE_CDR::Char *s,
  70                                          ACE_CDR::ULong b,
  71                                          ACE_CDR::Boolean nocopy)
  72   : val_ (const_cast<ACE_CDR::Char *> (s)),
  73     bound_ (b),
  74     nocopy_ (nocopy)
  75 {
  76 }
  77
  78 ACE_INLINE
  79 ACE_InputCDR::to_string::to_string (ACE_CDR::Char *&s,
  80                                     ACE_CDR::ULong b)
  81   : val_ (const_cast<const ACE_CDR::Char *&> (s)),
  82     bound_ (b)
  83 {
  84 }
  85
  86 ACE_INLINE
  87 ACE_InputCDR::to_string::to_string (const ACE_CDR::Char *&s,
  88                                     ACE_CDR::ULong b)
  89   : val_ (s),
  90     bound_ (b)
  91 {
  92 }
  93
  94 ACE_INLINE
  95 ACE_OutputCDR::from_wstring::from_wstring (ACE_CDR::WChar *ws,
  96                                            ACE_CDR::ULong b,
  97                                            ACE_CDR::Boolean nocopy)
  98   : val_ (ws),
  99     bound_ (b),
 100     nocopy_ (nocopy)
 101 {
 102 }
 103
 104 ACE_INLINE
 105 ACE_OutputCDR::from_wstring::from_wstring (const ACE_CDR::WChar *ws,
 106                                            ACE_CDR::ULong b,
 107                                            ACE_CDR::Boolean nocopy)
 108   : val_ (const_cast<ACE_CDR::WChar *> (ws)),
 109     bound_ (b),
 110     nocopy_ (nocopy)
 111 {
 112 }
 113
 114 ACE_INLINE
 115 ACE_InputCDR::to_wstring::to_wstring (ACE_CDR::WChar *&ws,
 116                                       ACE_CDR::ULong b)
 117   : val_ (const_cast<const ACE_CDR::WChar *&> (ws)),
 118     bound_ (b)
 119 {
 120 }
 121
 122 ACE_INLINE
 123 ACE_InputCDR::to_wstring::to_wstring (const ACE_CDR::WChar *&ws,
 124                                       ACE_CDR::ULong b)
 125   : val_ (ws),
 126     bound_ (b)
 127 {
 128 }
 129
 130 ACE_INLINE
 131 ACE_InputCDR::to_std_string::to_std_string (std::string &s,
 132                                             ACE_CDR::ULong b)
 133   : val_ (s),
 134     bound_ (b)
 135 {
 136 }
 137
 138 ACE_INLINE
 139 ACE_OutputCDR::from_std_string::from_std_string (const std::string &ws,
 140                                                  ACE_CDR::ULong b)
 141   : val_ (ws),
 142     bound_ (b)
 143 {
 144 }
 145
 146 #if !defined(ACE_LACKS_STD_WSTRING)
 147 ACE_INLINE
 148 ACE_InputCDR::to_std_wstring::to_std_wstring (std::wstring &s,
 149                                               ACE_CDR::ULong b)
 150   : val_ (s),
 151     bound_ (b)
 152 {
 153 }
 154
 155 ACE_INLINE
 156 ACE_OutputCDR::from_std_wstring::from_std_wstring (const std::wstring &ws,
 157                                                    ACE_CDR::ULong b)
 158   : val_ (ws),
 159     bound_ (b)
 160 {
 161 }
 162 #endif
 163
 164 ACE_INLINE
 165 ACE_InputCDR::to_int8::to_int8 (ACE_CDR::Int8 &ref)
 166   : ref_ (ref)
 167 {
 168 }
 169
 170 ACE_INLINE
 171 ACE_OutputCDR::from_int8::from_int8 (ACE_CDR::Int8 val)
 172   : val_ (val)
 173 {
 174 }
 175
 176 ACE_INLINE
 177 ACE_InputCDR::to_uint8::to_uint8 (ACE_CDR::UInt8 &ref)
 178   : ref_ (ref)
 179 {
 180 }
 181
 182 ACE_INLINE
 183 ACE_OutputCDR::from_uint8::from_uint8 (ACE_CDR::UInt8 val)
 184   : val_ (val)
 185 {
 186 }
 187
 188 ACE_INLINE
 189 ACE_InputCDR::Transfer_Contents::Transfer_Contents (ACE_InputCDR &rhs)
 190   :  rhs_ (rhs)
 191 {
 192 }
 193
 194 // ****************************************************************
 195
 196 ACE_INLINE
 197 ACE_OutputCDR::~ACE_OutputCDR ()
 198 {
 199   if (this->start_.cont () != 0)
 200     {
 201       ACE_Message_Block::release (this->start_.cont ());
 202       this->start_.cont (0);
 203     }
 204
 205   this->current_ = 0;
 206
 207 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
 208   this->monitor_->remove_ref ();
 209 #endif /* ACE_HAS_MONITOR_POINTS==1 */
 210 }
 211
 212 ACE_INLINE void
 213 ACE_OutputCDR::reset ()
 214 {
 215   this->current_ = &this->start_;
 216   this->current_is_writable_ = true;
 217   ACE_CDR::mb_align (&this->start_);
 218
 219 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 220   this->current_alignment_ = 0;
 221 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 222
 223   // It is tempting not to remove the memory, but we need to do so to
 224   // release any potential user buffers chained in the continuation
 225   // field.
 226
 227   ACE_Message_Block * const cont = this->start_.cont ();
 228   if (cont)
 229     {
 230       ACE_Message_Block::release (cont);
 231       this->start_.cont (0);
 232     }
 233
 234 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
 235   this->monitor_->receive (this->start_.total_size ());
 236 #endif /* ACE_HAS_MONITOR_POINTS==1 */
 237 }
 238
 239 // Encode the CDR stream.
 240
 241 ACE_INLINE ACE_CDR::Boolean
 242 ACE_OutputCDR::write_octet (ACE_CDR::Octet x)
 243 {
 244   return this->write_1 (&x);
 245 }
 246
 247 ACE_INLINE ACE_CDR::Boolean
 248 ACE_OutputCDR::write_boolean (ACE_CDR::Boolean x)
 249 {
 250   return
 251     static_cast<ACE_CDR::Boolean> (
 252       this->write_octet (
 253         x
 254         ? static_cast<ACE_CDR::Octet> (1)
 255         : static_cast<ACE_CDR::Octet> (0)));
 256 }
 257
 258 ACE_INLINE ACE_CDR::Boolean
 259 ACE_OutputCDR::write_char (ACE_CDR::Char x)
 260 {
 261   if (this->char_translator_ == 0)
 262     {
 263       ACE_CDR::Octet temp = static_cast<ACE_CDR::Octet> (x);
 264       return this->write_1 (&temp);
 265     }
 266   return this->char_translator_->write_char (*this, x);
 267 }
 268
 269 ACE_INLINE ACE_CDR::Boolean
 270 ACE_OutputCDR::write_short (ACE_CDR::Short x)
 271 {
 272   ACE_CDR::UShort temp = static_cast<ACE_CDR::UShort> (x);
 273   return this->write_2 (&temp);
 274 }
 275
 276 ACE_INLINE ACE_CDR::Boolean
 277 ACE_OutputCDR::write_ushort (ACE_CDR::UShort x)
 278 {
 279   return this->write_2 (&x);
 280 }
 281
 282 ACE_INLINE ACE_CDR::Boolean
 283 ACE_OutputCDR::write_long (ACE_CDR::Long x)
 284 {
 285   ACE_CDR::ULong temp = static_cast<ACE_CDR::ULong> (x);
 286   return this->write_4 (&temp);
 287 }
 288
 289 ACE_INLINE ACE_CDR::Boolean
 290 ACE_OutputCDR::write_ulong (ACE_CDR::ULong x)
 291 {
 292   return this->write_4 (&x);
 293 }
 294
 295 ACE_INLINE ACE_CDR::Boolean
 296 ACE_OutputCDR::write_longlong (const ACE_CDR::LongLong &x)
 297 {
 298   void const * const temp = &x;
 299   return this->write_8 (reinterpret_cast<ACE_CDR::ULongLong const *> (temp));
 300 }
 301
 302 ACE_INLINE ACE_CDR::Boolean
 303 ACE_OutputCDR::write_ulonglong (const ACE_CDR::ULongLong &x)
 304 {
 305   return this->write_8 (&x);
 306 }
 307
 308 ACE_INLINE ACE_CDR::Boolean
 309 ACE_OutputCDR::write_float (ACE_CDR::Float x)
 310 {
 311   void const * const temp = &x;
 312   return this->write_4 (reinterpret_cast<ACE_CDR::ULong const *> (temp));
 313 }
 314
 315 ACE_INLINE ACE_CDR::Boolean
 316 ACE_OutputCDR::write_double (const ACE_CDR::Double &x)
 317 {
 318   void const * const temp = &x;
 319   return this->write_8 (reinterpret_cast<ACE_CDR::ULongLong const *> (temp));
 320 }
 321
 322 ACE_INLINE ACE_CDR::Boolean
 323 ACE_OutputCDR::write_longdouble (const ACE_CDR::LongDouble &x)
 324 {
 325   return this->write_16 (&x);
 326 }
 327
 328 ACE_INLINE ACE_CDR::Boolean
 329 ACE_OutputCDR::write_fixed (const ACE_CDR::Fixed &x)
 330 {
 331   int n;
 332   const ACE_CDR::Octet *arr = x.to_octets (n);
 333   return this->write_array (arr, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, n);
 334 }
 335
 336 ACE_INLINE ACE_CDR::Boolean
 337 ACE_OutputCDR::write_string (const ACE_CDR::Char *x)
 338 {
 339   if (x)
 340     {
 341       ACE_CDR::ULong const len =
 342         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 343       return this->write_string (len, x);
 344     }
 345
 346   return this->write_string (0, 0);
 347 }
 348
 349 ACE_INLINE ACE_CDR::Boolean
 350 ACE_OutputCDR::write_wstring (const ACE_CDR::WChar *x)
 351 {
 352   if (x)
 353     {
 354       ACE_CDR::ULong const len =
 355         static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x));
 356       return this->write_wstring (len, x);
 357     }
 358
 359   return this->write_wstring (0, 0);
 360 }
 361
 362 ACE_INLINE ACE_CDR::Boolean
 363 ACE_OutputCDR::write_string (const std::string &x)
 364 {
 365   ACE_CDR::ULong const len =
 366     static_cast<ACE_CDR::ULong> (x.size ());
 367   return this->write_string (len,
 368                              x.empty () ? 0 : x.c_str ());
 369 }
 370
 371 #if !defined(ACE_LACKS_STD_WSTRING)
 372 ACE_INLINE ACE_CDR::Boolean
 373 ACE_OutputCDR::write_wstring (const std::wstring &x)
 374 {
 375   ACE_CDR::ULong const len =
 376     static_cast<ACE_CDR::ULong> (x.size ());
 377   return this->write_wstring (len,
 378                               x.empty () ? 0 : x.c_str ());
 379 }
 380 #endif
 381
 382 ACE_INLINE ACE_CDR::Boolean
 383 ACE_OutputCDR::write_int8 (ACE_CDR::Int8 x)
 384 {
 385   return this->write_1 (reinterpret_cast<ACE_CDR::Octet *> (&x));
 386 }
 387
 388 ACE_INLINE ACE_CDR::Boolean
 389 ACE_OutputCDR::write_uint8 (ACE_CDR::UInt8 x)
 390 {
 391   return this->write_1 (reinterpret_cast<ACE_CDR::Octet *> (&x));
 392 }
 393
 394 ACE_INLINE ACE_CDR::Boolean
 395 ACE_OutputCDR::write_char_array (const ACE_CDR::Char *x,
 396                                  ACE_CDR::ULong length)
 397 {
 398   if (this->char_translator_ == 0)
 399     return this->write_array (x,
 400                               ACE_CDR::OCTET_SIZE,
 401                               ACE_CDR::OCTET_ALIGN,
 402                               length);
 403   return this->char_translator_->write_char_array (*this, x, length);
 404 }
 405
 406 ACE_INLINE ACE_CDR::Boolean
 407 ACE_OutputCDR::write_wchar_array (const ACE_CDR::WChar* x,
 408                                   ACE_CDR::ULong length)
 409 {
 410   if (this->wchar_translator_)
 411     return this->wchar_translator_->write_wchar_array (*this, x, length);
 412
 413   if (ACE_OutputCDR::wchar_maxbytes_ == 0)
 414     {
 415       errno = EACCES;
 416       return (this->good_bit_ = false);
 417     }
 418
 419   if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar))
 420     return this->write_array (x,
 421                               sizeof (ACE_CDR::WChar),
 422                               sizeof (ACE_CDR::WChar) == 2
 423                               ? ACE_CDR::SHORT_ALIGN
 424                               : ACE_CDR::LONG_ALIGN,
 425                               length);
 426   return this->write_wchar_array_i (x,length);
 427 }
 428
 429 ACE_INLINE ACE_CDR::Boolean
 430 ACE_OutputCDR::write_octet_array (const ACE_CDR::Octet* x,
 431                                   ACE_CDR::ULong length)
 432 {
 433   return this->write_array (x,
 434                             ACE_CDR::OCTET_SIZE,
 435                             ACE_CDR::OCTET_ALIGN,
 436                             length);
 437 }
 438
 439 ACE_INLINE ACE_CDR::Boolean
 440 ACE_OutputCDR::write_short_array (const ACE_CDR::Short *x,
 441                                   ACE_CDR::ULong length)
 442 {
 443   return this->write_array (x,
 444                             ACE_CDR::SHORT_SIZE,
 445                             ACE_CDR::SHORT_ALIGN,
 446                             length);
 447 }
 448
 449 ACE_INLINE ACE_CDR::Boolean
 450 ACE_OutputCDR::write_ushort_array (const ACE_CDR::UShort *x,
 451                                    ACE_CDR::ULong length)
 452 {
 453   return this->write_array (x,
 454                             ACE_CDR::SHORT_SIZE,
 455                             ACE_CDR::SHORT_ALIGN,
 456                             length);
 457 }
 458
 459 ACE_INLINE ACE_CDR::Boolean
 460 ACE_OutputCDR::write_long_array (const ACE_CDR::Long *x,
 461                                  ACE_CDR::ULong length)
 462 {
 463   return this->write_array (x,
 464                             ACE_CDR::LONG_SIZE,
 465                             ACE_CDR::LONG_ALIGN,
 466                             length);
 467 }
 468
 469 ACE_INLINE ACE_CDR::Boolean
 470 ACE_OutputCDR::write_ulong_array (const ACE_CDR::ULong *x,
 471                                   ACE_CDR::ULong length)
 472 {
 473   return this->write_array (x,
 474                             ACE_CDR::LONG_SIZE,
 475                             ACE_CDR::LONG_ALIGN,
 476                             length);
 477 }
 478
 479 ACE_INLINE ACE_CDR::Boolean
 480 ACE_OutputCDR::write_longlong_array (const ACE_CDR::LongLong *x,
 481                                      ACE_CDR::ULong length)
 482 {
 483   return this->write_array (x,
 484                             ACE_CDR::LONGLONG_SIZE,
 485                             ACE_CDR::LONGLONG_ALIGN,
 486                             length);
 487 }
 488
 489 ACE_INLINE ACE_CDR::Boolean
 490 ACE_OutputCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x,
 491                                       ACE_CDR::ULong length)
 492 {
 493   return this->write_array (x,
 494                             ACE_CDR::LONGLONG_SIZE,
 495                             ACE_CDR::LONGLONG_ALIGN,
 496                             length);
 497 }
 498
 499 ACE_INLINE ACE_CDR::Boolean
 500 ACE_OutputCDR::write_float_array (const ACE_CDR::Float *x,
 501                                   ACE_CDR::ULong length)
 502 {
 503   return this->write_array (x,
 504                             ACE_CDR::LONG_SIZE,
 505                             ACE_CDR::LONG_ALIGN,
 506                             length);
 507 }
 508
 509
 510 ACE_INLINE ACE_CDR::Boolean
 511 ACE_OutputCDR::write_double_array (const ACE_CDR::Double *x,
 512                                    ACE_CDR::ULong length)
 513 {
 514   return this->write_array (x,
 515                             ACE_CDR::LONGLONG_SIZE,
 516                             ACE_CDR::LONGLONG_ALIGN,
 517                             length);
 518 }
 519
 520 ACE_INLINE ACE_CDR::Boolean
 521 ACE_OutputCDR::write_longdouble_array (const ACE_CDR::LongDouble* x,
 522                                        ACE_CDR::ULong length)
 523 {
 524   return this->write_array (x,
 525                             ACE_CDR::LONGDOUBLE_SIZE,
 526                             ACE_CDR::LONGDOUBLE_ALIGN,
 527                             length);
 528 }
 529
 530 ACE_INLINE ACE_CDR::Boolean
 531 ACE_OutputCDR::write_int8_array (const ACE_CDR::Int8 *x, ACE_CDR::ULong length)
 532 {
 533   return write_array (x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, length);
 534 }
 535
 536 ACE_INLINE ACE_CDR::Boolean
 537 ACE_OutputCDR::write_uint8_array (const ACE_CDR::UInt8 *x, ACE_CDR::ULong length)
 538 {
 539   return write_array (x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, length);
 540 }
 541
 542 ACE_INLINE bool
 543 ACE_OutputCDR::good_bit () const
 544 {
 545   return this->good_bit_;
 546 }
 547
 548 ACE_INLINE int
 549 ACE_OutputCDR::adjust (size_t size,
 550                        size_t align,
 551                        char*& buf)
 552 {
 553   if (!this->current_is_writable_)
 554     return this->grow_and_adjust (size, align, buf);
 555
 556 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 557   size_t const offset =
 558     ACE_align_binary (this->current_alignment_, align)
 559     - this->current_alignment_;
 560
 561   buf = this->current_->wr_ptr () + offset;
 562 #else
 563   buf = this->current_->wr_ptr ();
 564 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 565
 566   char * const end = buf + size;
 567
 568   if (end <= this->current_->end () &&
 569       end >= buf)
 570     {
 571 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 572       this->current_alignment_ += offset + size;
 573 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 574       this->current_->wr_ptr (end);
 575
 576 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
 577       this->monitor_->receive (this->total_length ());
 578 #endif /* ACE_HAS_MONITOR_POINTS==1 */
 579
 580       return 0;
 581     }
 582
 583   return this->grow_and_adjust (size, align, buf);
 584 }
 585
 586 ACE_INLINE int
 587 ACE_OutputCDR::adjust (size_t size, char*& buf)
 588 {
 589   return this->adjust (size, size, buf);
 590 }
 591
 592 ACE_INLINE void
 593 ACE_OutputCDR::set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor)
 594 {
 595   this->major_version_ = major;
 596   this->minor_version_ = minor;
 597 }
 598
 599 ACE_INLINE void
 600 ACE_OutputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor)
 601 {
 602   major = this->major_version_;
 603   minor = this->minor_version_;
 604 }
 605
 606
 607 ACE_INLINE const ACE_Message_Block*
 608 ACE_OutputCDR::begin () const
 609 {
 610   return &this->start_;
 611 }
 612
 613 ACE_INLINE const ACE_Message_Block*
 614 ACE_OutputCDR::end () const
 615 {
 616   return this->current_->cont ();
 617 }
 618
 619 ACE_INLINE const ACE_Message_Block*
 620 ACE_OutputCDR::current () const
 621 {
 622   return this->current_;
 623 }
 624
 625 ACE_INLINE size_t
 626 ACE_OutputCDR::total_length () const
 627 {
 628   return ACE_CDR::total_length (this->begin (), this->end ());
 629 }
 630
 631 ACE_INLINE const char*
 632 ACE_OutputCDR::buffer () const
 633 {
 634   return this->start_.rd_ptr ();
 635 }
 636
 637 ACE_INLINE size_t
 638 ACE_OutputCDR::length () const
 639 {
 640   return this->start_.length ();
 641 }
 642
 643 ACE_INLINE bool
 644 ACE_OutputCDR::do_byte_swap () const
 645 {
 646   return this->do_byte_swap_;
 647 }
 648
 649 ACE_INLINE int
 650 ACE_OutputCDR::byte_order () const
 651 {
 652   if (this->do_byte_swap ())
 653     return !ACE_CDR_BYTE_ORDER;
 654   else
 655     return ACE_CDR_BYTE_ORDER;
 656 }
 657
 658 ACE_INLINE void
 659 ACE_OutputCDR::reset_byte_order (int byte_order)
 660 {
 661   this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER);
 662 }
 663
 664 ACE_INLINE size_t
 665 ACE_OutputCDR::current_alignment () const
 666 {
 667 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 668   return this->current_alignment_;
 669 #else
 670   // Default value set to 0
 671   return 0;
 672 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 673 }
 674
 675 ACE_INLINE void
 676 ACE_OutputCDR::current_alignment (size_t current_alignment)
 677 {
 678 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 679   this->current_alignment_ = current_alignment;
 680 #else
 681   ACE_UNUSED_ARG (current_alignment);
 682 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 683 }
 684
 685 ACE_INLINE int
 686 ACE_OutputCDR::align_write_ptr (size_t alignment)
 687 {
 688 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
 689   char *dummy;
 690   return this->adjust (0, alignment, dummy);
 691 #else
 692   ACE_UNUSED_ARG (alignment);
 693   // A return value of -1 from this function is used
 694   // to indicate failure, returning 0
 695   return 0;
 696 #endif /* ACE_LACKS_CDR_ALIGNMENT */
 697 }
 698
 699 ACE_INLINE ACE_Char_Codeset_Translator *
 700 ACE_OutputCDR::char_translator () const
 701 {
 702   return this->char_translator_;
 703 }
 704
 705 ACE_INLINE ACE_WChar_Codeset_Translator *
 706 ACE_OutputCDR::wchar_translator () const
 707 {
 708   return this->wchar_translator_;
 709 }
 710
 711 ACE_INLINE void
 712 ACE_OutputCDR::char_translator (ACE_Char_Codeset_Translator * ctran)
 713 {
 714   this->char_translator_ = ctran;
 715 }
 716
 717 ACE_INLINE void
 718 ACE_OutputCDR::wchar_translator (ACE_WChar_Codeset_Translator * wctran)
 719 {
 720   this->wchar_translator_ = wctran;
 721 }
 722
 723 // ****************************************************************
 724
 725 ACE_INLINE
 726 ACE_InputCDR::~ACE_InputCDR ()
 727 {
 728 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
 729   this->monitor_->remove_ref ();
 730 #endif /* ACE_HAS_MONITOR_POINTS==1 */
 731 }
 732
 733 ACE_INLINE ACE_CDR::Boolean
 734 ACE_InputCDR::read_octet (ACE_CDR::Octet& x)
 735 {
 736   return this->read_1 (&x);
 737 }
 738
 739 ACE_INLINE ACE_CDR::Boolean
 740 ACE_InputCDR::read_boolean (ACE_CDR::Boolean& x)
 741 {
 742   ACE_CDR::Octet tmp = 0;
 743   (void) this->read_octet (tmp);
 744   x = tmp ? true : false;
 745   return this->good_bit_;
 746 }
 747
 748 ACE_INLINE ACE_CDR::Boolean
 749 ACE_InputCDR::read_char (ACE_CDR::Char &x)
 750 {
 751   if (this->char_translator_ == 0)
 752     {
 753       void *temp = &x;
 754       return this->read_1 (reinterpret_cast<ACE_CDR::Octet*> (temp));
 755     }
 756   return this->char_translator_->read_char (*this, x);
 757 }
 758
 759
 760 ACE_INLINE ACE_CDR::Boolean
 761 ACE_InputCDR::read_short (ACE_CDR::Short &x)
 762 {
 763   void *temp = &x;
 764   return this->read_2 (reinterpret_cast<ACE_CDR::UShort*> (temp));
 765 }
 766
 767 ACE_INLINE ACE_CDR::Boolean
 768 ACE_InputCDR::read_ushort (ACE_CDR::UShort &x)
 769 {
 770   return this->read_2 (&x);
 771 }
 772
 773
 774 ACE_INLINE ACE_CDR::Boolean
 775 ACE_InputCDR::read_long (ACE_CDR::Long &x)
 776 {
 777   void *temp = &x;
 778   return this->read_4 (reinterpret_cast<ACE_CDR::ULong*> (temp));
 779 }
 780
 781
 782 ACE_INLINE ACE_CDR::Boolean
 783 ACE_InputCDR::read_ulong (ACE_CDR::ULong &x)
 784 {
 785   return this->read_4 (&x);
 786 }
 787
 788
 789 ACE_INLINE ACE_CDR::Boolean
 790 ACE_InputCDR::read_longlong (ACE_CDR::LongLong &x)
 791 {
 792   void *temp = &x;
 793   return this->read_8 (reinterpret_cast<ACE_CDR::ULongLong*> (temp));
 794 }
 795
 796 ACE_INLINE ACE_CDR::Boolean
 797 ACE_InputCDR::read_ulonglong (ACE_CDR::ULongLong &x)
 798 {
 799   return this->read_8 (&x);
 800 }
 801
 802 ACE_INLINE ACE_CDR::Boolean
 803 ACE_InputCDR::read_float (ACE_CDR::Float &x)
 804 {
 805   void *temp = &x;
 806   return this->read_4 (reinterpret_cast<ACE_CDR::ULong*> (temp));
 807 }
 808
 809 ACE_INLINE ACE_CDR::Boolean
 810 ACE_InputCDR::read_double (ACE_CDR::Double &x)
 811 {
 812   void *temp = &x;
 813   return this->read_8 (reinterpret_cast<ACE_CDR::ULongLong*> (temp));
 814 }
 815
 816 ACE_INLINE ACE_CDR::Boolean
 817 ACE_InputCDR::read_longdouble (ACE_CDR::LongDouble &x)
 818 {
 819   return this->read_16 (&x);
 820 }
 821
 822 ACE_INLINE ACE_CDR::Boolean
 823 ACE_InputCDR::read_fixed (ACE_CDR::Fixed &x)
 824 {
 825   ACE_CDR::Octet a[16];
 826   for (int i = 0; i < 16; ++i)
 827     {
 828       if (!this->read_1 (a + i))
 829         return false;
 830       const unsigned low = a[i] & 0xf;
 831       if (low == ACE_CDR::Fixed::POSITIVE ||
 832           low == ACE_CDR::Fixed::NEGATIVE)
 833         {
 834           x = ACE_CDR::Fixed::from_octets (a, i + 1);
 835           return true;
 836         }
 837     }
 838
 839   return false;
 840 }
 841
 842 ACE_INLINE ACE_CDR::Boolean
 843 ACE_InputCDR::read_int8 (ACE_CDR::Int8 &x)
 844 {
 845   return read_1 (reinterpret_cast<ACE_CDR::Octet *>(&x));
 846 }
 847
 848 ACE_INLINE ACE_CDR::Boolean
 849 ACE_InputCDR::read_uint8 (ACE_CDR::UInt8 &x)
 850 {
 851   return read_1 (reinterpret_cast<ACE_CDR::Octet *>(&x));
 852 }
 853
 854 ACE_INLINE size_t
 855 ACE_InputCDR::length () const
 856 {
 857   return this->start_.length ();
 858 }
 859
 860 ACE_INLINE ACE_CDR::Boolean
 861 ACE_InputCDR::read_char_array (ACE_CDR::Char* x,
 862                                ACE_CDR::ULong length)
 863 {
 864   // Make sure the length of the array isn't greater than the length of
 865   // the stream.
 866   if (length > this->length ())
 867     {
 868       this->good_bit_ = false;
 869       return false;
 870     }
 871
 872   if (this->char_translator_ == 0)
 873     return this->read_array (x,
 874                              ACE_CDR::OCTET_SIZE,
 875                              ACE_CDR::OCTET_ALIGN,
 876                              length);
 877   return this->char_translator_->read_char_array (*this, x, length);
 878 }
 879
 880 ACE_INLINE ACE_CDR::Boolean
 881 ACE_InputCDR::read_wchar_array (ACE_CDR::WChar* x,
 882                                 ACE_CDR::ULong length)
 883 {
 884   // Make sure the length of the array isn't greater than the length of
 885   // the stream.
 886   if (length * ACE_OutputCDR::wchar_maxbytes_ > this->length ())
 887     {
 888       this->good_bit_ = false;
 889       return false;
 890     }
 891
 892   if (this->wchar_translator_ != 0)
 893     return this->wchar_translator_->read_wchar_array (*this, x, length);
 894   if (ACE_OutputCDR::wchar_maxbytes_ != sizeof (ACE_CDR::WChar))
 895     return this->read_wchar_array_i (x, length);
 896   return this->read_array (x,
 897                            sizeof (ACE_CDR::WChar),
 898                            sizeof (ACE_CDR::WChar) == 2
 899                            ? ACE_CDR::SHORT_ALIGN
 900                            : ACE_CDR::LONG_ALIGN,
 901                            length);
 902 }
 903
 904 ACE_INLINE ACE_CDR::Boolean
 905 ACE_InputCDR::read_octet_array (ACE_CDR::Octet* x,
 906                                 ACE_CDR::ULong length)
 907 {
 908   // Make sure the length of the array isn't greater than the length of
 909   // the stream.
 910   if (length * ACE_CDR::OCTET_SIZE > this->length ())
 911     {
 912       this->good_bit_ = false;
 913       return false;
 914     }
 915
 916   return this->read_array (x,
 917                            ACE_CDR::OCTET_SIZE,
 918                            ACE_CDR::OCTET_ALIGN,
 919                            length);
 920 }
 921
 922 ACE_INLINE ACE_CDR::Boolean
 923 ACE_InputCDR::read_short_array (ACE_CDR::Short *x,
 924                                 ACE_CDR::ULong length)
 925 {
 926   // Make sure the length of the array isn't greater than the length of
 927   // the stream.
 928   if (length * ACE_CDR::SHORT_SIZE > this->length ())
 929     {
 930       this->good_bit_ = false;
 931       return false;
 932     }
 933
 934   return this->read_array (x,
 935                            ACE_CDR::SHORT_SIZE,
 936                            ACE_CDR::SHORT_ALIGN,
 937                            length);
 938 }
 939
 940 ACE_INLINE ACE_CDR::Boolean
 941 ACE_InputCDR::read_ushort_array (ACE_CDR::UShort *x,
 942                                  ACE_CDR::ULong length)
 943 {
 944   // Make sure the length of the array isn't greater than the length of
 945   // the stream.
 946   if (length * ACE_CDR::SHORT_SIZE > this->length ())
 947     {
 948       this->good_bit_ = false;
 949       return false;
 950     }
 951
 952   return this->read_array (x,
 953                            ACE_CDR::SHORT_SIZE,
 954                            ACE_CDR::SHORT_ALIGN,
 955                            length);
 956 }
 957
 958 ACE_INLINE ACE_CDR::Boolean
 959 ACE_InputCDR::read_long_array (ACE_CDR::Long *x,
 960                                ACE_CDR::ULong length)
 961 {
 962   // Make sure the length of the array isn't greater than the length of
 963   // the stream.
 964   if (length * ACE_CDR::LONG_SIZE > this->length ())
 965     {
 966       this->good_bit_ = false;
 967       return false;
 968     }
 969
 970   return this->read_array (x,
 971                            ACE_CDR::LONG_SIZE,
 972                            ACE_CDR::LONG_ALIGN,
 973                            length);
 974 }
 975
 976 ACE_INLINE ACE_CDR::Boolean
 977 ACE_InputCDR::read_ulong_array (ACE_CDR::ULong *x,
 978                                 ACE_CDR::ULong length)
 979 {
 980   // Make sure the length of the array isn't greater than the length of
 981   // the stream.
 982   if (length * ACE_CDR::LONG_SIZE > this->length ())
 983     {
 984       this->good_bit_ = false;
 985       return false;
 986     }
 987
 988   return this->read_array (x,
 989                            ACE_CDR::LONG_SIZE,
 990                            ACE_CDR::LONG_ALIGN,
 991                            length);
 992 }
 993
 994 ACE_INLINE ACE_CDR::Boolean
 995 ACE_InputCDR::read_longlong_array (ACE_CDR::LongLong *x,
 996                                    ACE_CDR::ULong length)
 997 {
 998   // Make sure the length of the array isn't greater than the length of
 999   // the stream.
1000   if (length * ACE_CDR::LONGLONG_SIZE > this->length ())
1001     {
1002       this->good_bit_ = false;
1003       return false;
1004     }
1005
1006   return this->read_array (x,
1007                            ACE_CDR::LONGLONG_SIZE,
1008                            ACE_CDR::LONGLONG_ALIGN,
1009                            length);
1010 }
1011
1012 ACE_INLINE ACE_CDR::Boolean
1013 ACE_InputCDR::read_ulonglong_array (ACE_CDR::ULongLong *x,
1014                                     ACE_CDR::ULong length)
1015 {
1016   // Make sure the length of the array isn't greater than the length of
1017   // the stream.
1018   if (length * ACE_CDR::LONGLONG_SIZE > this->length ())
1019     {
1020       this->good_bit_ = false;
1021       return false;
1022     }
1023
1024   return this->read_array (x,
1025                            ACE_CDR::LONGLONG_SIZE,
1026                            ACE_CDR::LONGLONG_ALIGN,
1027                            length);
1028 }
1029
1030 ACE_INLINE ACE_CDR::Boolean
1031 ACE_InputCDR::read_float_array (ACE_CDR::Float *x,
1032                                 ACE_CDR::ULong length)
1033 {
1034   // Make sure the length of the array isn't greater than the length of
1035   // the stream.
1036   if (length * ACE_CDR::LONG_SIZE > this->length ())
1037     {
1038       this->good_bit_ = false;
1039       return false;
1040     }
1041
1042   return this->read_array (x,
1043                            ACE_CDR::LONG_SIZE,
1044                            ACE_CDR::LONG_ALIGN,
1045                            length);
1046 }
1047
1048
1049 ACE_INLINE ACE_CDR::Boolean
1050 ACE_InputCDR::read_double_array (ACE_CDR::Double *x,
1051                                  ACE_CDR::ULong length)
1052 {
1053   // Make sure the length of the array isn't greater than the length of
1054   // the stream.
1055   if (length * ACE_CDR::LONGLONG_SIZE > this->length ())
1056     {
1057       this->good_bit_ = false;
1058       return false;
1059     }
1060
1061   return this->read_array (x,
1062                            ACE_CDR::LONGLONG_SIZE,
1063                            ACE_CDR::LONGLONG_ALIGN,
1064                            length);
1065 }
1066
1067 ACE_INLINE ACE_CDR::Boolean
1068 ACE_InputCDR::read_longdouble_array (ACE_CDR::LongDouble* x,
1069                                      ACE_CDR::ULong length)
1070 {
1071   // Make sure the length of the array isn't greater than the length of
1072   // the stream.
1073   if (length * ACE_CDR::LONGDOUBLE_SIZE > this->length ())
1074     {
1075       this->good_bit_ = false;
1076       return false;
1077     }
1078   return this->read_array (x,
1079                            ACE_CDR::LONGDOUBLE_SIZE,
1080                            ACE_CDR::LONGDOUBLE_ALIGN,
1081                            length);
1082 }
1083
1084 ACE_INLINE ACE_CDR::Boolean
1085 ACE_InputCDR::read_int8_array (ACE_CDR::Int8 *x, ACE_CDR::ULong length)
1086 {
1087   if (length * ACE_CDR::OCTET_SIZE > this->length ())
1088     {
1089       this->good_bit_ = false;
1090       return false;
1091     }
1092
1093   return read_array (x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, length);
1094 }
1095
1096 ACE_INLINE ACE_CDR::Boolean
1097 ACE_InputCDR::read_uint8_array (ACE_CDR::UInt8 *x, ACE_CDR::ULong length)
1098 {
1099   if (length * ACE_CDR::OCTET_SIZE > this->length ())
1100     {
1101       this->good_bit_ = false;
1102       return false;
1103     }
1104
1105   return read_array (x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, length);
1106 }
1107
1108 ACE_INLINE ACE_CDR::Boolean
1109 ACE_InputCDR::skip_octet ()
1110 {
1111   ACE_CDR::Octet x;
1112   return this->read_1 (&x);
1113 }
1114
1115 ACE_INLINE ACE_CDR::Boolean
1116 ACE_InputCDR::skip_char ()
1117 {
1118   return this->skip_octet ();  // sizeof (Char) == sizeof (Octet)
1119 }
1120
1121 ACE_INLINE ACE_CDR::Boolean
1122 ACE_InputCDR::skip_boolean ()
1123 {
1124   return this->skip_octet () && this->good_bit_;
1125 }
1126
1127 ACE_INLINE ACE_CDR::Boolean
1128 ACE_InputCDR::skip_ushort ()
1129 {
1130   ACE_CDR::UShort x;
1131   return this->read_2 (&x);
1132 }
1133
1134 ACE_INLINE ACE_CDR::Boolean
1135 ACE_InputCDR::skip_short ()
1136 {
1137   return this->skip_ushort ();
1138 }
1139
1140 ACE_INLINE ACE_CDR::Boolean
1141 ACE_InputCDR::skip_ulong ()
1142 {
1143   ACE_CDR::ULong x;
1144   return this->read_4 (&x);
1145 }
1146
1147 ACE_INLINE ACE_CDR::Boolean
1148 ACE_InputCDR::skip_long ()
1149 {
1150   return this->skip_ulong ();  // sizeof (Long) == sizeof (ULong)
1151 }
1152
1153 ACE_INLINE ACE_CDR::Boolean
1154 ACE_InputCDR::skip_ulonglong ()
1155 {
1156   ACE_CDR::ULongLong x;
1157   return this->read_8 (&x);
1158 }
1159
1160 ACE_INLINE ACE_CDR::Boolean
1161 ACE_InputCDR::skip_longlong ()
1162 {
1163   return this->skip_ulonglong ();  // sizeof (LongLong) == sizeof (ULongLong)
1164 }
1165
1166 ACE_INLINE ACE_CDR::Boolean
1167 ACE_InputCDR::skip_float ()
1168 {
1169   return this->skip_ulong ();  // sizeof(Float) == sizeof (ULong)
1170 }
1171
1172 ACE_INLINE ACE_CDR::Boolean
1173 ACE_InputCDR::skip_double ()
1174 {
1175   return this->skip_ulonglong ();  // sizeof(Double) == sizeof (ULongLong)
1176 }
1177
1178 ACE_INLINE ACE_CDR::Boolean
1179 ACE_InputCDR::skip_longdouble ()
1180 {
1181   ACE_CDR::LongDouble x;
1182   return this->read_16 (&x);
1183 }
1184
1185 ACE_INLINE ACE_CDR::Boolean
1186 ACE_InputCDR::skip_fixed ()
1187 {
1188   for (int i = 0; i < 16; ++i)
1189     {
1190       ACE_CDR::Octet x;
1191       if (!this->read_1 (&x))
1192         return false;
1193       const unsigned low = x & 0xf;
1194       if (low == 0xc || low == 0xd)
1195         return true;
1196     }
1197   return false;
1198 }
1199
1200 ACE_INLINE char*
1201 ACE_InputCDR::end ()
1202 {
1203   return this->start_.end ();
1204 }
1205
1206 ACE_INLINE void
1207 ACE_InputCDR::rd_ptr (size_t offset)
1208 {
1209   this->start_.rd_ptr (offset);
1210 }
1211
1212 ACE_INLINE char*
1213 ACE_InputCDR::rd_ptr ()
1214 {
1215   return this->start_.rd_ptr ();
1216 }
1217
1218 ACE_INLINE char*
1219 ACE_InputCDR::wr_ptr ()
1220 {
1221   return this->start_.wr_ptr ();
1222 }
1223
1224 ACE_INLINE int
1225 ACE_InputCDR::adjust (size_t size,
1226                       size_t align,
1227                       char*& buf)
1228 {
1229 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
1230   buf = ACE_ptr_align_binary (this->rd_ptr (), align);
1231 #else
1232   buf = this->rd_ptr ();
1233 #endif /* ACE_LACKS_CDR_ALIGNMENT */
1234
1235   char * const end = buf + size;
1236   if (end <= this->wr_ptr ())
1237     {
1238       this->start_.rd_ptr (end);
1239       return 0;
1240     }
1241
1242   this->good_bit_ = false;
1243   return -1;
1244 #if defined (ACE_LACKS_CDR_ALIGNMENT)
1245   ACE_UNUSED_ARG (align);
1246 #endif /* ACE_LACKS_CDR_ALIGNMENT */
1247 }
1248
1249 ACE_INLINE int
1250 ACE_InputCDR::adjust (size_t size,
1251                       char*& buf)
1252 {
1253   return this->adjust (size, size, buf);
1254 }
1255
1256 ACE_INLINE const ACE_Message_Block*
1257 ACE_InputCDR::start () const
1258 {
1259   return &this->start_;
1260 }
1261
1262 ACE_INLINE bool
1263 ACE_InputCDR::good_bit () const
1264 {
1265   return this->good_bit_;
1266 }
1267
1268 // ****************************************************************
1269
1270 ACE_INLINE ACE_CDR::Boolean
1271 operator<< (ACE_OutputCDR &os, ACE_CDR::Char x)
1272 {
1273   os.write_char (x);
1274   return os.good_bit ();
1275 }
1276
1277 ACE_INLINE ACE_CDR::Boolean
1278 operator<< (ACE_OutputCDR &os, ACE_CDR::Short x)
1279 {
1280   os.write_short (x);
1281   return os.good_bit ();
1282 }
1283
1284 ACE_INLINE ACE_CDR::Boolean
1285 operator<< (ACE_OutputCDR &os, ACE_CDR::UShort x)
1286 {
1287   os.write_ushort (x);
1288   return os.good_bit ();
1289 }
1290
1291 ACE_INLINE ACE_CDR::Boolean
1292 operator<< (ACE_OutputCDR &os, ACE_CDR::Long x)
1293 {
1294   os.write_long (x);
1295   return os.good_bit ();
1296 }
1297
1298 ACE_INLINE ACE_CDR::Boolean
1299 operator<< (ACE_OutputCDR &os, ACE_CDR::ULong x)
1300 {
1301   os.write_ulong (x);
1302   return os.good_bit ();
1303 }
1304
1305 ACE_INLINE ACE_CDR::Boolean
1306 operator<< (ACE_OutputCDR &os, ACE_CDR::LongLong x)
1307 {
1308   os.write_longlong (x);
1309   return os.good_bit ();
1310 }
1311
1312 ACE_INLINE ACE_CDR::Boolean
1313 operator<< (ACE_OutputCDR &os, ACE_CDR::ULongLong x)
1314 {
1315   os.write_ulonglong (x);
1316   return os.good_bit ();
1317 }
1318
1319 ACE_INLINE ACE_CDR::Boolean
1320 operator<< (ACE_OutputCDR &os, ACE_CDR::LongDouble x)
1321 {
1322   os.write_longdouble (x);
1323   return os.good_bit ();
1324 }
1325
1326 ACE_INLINE ACE_CDR::Boolean
1327 operator<< (ACE_OutputCDR &os, ACE_CDR::Float x)
1328 {
1329   os.write_float (x);
1330   return os.good_bit ();
1331 }
1332
1333 ACE_INLINE ACE_CDR::Boolean
1334 operator<< (ACE_OutputCDR &os, ACE_CDR::Double x)
1335 {
1336   os.write_double (x);
1337   return os.good_bit ();
1338 }
1339
1340 ACE_INLINE ACE_CDR::Boolean
1341 operator<< (ACE_OutputCDR &os, const ACE_CDR::Fixed &x)
1342 {
1343   os.write_fixed (x);
1344   return os.good_bit ();
1345 }
1346
1347 ACE_INLINE ACE_CDR::Boolean
1348 operator<< (ACE_OutputCDR &os, const ACE_CDR::Char *x)
1349 {
1350   os.write_string (x);
1351   return os.good_bit ();
1352 }
1353
1354 ACE_INLINE ACE_CDR::Boolean
1355 operator<< (ACE_OutputCDR &os, const ACE_CDR::WChar *x)
1356 {
1357   os.write_wstring (x);
1358   return os.good_bit ();
1359 }
1360
1361 ACE_INLINE ACE_CDR::Boolean
1362 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_std_string x)
1363 {
1364   ACE_CDR::ULong const len = static_cast<ACE_CDR::ULong> (x.val_.size ());
1365
1366   os.write_string (len, x.val_.c_str ());
1367   return (os.good_bit () && (!x.bound_ || len <= x.bound_));
1368 }
1369
1370 #if !defined(ACE_LACKS_STD_WSTRING)
1371 ACE_INLINE ACE_CDR::Boolean
1372 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_std_wstring x)
1373 {
1374   ACE_CDR::ULong const len = static_cast<ACE_CDR::ULong> (x.val_.size ());
1375
1376   os.write_wstring (len, x.val_.c_str ());
1377   return (os.good_bit () && (!x.bound_ || len <= x.bound_));
1378 }
1379 #endif
1380
1381 ACE_INLINE ACE_CDR::Boolean
1382 operator<< (ACE_OutputCDR &os, const std::string& x)
1383 {
1384   os.write_string (x);
1385   return os.good_bit ();
1386 }
1387
1388 #if !defined(ACE_LACKS_STD_WSTRING)
1389 ACE_INLINE ACE_CDR::Boolean
1390 operator<< (ACE_OutputCDR &os, const std::wstring& x)
1391 {
1392   os.write_wstring (x);
1393   return os.good_bit ();
1394 }
1395 #endif
1396
1397 // The following use the helper classes
1398 ACE_INLINE ACE_CDR::Boolean
1399 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_boolean x)
1400 {
1401   (void) os.write_boolean (x.val_);
1402   return os.good_bit ();
1403 }
1404
1405 ACE_INLINE ACE_CDR::Boolean
1406 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_char x)
1407 {
1408   os.write_char (x.val_);
1409   return os.good_bit ();
1410 }
1411
1412 ACE_INLINE ACE_CDR::Boolean
1413 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_wchar x)
1414 {
1415   os.write_wchar (x.val_);
1416   return os.good_bit ();
1417 }
1418
1419 ACE_INLINE ACE_CDR::Boolean
1420 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_octet x)
1421 {
1422   os.write_octet (x.val_);
1423   return os.good_bit ();
1424 }
1425
1426 ACE_INLINE ACE_CDR::Boolean
1427 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_string x)
1428 {
1429   ACE_CDR::ULong len = 0;
1430
1431   if (x.val_ != 0)
1432     {
1433       len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
1434     }
1435
1436   os.write_string (len, x.val_);
1437   return (os.good_bit () && (!x.bound_ || len <= x.bound_));
1438 }
1439
1440 ACE_INLINE ACE_CDR::Boolean
1441 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_wstring x)
1442 {
1443   ACE_CDR::ULong len = 0;
1444
1445   if (x.val_ != 0)
1446     {
1447       len = static_cast<ACE_CDR::ULong> (ACE_OS::strlen (x.val_));
1448     }
1449
1450   os.write_wstring (len, x.val_);
1451   return (os.good_bit () && (!x.bound_ || len <= x.bound_));
1452 }
1453
1454 ACE_INLINE ACE_CDR::Boolean
1455 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_uint8 x)
1456 {
1457   os.write_uint8 (x.val_);
1458   return os.good_bit ();
1459 }
1460
1461 ACE_INLINE ACE_CDR::Boolean
1462 operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_int8 x)
1463 {
1464   os.write_int8 (x.val_);
1465   return os.good_bit ();
1466 }
1467
1468 // ****************************************************************
1469
1470 ACE_INLINE ACE_CDR::Boolean
1471 operator>> (ACE_InputCDR &is, ACE_CDR::Char &x)
1472 {
1473   return is.read_char (x) && is.good_bit ();
1474 }
1475
1476 ACE_INLINE ACE_CDR::Boolean
1477 operator>> (ACE_InputCDR &is, ACE_CDR::Short &x)
1478 {
1479   return is.read_short (x) && is.good_bit ();
1480 }
1481
1482 ACE_INLINE ACE_CDR::Boolean
1483 operator>> (ACE_InputCDR &is, ACE_CDR::UShort &x)
1484 {
1485   return is.read_ushort (x) && is.good_bit ();
1486 }
1487
1488 ACE_INLINE ACE_CDR::Boolean
1489 operator>>(ACE_InputCDR &is, ACE_CDR::Long &x)
1490 {
1491   return is.read_long (x) && is.good_bit ();
1492 }
1493
1494 ACE_INLINE ACE_CDR::Boolean
1495 operator>> (ACE_InputCDR &is, ACE_CDR::ULong &x)
1496 {
1497   return is.read_ulong (x) && is.good_bit ();
1498 }
1499
1500 ACE_INLINE ACE_CDR::Boolean
1501 operator>> (ACE_InputCDR& is, ACE_CDR::LongLong &x)
1502 {
1503   return is.read_longlong (x) && is.good_bit ();
1504 }
1505
1506 ACE_INLINE ACE_CDR::Boolean
1507 operator>> (ACE_InputCDR& is, ACE_CDR::ULongLong &x)
1508 {
1509   return is.read_ulonglong (x) && is.good_bit ();
1510 }
1511
1512 ACE_INLINE ACE_CDR::Boolean
1513 operator>> (ACE_InputCDR& is, ACE_CDR::LongDouble &x)
1514 {
1515   return is.read_longdouble (x) && is.good_bit ();
1516 }
1517
1518 ACE_INLINE ACE_CDR::Boolean
1519 operator>> (ACE_InputCDR &is, ACE_CDR::Float &x)
1520 {
1521   return is.read_float (x) && is.good_bit ();
1522 }
1523
1524 ACE_INLINE ACE_CDR::Boolean
1525 operator>> (ACE_InputCDR &is, ACE_CDR::Double &x)
1526 {
1527   return is.read_double (x) && is.good_bit ();
1528 }
1529
1530 ACE_INLINE ACE_CDR::Boolean
1531 operator>> (ACE_InputCDR &is, ACE_CDR::Fixed &x)
1532 {
1533   return is.read_fixed (x) && is.good_bit ();
1534 }
1535
1536 ACE_INLINE ACE_CDR::Boolean
1537 operator>> (ACE_InputCDR &is, ACE_CDR::Char *&x)
1538 {
1539   return is.read_string (x) && is.good_bit ();
1540 }
1541
1542 ACE_INLINE ACE_CDR::Boolean
1543 operator>> (ACE_InputCDR &is, ACE_CDR::WChar *&x)
1544 {
1545   return is.read_wstring (x) && is.good_bit ();
1546 }
1547
1548 ACE_INLINE ACE_CDR::Boolean
1549 operator>> (ACE_InputCDR &is, std::string& x)
1550 {
1551   return is.read_string (x) && is.good_bit ();
1552 }
1553
1554 #if !defined(ACE_LACKS_STD_WSTRING)
1555 ACE_INLINE ACE_CDR::Boolean
1556 operator>> (ACE_InputCDR &is, std::wstring& x)
1557 {
1558   return is.read_wstring (x) && is.good_bit ();
1559 }
1560 #endif
1561
1562 // The following use the helper classes
1563 ACE_INLINE ACE_CDR::Boolean
1564 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_boolean x)
1565 {
1566   return is.read_boolean (x.ref_);
1567 }
1568
1569 ACE_INLINE ACE_CDR::Boolean
1570 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_char x)
1571 {
1572   return is.read_char (x.ref_) && is.good_bit ();
1573 }
1574
1575 ACE_INLINE ACE_CDR::Boolean
1576 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_wchar x)
1577 {
1578   return is.read_wchar (x.ref_) && is.good_bit ();
1579 }
1580
1581 ACE_INLINE ACE_CDR::Boolean
1582 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_octet x)
1583 {
1584   return is.read_octet (x.ref_) && is.good_bit ();
1585 }
1586
1587 ACE_INLINE ACE_CDR::Boolean
1588 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_string x)
1589 {
1590   // check if the bounds are satisfied
1591   return
1592     (is.read_string (const_cast<char *&> (x.val_))
1593      && is.good_bit ()
1594      && (!x.bound_
1595          || ACE_OS::strlen (x.val_) <= x.bound_));
1596 }
1597
1598 ACE_INLINE ACE_CDR::Boolean
1599 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_wstring x)
1600 {
1601   // check if the bounds are satisfied
1602   return
1603     (is.read_wstring (const_cast<ACE_CDR::WChar *&> (x.val_))
1604      && is.good_bit ()
1605      && (!x.bound_
1606          || ACE_OS::strlen (x.val_) <= x.bound_));
1607 }
1608
1609 ACE_INLINE ACE_CDR::Boolean
1610 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_std_string x)
1611 {
1612   // check if the bounds are satisfied
1613   return
1614     (is.read_string (x.val_)
1615      && is.good_bit ()
1616      && (!x.bound_
1617          || static_cast<ACE_CDR::ULong> (x.val_.size ()) <= x.bound_));
1618 }
1619
1620 #if !defined(ACE_LACKS_STD_WSTRING)
1621 ACE_INLINE ACE_CDR::Boolean
1622 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_std_wstring x)
1623 {
1624   // check if the bounds are satisfied
1625   return
1626     (is.read_wstring (x.val_)
1627      && is.good_bit ()
1628      && (!x.bound_
1629          || static_cast<ACE_CDR::ULong> (x.val_.size ()) <= x.bound_));
1630 }
1631 #endif
1632
1633 ACE_INLINE ACE_CDR::Boolean
1634 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_uint8 x)
1635 {
1636   return is.read_uint8 (x.ref_) && is.good_bit ();
1637 }
1638
1639 ACE_INLINE ACE_CDR::Boolean
1640 operator>> (ACE_InputCDR &is, ACE_InputCDR::to_int8 x)
1641 {
1642   return is.read_int8 (x.ref_) && is.good_bit ();
1643 }
1644
1645 // ***************************************************************************
1646 // We must define these methods here because they use the "read_*" inlined
1647 // methods of the ACE_InputCDR class
1648 // ***************************************************************************
1649
1650 ACE_INLINE ACE_CDR::Boolean
1651 ACE_OutputCDR::append_boolean (ACE_InputCDR &stream)
1652 {
1653   ACE_CDR::Boolean x;
1654   return stream.read_boolean (x) ? this->write_boolean (x) : false;
1655 }
1656
1657 ACE_INLINE ACE_CDR::Boolean
1658 ACE_OutputCDR::append_char (ACE_InputCDR &stream)
1659 {
1660   ACE_CDR::Char x;
1661   return stream.read_char (x) ? this->write_char (x) : false;
1662 }
1663
1664 ACE_INLINE ACE_CDR::Boolean
1665 ACE_OutputCDR::append_wchar (ACE_InputCDR &stream)
1666 {
1667   ACE_CDR::WChar x;
1668   return stream.read_wchar (x) ? this->write_wchar (x) : false;
1669 }
1670
1671 ACE_INLINE ACE_CDR::Boolean
1672 ACE_OutputCDR::append_octet (ACE_InputCDR &stream)
1673 {
1674   ACE_CDR::Octet x;
1675   return stream.read_octet (x) ? this->write_octet (x) : false;
1676 }
1677
1678 ACE_INLINE ACE_CDR::Boolean
1679 ACE_OutputCDR::append_short (ACE_InputCDR &stream)
1680 {
1681   ACE_CDR::Short x;
1682   return stream.read_short (x) ? this->write_short (x) : false;
1683 }
1684
1685 ACE_INLINE ACE_CDR::Boolean
1686 ACE_OutputCDR::append_ushort (ACE_InputCDR &stream)
1687 {
1688   ACE_CDR::UShort x;
1689   return stream.read_ushort (x) ? this->write_ushort (x) : false;
1690 }
1691
1692 ACE_INLINE ACE_CDR::Boolean
1693 ACE_OutputCDR::append_long (ACE_InputCDR &stream)
1694 {
1695   ACE_CDR::Long x;
1696   return stream.read_long (x) ? this->write_long (x) : false;
1697 }
1698
1699 ACE_INLINE ACE_CDR::Boolean
1700 ACE_OutputCDR::append_ulong (ACE_InputCDR &stream)
1701 {
1702   ACE_CDR::ULong x;
1703   return stream.read_ulong (x) ? this->write_ulong (x) : false;
1704 }
1705
1706 ACE_INLINE ACE_CDR::Boolean
1707 ACE_OutputCDR::append_longlong (ACE_InputCDR &stream)
1708 {
1709   ACE_CDR::LongLong x;
1710   return stream.read_longlong (x) ? this->write_longlong (x) : false;
1711 }
1712
1713 ACE_INLINE ACE_CDR::Boolean
1714 ACE_OutputCDR::append_ulonglong (ACE_InputCDR &stream)
1715 {
1716   ACE_CDR::ULongLong x;
1717   return stream.read_ulonglong (x) ? this->write_ulonglong (x) : false;
1718 }
1719
1720 ACE_INLINE ACE_CDR::Boolean
1721 ACE_OutputCDR::append_float (ACE_InputCDR &stream)
1722 {
1723   ACE_CDR::Float x;
1724   return stream.read_float (x) ? this->write_float (x) : false;
1725 }
1726
1727 ACE_INLINE ACE_CDR::Boolean
1728 ACE_OutputCDR::append_double (ACE_InputCDR &stream)
1729 {
1730   ACE_CDR::Double x;
1731   return stream.read_double (x) ? this->write_double (x) : false;
1732 }
1733
1734 ACE_INLINE ACE_CDR::Boolean
1735 ACE_OutputCDR::append_longdouble (ACE_InputCDR &stream)
1736 {
1737   ACE_CDR::LongDouble x;
1738   return stream.read_longdouble (x) ? this->write_longdouble (x) : false;
1739 }
1740
1741 ACE_INLINE ACE_CDR::Boolean
1742 ACE_OutputCDR::append_fixed (ACE_InputCDR &stream)
1743 {
1744   ACE_CDR::Fixed x;
1745   return stream.read_fixed (x) ? this->write_fixed (x) : false;
1746 }
1747
1748 ACE_INLINE ACE_CDR::Boolean
1749 ACE_OutputCDR::append_string (ACE_InputCDR &stream)
1750 {
1751   ACE_CDR::Char *x = 0;
1752   ACE_CDR::Boolean const flag =
1753     (stream.read_string (x) ? this->write_string (x) : false);
1754 #if defined (ACE_HAS_ALLOC_HOOKS)
1755   ACE_Allocator::instance()->free(x);
1756 #else
1757   delete [] x;
1758 #endif /* ACE_HAS_ALLOC_HOOKS */
1759   return flag;
1760 }
1761
1762 ACE_INLINE ACE_CDR::Boolean
1763 ACE_OutputCDR::append_wstring (ACE_InputCDR &stream)
1764 {
1765   ACE_CDR::WChar *x = 0;
1766   ACE_CDR::Boolean const flag =
1767     (stream.read_wstring (x) ? this->write_wstring (x) : false);
1768 #if defined (ACE_HAS_ALLOC_HOOKS)
1769   ACE_Allocator::instance()->free(x);
1770 #else
1771   delete [] x;
1772 #endif /* ACE_HAS_ALLOC_HOOKS */
1773   return flag;
1774 }
1775
1776 ACE_INLINE void
1777 ACE_InputCDR::reset_byte_order (int byte_order)
1778 {
1779   this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER);
1780 }
1781
1782 ACE_INLINE bool
1783 ACE_InputCDR::do_byte_swap () const
1784 {
1785   return this->do_byte_swap_;
1786 }
1787
1788 ACE_INLINE int
1789 ACE_InputCDR::byte_order () const
1790 {
1791   return this->do_byte_swap () ? !ACE_CDR_BYTE_ORDER : ACE_CDR_BYTE_ORDER;
1792 }
1793
1794 ACE_INLINE int
1795 ACE_InputCDR::align_read_ptr (size_t alignment)
1796 {
1797 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
1798   char *buf = ACE_ptr_align_binary (this->rd_ptr (),
1799                                     alignment);
1800 #else
1801   char *buf = this->rd_ptr ();
1802 #endif /* ACE_LACKS_CDR_ALIGNMENT */
1803
1804   if (buf <= this->wr_ptr ())
1805     {
1806       this->start_.rd_ptr (buf);
1807       return 0;
1808     }
1809
1810   this->good_bit_ = false;
1811   return -1;
1812 }
1813
1814 ACE_INLINE void
1815 ACE_InputCDR::set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor)
1816 {
1817   this->major_version_ = major;
1818   this->minor_version_ = minor;
1819 }
1820
1821 ACE_INLINE void
1822 ACE_InputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor)
1823 {
1824   major = this->major_version_;
1825   minor = this->minor_version_;
1826 }
1827
1828 ACE_INLINE ACE_Char_Codeset_Translator *
1829 ACE_InputCDR::char_translator () const
1830 {
1831   return this->char_translator_;
1832 }
1833
1834 ACE_INLINE ACE_WChar_Codeset_Translator *
1835 ACE_InputCDR::wchar_translator () const
1836 {
1837   return this->wchar_translator_;
1838 }
1839
1840
1841 ACE_INLINE void
1842 ACE_InputCDR::char_translator (ACE_Char_Codeset_Translator * ctran)
1843 {
1844   this->char_translator_ = ctran;
1845 }
1846
1847 ACE_INLINE void
1848 ACE_InputCDR::wchar_translator (ACE_WChar_Codeset_Translator * wctran)
1849 {
1850   this->wchar_translator_ = wctran;
1851 }
1852
1853 // ****************************************************************
1854
1855 ACE_INLINE ACE_CDR::Boolean
1856 ACE_Char_Codeset_Translator::read_1 (ACE_InputCDR& input,
1857                                      ACE_CDR::Octet *x)
1858 {
1859   return input.read_1 (x);
1860 }
1861
1862 ACE_INLINE ACE_CDR::Boolean
1863 ACE_Char_Codeset_Translator::write_1 (ACE_OutputCDR& output,
1864                                       const ACE_CDR::Octet *x)
1865 {
1866   return output.write_1 (x);
1867 }
1868
1869 ACE_INLINE ACE_CDR::Boolean
1870 ACE_Char_Codeset_Translator::read_array (ACE_InputCDR& in,
1871                                          void* x,
1872                                          size_t size,
1873                                          size_t align,
1874                                          ACE_CDR::ULong length)
1875 {
1876   return in.read_array (x, size, align, length);
1877 }
1878
1879 ACE_INLINE ACE_CDR::Boolean
1880 ACE_Char_Codeset_Translator::write_array (ACE_OutputCDR& out,
1881                                           const void *x,
1882                                           size_t size,
1883                                           size_t align,
1884                                           ACE_CDR::ULong length)
1885 {
1886   return out.write_array(x, size, align, length);
1887 }
1888
1889 ACE_INLINE int
1890 ACE_Char_Codeset_Translator::adjust (ACE_OutputCDR& out,
1891                                      size_t size,
1892                                      size_t align,
1893                                      char *&buf)
1894 {
1895   return out.adjust(size, align, buf);
1896 }
1897
1898 ACE_INLINE void
1899 ACE_Char_Codeset_Translator::good_bit (ACE_OutputCDR& out, bool bit)
1900 {
1901   out.good_bit_ = bit;
1902 }
1903
1904 ACE_INLINE ACE_CDR::Octet
1905 ACE_Char_Codeset_Translator::major_version (ACE_InputCDR& input)
1906 {
1907   return input.major_version_;
1908 }
1909
1910 ACE_INLINE ACE_CDR::Octet
1911 ACE_Char_Codeset_Translator::minor_version (ACE_InputCDR& input)
1912 {
1913   return input.minor_version_;
1914 }
1915
1916 ACE_INLINE ACE_CDR::Octet
1917 ACE_Char_Codeset_Translator::major_version (ACE_OutputCDR& output)
1918 {
1919   return output.major_version_;
1920 }
1921
1922 ACE_INLINE ACE_CDR::Octet
1923 ACE_Char_Codeset_Translator::minor_version (ACE_OutputCDR& output)
1924 {
1925   return output.minor_version_;
1926 }
1927
1928 // ****************************************************************
1929
1930 ACE_INLINE ACE_CDR::Boolean
1931 ACE_WChar_Codeset_Translator::read_1 (ACE_InputCDR& input,
1932                                       ACE_CDR::Octet *x)
1933 {
1934   return input.read_1 (x);
1935 }
1936
1937 ACE_INLINE ACE_CDR::Boolean
1938 ACE_WChar_Codeset_Translator::read_2 (ACE_InputCDR& input,
1939                                       ACE_CDR::UShort *x)
1940 {
1941   return input.read_2 (x);
1942 }
1943
1944 ACE_INLINE ACE_CDR::Boolean
1945 ACE_WChar_Codeset_Translator::read_4 (ACE_InputCDR& input,
1946                                       ACE_CDR::ULong *x)
1947 {
1948   return input.read_4 (x);
1949 }
1950
1951 ACE_INLINE ACE_CDR::Boolean
1952 ACE_WChar_Codeset_Translator::write_1 (ACE_OutputCDR& output,
1953                                        const ACE_CDR::Octet *x)
1954 {
1955   return output.write_1 (x);
1956 }
1957
1958 ACE_INLINE ACE_CDR::Boolean
1959 ACE_WChar_Codeset_Translator::write_2 (ACE_OutputCDR& output,
1960                                        const ACE_CDR::UShort *x)
1961 {
1962   return output.write_2 (x);
1963 }
1964
1965 ACE_INLINE ACE_CDR::Boolean
1966 ACE_WChar_Codeset_Translator::write_4 (ACE_OutputCDR& output,
1967                                        const ACE_CDR::ULong *x)
1968 {
1969   return output.write_4 (x);
1970 }
1971
1972 ACE_INLINE ACE_CDR::Boolean
1973 ACE_WChar_Codeset_Translator::read_array (ACE_InputCDR& in,
1974                                           void* x,
1975                                           size_t size,
1976                                           size_t align,
1977                                           ACE_CDR::ULong length)
1978 {
1979   return in.read_array (x, size, align, length);
1980 }
1981
1982 ACE_INLINE ACE_CDR::Boolean
1983 ACE_WChar_Codeset_Translator::write_array (ACE_OutputCDR& out,
1984                                            const void *x,
1985                                            size_t size,
1986                                            size_t align,
1987                                            ACE_CDR::ULong length)
1988 {
1989   return out.write_array(x, size, align, length);
1990 }
1991
1992 ACE_INLINE int
1993 ACE_WChar_Codeset_Translator::adjust (ACE_OutputCDR& out,
1994                                       size_t size,
1995                                       size_t align,
1996                                       char *&buf)
1997 {
1998   return out.adjust(size, align, buf);
1999 }
2000
2001 ACE_INLINE void
2002 ACE_WChar_Codeset_Translator::good_bit (ACE_OutputCDR& out, bool bit)
2003 {
2004   out.good_bit_ = bit;
2005 }
2006
2007 ACE_INLINE ACE_CDR::Octet
2008 ACE_WChar_Codeset_Translator::major_version (ACE_InputCDR& input)
2009 {
2010   return input.major_version_;
2011 }
2012
2013 ACE_INLINE ACE_CDR::Octet
2014 ACE_WChar_Codeset_Translator::minor_version (ACE_InputCDR& input)
2015 {
2016   return input.minor_version_;
2017 }
2018
2019 ACE_INLINE ACE_CDR::Octet
2020 ACE_WChar_Codeset_Translator::major_version (ACE_OutputCDR& output)
2021 {
2022   return output.major_version_;
2023 }
2024
2025 ACE_INLINE ACE_CDR::Octet
2026 ACE_WChar_Codeset_Translator::minor_version (ACE_OutputCDR& output)
2027 {
2028   return output.minor_version_;
2029 }
2030
2031 ACE_END_VERSIONED_NAMESPACE_DECL