00001 #include "ace/CDR_Stream.h"
00002 #include "ace/SString.h"
00003 #include "ace/Auto_Ptr.h"
00004 #include "ace/Truncate.h"
00005
00006 #if !defined (__ACE_INLINE__)
00007 # include "ace/CDR_Stream.inl"
00008 #endif
00009
00010 ACE_RCSID (ace,
00011 CDR_Stream,
00012 "$Id: CDR_Stream.cpp 88653 2010-01-21 23:19:50Z sowayaa $")
00013
00014
00015
00016 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00017
00018 size_t ACE_OutputCDR::wchar_maxbytes_ = sizeof (ACE_CDR::WChar);
00019
00020 ACE_OutputCDR::ACE_OutputCDR (size_t size,
00021 int byte_order,
00022 ACE_Allocator *buffer_allocator,
00023 ACE_Allocator *data_block_allocator,
00024 ACE_Allocator *message_block_allocator,
00025 size_t memcpy_tradeoff,
00026 ACE_CDR::Octet major_version,
00027 ACE_CDR::Octet minor_version)
00028 : start_ ((size ? size : (size_t) ACE_CDR::DEFAULT_BUFSIZE) + ACE_CDR::MAX_ALIGNMENT,
00029 ACE_Message_Block::MB_DATA,
00030 0,
00031 0,
00032 buffer_allocator,
00033 0,
00034 0,
00035 ACE_Time_Value::zero,
00036 ACE_Time_Value::max_time,
00037 data_block_allocator,
00038 message_block_allocator),
00039 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00040 current_alignment_ (0),
00041 #endif
00042 current_is_writable_ (true),
00043 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00044 good_bit_ (true),
00045 memcpy_tradeoff_ (memcpy_tradeoff),
00046 major_version_ (major_version),
00047 minor_version_ (minor_version),
00048 char_translator_ (0),
00049 wchar_translator_ (0)
00050
00051 {
00052 ACE_CDR::mb_align (&this->start_);
00053 this->current_ = &this->start_;
00054
00055 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00056 ACE_NEW (this->monitor_,
00057 ACE::Monitor_Control::Size_Monitor);
00058 this->monitor_->receive (this->total_length ());
00059 #endif
00060 }
00061
00062 ACE_OutputCDR::ACE_OutputCDR (char *data,
00063 size_t size,
00064 int byte_order,
00065 ACE_Allocator *buffer_allocator,
00066 ACE_Allocator *data_block_allocator,
00067 ACE_Allocator *message_block_allocator,
00068 size_t memcpy_tradeoff,
00069 ACE_CDR::Octet major_version,
00070 ACE_CDR::Octet minor_version)
00071 : start_ (size,
00072 ACE_Message_Block::MB_DATA,
00073 0,
00074 data,
00075 buffer_allocator,
00076 0,
00077 0,
00078 ACE_Time_Value::zero,
00079 ACE_Time_Value::max_time,
00080 data_block_allocator,
00081 message_block_allocator),
00082 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00083 current_alignment_ (0),
00084 #endif
00085 current_is_writable_ (true),
00086 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00087 good_bit_ (true),
00088 memcpy_tradeoff_ (memcpy_tradeoff),
00089 major_version_ (major_version),
00090 minor_version_ (minor_version),
00091 char_translator_ (0),
00092 wchar_translator_ (0)
00093 {
00094
00095 ACE_CDR::mb_align (&this->start_);
00096 this->current_ = &this->start_;
00097
00098 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00099 ACE_NEW (this->monitor_,
00100 ACE::Monitor_Control::Size_Monitor);
00101 this->monitor_->receive (this->total_length ());
00102 #endif
00103 }
00104
00105 ACE_OutputCDR::ACE_OutputCDR (ACE_Data_Block *data_block,
00106 int byte_order,
00107 ACE_Allocator *message_block_allocator,
00108 size_t memcpy_tradeoff,
00109 ACE_CDR::Octet major_version,
00110 ACE_CDR::Octet minor_version)
00111 : start_ (data_block,
00112 ACE_Message_Block::DONT_DELETE,
00113 message_block_allocator),
00114 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00115 current_alignment_ (0),
00116 #endif
00117 current_is_writable_ (true),
00118 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00119 good_bit_ (true),
00120 memcpy_tradeoff_ (memcpy_tradeoff),
00121 major_version_ (major_version),
00122 minor_version_ (minor_version),
00123 char_translator_ (0),
00124 wchar_translator_ (0)
00125 {
00126
00127 ACE_CDR::mb_align (&this->start_);
00128 this->current_ = &this->start_;
00129
00130 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00131 ACE_NEW (this->monitor_,
00132 ACE::Monitor_Control::Size_Monitor);
00133 this->monitor_->receive (this->total_length ());
00134 #endif
00135 }
00136
00137 ACE_OutputCDR::ACE_OutputCDR (ACE_Message_Block *data,
00138 int byte_order,
00139 size_t memcpy_tradeoff,
00140 ACE_CDR::Octet major_version,
00141 ACE_CDR::Octet minor_version)
00142 : start_ (data->data_block ()->duplicate ()),
00143 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00144 current_alignment_ (0),
00145 #endif
00146 current_is_writable_ (true),
00147 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00148 good_bit_ (true),
00149 memcpy_tradeoff_ (memcpy_tradeoff),
00150 major_version_ (major_version),
00151 minor_version_ (minor_version),
00152 char_translator_ (0),
00153 wchar_translator_ (0)
00154 {
00155
00156 ACE_CDR::mb_align (&this->start_);
00157 this->current_ = &this->start_;
00158
00159 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00160 ACE_NEW (this->monitor_,
00161 ACE::Monitor_Control::Size_Monitor);
00162 this->monitor_->receive (this->total_length ());
00163 #endif
00164 }
00165
00166 void
00167 ACE_OutputCDR::wchar_maxbytes (size_t maxbytes)
00168 {
00169 ACE_OutputCDR::wchar_maxbytes_ = maxbytes;
00170 }
00171
00172 size_t
00173 ACE_OutputCDR::wchar_maxbytes ()
00174 {
00175 return ACE_OutputCDR::wchar_maxbytes_;
00176 }
00177
00178 int
00179 ACE_OutputCDR::grow_and_adjust (size_t size,
00180 size_t align,
00181 char*& buf)
00182 {
00183 if (!this->current_is_writable_
00184 || this->current_->cont () == 0
00185 || this->current_->cont ()->size () < size + ACE_CDR::MAX_ALIGNMENT)
00186 {
00187
00188
00189 size_t cursize = this->current_->size ();
00190 if (this->current_->cont () != 0)
00191 cursize = this->current_->cont ()->size ();
00192 size_t minsize = size;
00193
00194 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00195 minsize += ACE_CDR::MAX_ALIGNMENT;
00196 #endif
00197
00198
00199
00200 if (minsize < cursize)
00201 minsize = cursize;
00202
00203 size_t const newsize = ACE_CDR::next_size (minsize);
00204
00205 this->good_bit_ = false;
00206 ACE_Message_Block* tmp = 0;
00207 ACE_NEW_RETURN (tmp,
00208 ACE_Message_Block (newsize,
00209 ACE_Message_Block::MB_DATA,
00210 0,
00211 0,
00212 this->current_->data_block ()->allocator_strategy (),
00213 0,
00214 0,
00215 ACE_Time_Value::zero,
00216 ACE_Time_Value::max_time,
00217 this->current_->data_block ()->data_block_allocator ()),
00218 -1);
00219
00220
00221
00222
00223 if (tmp != 0 && tmp->size () < newsize)
00224 {
00225 delete tmp;
00226 errno = ENOMEM;
00227 return -1;
00228 }
00229
00230 this->good_bit_ = true;
00231
00232 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00233
00234
00235 ptrdiff_t const tmpalign =
00236 reinterpret_cast<ptrdiff_t> (tmp->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT;
00237 ptrdiff_t const curalign =
00238 static_cast<ptrdiff_t> (this->current_alignment_) % ACE_CDR::MAX_ALIGNMENT;
00239 ptrdiff_t offset = curalign - tmpalign;
00240 if (offset < 0)
00241 offset += ACE_CDR::MAX_ALIGNMENT;
00242 tmp->rd_ptr (static_cast<size_t> (offset));
00243 tmp->wr_ptr (tmp->rd_ptr ());
00244 #endif
00245
00246
00247 tmp->cont (this->current_->cont ());
00248 this->current_->cont (tmp);
00249 }
00250 this->current_ = this->current_->cont ();
00251 this->current_is_writable_ = true;
00252
00253 return this->adjust (size, align, buf);
00254 }
00255
00256 ACE_CDR::Boolean
00257 ACE_OutputCDR::write_wchar (ACE_CDR::WChar x)
00258 {
00259 if (this->wchar_translator_ != 0)
00260 return (this->good_bit_ = this->wchar_translator_->write_wchar (*this, x));
00261 if (ACE_OutputCDR::wchar_maxbytes_ == 0)
00262 {
00263 errno = EACCES;
00264 return (this->good_bit_ = false);
00265 }
00266 if (static_cast<ACE_CDR::Short> (major_version_) == 1
00267 && static_cast<ACE_CDR::Short> (minor_version_) == 2)
00268 {
00269 ACE_CDR::Octet len =
00270 static_cast<ACE_CDR::Octet> (ACE_OutputCDR::wchar_maxbytes_);
00271 if (this->write_1 (&len))
00272 {
00273 if (ACE_OutputCDR::wchar_maxbytes_ == sizeof(ACE_CDR::WChar))
00274 return
00275 this->write_octet_array (
00276 reinterpret_cast<const ACE_CDR::Octet*> (&x),
00277 static_cast<ACE_CDR::ULong> (len));
00278 else
00279 if (ACE_OutputCDR::wchar_maxbytes_ == 2)
00280 {
00281 ACE_CDR::Short sx = static_cast<ACE_CDR::Short> (x);
00282 return
00283 this->write_octet_array (
00284 reinterpret_cast<const ACE_CDR::Octet*> (&sx),
00285 static_cast<ACE_CDR::ULong> (len));
00286 }
00287 else
00288 {
00289 ACE_CDR::Octet ox = static_cast<ACE_CDR::Octet> (x);
00290 return
00291 this->write_octet_array (
00292 reinterpret_cast<const ACE_CDR::Octet*> (&ox),
00293 static_cast<ACE_CDR::ULong> (len));
00294 }
00295 }
00296 }
00297 else if (static_cast<ACE_CDR::Short> (minor_version_) == 0)
00298 {
00299 errno = EINVAL;
00300 return (this->good_bit_ = false);
00301 }
00302 if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar))
00303 {
00304 void const * const temp = &x;
00305 return
00306 this->write_4 (reinterpret_cast<const ACE_CDR::ULong *> (temp));
00307 }
00308 else if (ACE_OutputCDR::wchar_maxbytes_ == 2)
00309 {
00310 ACE_CDR::Short sx = static_cast<ACE_CDR::Short> (x);
00311 return this->write_2 (reinterpret_cast<const ACE_CDR::UShort *> (&sx));
00312 }
00313 ACE_CDR::Octet ox = static_cast<ACE_CDR::Octet> (x);
00314 return this->write_1 (reinterpret_cast<const ACE_CDR::Octet *> (&ox));
00315 }
00316
00317 ACE_CDR::Boolean
00318 ACE_OutputCDR::write_string (ACE_CDR::ULong len,
00319 const ACE_CDR::Char *x)
00320 {
00321
00322
00323
00324 if (this->char_translator_ != 0)
00325 return this->char_translator_->write_string (*this, len, x);
00326
00327 if (len != 0)
00328 {
00329 if (this->write_ulong (len + 1))
00330 return this->write_char_array (x, len + 1);
00331 }
00332 else
00333 {
00334
00335
00336
00337
00338 if (this->write_ulong (1))
00339 return this->write_char (0);
00340 }
00341
00342 return (this->good_bit_ = false);
00343 }
00344
00345 ACE_CDR::Boolean
00346 ACE_OutputCDR::write_string (const ACE_CString &x)
00347 {
00348
00349
00350 return this->write_string (static_cast<ACE_CDR::ULong> (x.length ()),
00351 x.c_str());
00352 }
00353
00354 ACE_CDR::Boolean
00355 ACE_OutputCDR::write_wstring (ACE_CDR::ULong len,
00356 const ACE_CDR::WChar *x)
00357 {
00358
00359
00360
00361
00362 if (this->wchar_translator_ != 0)
00363 return this->wchar_translator_->write_wstring (*this, len, x);
00364 if (ACE_OutputCDR::wchar_maxbytes_ == 0)
00365 {
00366 errno = EACCES;
00367 return (this->good_bit_ = false);
00368 }
00369
00370 if (static_cast<ACE_CDR::Short> (this->major_version_) == 1
00371 && static_cast<ACE_CDR::Short> (this->minor_version_) == 2)
00372 {
00373 if (x != 0)
00374 {
00375
00376
00377
00378 ACE_CDR::Boolean good_ulong =
00379 this->write_ulong (
00380 ACE_Utils::truncate_cast<ACE_CDR::ULong> (
00381 ACE_OutputCDR::wchar_maxbytes_ * len));
00382
00383 if (good_ulong)
00384 {
00385 return this->write_wchar_array (x, len);
00386 }
00387 }
00388 else
00389 {
00390
00391 return this->write_ulong (0);
00392 }
00393 }
00394
00395 else
00396 if (x != 0)
00397 {
00398 if (this->write_ulong (len + 1))
00399 return this->write_wchar_array (x, len + 1);
00400 }
00401 else if (this->write_ulong (1))
00402 return this->write_wchar (0);
00403 return (this->good_bit_ = false);
00404 }
00405
00406 ACE_CDR::Boolean
00407 ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb)
00408 {
00409
00410
00411 for (const ACE_Message_Block* i = mb;
00412 i != 0;
00413 i = i->cont ())
00414 {
00415 size_t const length = i->length ();
00416
00417
00418 if (ACE_BIT_ENABLED (i->flags (),
00419 ACE_Message_Block::DONT_DELETE))
00420 {
00421 if (! this->write_array (i->rd_ptr (),
00422 ACE_CDR::OCTET_SIZE,
00423 ACE_CDR::OCTET_ALIGN,
00424 static_cast<ACE_CDR::ULong> (length)))
00425 return (this->good_bit_ = false);
00426 continue;
00427 }
00428
00429 if (length < this->memcpy_tradeoff_
00430 && this->current_->wr_ptr () + length < this->current_->end ())
00431 {
00432 if (! this->write_array (i->rd_ptr (),
00433 ACE_CDR::OCTET_SIZE,
00434 ACE_CDR::OCTET_ALIGN,
00435 static_cast<ACE_CDR::ULong> (length)))
00436 return (this->good_bit_ = false);
00437 continue;
00438 }
00439
00440 ACE_Message_Block* cont = 0;
00441 this->good_bit_ = false;
00442 ACE_NEW_RETURN (cont,
00443 ACE_Message_Block (i->data_block ()->duplicate ()),
00444 false);
00445 this->good_bit_ = true;
00446
00447 if (this->current_->cont () != 0)
00448 ACE_Message_Block::release (this->current_->cont ());
00449 cont->rd_ptr (i->rd_ptr ());
00450 cont->wr_ptr (i->wr_ptr ());
00451
00452 this->current_->cont (cont);
00453 this->current_ = cont;
00454 this->current_is_writable_ = false;
00455 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00456 this->current_alignment_ =
00457 (this->current_alignment_ + cont->length ()) % ACE_CDR::MAX_ALIGNMENT;
00458 #endif
00459 }
00460
00461 return true;
00462 }
00463
00464 ACE_CDR::Boolean
00465 ACE_OutputCDR::write_1 (const ACE_CDR::Octet *x)
00466 {
00467 char *buf = 0;
00468 if (this->adjust (1, buf) == 0)
00469 {
00470 *reinterpret_cast<ACE_CDR::Octet*> (buf) = *x;
00471 return true;
00472 }
00473
00474 return false;
00475 }
00476
00477 ACE_CDR::Boolean
00478 ACE_OutputCDR::write_2 (const ACE_CDR::UShort *x)
00479 {
00480 char *buf = 0;
00481 if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0)
00482 {
00483 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00484 *reinterpret_cast<ACE_CDR::UShort*> (buf) = *x;
00485 return true;
00486 #else
00487 if (!this->do_byte_swap_)
00488 {
00489 *reinterpret_cast<ACE_CDR::UShort *> (buf) = *x;
00490 return true;
00491 }
00492 else
00493 {
00494 ACE_CDR::swap_2 (reinterpret_cast<const char*> (x), buf);
00495 return true;
00496 }
00497 #endif
00498 }
00499
00500 return false;
00501 }
00502
00503 ACE_CDR::Boolean
00504 ACE_OutputCDR::write_4 (const ACE_CDR::ULong *x)
00505 {
00506 char *buf = 0;
00507 if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0)
00508 {
00509 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00510 *reinterpret_cast<ACE_CDR::ULong*> (buf) = *x;
00511 return true;
00512 #else
00513 if (!this->do_byte_swap_)
00514 {
00515 *reinterpret_cast<ACE_CDR::ULong *> (buf) = *x;
00516 return true;
00517 }
00518 else
00519 {
00520 ACE_CDR::swap_4 (reinterpret_cast<const char*> (x), buf);
00521 return true;
00522 }
00523 #endif
00524 }
00525
00526 return false;
00527 }
00528
00529 ACE_CDR::Boolean
00530 ACE_OutputCDR::write_8 (const ACE_CDR::ULongLong *x)
00531 {
00532 char *buf = 0;
00533
00534 if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0)
00535 {
00536 #if defined (__arm__) && !defined (ACE_HAS_IPHONE)
00537
00538 const char *orig = reinterpret_cast<const char *> (x);
00539 char *target = buf;
00540 register ACE_UINT32 x =
00541 *reinterpret_cast<const ACE_UINT32 *> (orig);
00542 register ACE_UINT32 y =
00543 *reinterpret_cast<const ACE_UINT32 *> (orig + 4);
00544 *reinterpret_cast<ACE_UINT32 *> (target) = y;
00545 *reinterpret_cast<ACE_UINT32 *> (target + 4) = x;
00546 return true;
00547 #else
00548 # if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00549 *reinterpret_cast<ACE_CDR::ULongLong *> (buf) = *x;
00550 return true;
00551 # else
00552 if (!this->do_byte_swap_)
00553 {
00554 *reinterpret_cast<ACE_CDR::ULongLong *> (buf) = *x;
00555 return true;
00556 }
00557 else
00558 {
00559 ACE_CDR::swap_8 (reinterpret_cast<const char*> (x), buf);
00560 return true;
00561 }
00562 # endif
00563 #endif
00564 }
00565
00566 return false;
00567 }
00568
00569 ACE_CDR::Boolean
00570 ACE_OutputCDR::write_16 (const ACE_CDR::LongDouble *x)
00571 {
00572 char* buf = 0;
00573 if (this->adjust (ACE_CDR::LONGDOUBLE_SIZE,
00574 ACE_CDR::LONGDOUBLE_ALIGN,
00575 buf) == 0)
00576 {
00577 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00578 *reinterpret_cast<ACE_CDR::LongDouble*> (buf) = *x;
00579 return 1;
00580 #else
00581 if (!this->do_byte_swap_)
00582 {
00583 *reinterpret_cast<ACE_CDR::LongDouble *> (buf) = *x;
00584 return true;
00585 }
00586 else
00587 {
00588 ACE_CDR::swap_16 (reinterpret_cast<const char*> (x), buf);
00589 return true;
00590 }
00591 #endif
00592 }
00593
00594 return false;
00595 }
00596
00597 ACE_CDR::Boolean
00598 ACE_OutputCDR::write_wchar_array_i (const ACE_CDR::WChar *x,
00599 ACE_CDR::ULong length)
00600 {
00601 if (length == 0)
00602 return true;
00603 char* buf = 0;
00604 size_t const align = (ACE_OutputCDR::wchar_maxbytes_ == 2) ?
00605 ACE_CDR::SHORT_ALIGN :
00606 ACE_CDR::OCTET_ALIGN;
00607
00608 if (this->adjust (ACE_OutputCDR::wchar_maxbytes_ * length, align, buf) == 0)
00609 {
00610 if (ACE_OutputCDR::wchar_maxbytes_ == 2)
00611 {
00612 ACE_CDR::UShort *sb = reinterpret_cast<ACE_CDR::UShort *> (buf);
00613 for (size_t i = 0; i < length; ++i)
00614 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00615 sb[i] = static_cast<ACE_CDR::UShort> (x[i]);
00616 #else
00617 if (!this->do_byte_swap_)
00618 sb[i] = static_cast<ACE_CDR::UShort> (x[i]);
00619 else
00620 {
00621 ACE_CDR::UShort sx = static_cast<ACE_CDR::UShort> (x[i]);
00622 ACE_CDR::swap_2 (reinterpret_cast<char *> (&sx), &buf[i * 2]);
00623 }
00624 #endif
00625 }
00626 else
00627 {
00628 for (size_t i = 0; i < length; ++i)
00629 buf[i] = static_cast<char> (x[i]);
00630 }
00631 return this->good_bit_;
00632 }
00633 return false;
00634 }
00635
00636
00637 ACE_CDR::Boolean
00638 ACE_OutputCDR::write_array (const void *x,
00639 size_t size,
00640 size_t align,
00641 ACE_CDR::ULong length)
00642 {
00643 if (length == 0)
00644 return true;
00645 char *buf = 0;
00646 if (this->adjust (size * length, align, buf) == 0)
00647 {
00648 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00649 ACE_OS::memcpy (buf, x, size*length);
00650 return true;
00651 #else
00652 if (!this->do_byte_swap_ || size == 1)
00653 {
00654 ACE_OS::memcpy (buf, x, size*length);
00655 return true;
00656 }
00657 else
00658 {
00659 const char *source = reinterpret_cast<const char *> (x);
00660 switch (size)
00661 {
00662 case 2:
00663 ACE_CDR::swap_2_array (source, buf, length);
00664 return true;
00665 case 4:
00666 ACE_CDR::swap_4_array (source, buf, length);
00667 return true;
00668 case 8:
00669 ACE_CDR::swap_8_array (source, buf, length);
00670 return true;
00671 case 16:
00672 ACE_CDR::swap_16_array (source, buf, length);
00673 return true;
00674 default:
00675
00676 this->good_bit_ = false;
00677 return false;
00678 }
00679 }
00680 #endif
00681 }
00682 this->good_bit_ = false;
00683 return false;
00684 }
00685
00686
00687 ACE_CDR::Boolean
00688 ACE_OutputCDR::write_boolean_array (const ACE_CDR::Boolean* x,
00689 ACE_CDR::ULong length)
00690 {
00691
00692
00693
00694
00695
00696 ACE_CDR::Boolean const * const end = x + length;
00697
00698 for (ACE_CDR::Boolean const * i = x;
00699 i != end && this->good_bit ();
00700 ++i)
00701 (void) this->write_boolean (*i);
00702
00703 return this->good_bit ();
00704 }
00705
00706 char *
00707 ACE_OutputCDR::write_long_placeholder (void)
00708 {
00709 char *buf = 0;
00710 if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0)
00711 *reinterpret_cast<ACE_CDR::ULong*> (buf) = 0;
00712 else
00713 buf = 0;
00714 return buf;
00715 }
00716
00717 char *
00718 ACE_OutputCDR::write_short_placeholder (void)
00719 {
00720 char *buf = 0;
00721 if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0)
00722 *reinterpret_cast<ACE_CDR::UShort*> (buf) = 0;
00723 else
00724 buf = 0;
00725 return buf;
00726 }
00727
00728 ACE_CDR::Boolean
00729 ACE_OutputCDR::replace (ACE_CDR::Long x, char* loc)
00730 {
00731 if (this->find (loc) == 0)
00732 return false;
00733
00734 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00735 *reinterpret_cast<ACE_CDR::Long*> (loc) = x;
00736 #else
00737 if (!this->do_byte_swap_)
00738 {
00739 *reinterpret_cast<ACE_CDR::Long *> (loc) = x;
00740 }
00741 else
00742 {
00743 ACE_CDR::swap_4 (reinterpret_cast<const char*> (&x), loc);
00744 }
00745 #endif
00746
00747 return true;
00748 }
00749
00750
00751 ACE_CDR::Boolean
00752 ACE_OutputCDR::replace (ACE_CDR::Short x, char* loc)
00753 {
00754 if (this->find (loc) == 0)
00755 return false;
00756
00757 #if !defined (ACE_ENABLE_SWAP_ON_WRITE)
00758 *reinterpret_cast<ACE_CDR::Short*> (loc) = x;
00759 #else
00760 if (!this->do_byte_swap_)
00761 {
00762 *reinterpret_cast<ACE_CDR::Short *> (loc) = x;
00763 }
00764 else
00765 {
00766 ACE_CDR::swap_2 (reinterpret_cast<const char*> (&x), loc);
00767 }
00768 #endif
00769
00770 return true;
00771 }
00772
00773
00774 int
00775 ACE_OutputCDR::consolidate (void)
00776 {
00777
00778 if (this->current_ != &this->start_)
00779 {
00780
00781
00782
00783
00784 size_t const newsize =
00785 ACE_CDR::first_size (this->total_length ()
00786 + ACE_CDR::MAX_ALIGNMENT);
00787 if (this->start_.size (newsize) < 0)
00788 {
00789 return -1;
00790 }
00791
00792
00793
00794
00795
00796
00797
00798
00799
00800
00801 ACE_Message_Block *cont = this->start_.cont ();
00802 for (const ACE_Message_Block* i = cont; i != 0; i = i->cont ())
00803 {
00804 this->start_.copy (i->rd_ptr (), i->length ());
00805 }
00806
00807
00808
00809 ACE_Message_Block::release (cont);
00810 this->start_.cont (0);
00811 this->current_ = &this->start_;
00812 this->current_is_writable_ = true;
00813 }
00814
00815 return 0;
00816 }
00817
00818
00819 ACE_Message_Block*
00820 ACE_OutputCDR::find (char* loc)
00821 {
00822 ACE_Message_Block* mb = 0;
00823 for (mb = &this->start_; mb != 0; mb = mb->cont ())
00824 {
00825 if (loc <= mb->wr_ptr () && loc >= mb->rd_ptr ())
00826 {
00827 break;
00828 }
00829 }
00830
00831 return mb;
00832 }
00833
00834 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00835
00836 void
00837 ACE_OutputCDR::register_monitor (const char *id)
00838 {
00839 this->monitor_->name (id);
00840 this->monitor_->add_to_registry ();
00841 }
00842
00843 void
00844 ACE_OutputCDR::unregister_monitor (void)
00845 {
00846 this->monitor_->remove_from_registry ();
00847 }
00848
00849 #endif
00850
00851
00852
00853 ACE_InputCDR::ACE_InputCDR (const char *buf,
00854 size_t bufsiz,
00855 int byte_order,
00856 ACE_CDR::Octet major_version,
00857 ACE_CDR::Octet minor_version)
00858 : start_ (buf, bufsiz),
00859 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00860 good_bit_ (true),
00861 major_version_ (major_version),
00862 minor_version_ (minor_version),
00863 char_translator_ (0),
00864 wchar_translator_ (0)
00865 {
00866 this->start_.wr_ptr (bufsiz);
00867
00868 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00869 ACE_NEW (this->monitor_,
00870 ACE::Monitor_Control::Size_Monitor);
00871 this->monitor_->receive (bufsiz);
00872 #endif
00873 }
00874
00875 ACE_InputCDR::ACE_InputCDR (size_t bufsiz,
00876 int byte_order,
00877 ACE_CDR::Octet major_version,
00878 ACE_CDR::Octet minor_version)
00879 : start_ (bufsiz),
00880 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00881 good_bit_ (true),
00882 major_version_ (major_version),
00883 minor_version_ (minor_version),
00884 char_translator_ (0),
00885 wchar_translator_ (0)
00886 {
00887 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00888 ACE_NEW (this->monitor_,
00889 ACE::Monitor_Control::Size_Monitor);
00890 this->monitor_->receive (bufsiz);
00891 #endif
00892 }
00893
00894 ACE_InputCDR::ACE_InputCDR (const ACE_Message_Block *data,
00895 int byte_order,
00896 ACE_CDR::Octet major_version,
00897 ACE_CDR::Octet minor_version,
00898 ACE_Lock* lock)
00899 : start_ (0, ACE_Message_Block::MB_DATA, 0, 0, 0, lock),
00900 good_bit_ (true),
00901 major_version_ (major_version),
00902 minor_version_ (minor_version),
00903 char_translator_ (0),
00904 wchar_translator_ (0)
00905 {
00906 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00907 ACE_NEW (this->monitor_,
00908 ACE::Monitor_Control::Size_Monitor);
00909 this->monitor_->receive (this->start_.total_size ());
00910 #endif
00911
00912 this->reset (data, byte_order);
00913 }
00914
00915 ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data,
00916 ACE_Message_Block::Message_Flags flag,
00917 int byte_order,
00918 ACE_CDR::Octet major_version,
00919 ACE_CDR::Octet minor_version)
00920 : start_ (data, flag),
00921 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00922 good_bit_ (true),
00923 major_version_ (major_version),
00924 minor_version_ (minor_version),
00925 char_translator_ (0),
00926 wchar_translator_ (0)
00927 {
00928 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00929 ACE_NEW (this->monitor_,
00930 ACE::Monitor_Control::Size_Monitor);
00931 this->monitor_->receive (data->size ());
00932 #endif
00933 }
00934
00935 ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data,
00936 ACE_Message_Block::Message_Flags flag,
00937 size_t rd_pos,
00938 size_t wr_pos,
00939 int byte_order,
00940 ACE_CDR::Octet major_version,
00941 ACE_CDR::Octet minor_version)
00942 : start_ (data, flag),
00943 do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER),
00944 good_bit_ (true),
00945 major_version_ (major_version),
00946 minor_version_ (minor_version),
00947 char_translator_ (0),
00948 wchar_translator_ (0)
00949 {
00950
00951 this->start_.rd_ptr (rd_pos);
00952
00953
00954 char* wrpos = this->start_.base () + wr_pos;
00955
00956 if (this->start_.end () >= wrpos)
00957 {
00958 this->start_.wr_ptr (wr_pos);
00959 }
00960
00961 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
00962 ACE_NEW (this->monitor_,
00963 ACE::Monitor_Control::Size_Monitor);
00964 this->monitor_->receive (data->size ());
00965 #endif
00966 }
00967
00968 ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs,
00969 size_t size,
00970 ACE_CDR::Long offset)
00971 : start_ (rhs.start_,
00972 ACE_CDR::MAX_ALIGNMENT),
00973 do_byte_swap_ (rhs.do_byte_swap_),
00974 good_bit_ (true),
00975 major_version_ (rhs.major_version_),
00976 minor_version_ (rhs.minor_version_),
00977 char_translator_ (rhs.char_translator_),
00978 wchar_translator_ (rhs.wchar_translator_)
00979 {
00980 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
00981
00982
00983 char *incoming_start = ACE_ptr_align_binary (rhs.start_.base (),
00984 ACE_CDR::MAX_ALIGNMENT);
00985 #else
00986 char *incoming_start = rhs.start_.base ();
00987 #endif
00988
00989 const size_t newpos =
00990 (rhs.start_.rd_ptr() - incoming_start) + offset;
00991
00992 if (newpos <= this->start_.space ()
00993 && newpos + size <= this->start_.space ())
00994 {
00995 this->start_.rd_ptr (newpos);
00996 this->start_.wr_ptr (newpos + size);
00997 }
00998 else
00999 {
01000 this->good_bit_ = false;
01001 }
01002
01003 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01004 ACE_NEW (this->monitor_,
01005 ACE::Monitor_Control::Size_Monitor);
01006 this->monitor_->receive (this->start_.total_size ());
01007 #endif
01008 }
01009
01010 ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs,
01011 size_t size)
01012 : start_ (rhs.start_,
01013 ACE_CDR::MAX_ALIGNMENT),
01014 do_byte_swap_ (rhs.do_byte_swap_),
01015 good_bit_ (true),
01016 major_version_ (rhs.major_version_),
01017 minor_version_ (rhs.minor_version_),
01018 char_translator_ (rhs.char_translator_),
01019 wchar_translator_ (rhs.wchar_translator_)
01020 {
01021 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
01022
01023
01024 char *incoming_start = ACE_ptr_align_binary (rhs.start_.base (),
01025 ACE_CDR::MAX_ALIGNMENT);
01026 #else
01027 char *incoming_start = rhs.start_.base ();
01028 #endif
01029
01030 const size_t newpos =
01031 rhs.start_.rd_ptr() - incoming_start;
01032
01033 if (newpos <= this->start_.space ()
01034 && newpos + size <= this->start_.space ())
01035 {
01036
01037
01038 this->start_.rd_ptr (newpos);
01039 this->start_.wr_ptr (newpos + size);
01040
01041 ACE_CDR::Octet byte_order = 0;
01042 (void) this->read_octet (byte_order);
01043 this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER);
01044 }
01045 else
01046 {
01047 this->good_bit_ = false;
01048 }
01049
01050 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01051 ACE_NEW (this->monitor_,
01052 ACE::Monitor_Control::Size_Monitor);
01053 this->monitor_->receive (this->start_.total_size ());
01054 #endif
01055 }
01056
01057 ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs)
01058 : start_ (rhs.start_,
01059 ACE_CDR::MAX_ALIGNMENT),
01060 do_byte_swap_ (rhs.do_byte_swap_),
01061 good_bit_ (true),
01062 major_version_ (rhs.major_version_),
01063 minor_version_ (rhs.minor_version_),
01064 char_translator_ (rhs.char_translator_),
01065 wchar_translator_ (rhs.wchar_translator_)
01066 {
01067 #if !defined (ACE_LACKS_CDR_ALIGNMENT)
01068 char *buf = ACE_ptr_align_binary (rhs.start_.base (),
01069 ACE_CDR::MAX_ALIGNMENT);
01070 #else
01071 char *buf = rhs.start_.base ();
01072 #endif
01073
01074 size_t rd_offset = rhs.start_.rd_ptr () - buf;
01075 size_t wr_offset = rhs.start_.wr_ptr () - buf;
01076 this->start_.rd_ptr (rd_offset);
01077 this->start_.wr_ptr (wr_offset);
01078
01079 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01080 ACE_NEW (this->monitor_,
01081 ACE::Monitor_Control::Size_Monitor);
01082 this->monitor_->receive (this->start_.total_size ());
01083 #endif
01084 }
01085
01086 ACE_InputCDR::ACE_InputCDR (ACE_InputCDR::Transfer_Contents x)
01087 : start_ (x.rhs_.start_.data_block ()),
01088 do_byte_swap_ (x.rhs_.do_byte_swap_),
01089 good_bit_ (true),
01090 major_version_ (x.rhs_.major_version_),
01091 minor_version_ (x.rhs_.minor_version_),
01092 char_translator_ (x.rhs_.char_translator_),
01093 wchar_translator_ (x.rhs_.wchar_translator_)
01094 {
01095 this->start_.rd_ptr (x.rhs_.start_.rd_ptr ());
01096 this->start_.wr_ptr (x.rhs_.start_.wr_ptr ());
01097
01098 ACE_Data_Block* db = this->start_.data_block ()->clone_nocopy ();
01099 (void) x.rhs_.start_.replace_data_block (db);
01100
01101 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01102 ACE_NEW (this->monitor_,
01103 ACE::Monitor_Control::Size_Monitor);
01104 this->monitor_->receive (this->start_.total_size ());
01105 #endif
01106 }
01107
01108 ACE_InputCDR&
01109 ACE_InputCDR::operator= (const ACE_InputCDR& rhs)
01110 {
01111 if (this != &rhs)
01112 {
01113 this->start_.data_block (rhs.start_.data_block ()->duplicate ());
01114 this->start_.rd_ptr (rhs.start_.rd_ptr ());
01115 this->start_.wr_ptr (rhs.start_.wr_ptr ());
01116 this->do_byte_swap_ = rhs.do_byte_swap_;
01117 this->good_bit_ = true;
01118 this->char_translator_ = rhs.char_translator_;
01119 this->major_version_ = rhs.major_version_;
01120 this->minor_version_ = rhs.minor_version_;
01121 }
01122
01123 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01124 this->monitor_->receive (this->start_.total_size ());
01125 #endif
01126
01127 return *this;
01128 }
01129
01130 ACE_InputCDR::ACE_InputCDR (const ACE_OutputCDR& rhs,
01131 ACE_Allocator* buffer_allocator,
01132 ACE_Allocator* data_block_allocator,
01133 ACE_Allocator* message_block_allocator)
01134 : start_ (rhs.total_length () + ACE_CDR::MAX_ALIGNMENT,
01135 ACE_Message_Block::MB_DATA,
01136 0,
01137 0,
01138 buffer_allocator,
01139 0,
01140 0,
01141 ACE_Time_Value::zero,
01142 ACE_Time_Value::max_time,
01143 data_block_allocator,
01144 message_block_allocator),
01145 do_byte_swap_ (rhs.do_byte_swap_),
01146 good_bit_ (true),
01147 major_version_ (rhs.major_version_),
01148 minor_version_ (rhs.minor_version_),
01149 char_translator_ (rhs.char_translator_),
01150 wchar_translator_ (rhs.wchar_translator_)
01151 {
01152 ACE_CDR::mb_align (&this->start_);
01153 for (const ACE_Message_Block *i = rhs.begin ();
01154 i != rhs.end ();
01155 i = i->cont ())
01156 {
01157 this->start_.copy (i->rd_ptr (), i->length ());
01158 }
01159
01160 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01161 ACE_NEW (this->monitor_,
01162 ACE::Monitor_Control::Size_Monitor);
01163 this->monitor_->receive (this->start_.total_size ());
01164 #endif
01165 }
01166
01167 ACE_CDR::Boolean
01168 ACE_InputCDR::skip_wchar (void)
01169 {
01170 if (static_cast<ACE_CDR::Short> (major_version_) == 1
01171 && static_cast<ACE_CDR::Short> (minor_version_) == 2)
01172 {
01173 ACE_CDR::Octet len;
01174 if (this->read_1 (&len))
01175 return this->skip_bytes (static_cast<size_t> (len));
01176 }
01177 else
01178 {
01179 ACE_CDR::WChar x;
01180 void * const temp = &x;
01181 if (ACE_OutputCDR::wchar_maxbytes_ == 2)
01182 return this->read_2 (reinterpret_cast<ACE_CDR::UShort *> (temp));
01183 else
01184 return this->read_4 (reinterpret_cast<ACE_CDR::ULong *> (temp));
01185 }
01186
01187 return (this->good_bit_ = false);
01188 }
01189
01190 ACE_CDR::Boolean
01191 ACE_InputCDR::read_wchar (ACE_CDR::WChar& x)
01192 {
01193 if (this->wchar_translator_ != 0)
01194 {
01195 this->good_bit_ = this->wchar_translator_->read_wchar (*this,x);
01196 return this->good_bit_;
01197 }
01198 if (ACE_OutputCDR::wchar_maxbytes_ == 0)
01199 {
01200 errno = EACCES;
01201 return (this->good_bit_ = false);
01202 }
01203
01204 if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar))
01205 {
01206 if (static_cast<ACE_CDR::Short> (major_version_) == 1
01207 && static_cast<ACE_CDR::Short> (minor_version_) == 2)
01208 {
01209 ACE_CDR::Octet len;
01210
01211 if (this->read_1 (&len))
01212 return this->read_array
01213 (reinterpret_cast<ACE_CDR::Octet*> (&x),
01214 static_cast<ACE_CDR::ULong> (len),
01215 ACE_CDR::OCTET_ALIGN,
01216 1);
01217
01218 else
01219 return (this->good_bit_ = false);
01220 }
01221
01222 void * const temp = &x;
01223 if (sizeof (ACE_CDR::WChar) == 2)
01224 return this->read_2 (reinterpret_cast<ACE_CDR::UShort *> (temp));
01225 else
01226 return this->read_4 (reinterpret_cast<ACE_CDR::ULong *> (temp));
01227 }
01228
01229 if (static_cast<ACE_CDR::Short> (major_version_) == 1
01230 && static_cast<ACE_CDR::Short> (minor_version_) == 2)
01231 {
01232 ACE_CDR::Octet len;
01233
01234 if (this->read_1 (&len))
01235 {
01236 if (len == 2)
01237 {
01238 ACE_CDR::Short sx;
01239 if (this->read_array
01240 (reinterpret_cast<ACE_CDR::Octet*> (&sx),
01241 static_cast<ACE_CDR::ULong> (len),
01242 ACE_CDR::OCTET_ALIGN,
01243 1))
01244 {
01245 x = static_cast<ACE_CDR::WChar> (sx);
01246 return true;
01247 }
01248 }
01249 else
01250 {
01251 ACE_CDR::Octet ox;
01252 if (this->read_array
01253 (reinterpret_cast<ACE_CDR::Octet*> (&ox),
01254 static_cast<ACE_CDR::ULong> (len),
01255 ACE_CDR::OCTET_ALIGN,
01256 1))
01257 {
01258 x = static_cast<ACE_CDR::WChar> (ox);
01259 return true;
01260 }
01261 }
01262 }
01263 }
01264 else
01265 {
01266 if (ACE_OutputCDR::wchar_maxbytes_ == 2)
01267 {
01268 ACE_CDR::UShort sx;
01269 if (this->read_2 (reinterpret_cast<ACE_CDR::UShort *> (&sx)))
01270 {
01271 x = static_cast<ACE_CDR::WChar> (sx);
01272 return true;
01273 }
01274 }
01275 else
01276 {
01277 ACE_CDR::Octet ox;
01278 if (this->read_1 (&ox))
01279 {
01280 x = static_cast<ACE_CDR::WChar> (ox);
01281 return true;
01282 }
01283
01284 }
01285 }
01286 return (this->good_bit_ = false);
01287 }
01288
01289 ACE_CDR::Boolean
01290 ACE_InputCDR::read_string (ACE_CDR::Char *&x)
01291 {
01292
01293
01294
01295 if (this->char_translator_ != 0)
01296 {
01297 this->good_bit_ = this->char_translator_->read_string (*this, x);
01298 return this->good_bit_;
01299 }
01300
01301 ACE_CDR::ULong len = 0;
01302
01303 if (!this->read_ulong (len))
01304 return false;
01305
01306
01307
01308
01309 if (len > 0 && len <= this->length())
01310 {
01311 ACE_NEW_RETURN (x,
01312 ACE_CDR::Char[len],
01313 0);
01314
01315 ACE_Auto_Basic_Array_Ptr<ACE_CDR::Char> safe_data (x);
01316
01317 if (this->read_char_array (x, len))
01318 {
01319 (void) safe_data.release ();
01320 return true;
01321 }
01322 }
01323 else if (len == 0)
01324 {
01325
01326
01327 ACE_NEW_RETURN (x,
01328 ACE_CDR::Char[1],
01329 0);
01330 ACE_OS::strcpy (const_cast<char *&> (x), "");
01331 return true;
01332 }
01333
01334 x = 0;
01335 return (this->good_bit_ = false);
01336 }
01337
01338 ACE_CDR::Boolean
01339 ACE_InputCDR::read_string (ACE_CString &x)
01340 {
01341 ACE_CDR::Char * data = 0;
01342 if (this->read_string (data))
01343 {
01344 ACE_Auto_Basic_Array_Ptr<ACE_CDR::Char> safe_data (data);
01345 x = data;
01346 return true;
01347 }
01348
01349 x = "";
01350 return (this->good_bit_ = false);
01351 }
01352
01353 ACE_CDR::Boolean
01354 ACE_InputCDR::read_wstring (ACE_CDR::WChar*& x)
01355 {
01356
01357
01358
01359 if (this->wchar_translator_ != 0)
01360 {
01361 this->good_bit_ = this->wchar_translator_->read_wstring (*this, x);
01362 return this->good_bit_;
01363 }
01364 if (ACE_OutputCDR::wchar_maxbytes_ == 0)
01365 {
01366 errno = EACCES;
01367 return (this->good_bit_ = false);
01368 }
01369
01370 ACE_CDR::ULong len = 0;
01371
01372 if (!this->read_ulong (len))
01373 {
01374 return false;
01375 }
01376
01377
01378
01379
01380 if (len > 0 && len <= this->length ())
01381 {
01382 ACE_Auto_Basic_Array_Ptr<ACE_CDR::WChar> safe_data;
01383
01384 if (static_cast<ACE_CDR::Short> (this->major_version_) == 1
01385 && static_cast<ACE_CDR::Short> (this->minor_version_) == 2)
01386 {
01387 len /=
01388 ACE_Utils::truncate_cast<ACE_CDR::ULong> (
01389 ACE_OutputCDR::wchar_maxbytes_);
01390
01391
01392 ACE_NEW_RETURN (x,
01393 ACE_CDR::WChar [len + 1],
01394 false);
01395
01396 ACE_auto_ptr_reset (safe_data, x);
01397
01398 if (this->read_wchar_array (x, len))
01399 {
01400
01401
01402
01403
01404 x[len] = '\x00';
01405
01406 (void) safe_data.release ();
01407
01408 return true;
01409 }
01410 }
01411 else
01412 {
01413 ACE_NEW_RETURN (x,
01414 ACE_CDR::WChar [len],
01415 false);
01416
01417 ACE_auto_ptr_reset (safe_data, x);
01418
01419 if (this->read_wchar_array (x, len))
01420 {
01421 (void) safe_data.release ();
01422
01423 return true;
01424 }
01425 }
01426 }
01427 else if (len == 0)
01428 {
01429
01430
01431 ACE_NEW_RETURN (x,
01432 ACE_CDR::WChar[1],
01433 false);
01434 x[0] = '\x00';
01435 return true;
01436 }
01437
01438 this->good_bit_ = false;
01439 x = 0;
01440 return false;
01441 }
01442
01443 ACE_CDR::Boolean
01444 ACE_InputCDR::read_array (void* x,
01445 size_t size,
01446 size_t align,
01447 ACE_CDR::ULong length)
01448 {
01449 if (length == 0)
01450 return true;
01451 char* buf = 0;
01452
01453 if (this->adjust (size * length, align, buf) == 0)
01454 {
01455 #if defined (ACE_DISABLE_SWAP_ON_READ)
01456 ACE_OS::memcpy (x, buf, size*length);
01457 #else
01458 if (!this->do_byte_swap_ || size == 1)
01459 ACE_OS::memcpy (x, buf, size*length);
01460 else
01461 {
01462 char *target = reinterpret_cast<char*> (x);
01463 switch (size)
01464 {
01465 case 2:
01466 ACE_CDR::swap_2_array (buf, target, length);
01467 break;
01468 case 4:
01469 ACE_CDR::swap_4_array (buf, target, length);
01470 break;
01471 case 8:
01472 ACE_CDR::swap_8_array (buf, target, length);
01473 break;
01474 case 16:
01475 ACE_CDR::swap_16_array (buf, target, length);
01476 break;
01477 default:
01478
01479 this->good_bit_ = false;
01480 return false;
01481 }
01482 }
01483 #endif
01484 return this->good_bit_;
01485 }
01486 return false;
01487 }
01488
01489 ACE_CDR::Boolean
01490 ACE_InputCDR::read_wchar_array_i (ACE_CDR::WChar* x,
01491 ACE_CDR::ULong length)
01492 {
01493 if (length == 0)
01494 return true;
01495 char* buf = 0;
01496 size_t const align = (ACE_OutputCDR::wchar_maxbytes_ == 2) ?
01497 ACE_CDR::SHORT_ALIGN :
01498 ACE_CDR::OCTET_ALIGN;
01499
01500 if (this->adjust (ACE_OutputCDR::wchar_maxbytes_ * length, align, buf) == 0)
01501 {
01502 if (ACE_OutputCDR::wchar_maxbytes_ == 2)
01503 {
01504 ACE_CDR::UShort *sb = reinterpret_cast<ACE_CDR::UShort *> (buf);
01505 for (size_t i = 0; i < length; ++i)
01506 #if defined (ACE_DISABLE_SWAP_ON_READ)
01507 x[i] = static_cast<ACE_CDR::WChar> (sb[i]);
01508 #else
01509 if (!this->do_byte_swap_)
01510 x[i] = static_cast<ACE_CDR::WChar> (sb[i]);
01511 else
01512 {
01513 ACE_CDR::UShort sx;
01514 ACE_CDR::swap_2 (&buf[i * 2], reinterpret_cast<char *> (&sx));
01515 x[i] = static_cast<ACE_CDR::WChar> (sx);
01516 }
01517 #endif
01518 }
01519 else
01520 {
01521 for (size_t i = 0; i < length; ++i)
01522 x[i] = static_cast<ACE_CDR::Octet> (buf[i]);
01523 }
01524 return this->good_bit_;
01525 }
01526 return false;
01527 }
01528
01529
01530 ACE_CDR::Boolean
01531 ACE_InputCDR::read_boolean_array (ACE_CDR::Boolean *x,
01532 ACE_CDR::ULong length)
01533 {
01534
01535
01536 if (length > this->length ())
01537 {
01538 this->good_bit_ = false;
01539 return false;
01540 }
01541
01542
01543
01544
01545
01546
01547 for (ACE_CDR::ULong i = 0; i != length && this->good_bit_; ++i)
01548 (void) this->read_boolean (x[i]);
01549
01550 return this->good_bit_;
01551 }
01552
01553 ACE_CDR::Boolean
01554 ACE_InputCDR::read_1 (ACE_CDR::Octet *x)
01555 {
01556 if (this->rd_ptr () < this->wr_ptr ())
01557 {
01558 *x = *reinterpret_cast<ACE_CDR::Octet*> (this->rd_ptr ());
01559 this->start_.rd_ptr (1);
01560 return true;
01561 }
01562
01563 this->good_bit_ = false;
01564 return false;
01565 }
01566
01567 ACE_CDR::Boolean
01568 ACE_InputCDR::read_2 (ACE_CDR::UShort *x)
01569 {
01570 char *buf = 0;
01571 if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0)
01572 {
01573 #if !defined (ACE_DISABLE_SWAP_ON_READ)
01574 if (!this->do_byte_swap_)
01575 *x = *reinterpret_cast<ACE_CDR::UShort*> (buf);
01576 else
01577 ACE_CDR::swap_2 (buf, reinterpret_cast<char*> (x));
01578 #else
01579 *x = *reinterpret_cast<ACE_CDR::UShort*> (buf);
01580 #endif
01581 return true;
01582 }
01583 this->good_bit_ = false;
01584 return false;
01585 }
01586
01587 ACE_CDR::Boolean
01588 ACE_InputCDR::read_4 (ACE_CDR::ULong *x)
01589 {
01590 char *buf = 0;
01591 if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0)
01592 {
01593 #if !defined (ACE_DISABLE_SWAP_ON_READ)
01594 if (!this->do_byte_swap_)
01595 *x = *reinterpret_cast<ACE_CDR::ULong*> (buf);
01596 else
01597 ACE_CDR::swap_4 (buf, reinterpret_cast<char*> (x));
01598 #else
01599 *x = *reinterpret_cast<ACE_CDR::ULong*> (buf);
01600 #endif
01601 return true;
01602 }
01603 this->good_bit_ = false;
01604 return false;
01605 }
01606
01607 ACE_CDR::Boolean
01608 ACE_InputCDR::read_8 (ACE_CDR::ULongLong *x)
01609 {
01610 char *buf = 0;
01611
01612 if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0)
01613 {
01614 #if !defined (ACE_DISABLE_SWAP_ON_READ)
01615 # if defined (__arm__) && !defined (ACE_HAS_IPHONE)
01616 if (!this->do_byte_swap_)
01617 {
01618
01619 const char *orig = buf;
01620 char *target = reinterpret_cast<char *> (x);
01621 register ACE_UINT32 x =
01622 *reinterpret_cast<const ACE_UINT32 *> (orig);
01623 register ACE_UINT32 y =
01624 *reinterpret_cast<const ACE_UINT32 *> (orig + 4);
01625 *reinterpret_cast<ACE_UINT32 *> (target) = y;
01626 *reinterpret_cast<ACE_UINT32 *> (target + 4) = x;
01627 }
01628 else
01629 {
01630
01631 const char *orig = buf;
01632 char *target = reinterpret_cast<char *> (x);
01633 register ACE_UINT32 x =
01634 *reinterpret_cast<const ACE_UINT32 *> (orig);
01635 register ACE_UINT32 y =
01636 *reinterpret_cast<const ACE_UINT32 *> (orig + 4);
01637 x = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24);
01638 y = (y << 24) | ((y & 0xff00) << 8) | ((y & 0xff0000) >> 8) | (y >> 24);
01639 *reinterpret_cast<ACE_UINT32 *> (target) = x;
01640 *reinterpret_cast<ACE_UINT32 *> (target + 4) = y;
01641 }
01642 # else
01643 if (!this->do_byte_swap_)
01644 *x = *reinterpret_cast<ACE_CDR::ULongLong *> (buf);
01645 else
01646 ACE_CDR::swap_8 (buf, reinterpret_cast<char *> (x));
01647 # endif
01648 #else
01649 *x = *reinterpret_cast<ACE_CDR::ULongLong *> (buf);
01650 #endif
01651 return true;
01652 }
01653
01654 this->good_bit_ = false;
01655 return false;
01656 }
01657
01658 ACE_CDR::Boolean
01659 ACE_InputCDR::read_16 (ACE_CDR::LongDouble *x)
01660 {
01661 char *buf = 0;
01662 if (this->adjust (ACE_CDR::LONGDOUBLE_SIZE,
01663 ACE_CDR::LONGDOUBLE_ALIGN,
01664 buf) == 0)
01665 {
01666 #if !defined (ACE_DISABLE_SWAP_ON_READ)
01667 if (!this->do_byte_swap_)
01668 *x = *reinterpret_cast<ACE_CDR::LongDouble *> (buf);
01669 else
01670 ACE_CDR::swap_16 (buf, reinterpret_cast<char*> (x));
01671 #else
01672 *x = *reinterpret_cast<ACE_CDR::LongDouble*> (buf);
01673 #endif
01674 return true;
01675 }
01676
01677 this->good_bit_ = false;
01678 return false;
01679 }
01680
01681 ACE_CDR::Boolean
01682 ACE_InputCDR::skip_string (void)
01683 {
01684 ACE_CDR::ULong len = 0;
01685 if (this->read_ulong (len))
01686 {
01687 if (this->rd_ptr () + len <= this->wr_ptr ())
01688 {
01689 this->rd_ptr (len);
01690 return true;
01691 }
01692 this->good_bit_ = false;
01693 }
01694 return false;
01695 }
01696
01697 ACE_CDR::Boolean
01698 ACE_InputCDR::skip_wstring (void)
01699 {
01700 ACE_CDR::ULong len = 0;
01701 ACE_CDR::Boolean continue_skipping = read_ulong (len);
01702
01703 if (continue_skipping && len != 0)
01704 {
01705 if (static_cast<ACE_CDR::Short> (this->major_version_) == 1
01706 && static_cast<ACE_CDR::Short> (this->minor_version_) == 2)
01707 continue_skipping = this->skip_bytes ((size_t)len);
01708 else
01709 while (continue_skipping && len--)
01710 continue_skipping = this->skip_wchar ();
01711 }
01712 return continue_skipping;
01713 }
01714
01715 ACE_CDR::Boolean
01716 ACE_InputCDR::skip_bytes (size_t len)
01717 {
01718 if (this->rd_ptr () + len <= this->wr_ptr ())
01719 {
01720 this->rd_ptr (len);
01721 return true;
01722 }
01723 this->good_bit_ = false;
01724 return false;
01725 }
01726
01727 int
01728 ACE_InputCDR::grow (size_t newsize)
01729 {
01730 if (ACE_CDR::grow (&this->start_, newsize) == -1)
01731 return -1;
01732
01733 ACE_CDR::mb_align (&this->start_);
01734 this->start_.wr_ptr (newsize);
01735
01736 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01737 if (newsize > this->start_.total_size ())
01738 {
01739 this->monitor_->receive (newsize);
01740 }
01741 #endif
01742
01743 return 0;
01744 }
01745
01746 void
01747 ACE_InputCDR::reset (const ACE_Message_Block* data,
01748 int byte_order)
01749 {
01750 this->reset_byte_order (byte_order);
01751 ACE_CDR::consolidate (&this->start_, data);
01752
01753 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01754 this->monitor_->receive (this->start_.total_size ());
01755 #endif
01756 }
01757
01758 void
01759 ACE_InputCDR::steal_from (ACE_InputCDR &cdr)
01760 {
01761 this->do_byte_swap_ = cdr.do_byte_swap_;
01762 this->start_.data_block (cdr.start_.data_block ()->duplicate ());
01763
01764
01765 this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE);
01766 this->start_.rd_ptr (cdr.start_.rd_ptr ());
01767
01768 this->start_.wr_ptr (cdr.start_.wr_ptr ());
01769 this->major_version_ = cdr.major_version_;
01770 this->minor_version_ = cdr.minor_version_;
01771 cdr.reset_contents ();
01772
01773 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01774 this->monitor_->receive (this->start_.total_size ());
01775 #endif
01776 }
01777
01778 void
01779 ACE_InputCDR::exchange_data_blocks (ACE_InputCDR &cdr)
01780 {
01781
01782 int const byte_order = cdr.do_byte_swap_;
01783 cdr.do_byte_swap_ = this->do_byte_swap_;
01784 this->do_byte_swap_ = byte_order;
01785
01786
01787 size_t const drd_pos =
01788 cdr.start_.rd_ptr () - cdr.start_.base ();
01789 size_t const dwr_pos =
01790 cdr.start_.wr_ptr () - cdr.start_.base ();
01791
01792
01793 size_t const srd_pos =
01794 this->start_.rd_ptr () - this->start_.base ();
01795 size_t const swr_pos =
01796 this->start_.wr_ptr () - this->start_.base ();
01797
01798
01799 ACE_Data_Block *dnb =
01800 this->start_.replace_data_block (cdr.start_.data_block ());
01801 cdr.start_.replace_data_block (dnb);
01802
01803
01804 ACE_Message_Block::Message_Flags df = cdr.start_.self_flags ();
01805 ACE_Message_Block::Message_Flags sf = this->start_.self_flags ();
01806
01807 cdr.start_.clr_self_flags (df);
01808 this->start_.clr_self_flags (sf);
01809
01810 cdr.start_.set_self_flags (sf);
01811 this->start_.set_self_flags (df);
01812
01813
01814 cdr.start_.reset ();
01815 this->start_.reset ();
01816
01817
01818 if (cdr.start_.size () >= srd_pos)
01819 {
01820 cdr.start_.rd_ptr (srd_pos);
01821 }
01822
01823 if (cdr.start_.size () >= swr_pos)
01824 {
01825 cdr.start_.wr_ptr (swr_pos);
01826 }
01827
01828 if (this->start_.size () >= drd_pos)
01829 {
01830 this->start_.rd_ptr (drd_pos);
01831 }
01832
01833 if (this->start_.size () >= dwr_pos)
01834 {
01835 this->start_.wr_ptr (dwr_pos);
01836 }
01837
01838 ACE_CDR::Octet const dmajor = cdr.major_version_;
01839 ACE_CDR::Octet const dminor = cdr.minor_version_;
01840
01841
01842 cdr.major_version_ = this->major_version_;
01843 cdr.minor_version_ = this->minor_version_;
01844
01845 this->major_version_ = dmajor;
01846 this->minor_version_ = dminor;
01847
01848 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01849 this->monitor_->receive (this->start_.total_size ());
01850 #endif
01851 }
01852
01853 ACE_Data_Block *
01854 ACE_InputCDR::clone_from (ACE_InputCDR &cdr)
01855 {
01856 this->do_byte_swap_ = cdr.do_byte_swap_;
01857
01858
01859
01860 char *rd_ptr = cdr.start_.rd_ptr ();
01861 char *wr_ptr = cdr.start_.wr_ptr ();
01862
01863
01864 cdr.start_.reset ();
01865
01866
01867
01868 ACE_CDR::mb_align (&cdr.start_);
01869
01870
01871 char *nrd_ptr = cdr.start_.rd_ptr ();
01872 char *nwr_ptr = cdr.start_.wr_ptr ();
01873
01874
01875
01876
01877
01878
01879
01880
01881
01882
01883
01884
01885
01886
01887
01888
01889
01890
01891
01892 size_t rd_bytes = rd_ptr - nrd_ptr;
01893 size_t wr_bytes = wr_ptr - nwr_ptr;
01894
01895 ACE_CDR::mb_align (&this->start_);
01896
01897 ACE_Data_Block *db = this->start_.data_block ();
01898
01899
01900
01901 if (wr_bytes > (this->start_.size () - ACE_CDR::MAX_ALIGNMENT))
01902 {
01903
01904
01905 db = cdr.start_.data_block ()->clone_nocopy ();
01906
01907 if (db == 0 || db->size ((wr_bytes) +
01908 ACE_CDR::MAX_ALIGNMENT) == -1)
01909 return 0;
01910
01911
01912 db = this->start_.replace_data_block (db);
01913
01914
01915 ACE_CDR::mb_align (&this->start_);
01916
01917
01918 this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE);
01919 }
01920
01921
01922 (void) ACE_OS::memcpy (this->start_.wr_ptr (),
01923 cdr.start_.rd_ptr (),
01924 wr_bytes);
01925
01926
01927
01928 this->start_.rd_ptr (rd_bytes);
01929 this->start_.wr_ptr (wr_bytes);
01930
01931
01932
01933 cdr.start_.rd_ptr (rd_bytes);
01934 cdr.start_.wr_ptr (wr_bytes);
01935
01936 this->major_version_ = cdr.major_version_;
01937 this->minor_version_ = cdr.minor_version_;
01938
01939
01940 this->char_translator_ = cdr.char_translator_;
01941 this->wchar_translator_ = cdr.wchar_translator_;
01942
01943 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01944 this->monitor_->receive (this->start_.total_size ());
01945 #endif
01946
01947 return db;
01948 }
01949
01950 ACE_Message_Block*
01951 ACE_InputCDR::steal_contents (void)
01952 {
01953 ACE_Message_Block* block = this->start_.clone ();
01954 this->start_.data_block (block->data_block ()->clone ());
01955
01956
01957
01958 this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE);
01959
01960 ACE_CDR::mb_align (&this->start_);
01961
01962 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01963 this->monitor_->receive (this->start_.total_size ());
01964 #endif
01965
01966 return block;
01967 }
01968
01969 void
01970 ACE_InputCDR::reset_contents (void)
01971 {
01972 this->start_.data_block (this->start_.data_block ()->clone_nocopy ());
01973
01974
01975 this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE);
01976
01977 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01978 this->monitor_->receive (this->start_.total_size ());
01979 #endif
01980 }
01981
01982 #if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1)
01983
01984 void
01985 ACE_InputCDR::register_monitor (const char *id)
01986 {
01987 this->monitor_->name (id);
01988 this->monitor_->add_to_registry ();
01989 }
01990
01991 void
01992 ACE_InputCDR::unregister_monitor (void)
01993 {
01994 this->monitor_->remove_from_registry ();
01995 }
01996
01997 #endif
01998
01999
02000
02001 ACE_Char_Codeset_Translator::~ACE_Char_Codeset_Translator (void)
02002 {
02003 }
02004
02005
02006
02007 ACE_WChar_Codeset_Translator::~ACE_WChar_Codeset_Translator (void)
02008 {
02009 }
02010
02011
02012
02013 ACE_CDR::Boolean
02014 operator<< (ACE_OutputCDR &os, const ACE_CString &x)
02015 {
02016 os.write_string (x);
02017 return os.good_bit ();
02018 }
02019
02020 ACE_CDR::Boolean
02021 operator>> (ACE_InputCDR &is, ACE_CString &x)
02022 {
02023 is.read_string (x);
02024 return is.good_bit ();
02025 }
02026
02027 #if defined (GEN_OSTREAM_OPS)
02028
02029 std::ostream&
02030 operator<< (std::ostream &os, ACE_OutputCDR::from_boolean x)
02031 {
02032 return (x.val_ ? os << "true" : os << "false");
02033 }
02034
02035 std::ostream&
02036 operator<< (std::ostream &os, ACE_OutputCDR::from_char x)
02037 {
02038 return os << '\'' << x.val_ << '\'';
02039 }
02040
02041 std::ostream&
02042 operator<< (std::ostream &os, ACE_OutputCDR::from_wchar x)
02043 {
02044 os.setf (ios_base::showbase);
02045 os.setf (ios_base::hex, ios_base::basefield);
02046 os << x.val_;
02047 os.unsetf (ios_base::showbase);
02048 os.setf (ios_base::dec, ios_base::basefield);
02049 return os;
02050 }
02051
02052 std::ostream&
02053 operator<< (std::ostream &os, ACE_OutputCDR::from_octet x)
02054 {
02055
02056 ACE_CDR::WChar w = static_cast<ACE_CDR::WChar> (x.val_);
02057 ACE_OutputCDR::from_wchar tmp (w);
02058 return os << tmp;
02059 }
02060
02061 #endif
02062
02063 ACE_END_VERSIONED_NAMESPACE_DECL