diff options
Diffstat (limited to 'ace')
| -rw-r--r-- | ace/CDR_Stream.cpp | 308 | ||||
| -rw-r--r-- | ace/CDR_Stream.h | 475 | ||||
| -rw-r--r-- | ace/CDR_Stream.i | 685 |
3 files changed, 749 insertions, 719 deletions
diff --git a/ace/CDR_Stream.cpp b/ace/CDR_Stream.cpp index f0be64bbb19..1faa090850b 100644 --- a/ace/CDR_Stream.cpp +++ b/ace/CDR_Stream.cpp @@ -40,7 +40,7 @@ #endif /* ! __ACE_INLINE__ */ int -CDR::grow (ACE_Message_Block *mb, size_t minsize) +ACE_CDR::grow (ACE_Message_Block *mb, size_t minsize) { // Calculate the new buffer's length; if growing for encode, we // don't grow in "small" chunks because of the cost. @@ -53,31 +53,31 @@ CDR::grow (ACE_Message_Block *mb, size_t minsize) // TODO The growth strategy should be controlled using // the ORB parameters.... if (newsize == 0) - newsize = CDR::DEFAULT_BUFSIZE; - else if (size < CDR::EXP_GROWTH_MAX) + newsize = ACE_CDR::DEFAULT_BUFSIZE; + else if (size < ACE_CDR::EXP_GROWTH_MAX) newsize *= 2; else - newsize += CDR::LINEAR_GROWTH_CHUNK; + newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; } - else if (minsize + CDR::MAX_ALIGNMENT <= size) + else if (minsize + ACE_CDR::MAX_ALIGNMENT <= size) return 0; else { if (newsize == 0) - newsize = CDR::DEFAULT_BUFSIZE; + newsize = ACE_CDR::DEFAULT_BUFSIZE; - while (newsize < minsize + CDR::MAX_ALIGNMENT) + while (newsize < minsize + ACE_CDR::MAX_ALIGNMENT) { - if (newsize < CDR::EXP_GROWTH_MAX) + if (newsize < ACE_CDR::EXP_GROWTH_MAX) newsize *= 2; else - newsize += CDR::LINEAR_GROWTH_CHUNK; + newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; } } ACE_Message_Block tmp (newsize); - CDR::mb_align (&tmp); + ACE_CDR::mb_align (&tmp); tmp.copy (mb->rd_ptr (), mb->length()); mb->data_block (tmp.data_block ()->duplicate ()); @@ -87,15 +87,29 @@ CDR::grow (ACE_Message_Block *mb, size_t minsize) return 0; } +size_t +ACE_CDR::total_length (const ACE_Message_Block* begin, + const ACE_Message_Block* end) +{ + size_t l = 0; + // Compute the total size. + for (const ACE_Message_Block *i = begin; + i != end; + i = i->cont ()) + l += i->length (); + return l; +} + + #if defined (NONNATIVE_LONGDOUBLE) int -CDR::LongDouble::operator== (const CDR::LongDouble &rhs) const +ACE_CDR::LongDouble::operator== (const ACE_CDR::LongDouble &rhs) const { return ACE_OS::memcmp (this->ld, rhs.ld, 16) == 0; } int -CDR::LongDouble::operator!= (const CDR::LongDouble &rhs) const +ACE_CDR::LongDouble::operator!= (const ACE_CDR::LongDouble &rhs) const { return ACE_OS::memcmp (this->ld, rhs.ld, 16) != 0; } @@ -108,7 +122,7 @@ ACE_OutputCDR::ACE_OutputCDR (size_t size, ACE_Allocator *buffer_allocator, ACE_Allocator *data_block_allocator, size_t memcpy_tradeoff) - : start_ (size ? size : CDR::DEFAULT_BUFSIZE + CDR::MAX_ALIGNMENT, + : start_ (size ? size : ACE_CDR::DEFAULT_BUFSIZE + ACE_CDR::MAX_ALIGNMENT, ACE_Message_Block::MB_DATA, 0, 0, @@ -122,7 +136,7 @@ ACE_OutputCDR::ACE_OutputCDR (size_t size, good_bit_ (1), memcpy_tradeoff_ (memcpy_tradeoff) { - CDR::mb_align (&this->start_); + ACE_CDR::mb_align (&this->start_); this->current_ = &this->start_; } @@ -146,7 +160,7 @@ ACE_OutputCDR::ACE_OutputCDR (char *data, size_t size, memcpy_tradeoff_ (memcpy_tradeoff) { // We cannot trust the buffer to be properly aligned - CDR::mb_align (&this->start_); + ACE_CDR::mb_align (&this->start_); this->current_ = &this->start_; } @@ -159,7 +173,7 @@ ACE_OutputCDR::ACE_OutputCDR (ACE_Message_Block *data, memcpy_tradeoff_ (memcpy_tradeoff) { // We cannot trust the buffer to be properly aligned - CDR::mb_align (&this->start_); + ACE_CDR::mb_align (&this->start_); this->current_ = &this->start_; } @@ -177,19 +191,13 @@ void ACE_OutputCDR::reset (void) { this->current_ = &this->start_; - CDR::mb_align (&this->start_); + ACE_CDR::mb_align (&this->start_); } size_t ACE_OutputCDR::total_length (void) const { - size_t l = 0; - // Compute the total size. - for (const ACE_Message_Block *i = this->begin (); - i != this->end (); - i = i->cont ()) - l += i->length (); - return l; + return ACE_CDR::total_length (this->begin (), this->end ()); } int @@ -198,16 +206,16 @@ ACE_OutputCDR::grow_and_adjust (size_t size, char*& buf) { if (this->current_->cont () == 0 - || this->current_->cont ()->size () < size + CDR::MAX_ALIGNMENT) + || this->current_->cont ()->size () < size + ACE_CDR::MAX_ALIGNMENT) { // Allocate the next block, it must be large enough. - size_t block_size = CDR::DEFAULT_BUFSIZE; - while (block_size < size + CDR::MAX_ALIGNMENT) + size_t block_size = ACE_CDR::DEFAULT_BUFSIZE; + while (block_size < size + ACE_CDR::MAX_ALIGNMENT) { - if (block_size < CDR::EXP_GROWTH_MAX) + if (block_size < ACE_CDR::EXP_GROWTH_MAX) block_size *= 2; else - block_size += CDR::LINEAR_GROWTH_CHUNK; + block_size += ACE_CDR::LINEAR_GROWTH_CHUNK; } this->good_bit_ = 0; ACE_Message_Block* tmp; @@ -228,12 +236,12 @@ ACE_OutputCDR::grow_and_adjust (size_t size, // The new block must start with the same alignment as the // previous block finished. ptr_arith_t tmpalign = - ptr_arith_t(tmp->wr_ptr ()) % CDR::MAX_ALIGNMENT; + ptr_arith_t(tmp->wr_ptr ()) % ACE_CDR::MAX_ALIGNMENT; ptr_arith_t curalign = - ptr_arith_t(this->current_->wr_ptr ()) % CDR::MAX_ALIGNMENT; + ptr_arith_t(this->current_->wr_ptr ()) % ACE_CDR::MAX_ALIGNMENT; int offset = curalign - tmpalign; if (offset < 0) - offset += CDR::MAX_ALIGNMENT; + offset += ACE_CDR::MAX_ALIGNMENT; tmp->rd_ptr (offset); tmp->wr_ptr (tmp->rd_ptr ()); @@ -250,8 +258,8 @@ ACE_OutputCDR::grow_and_adjust (size_t size, return 0; } -CDR::Boolean -ACE_OutputCDR::write_string (CDR::ULong len, +ACE_CDR::Boolean +ACE_OutputCDR::write_string (ACE_CDR::ULong len, const char *x) { if (len != 0) @@ -276,9 +284,9 @@ ACE_OutputCDR::write_string (CDR::ULong len, return 0; } -CDR::Boolean -ACE_OutputCDR::write_wstring (CDR::ULong len, - const CDR::WChar *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_wstring (ACE_CDR::ULong len, + const ACE_CDR::WChar *x) { if (x != 0) { @@ -297,7 +305,7 @@ ACE_OutputCDR::write_wstring (CDR::ULong len, return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb) { // If the buffer is small and it fits in the current message @@ -313,8 +321,8 @@ ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb) ACE_Message_Block::DONT_DELETE)) { if (! this->write_array (i->rd_ptr (), - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length)) { return 0; @@ -326,8 +334,8 @@ ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb) && this->current_->wr_ptr () + length < this->current_->end ()) { if (! this->write_array (i->rd_ptr (), - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length)) { return 0; @@ -351,37 +359,37 @@ ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb) return 1; } -CDR::Boolean -ACE_OutputCDR::write_1 (const CDR::Octet *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_1 (const ACE_CDR::Octet *x) { char *buf; if (this->adjust (1, buf) == 0) { - *ACE_reinterpret_cast(CDR::Octet*, buf) = *x; + *ACE_reinterpret_cast(ACE_CDR::Octet*, buf) = *x; return 1; } return 0; } -CDR::Boolean -ACE_OutputCDR::write_2 (const CDR::UShort *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_2 (const ACE_CDR::UShort *x) { char *buf; - if (this->adjust (CDR::SHORT_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0) { #if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *ACE_reinterpret_cast(CDR::UShort*,buf) = *x; + *ACE_reinterpret_cast(ACE_CDR::UShort*,buf) = *x; return 1; #else if (!this->do_byte_swap_) { - *ACE_reinterpret_cast (CDR::UShort *, buf) = *x; + *ACE_reinterpret_cast (ACE_CDR::UShort *, buf) = *x; return 1; } else { - CDR::swap_2 (ACE_reinterpret_cast (const char*, x), buf); + ACE_CDR::swap_2 (ACE_reinterpret_cast (const char*, x), buf); return 1; } #endif /* ACE_ENABLE_SWAP_ON_WRITE */ @@ -390,24 +398,24 @@ ACE_OutputCDR::write_2 (const CDR::UShort *x) return 0; } -CDR::Boolean -ACE_OutputCDR::write_4 (const CDR::ULong *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_4 (const ACE_CDR::ULong *x) { char *buf; - if (this->adjust (CDR::LONG_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) { #if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *ACE_reinterpret_cast(CDR::ULong*,buf) = *x; + *ACE_reinterpret_cast(ACE_CDR::ULong*,buf) = *x; return 1; #else if (!this->do_byte_swap_) { - *ACE_reinterpret_cast (CDR::ULong *, buf) = *x; + *ACE_reinterpret_cast (ACE_CDR::ULong *, buf) = *x; return 1; } else { - CDR::swap_4 (ACE_reinterpret_cast (const char*, x), buf); + ACE_CDR::swap_4 (ACE_reinterpret_cast (const char*, x), buf); return 1; } #endif /* ACE_ENABLE_SWAP_ON_WRITE */ @@ -416,24 +424,24 @@ ACE_OutputCDR::write_4 (const CDR::ULong *x) return 0; } -CDR::Boolean -ACE_OutputCDR::write_8 (const CDR::ULongLong *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_8 (const ACE_CDR::ULongLong *x) { char *buf; - if (this->adjust (CDR::LONGLONG_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) { #if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *ACE_reinterpret_cast(CDR::ULongLong*,buf) = *x; + *ACE_reinterpret_cast(ACE_CDR::ULongLong*,buf) = *x; return 1; #else if (!this->do_byte_swap_) { - *ACE_reinterpret_cast (CDR::ULongLong *, buf) = *x; + *ACE_reinterpret_cast (ACE_CDR::ULongLong *, buf) = *x; return 1; } else { - CDR::swap_8 (ACE_reinterpret_cast (const char*, x), buf); + ACE_CDR::swap_8 (ACE_reinterpret_cast (const char*, x), buf); return 1; } #endif /* ACE_ENABLE_SWAP_ON_WRITE */ @@ -442,26 +450,26 @@ ACE_OutputCDR::write_8 (const CDR::ULongLong *x) return 0; } -CDR::Boolean -ACE_OutputCDR::write_16 (const CDR::LongDouble *x) +ACE_CDR::Boolean +ACE_OutputCDR::write_16 (const ACE_CDR::LongDouble *x) { char* buf; - if (this->adjust (CDR::LONGDOUBLE_SIZE, - CDR::LONGDOUBLE_ALIGN, + if (this->adjust (ACE_CDR::LONGDOUBLE_SIZE, + ACE_CDR::LONGDOUBLE_ALIGN, buf) == 0) { #if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *ACE_reinterpret_cast(CDR::LongDouble*,buf) = *x; + *ACE_reinterpret_cast(ACE_CDR::LongDouble*,buf) = *x; return 1; #else if (!this->do_byte_swap_) { - *ACE_reinterpret_cast (CDR::LongDouble *, buf) = *x; + *ACE_reinterpret_cast (ACE_CDR::LongDouble *, buf) = *x; return 1; } else { - CDR::swap_16 (ACE_reinterpret_cast (const char*, x), buf); + ACE_CDR::swap_16 (ACE_reinterpret_cast (const char*, x), buf); return 1; } #endif /* ACE_ENABLE_SWAP_ON_WRITE */ @@ -470,11 +478,11 @@ ACE_OutputCDR::write_16 (const CDR::LongDouble *x) return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_OutputCDR::write_array (const void *x, - size_t size, - size_t align, - CDR::ULong length) + size_t size, + size_t align, + ACE_CDR::ULong length) { char *buf; if (this->adjust (size * length, align, buf) == 0) @@ -496,16 +504,16 @@ ACE_OutputCDR::write_array (const void *x, switch (size) { case 2: - swapper = CDR::swap_2; + swapper = ACE_CDR::swap_2; break; case 4: - swapper = CDR::swap_4; + swapper = ACE_CDR::swap_4; break; case 8: - swapper = CDR::swap_8; + swapper = ACE_CDR::swap_8; break; case 16: - swapper = CDR::swap_16; + swapper = ACE_CDR::swap_16; break; default: // TODO: print something? @@ -529,17 +537,17 @@ ACE_OutputCDR::write_array (const void *x, return 0; } -CDR::Boolean -ACE_OutputCDR::write_boolean_array (const CDR::Boolean* x, - CDR::ULong length) +ACE_CDR::Boolean +ACE_OutputCDR::write_boolean_array (const ACE_CDR::Boolean* x, + ACE_CDR::ULong length) { // It is hard to optimize this, the spec requires that on the wire // booleans be represented as a byte with value 0 or 1, but in // memoery it is possible (though very unlikely) that a boolean has // a non-zero value (different from 1). // We resort to a simple loop. - const CDR::Boolean* end = x + length; - for (const CDR::Boolean* i = x; i != end && this->good_bit (); ++i) + const ACE_CDR::Boolean* end = x + length; + for (const ACE_CDR::Boolean* i = x; i != end && this->good_bit (); ++i) { this->write_boolean (*i); } @@ -566,14 +574,32 @@ ACE_InputCDR::ACE_InputCDR (size_t bufsiz, { } -ACE_InputCDR::ACE_InputCDR (ACE_Message_Block *data, +ACE_InputCDR::ACE_InputCDR (const ACE_Message_Block *data, int byte_order) - : start_ (data->data_block ()->duplicate ()), + : start_ (ACE_CDR::total_length (data, 0) + ACE_CDR::MAX_ALIGNMENT), + // @@ We may need allocators for the previous line, and the size may + // be a standard ACE_*CDR size... do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), good_bit_ (1) { - this->start_.rd_ptr (data->rd_ptr ()); - this->start_.wr_ptr (data->wr_ptr ()); + // We must copy the contents of <data> into the new buffer, but + // respecting the alignment. + ptr_arith_t curalign = + ptr_arith_t(data->wr_ptr ()) % ACE_CDR::MAX_ALIGNMENT; + ptr_arith_t tmpalign = + ptr_arith_t(this->start_.rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; + int offset = curalign - tmpalign; + if (offset < 0) + offset += ACE_CDR::MAX_ALIGNMENT; + this->start_.rd_ptr (offset); + this->start_.wr_ptr (offset); + + for (const ACE_Message_Block* i = data; + i != 0; + i = i->cont ()) + { + this->start_.copy (i->rd_ptr (), i->length ()); + } } ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data, @@ -586,7 +612,7 @@ ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data, ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs, size_t size, - CDR::Long offset) + ACE_CDR::Long offset) : start_ (rhs.start_.data_block ()->duplicate ()), do_byte_swap_ (rhs.do_byte_swap_), good_bit_ (1) @@ -621,7 +647,7 @@ ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs, this->start_.rd_ptr (newpos); this->start_.wr_ptr (newpos + size); - CDR::Octet byte_order; + ACE_CDR::Octet byte_order; this->read_octet (byte_order); this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER); } @@ -657,7 +683,7 @@ ACE_InputCDR::operator= (const ACE_InputCDR& rhs) ACE_InputCDR::ACE_InputCDR (const ACE_OutputCDR& rhs, ACE_Allocator* buffer_allocator, ACE_Allocator* data_block_allocator) - : start_ (rhs.total_length () + CDR::MAX_ALIGNMENT, + : start_ (rhs.total_length () + ACE_CDR::MAX_ALIGNMENT, ACE_Message_Block::MB_DATA, 0, 0, @@ -670,7 +696,7 @@ ACE_InputCDR::ACE_InputCDR (const ACE_OutputCDR& rhs, do_byte_swap_ (rhs.do_byte_swap_), good_bit_ (1) { - CDR::mb_align (&this->start_); + ACE_CDR::mb_align (&this->start_); for (const ACE_Message_Block *i = rhs.begin (); i != rhs.end (); i = i->cont ()) @@ -681,15 +707,15 @@ ACE_InputCDR::~ACE_InputCDR (void) { } -CDR::Boolean +ACE_CDR::Boolean ACE_InputCDR::read_string (char *&x) { - CDR::ULong len; + ACE_CDR::ULong len; this->read_ulong (len); if (len > 0) { - ACE_NEW_RETURN (x, CDR::Char[len], 0); + ACE_NEW_RETURN (x, ACE_CDR::Char[len], 0); if (this->read_char_array (x, len)) return 1; delete [] x; @@ -699,10 +725,10 @@ ACE_InputCDR::read_string (char *&x) return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_InputCDR::read_string (ACE_CString &x) { - CDR::Char *data; + ACE_CDR::Char *data; if (this->read_string (data)) { x = data; @@ -714,14 +740,14 @@ ACE_InputCDR::read_string (ACE_CString &x) return 0; } -CDR::Boolean -ACE_InputCDR::read_wstring (CDR::WChar*& x) +ACE_CDR::Boolean +ACE_InputCDR::read_wstring (ACE_CDR::WChar*& x) { - CDR::ULong len; + ACE_CDR::ULong len; this->read_ulong (len); if (this->good_bit()) { - ACE_NEW_RETURN (x, CDR::WChar[len], 0); + ACE_NEW_RETURN (x, ACE_CDR::WChar[len], 0); if (this->read_wchar_array (x, len)) return 1; @@ -731,11 +757,11 @@ ACE_InputCDR::read_wstring (CDR::WChar*& x) return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_InputCDR::read_array (void* x, size_t size, size_t align, - CDR::ULong length) + ACE_CDR::ULong length) { char* buf; if (this->adjust (size * length, align, buf) == 0) @@ -755,25 +781,25 @@ ACE_InputCDR::read_array (void* x, case 2: for (; target != end; target += size, buf += size) { - CDR::swap_2 (buf, target); + ACE_CDR::swap_2 (buf, target); } break; case 4: for (; target != end; target += size, buf += size) { - CDR::swap_4 (buf, target); + ACE_CDR::swap_4 (buf, target); } break; case 8: for (; target != end; target += size, buf += size) { - CDR::swap_8 (buf, target); + ACE_CDR::swap_8 (buf, target); } break; case 16: for (; target != end; target += size, buf += size) { - CDR::swap_16 (buf, target); + ACE_CDR::swap_16 (buf, target); } break; default: @@ -790,28 +816,28 @@ ACE_InputCDR::read_array (void* x, return 0; } -CDR::Boolean -ACE_InputCDR::read_boolean_array (CDR::Boolean *x, - CDR::ULong length) +ACE_CDR::Boolean +ACE_InputCDR::read_boolean_array (ACE_CDR::Boolean *x, + ACE_CDR::ULong length) { // It is hard to optimize this, the spec requires that on the wire // booleans be represented as a byte with value 0 or 1, but in // memoery it is possible (though very unlikely) that a boolean has // a non-zero value (different from 1). // We resort to a simple loop. - for (CDR::ULong i = 0; i != length && this->good_bit_; ++i) + for (ACE_CDR::ULong i = 0; i != length && this->good_bit_; ++i) { this->read_boolean (x[i]); } return this->good_bit_; } -CDR::Boolean -ACE_InputCDR::read_1 (CDR::Octet *x) +ACE_CDR::Boolean +ACE_InputCDR::read_1 (ACE_CDR::Octet *x) { if (this->rd_ptr () < this->end ()) { - *x = *ACE_reinterpret_cast (CDR::Octet*,this->rd_ptr()); + *x = *ACE_reinterpret_cast (ACE_CDR::Octet*,this->rd_ptr()); this->start_.rd_ptr (1); return 1; } @@ -820,104 +846,104 @@ ACE_InputCDR::read_1 (CDR::Octet *x) return 0; } -CDR::Boolean -ACE_InputCDR::read_2 (CDR::UShort *x) +ACE_CDR::Boolean +ACE_InputCDR::read_2 (ACE_CDR::UShort *x) { char *buf; - if (this->adjust (CDR::SHORT_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0) { #if !defined (ACE_DISABLE_SWAP_ON_READ) if (!this->do_byte_swap_) { - *x = *ACE_reinterpret_cast (CDR::UShort*, buf); + *x = *ACE_reinterpret_cast (ACE_CDR::UShort*, buf); } else { - CDR::swap_2 (buf, ACE_reinterpret_cast (char*, x)); + ACE_CDR::swap_2 (buf, ACE_reinterpret_cast (char*, x)); } #else - *x = *ACE_reinterpret_cast(CDR::UShort*,buf); + *x = *ACE_reinterpret_cast(ACE_CDR::UShort*,buf); #endif /* ACE_DISABLE_SWAP_ON_READ */ return 1; } return 0; } -CDR::Boolean -ACE_InputCDR::read_4 (CDR::ULong *x) +ACE_CDR::Boolean +ACE_InputCDR::read_4 (ACE_CDR::ULong *x) { char *buf; - if (this->adjust (CDR::LONG_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) { #if !defined (ACE_DISABLE_SWAP_ON_READ) if (!this->do_byte_swap_) { - *x = *ACE_reinterpret_cast (CDR::ULong*, buf); + *x = *ACE_reinterpret_cast (ACE_CDR::ULong*, buf); } else { - CDR::swap_4 (buf, ACE_reinterpret_cast (char*, x)); + ACE_CDR::swap_4 (buf, ACE_reinterpret_cast (char*, x)); } #else - *x = *ACE_reinterpret_cast(CDR::ULong*,buf); + *x = *ACE_reinterpret_cast(ACE_CDR::ULong*,buf); #endif /* ACE_DISABLE_SWAP_ON_READ */ return 1; } return 0; } -CDR::Boolean -ACE_InputCDR::read_8 (CDR::ULongLong *x) +ACE_CDR::Boolean +ACE_InputCDR::read_8 (ACE_CDR::ULongLong *x) { char *buf; - if (this->adjust (CDR::LONGLONG_SIZE, buf) == 0) + if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) { #if !defined (ACE_DISABLE_SWAP_ON_READ) if (!this->do_byte_swap_) { - *x = *ACE_reinterpret_cast (CDR::ULongLong *, buf); + *x = *ACE_reinterpret_cast (ACE_CDR::ULongLong *, buf); } else { - CDR::swap_8 (buf, ACE_reinterpret_cast (char*, x)); + ACE_CDR::swap_8 (buf, ACE_reinterpret_cast (char*, x)); } #else - *x = *ACE_reinterpret_cast(CDR::ULongLong*,buf); + *x = *ACE_reinterpret_cast(ACE_CDR::ULongLong*,buf); #endif /* ACE_DISABLE_SWAP_ON_READ */ return 1; } return 0; } -CDR::Boolean -ACE_InputCDR::read_16 (CDR::LongDouble *x) +ACE_CDR::Boolean +ACE_InputCDR::read_16 (ACE_CDR::LongDouble *x) { char *buf; - if (this->adjust (CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + if (this->adjust (ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, buf) == 0) { #if !defined (ACE_DISABLE_SWAP_ON_READ) if (!this->do_byte_swap_) { - *x = *ACE_reinterpret_cast (CDR::LongDouble *, buf); + *x = *ACE_reinterpret_cast (ACE_CDR::LongDouble *, buf); } else { - CDR::swap_16 (buf, ACE_reinterpret_cast (char*, x)); + ACE_CDR::swap_16 (buf, ACE_reinterpret_cast (char*, x)); } #else - *x = *ACE_reinterpret_cast(CDR::LongDouble*,buf); + *x = *ACE_reinterpret_cast(ACE_CDR::LongDouble*,buf); #endif /* ACE_DISABLE_SWAP_ON_READ */ return 1; } return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_InputCDR::skip_string (void) { - CDR::ULong len; + ACE_CDR::ULong len; if (this->read_ulong (len)) { if (this->rd_ptr () + len <= this->end ()) @@ -931,7 +957,7 @@ ACE_InputCDR::skip_string (void) return 0; } -CDR::Boolean +ACE_CDR::Boolean ACE_InputCDR::skip_bytes (size_t len) { if (this->rd_ptr () + len <= this->end ()) diff --git a/ace/CDR_Stream.h b/ace/CDR_Stream.h index 106c92c074b..36c2f683526 100644 --- a/ace/CDR_Stream.h +++ b/ace/CDR_Stream.h @@ -54,11 +54,12 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -class ACE_Export CDR +class ACE_Export ACE_CDR { // = TITLE // Keep constants and some routines common to both Output and // Input CDR streams. + // public: // = Constants defined by the CDR protocol. // By defining as many of these constants as possible as enums we @@ -122,6 +123,9 @@ public: // large enough to contain any of the basic IDL types. Return -1 on // failure, 0 on success. + static size_t total_length (const ACE_Message_Block *begin, + const ACE_Message_Block *end); + // Definitions of the IDL basic types, for use in the CDR // classes. The cleanest way to avoid complaints from all compilers // is to define them all. @@ -163,9 +167,9 @@ public: // application can cope with the loss of range, it can define // conversion operators itself. # if defined (ACE_BIG_ENDIAN) - struct LongLong { CDR::Long h, l; }; + struct LongLong { ACE_CDR::Long h, l; }; # else - struct LongLong { CDR::Long l, h; }; + struct LongLong { ACE_CDR::Long l, h; }; # endif /* ! ACE_BIG_ENDIAN */ # endif /* no native 64 bit integer type */ @@ -277,114 +281,115 @@ public: struct ACE_Export from_boolean { - from_boolean (CDR::Boolean b); - CDR::Boolean val_; + from_boolean (ACE_CDR::Boolean b); + ACE_CDR::Boolean val_; }; struct ACE_Export from_octet { - from_octet (CDR::Octet o); - CDR::Octet val_; + from_octet (ACE_CDR::Octet o); + ACE_CDR::Octet val_; }; struct ACE_Export from_char { - from_char (CDR::Char c); - CDR::Char val_; + from_char (ACE_CDR::Char c); + ACE_CDR::Char val_; }; struct ACE_Export from_wchar { - from_wchar (CDR::WChar wc); - CDR::WChar val_; + from_wchar (ACE_CDR::WChar wc); + ACE_CDR::WChar val_; }; struct ACE_Export from_string { - from_string (CDR::Char* s, - CDR::ULong b, - CDR::Boolean nocopy = 0); - CDR::Char *val_; - CDR::ULong bound_; - CDR::Boolean nocopy_; + from_string (ACE_CDR::Char* s, + ACE_CDR::ULong b, + ACE_CDR::Boolean nocopy = 0); + ACE_CDR::Char *val_; + ACE_CDR::ULong bound_; + ACE_CDR::Boolean nocopy_; }; // = We have one method per basic IDL type.... // They return 0 on failure and 1 on success. - CDR::Boolean write_boolean (CDR::Boolean x); - CDR::Boolean write_char (CDR::Char x); - CDR::Boolean write_wchar (CDR::WChar x); - CDR::Boolean write_octet (CDR::Octet x); - CDR::Boolean write_short (CDR::Short x); - CDR::Boolean write_ushort (CDR::UShort x); - CDR::Boolean write_long (CDR::Long x); - CDR::Boolean write_ulong (CDR::ULong x); - CDR::Boolean write_longlong (const CDR::LongLong &x); - CDR::Boolean write_ulonglong (const CDR::ULongLong &x); - CDR::Boolean write_float (CDR::Float x); - CDR::Boolean write_double (const CDR::Double &x); - CDR::Boolean write_longdouble (const CDR::LongDouble &x); + ACE_CDR::Boolean write_boolean (ACE_CDR::Boolean x); + ACE_CDR::Boolean write_char (ACE_CDR::Char x); + ACE_CDR::Boolean write_wchar (ACE_CDR::WChar x); + ACE_CDR::Boolean write_octet (ACE_CDR::Octet x); + ACE_CDR::Boolean write_short (ACE_CDR::Short x); + ACE_CDR::Boolean write_ushort (ACE_CDR::UShort x); + ACE_CDR::Boolean write_long (ACE_CDR::Long x); + ACE_CDR::Boolean write_ulong (ACE_CDR::ULong x); + ACE_CDR::Boolean write_longlong (const ACE_CDR::LongLong &x); + ACE_CDR::Boolean write_ulonglong (const ACE_CDR::ULongLong &x); + ACE_CDR::Boolean write_float (ACE_CDR::Float x); + ACE_CDR::Boolean write_double (const ACE_CDR::Double &x); + ACE_CDR::Boolean write_longdouble (const ACE_CDR::LongDouble &x); // = For string we offer methods that accept a precomputed length. - CDR::Boolean write_string (const CDR::Char *x); - CDR::Boolean write_string (CDR::ULong len, const CDR::Char *x); - CDR::Boolean write_string (const ACE_CString &x); - CDR::Boolean write_wstring (const CDR::WChar *x); - CDR::Boolean write_wstring (CDR::ULong length, - const CDR::WChar *x); + ACE_CDR::Boolean write_string (const ACE_CDR::Char *x); + ACE_CDR::Boolean write_string (ACE_CDR::ULong len, + const ACE_CDR::Char *x); + ACE_CDR::Boolean write_string (const ACE_CString &x); + ACE_CDR::Boolean write_wstring (const ACE_CDR::WChar *x); + ACE_CDR::Boolean write_wstring (ACE_CDR::ULong length, + const ACE_CDR::WChar *x); // = We add one method to write arrays of basic IDL types. // Note: the portion written starts at <x> and ends at <x + length>. // The length is *NOT* stored into the CDR stream. - CDR::Boolean write_boolean_array (const CDR::Boolean *x, - CDR::ULong length); - CDR::Boolean write_char_array (const CDR::Char *x, - CDR::ULong length); - CDR::Boolean write_wchar_array (const CDR::WChar* x, - CDR::ULong length); - CDR::Boolean write_octet_array (const CDR::Octet* x, - CDR::ULong length); - CDR::Boolean write_short_array (const CDR::Short *x, - CDR::ULong length); - CDR::Boolean write_ushort_array (const CDR::UShort *x, - CDR::ULong length); - CDR::Boolean write_long_array (const CDR::Long *x, - CDR::ULong length); - CDR::Boolean write_ulong_array (const CDR::ULong *x, - CDR::ULong length); - CDR::Boolean write_longlong_array (const CDR::LongLong* x, - CDR::ULong length); - CDR::Boolean write_ulonglong_array (const CDR::ULongLong *x, - CDR::ULong length); - CDR::Boolean write_float_array (const CDR::Float *x, - CDR::ULong length); - CDR::Boolean write_double_array (const CDR::Double *x, - CDR::ULong length); - CDR::Boolean write_longdouble_array (const CDR::LongDouble* x, - CDR::ULong length); - - CDR::Boolean write_octet_array_mb (const ACE_Message_Block* mb); + ACE_CDR::Boolean write_boolean_array (const ACE_CDR::Boolean *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_char_array (const ACE_CDR::Char *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_wchar_array (const ACE_CDR::WChar* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_octet_array (const ACE_CDR::Octet* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_short_array (const ACE_CDR::Short *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_ushort_array (const ACE_CDR::UShort *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_long_array (const ACE_CDR::Long *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_ulong_array (const ACE_CDR::ULong *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_longlong_array (const ACE_CDR::LongLong* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_ulonglong_array (const ACE_CDR::ULongLong *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_float_array (const ACE_CDR::Float *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_double_array (const ACE_CDR::Double *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean write_longdouble_array (const ACE_CDR::LongDouble* x, + ACE_CDR::ULong length); + + ACE_CDR::Boolean write_octet_array_mb (const ACE_Message_Block* mb); // Write an octet array contained inside a MB, this can be optimized // to minimize copies. // = We have one method per basic IDL type.... // They return 0 on failure and 1 on success. - CDR::Boolean append_boolean (ACE_InputCDR &); - CDR::Boolean append_char (ACE_InputCDR &); - CDR::Boolean append_wchar (ACE_InputCDR &); - CDR::Boolean append_octet (ACE_InputCDR &); - CDR::Boolean append_short (ACE_InputCDR &); - CDR::Boolean append_ushort (ACE_InputCDR &); - CDR::Boolean append_long (ACE_InputCDR &); - CDR::Boolean append_ulong (ACE_InputCDR &); - CDR::Boolean append_longlong (ACE_InputCDR &); - CDR::Boolean append_ulonglong (ACE_InputCDR &); - CDR::Boolean append_float (ACE_InputCDR &); - CDR::Boolean append_double (ACE_InputCDR &); - CDR::Boolean append_longdouble (ACE_InputCDR &); - - CDR::Boolean append_wstring (ACE_InputCDR &); - CDR::Boolean append_string (ACE_InputCDR &); + ACE_CDR::Boolean append_boolean (ACE_InputCDR &); + ACE_CDR::Boolean append_char (ACE_InputCDR &); + ACE_CDR::Boolean append_wchar (ACE_InputCDR &); + ACE_CDR::Boolean append_octet (ACE_InputCDR &); + ACE_CDR::Boolean append_short (ACE_InputCDR &); + ACE_CDR::Boolean append_ushort (ACE_InputCDR &); + ACE_CDR::Boolean append_long (ACE_InputCDR &); + ACE_CDR::Boolean append_ulong (ACE_InputCDR &); + ACE_CDR::Boolean append_longlong (ACE_InputCDR &); + ACE_CDR::Boolean append_ulonglong (ACE_InputCDR &); + ACE_CDR::Boolean append_float (ACE_InputCDR &); + ACE_CDR::Boolean append_double (ACE_InputCDR &); + ACE_CDR::Boolean append_longdouble (ACE_InputCDR &); + + ACE_CDR::Boolean append_wstring (ACE_InputCDR &); + ACE_CDR::Boolean append_string (ACE_InputCDR &); int good_bit (void) const; // Returns 0 if an error has ocurred, the only expected error is to @@ -422,16 +427,16 @@ private: ACE_OutputCDR& operator= (const ACE_OutputCDR& rhs); // disallow copying... - CDR::Boolean write_1 (const CDR::Octet *x); - CDR::Boolean write_2 (const CDR::UShort *x); - CDR::Boolean write_4 (const CDR::ULong *x); - CDR::Boolean write_8 (const CDR::ULongLong *x); - CDR::Boolean write_16 (const CDR::LongDouble *x); + ACE_CDR::Boolean write_1 (const ACE_CDR::Octet *x); + ACE_CDR::Boolean write_2 (const ACE_CDR::UShort *x); + ACE_CDR::Boolean write_4 (const ACE_CDR::ULong *x); + ACE_CDR::Boolean write_8 (const ACE_CDR::ULongLong *x); + ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x); - CDR::Boolean write_array (const void *x, - size_t size, - size_t align, - CDR::ULong length); + ACE_CDR::Boolean write_array (const void *x, + size_t size, + size_t align, + ACE_CDR::ULong length); // write an array of <length> elements, each of <size> bytes and the // start aligned at a multiple of <align>. The elements are assumed // to be packed with the right alignment restrictions. It is mostly @@ -525,7 +530,7 @@ public: // Create an empty input stream. The caller is responsible for // putting the right data and providing the right alignment. - ACE_InputCDR (ACE_Message_Block *data, + ACE_InputCDR (const ACE_Message_Block *data, int byte_order = ACE_CDR_BYTE_ORDER); // Create an input stream from an ACE_Message_Block @@ -541,7 +546,7 @@ public: ACE_InputCDR (const ACE_InputCDR& rhs, size_t size, - CDR::Long offset); + ACE_CDR::Long offset); // When interpreting indirected TypeCodes it is useful to make a // "copy" of the stream starting in the new position. @@ -563,109 +568,109 @@ public: struct ACE_Export to_boolean { - to_boolean (CDR::Boolean &b); - CDR::Boolean &ref_; + to_boolean (ACE_CDR::Boolean &b); + ACE_CDR::Boolean &ref_; }; struct ACE_Export to_char { - to_char (CDR::Char &c); - CDR::Char &ref_; + to_char (ACE_CDR::Char &c); + ACE_CDR::Char &ref_; }; struct ACE_Export to_wchar { - to_wchar (CDR::WChar &wc); - CDR::WChar &ref_; + to_wchar (ACE_CDR::WChar &wc); + ACE_CDR::WChar &ref_; }; struct ACE_Export to_octet { - to_octet (CDR::Octet &o); - CDR::Octet &ref_; + to_octet (ACE_CDR::Octet &o); + ACE_CDR::Octet &ref_; }; struct ACE_Export to_string { - to_string (CDR::Char *&s, CDR::ULong b); - CDR::Char *&val_; - CDR::ULong bound_; + to_string (ACE_CDR::Char *&s, ACE_CDR::ULong b); + ACE_CDR::Char *&val_; + ACE_CDR::ULong bound_; }; // = We have one method per basic IDL type.... // They return 0 on failure and 1 on success. - CDR::Boolean read_boolean (CDR::Boolean& x); - CDR::Boolean read_char (CDR::Char &x); - CDR::Boolean read_wchar (CDR::WChar& x); - CDR::Boolean read_octet (CDR::Octet& x); - CDR::Boolean read_short (CDR::Short &x); - CDR::Boolean read_ushort (CDR::UShort &x); - CDR::Boolean read_long (CDR::Long &x); - CDR::Boolean read_ulong (CDR::ULong &x); - CDR::Boolean read_longlong (CDR::LongLong& x); - CDR::Boolean read_ulonglong (CDR::ULongLong& x); - CDR::Boolean read_float (CDR::Float &x); - CDR::Boolean read_double (CDR::Double &x); - CDR::Boolean read_longdouble (CDR::LongDouble &x); - - CDR::Boolean read_string (CDR::Char *&x); - CDR::Boolean read_string (ACE_CString &x); - CDR::Boolean read_wstring (CDR::WChar*& x); + ACE_CDR::Boolean read_boolean (ACE_CDR::Boolean& x); + ACE_CDR::Boolean read_char (ACE_CDR::Char &x); + ACE_CDR::Boolean read_wchar (ACE_CDR::WChar& x); + ACE_CDR::Boolean read_octet (ACE_CDR::Octet& x); + ACE_CDR::Boolean read_short (ACE_CDR::Short &x); + ACE_CDR::Boolean read_ushort (ACE_CDR::UShort &x); + ACE_CDR::Boolean read_long (ACE_CDR::Long &x); + ACE_CDR::Boolean read_ulong (ACE_CDR::ULong &x); + ACE_CDR::Boolean read_longlong (ACE_CDR::LongLong& x); + ACE_CDR::Boolean read_ulonglong (ACE_CDR::ULongLong& x); + ACE_CDR::Boolean read_float (ACE_CDR::Float &x); + ACE_CDR::Boolean read_double (ACE_CDR::Double &x); + ACE_CDR::Boolean read_longdouble (ACE_CDR::LongDouble &x); + + ACE_CDR::Boolean read_string (ACE_CDR::Char *&x); + ACE_CDR::Boolean read_string (ACE_CString &x); + ACE_CDR::Boolean read_wstring (ACE_CDR::WChar*& x); // = One method for each basic type... // The buffer <x> must be large enough to contain <length> // elements. // They return -1 on failure and 0 on success. - CDR::Boolean read_boolean_array (CDR::Boolean* x, - CDR::ULong length); - CDR::Boolean read_char_array (CDR::Char *x, - CDR::ULong length); - CDR::Boolean read_wchar_array (CDR::WChar* x, - CDR::ULong length); - CDR::Boolean read_octet_array (CDR::Octet* x, - CDR::ULong length); - CDR::Boolean read_short_array (CDR::Short *x, - CDR::ULong length); - CDR::Boolean read_ushort_array (CDR::UShort *x, - CDR::ULong length); - CDR::Boolean read_long_array (CDR::Long *x, - CDR::ULong length); - CDR::Boolean read_ulong_array (CDR::ULong *x, - CDR::ULong length); - CDR::Boolean read_longlong_array (CDR::LongLong* x, - CDR::ULong length); - CDR::Boolean read_ulonglong_array (CDR::ULongLong* x, - CDR::ULong length); - CDR::Boolean read_float_array (CDR::Float *x, - CDR::ULong length); - CDR::Boolean read_double_array (CDR::Double *x, - CDR::ULong length); - CDR::Boolean read_longdouble_array (CDR::LongDouble* x, - CDR::ULong length); + ACE_CDR::Boolean read_boolean_array (ACE_CDR::Boolean* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_char_array (ACE_CDR::Char *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_wchar_array (ACE_CDR::WChar* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_octet_array (ACE_CDR::Octet* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_short_array (ACE_CDR::Short *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_ushort_array (ACE_CDR::UShort *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_long_array (ACE_CDR::Long *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_ulong_array (ACE_CDR::ULong *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_longlong_array (ACE_CDR::LongLong* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_ulonglong_array (ACE_CDR::ULongLong* x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_float_array (ACE_CDR::Float *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_double_array (ACE_CDR::Double *x, + ACE_CDR::ULong length); + ACE_CDR::Boolean read_longdouble_array (ACE_CDR::LongDouble* x, + ACE_CDR::ULong length); // = We have one method per basic IDL type.... // They return 0 on failure and 1 on success. - CDR::Boolean skip_boolean (void); - CDR::Boolean skip_char (void); - CDR::Boolean skip_wchar (void); - CDR::Boolean skip_octet (void); - CDR::Boolean skip_short (void); - CDR::Boolean skip_ushort (void); - CDR::Boolean skip_long (void); - CDR::Boolean skip_ulong (void); - CDR::Boolean skip_longlong (void); - CDR::Boolean skip_ulonglong (void); - CDR::Boolean skip_float (void); - CDR::Boolean skip_double (void); - CDR::Boolean skip_longdouble (void); - - CDR::Boolean skip_wstring (void); - CDR::Boolean skip_string (void); + ACE_CDR::Boolean skip_boolean (void); + ACE_CDR::Boolean skip_char (void); + ACE_CDR::Boolean skip_wchar (void); + ACE_CDR::Boolean skip_octet (void); + ACE_CDR::Boolean skip_short (void); + ACE_CDR::Boolean skip_ushort (void); + ACE_CDR::Boolean skip_long (void); + ACE_CDR::Boolean skip_ulong (void); + ACE_CDR::Boolean skip_longlong (void); + ACE_CDR::Boolean skip_ulonglong (void); + ACE_CDR::Boolean skip_float (void); + ACE_CDR::Boolean skip_double (void); + ACE_CDR::Boolean skip_longdouble (void); + + ACE_CDR::Boolean skip_wstring (void); + ACE_CDR::Boolean skip_string (void); // The next field must be a string, this method skips it. It is // useful in parsing a TypeCode. // Return 0 on failure and 1 on success. - CDR::Boolean skip_bytes (size_t n); + ACE_CDR::Boolean skip_bytes (size_t n); // Skip <n> bytes in the CDR stream. // Return 0 on failure and 1 on success. @@ -706,11 +711,11 @@ protected: // set to 0 when an error occurs. private: - CDR::Boolean read_1 (CDR::Octet *x); - CDR::Boolean read_2 (CDR::UShort *x); - CDR::Boolean read_4 (CDR::ULong *x); - CDR::Boolean read_8 (CDR::ULongLong *x); - CDR::Boolean read_16 (CDR::LongDouble *x); + ACE_CDR::Boolean read_1 (ACE_CDR::Octet *x); + ACE_CDR::Boolean read_2 (ACE_CDR::UShort *x); + ACE_CDR::Boolean read_4 (ACE_CDR::ULong *x); + ACE_CDR::Boolean read_8 (ACE_CDR::ULongLong *x); + ACE_CDR::Boolean read_16 (ACE_CDR::LongDouble *x); // Several types can be read using the same routines, since TAO // tries to use native types with known size for each CORBA type. @@ -719,10 +724,10 @@ private: // alignment requirements of CDR streams and implement the // operations using asignment. - CDR::Boolean read_array (void* x, - size_t size, - size_t align, - CDR::ULong length); + ACE_CDR::Boolean read_array (void* x, + size_t size, + size_t align, + ACE_CDR::ULong length); // Read an array of <length> elements, each of <size> bytes and the // start aligned at a multiple of <align>. The elements are assumed // to be packed with the right alignment restrictions. It is mostly @@ -757,75 +762,75 @@ private: #else // CDR output operators for primitive types -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::Short x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::UShort x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::Long x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::ULong x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::LongLong x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::ULongLong x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR& os, - CDR::LongDouble x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::Float x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - CDR::Double x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - const ACE_CString &x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::Short x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::UShort x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::Long x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::ULong x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::LongLong x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::ULongLong x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR& os, + ACE_CDR::LongDouble x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::Float x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_CDR::Double x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + const ACE_CString &x); // CDR output operator from helper classes -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_boolean x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_char x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_wchar x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_octet x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_string x); -extern ACE_Export CDR::Boolean operator<< (ACE_OutputCDR &os, - const CDR::Char* x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_OutputCDR::from_boolean x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_OutputCDR::from_char x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_OutputCDR::from_wchar x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_OutputCDR::from_octet x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + ACE_OutputCDR::from_string x); +extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, + const ACE_CDR::Char* x); // CDR input operators for primitive types -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::Short &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::UShort &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::Long &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::ULong &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::LongLong &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::ULongLong &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::LongDouble &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::Float &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::Double &x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CString &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::Short &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::UShort &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::Long &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::ULong &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::LongLong &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::ULongLong &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::LongDouble &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::Float &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::Double &x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CString &x); // CDR input operator from helper classes -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_boolean x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_char x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_wchar x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_octet x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_string x); -extern ACE_Export CDR::Boolean operator>> (ACE_InputCDR &is, - CDR::Char*& x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_InputCDR::to_boolean x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_InputCDR::to_char x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_InputCDR::to_wchar x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_InputCDR::to_octet x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_InputCDR::to_string x); +extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, + ACE_CDR::Char*& x); #endif /* __ACE_INLINE */ diff --git a/ace/CDR_Stream.i b/ace/CDR_Stream.i index 7b92b59fc63..ce6541b006b 100644 --- a/ace/CDR_Stream.i +++ b/ace/CDR_Stream.i @@ -4,14 +4,14 @@ // **************************************************************** ACE_INLINE void -CDR::swap_2 (const char *orig, char* target) +ACE_CDR::swap_2 (const char *orig, char* target) { target[1] = *orig++; target[0] = *orig++; } ACE_INLINE void -CDR::swap_4 (const char *orig, char* target) +ACE_CDR::swap_4 (const char *orig, char* target) { target [3] = *orig++; target [2] = *orig++; @@ -20,7 +20,7 @@ CDR::swap_4 (const char *orig, char* target) } ACE_INLINE void -CDR::swap_8 (const char *orig, char* target) +ACE_CDR::swap_8 (const char *orig, char* target) { target [7] = *orig++; target [6] = *orig++; @@ -33,7 +33,7 @@ CDR::swap_8 (const char *orig, char* target) } ACE_INLINE void -CDR::swap_16 (const char *orig, char* target) +ACE_CDR::swap_16 (const char *orig, char* target) { target [15] = *orig++; target [14] = *orig++; @@ -54,10 +54,10 @@ CDR::swap_16 (const char *orig, char* target) } ACE_INLINE void -CDR::mb_align (ACE_Message_Block *mb) +ACE_CDR::mb_align (ACE_Message_Block *mb) { char *start = ptr_align_binary (mb->base (), - CDR::MAX_ALIGNMENT); + ACE_CDR::MAX_ALIGNMENT); mb->rd_ptr (start); mb->wr_ptr (start); @@ -75,57 +75,57 @@ CDR::mb_align (ACE_Message_Block *mb) // implementing the special types ACE_INLINE -ACE_OutputCDR::from_boolean::from_boolean (CDR::Boolean b) +ACE_OutputCDR::from_boolean::from_boolean (ACE_CDR::Boolean b) : val_ (b) { } ACE_INLINE -ACE_InputCDR::to_boolean::to_boolean (CDR::Boolean &b) +ACE_InputCDR::to_boolean::to_boolean (ACE_CDR::Boolean &b) : ref_ (b) { } ACE_INLINE -ACE_OutputCDR::from_octet::from_octet (CDR::Octet o) +ACE_OutputCDR::from_octet::from_octet (ACE_CDR::Octet o) : val_ (o) { } ACE_INLINE -ACE_InputCDR::to_octet::to_octet (CDR::Octet &o) +ACE_InputCDR::to_octet::to_octet (ACE_CDR::Octet &o) : ref_ (o) { } ACE_INLINE -ACE_OutputCDR::from_char::from_char (CDR::Char c) +ACE_OutputCDR::from_char::from_char (ACE_CDR::Char c) : val_ (c) { } ACE_INLINE -ACE_InputCDR::to_char::to_char (CDR::Char &c) +ACE_InputCDR::to_char::to_char (ACE_CDR::Char &c) : ref_ (c) { } ACE_INLINE -ACE_OutputCDR::from_wchar::from_wchar (CDR::WChar wc) +ACE_OutputCDR::from_wchar::from_wchar (ACE_CDR::WChar wc) : val_ (wc) { } ACE_INLINE -ACE_InputCDR::to_wchar::to_wchar (CDR::WChar &wc) +ACE_InputCDR::to_wchar::to_wchar (ACE_CDR::WChar &wc) : ref_ (wc) { } ACE_INLINE -ACE_OutputCDR::from_string::from_string (CDR::Char *s, - CDR::ULong b, - CDR::Boolean nocopy) +ACE_OutputCDR::from_string::from_string (ACE_CDR::Char *s, + ACE_CDR::ULong b, + ACE_CDR::Boolean nocopy) : val_ (s), bound_ (b), nocopy_ (nocopy) @@ -133,8 +133,8 @@ ACE_OutputCDR::from_string::from_string (CDR::Char *s, } ACE_INLINE -ACE_InputCDR::to_string::to_string (CDR::Char *&s, - CDR::ULong b) +ACE_InputCDR::to_string::to_string (ACE_CDR::Char *&s, + ACE_CDR::ULong b) : val_ (s), bound_ (b) { @@ -144,224 +144,224 @@ ACE_InputCDR::to_string::to_string (CDR::Char *&s, // Decode the CDR stream. -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_octet (CDR::Octet x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_octet (ACE_CDR::Octet x) { - return this->write_1 (ACE_reinterpret_cast (const CDR::Octet*,&x)); + return this->write_1 (ACE_reinterpret_cast (const ACE_CDR::Octet*,&x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_boolean (CDR::Boolean x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_boolean (ACE_CDR::Boolean x) { return this->write_octet (x ? 1 : 0); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_char (CDR::Char x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_char (ACE_CDR::Char x) { - return this->write_1 (ACE_reinterpret_cast (const CDR::Octet*, &x)); + return this->write_1 (ACE_reinterpret_cast (const ACE_CDR::Octet*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_wchar (CDR::WChar x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_wchar (ACE_CDR::WChar x) { - return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*,&x)); + return this->write_2 (ACE_reinterpret_cast (const ACE_CDR::UShort*,&x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_short (CDR::Short x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_short (ACE_CDR::Short x) { - return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*, &x)); + return this->write_2 (ACE_reinterpret_cast (const ACE_CDR::UShort*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ushort (CDR::UShort x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ushort (ACE_CDR::UShort x) { - return this->write_2 (ACE_reinterpret_cast (const CDR::UShort*, &x)); + return this->write_2 (ACE_reinterpret_cast (const ACE_CDR::UShort*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_long (CDR::Long x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_long (ACE_CDR::Long x) { - return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x)); + return this->write_4 (ACE_reinterpret_cast (const ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ulong (CDR::ULong x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ulong (ACE_CDR::ULong x) { - return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x)); + return this->write_4 (ACE_reinterpret_cast (const ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_longlong (const CDR::LongLong &x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_longlong (const ACE_CDR::LongLong &x) { - return this->write_8 (ACE_reinterpret_cast (const CDR::ULongLong*, &x)); + return this->write_8 (ACE_reinterpret_cast (const ACE_CDR::ULongLong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ulonglong (const CDR::ULongLong &x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ulonglong (const ACE_CDR::ULongLong &x) { - return this->write_8 (ACE_reinterpret_cast (const CDR::ULongLong*,&x)); + return this->write_8 (ACE_reinterpret_cast (const ACE_CDR::ULongLong*,&x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_float (CDR::Float x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_float (ACE_CDR::Float x) { - return this->write_4 (ACE_reinterpret_cast (const CDR::ULong*, &x)); + return this->write_4 (ACE_reinterpret_cast (const ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_double (const CDR::Double &x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_double (const ACE_CDR::Double &x) { - return this->write_8 (ACE_reinterpret_cast (const CDR::ULongLong*, &x)); + return this->write_8 (ACE_reinterpret_cast (const ACE_CDR::ULongLong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_longdouble (const CDR::LongDouble &x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_longdouble (const ACE_CDR::LongDouble &x) { - return this->write_16 (ACE_reinterpret_cast (const CDR::LongDouble*,&x)); + return this->write_16 (ACE_reinterpret_cast (const ACE_CDR::LongDouble*,&x)); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_string (const CDR::Char *x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_string (const ACE_CDR::Char *x) { if (x != 0) return this->write_string (ACE_OS::strlen(x), x); return this->write_string (0, 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_string (const ACE_CString &x) { return this->write_string (x.length(), x.c_str()); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_wstring (const CDR::WChar *x) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_wstring (const ACE_CDR::WChar *x) { if (x != 0) return this->write_wstring (ACE_OS::wslen (x), x); return this->write_wstring (0, 0); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_char_array (const CDR::Char *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_char_array (const ACE_CDR::Char *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_wchar_array (const CDR::WChar* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_wchar_array (const ACE_CDR::WChar* x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_octet_array (const CDR::Octet* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_octet_array (const ACE_CDR::Octet* x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_short_array (const CDR::Short *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_short_array (const ACE_CDR::Short *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ushort_array (const CDR::UShort *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ushort_array (const ACE_CDR::UShort *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_long_array (const CDR::Long *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_long_array (const ACE_CDR::Long *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ulong_array (const CDR::ULong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ulong_array (const ACE_CDR::ULong *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_longlong_array (const CDR::LongLong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_longlong_array (const ACE_CDR::LongLong *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_ulonglong_array (const CDR::ULongLong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_float_array (const CDR::Float *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_float_array (const ACE_CDR::Float *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_double_array (const CDR::Double *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_double_array (const ACE_CDR::Double *x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_OutputCDR::write_longdouble_array (const CDR::LongDouble* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_OutputCDR::write_longdouble_array (const ACE_CDR::LongDouble* x, + ACE_CDR::ULong length) { return this->write_array (x, - CDR::LONGDOUBLE_SIZE, - CDR::LONGDOUBLE_ALIGN, + ACE_CDR::LONGDOUBLE_SIZE, + ACE_CDR::LONGDOUBLE_ALIGN, length); } @@ -429,7 +429,7 @@ ACE_INLINE int ACE_OutputCDR::align_write_ptr (size_t alignment) { char *buf = ptr_align_binary (this->current_->wr_ptr (), - alignment); + alignment); if (buf <= this->current_->end ()) { @@ -438,307 +438,307 @@ ACE_OutputCDR::align_write_ptr (size_t alignment) } return this->grow_and_adjust (0, alignment, buf); -} +} // **************************************************************** -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_octet (CDR::Octet& x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_octet (ACE_CDR::Octet& x) { return this->read_1 (&x); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_boolean (CDR::Boolean& x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_boolean (ACE_CDR::Boolean& x) { - CDR::Octet tmp; + ACE_CDR::Octet tmp; this->read_octet (tmp); x = tmp ? 1 : 0; return this->good_bit_; } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_char (CDR::Char &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_char (ACE_CDR::Char &x) { - return this->read_1 (ACE_reinterpret_cast (CDR::Octet*, &x)); + return this->read_1 (ACE_reinterpret_cast (ACE_CDR::Octet*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_wchar (CDR::WChar& x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_wchar (ACE_CDR::WChar& x) { - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*,&x)); + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*,&x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_short (CDR::Short &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_short (ACE_CDR::Short &x) { - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*, &x)); + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ushort (CDR::UShort &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ushort (ACE_CDR::UShort &x) { - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*, &x)); + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_long (CDR::Long &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_long (ACE_CDR::Long &x) { - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*, &x)); + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ulong (CDR::ULong &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ulong (ACE_CDR::ULong &x) { - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*, &x)); + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_longlong (CDR::LongLong &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_longlong (ACE_CDR::LongLong &x) { - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*, &x)); + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ulonglong (CDR::ULongLong &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ulonglong (ACE_CDR::ULongLong &x) { - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*,&x)); + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*,&x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_float (CDR::Float &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_float (ACE_CDR::Float &x) { - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*, &x)); + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_double (CDR::Double &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_double (ACE_CDR::Double &x) { - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*, &x)); + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*, &x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_longdouble (CDR::LongDouble &x) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_longdouble (ACE_CDR::LongDouble &x) { - return this->read_16 (ACE_reinterpret_cast (CDR::LongDouble*,&x)); + return this->read_16 (ACE_reinterpret_cast (ACE_CDR::LongDouble*,&x)); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_char_array (CDR::Char* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_char_array (ACE_CDR::Char* x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_wchar_array (CDR::WChar* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_wchar_array (ACE_CDR::WChar* x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_octet_array (CDR::Octet* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_octet_array (ACE_CDR::Octet* x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::OCTET_SIZE, - CDR::OCTET_ALIGN, + ACE_CDR::OCTET_SIZE, + ACE_CDR::OCTET_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_short_array (CDR::Short *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_short_array (ACE_CDR::Short *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ushort_array (CDR::UShort *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ushort_array (ACE_CDR::UShort *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::SHORT_SIZE, - CDR::SHORT_ALIGN, + ACE_CDR::SHORT_SIZE, + ACE_CDR::SHORT_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_long_array (CDR::Long *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_long_array (ACE_CDR::Long *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ulong_array (CDR::ULong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ulong_array (ACE_CDR::ULong *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_longlong_array (CDR::LongLong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_longlong_array (ACE_CDR::LongLong *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_ulonglong_array (CDR::ULongLong *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_ulonglong_array (ACE_CDR::ULongLong *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_float_array (CDR::Float *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_float_array (ACE_CDR::Float *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONG_SIZE, - CDR::LONG_ALIGN, + ACE_CDR::LONG_SIZE, + ACE_CDR::LONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_double_array (CDR::Double *x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_double_array (ACE_CDR::Double *x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONGLONG_SIZE, - CDR::LONGLONG_ALIGN, + ACE_CDR::LONGLONG_SIZE, + ACE_CDR::LONGLONG_ALIGN, length); } -ACE_INLINE CDR::Boolean -ACE_InputCDR::read_longdouble_array (CDR::LongDouble* x, - CDR::ULong length) +ACE_INLINE ACE_CDR::Boolean +ACE_InputCDR::read_longdouble_array (ACE_CDR::LongDouble* x, + ACE_CDR::ULong length) { return this->read_array (x, - CDR::LONGDOUBLE_SIZE, - CDR::LONGDOUBLE_ALIGN, + ACE_CDR::LONGDOUBLE_SIZE, + ACE_CDR::LONGDOUBLE_ALIGN, length); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_char (void) { - CDR::Char x; - return this->read_1 (ACE_reinterpret_cast (CDR::Octet*,&x)); + ACE_CDR::Char x; + return this->read_1 (ACE_reinterpret_cast (ACE_CDR::Octet*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_wchar (void) { - CDR::WChar x; - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*,&x)); + ACE_CDR::WChar x; + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_octet (void) { - CDR::Octet x; + ACE_CDR::Octet x; return this->read_1 (&x); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_boolean (void) { - CDR::Octet tmp; + ACE_CDR::Octet tmp; this->read_octet (tmp); return this->good_bit_; } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_short (void) { - CDR::Short x; - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*,&x)); + ACE_CDR::Short x; + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ushort (void) { - CDR::UShort x; - return this->read_2 (ACE_reinterpret_cast (CDR::UShort*,&x)); + ACE_CDR::UShort x; + return this->read_2 (ACE_reinterpret_cast (ACE_CDR::UShort*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_long (void) { - CDR::Long x; - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*,&x)); + ACE_CDR::Long x; + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ulong (void) { - CDR::ULong x; - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*,&x)); + ACE_CDR::ULong x; + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_longlong (void) { - CDR::LongLong x; - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*,&x)); + ACE_CDR::LongLong x; + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ulonglong (void) { - CDR::ULongLong x; - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*,&x)); + ACE_CDR::ULongLong x; + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_float (void) { float x; - return this->read_4 (ACE_reinterpret_cast (CDR::ULong*,&x)); + return this->read_4 (ACE_reinterpret_cast (ACE_CDR::ULong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_double (void) { double x; - return this->read_8 (ACE_reinterpret_cast (CDR::ULongLong*,&x)); + return this->read_8 (ACE_reinterpret_cast (ACE_CDR::ULongLong*,&x)); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_longdouble (void) { - CDR::LongDouble x; - return this->read_16 (ACE_reinterpret_cast (CDR::LongDouble*,&x)); + ACE_CDR::LongDouble x; + return this->read_16 (ACE_reinterpret_cast (ACE_CDR::LongDouble*,&x)); } ACE_INLINE char* @@ -778,7 +778,7 @@ ACE_InputCDR::adjust (size_t size, ACE_INLINE int ACE_InputCDR::adjust (size_t size, - char*& buf) + char*& buf) { return this->adjust (size, size, buf); } @@ -803,77 +803,77 @@ ACE_InputCDR::good_bit (void) const // **************************************************************** -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::Short x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::Short x) { os.write_short (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::UShort x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::UShort x) { os.write_ushort (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::Long x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::Long x) { os.write_long (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::ULong x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::ULong x) { os.write_ulong (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::LongLong x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::LongLong x) { os.write_longlong (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::ULongLong x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::ULongLong x) { os.write_ulonglong (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::LongDouble x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::LongDouble x) { os.write_longdouble (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::Float x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::Float x) { os.write_float (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, CDR::Double x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, ACE_CDR::Double x) { os.write_double (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean -operator<< (ACE_OutputCDR &os, const CDR::Char *x) +ACE_INLINE ACE_CDR::Boolean +operator<< (ACE_OutputCDR &os, const ACE_CDR::Char *x) { os.write_string (x); return os.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, const ACE_CString &x) { os.write_string (x); @@ -881,35 +881,35 @@ operator<< (ACE_OutputCDR &os, const ACE_CString &x) } // The following use the helper classes -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_boolean x) { os.write_boolean (x.val_); return os.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_char x) { os.write_char (x.val_); return os.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_wchar x) { os.write_wchar (x.val_); return os.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_octet x) { os.write_octet (x.val_); return os.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_string x) { os.write_string (x.bound_, x.val_); @@ -918,77 +918,77 @@ operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_string x) // **************************************************************** -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::Short &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::Short &x) { is.read_short (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::UShort &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::UShort &x) { is.read_ushort (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>>(ACE_InputCDR &is, CDR::Long &x) +ACE_INLINE ACE_CDR::Boolean +operator>>(ACE_InputCDR &is, ACE_CDR::Long &x) { is.read_long (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::ULong &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::ULong &x) { is.read_ulong (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR& is, CDR::LongLong &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR& is, ACE_CDR::LongLong &x) { is.read_longlong (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR& is, CDR::ULongLong &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR& is, ACE_CDR::ULongLong &x) { is.read_ulonglong (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR& is, CDR::LongDouble &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR& is, ACE_CDR::LongDouble &x) { is.read_longdouble (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::Float &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::Float &x) { is.read_float (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::Double &x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::Double &x) { is.read_double (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean -operator>> (ACE_InputCDR &is, CDR::Char *&x) +ACE_INLINE ACE_CDR::Boolean +operator>> (ACE_InputCDR &is, ACE_CDR::Char *&x) { is.read_string (x); return is.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_CString &x) { is.read_string (x); @@ -996,35 +996,35 @@ operator>> (ACE_InputCDR &is, ACE_CString &x) } // The following use the helper classes -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_InputCDR::to_boolean x) { is.read_boolean (x.ref_); return is.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_InputCDR::to_char x) { is.read_char (x.ref_); return is.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_InputCDR::to_wchar x) { is.read_wchar (x.ref_); return is.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_InputCDR::to_octet x) { is.read_octet (x.ref_); return is.good_bit (); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean operator>> (ACE_InputCDR &is, ACE_InputCDR::to_string x) { is.read_string (x.val_); @@ -1038,112 +1038,112 @@ operator>> (ACE_InputCDR &is, ACE_InputCDR::to_string x) // methods of the ACE_InputCDR class // *************************************************************************** -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_boolean (ACE_InputCDR &stream) { - CDR::Boolean x; + ACE_CDR::Boolean x; return (stream.read_boolean (x) ? this->write_boolean (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_char (ACE_InputCDR &stream) { - CDR::Char x; + ACE_CDR::Char x; return (stream.read_char (x) ? this->write_char (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_wchar (ACE_InputCDR &stream) { - CDR::WChar x; + ACE_CDR::WChar x; return (stream.read_wchar (x) ? this->write_wchar (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_octet (ACE_InputCDR &stream) { - CDR::Octet x; + ACE_CDR::Octet x; return (stream.read_octet (x) ? this->write_octet (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_short (ACE_InputCDR &stream) { - CDR::Short x; + ACE_CDR::Short x; return (stream.read_short (x) ? this->write_short (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ushort (ACE_InputCDR &stream) { - CDR::UShort x; + ACE_CDR::UShort x; return (stream.read_ushort (x) ? this->write_ushort (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_long (ACE_InputCDR &stream) { - CDR::Long x; + ACE_CDR::Long x; return (stream.read_long (x) ? this->write_long (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ulong (ACE_InputCDR &stream) { - CDR::ULong x; + ACE_CDR::ULong x; return (stream.read_ulong (x) ? this->write_ulong (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_longlong (ACE_InputCDR &stream) { - CDR::LongLong x; + ACE_CDR::LongLong x; return (stream.read_longlong (x) ? this->write_longlong (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ulonglong (ACE_InputCDR &stream) { - CDR::ULongLong x; + ACE_CDR::ULongLong x; return (stream.read_ulonglong (x) ? this->write_ulonglong (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_float (ACE_InputCDR &stream) { - CDR::Float x; + ACE_CDR::Float x; return (stream.read_float (x) ? this->write_float (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_double (ACE_InputCDR &stream) { - CDR::Double x; + ACE_CDR::Double x; return (stream.read_double (x) ? this->write_double (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_longdouble (ACE_InputCDR &stream) { - CDR::LongDouble x; + ACE_CDR::LongDouble x; return (stream.read_longdouble (x) ? this->write_longdouble (x) : 0); } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_string (ACE_InputCDR &stream) { - CDR::Char *x; - CDR::Boolean flag = + ACE_CDR::Char *x; + ACE_CDR::Boolean flag = (stream.read_string (x) ? this->write_string (x) : 0); delete [] x; return flag; } -ACE_INLINE CDR::Boolean +ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_wstring (ACE_InputCDR &stream) { - CDR::WChar *x; - CDR::Boolean flag = + ACE_CDR::WChar *x; + ACE_CDR::Boolean flag = (stream.read_wstring (x) ? this->write_wstring (x) : 0); delete [] x; return flag; @@ -1170,4 +1170,3 @@ ACE_InputCDR::align_read_ptr (size_t alignment) this->good_bit_ = 0; return -1; } - |