---

ACE_CDR Class Reference

Keep constants and some routines common to both Output and Input CDR streams. More...

#include <CDR_Base.h>

List of all members.

Public Types
typedef u_char	Boolean
typedef u_char	Octet
typedef char	Char
typedef ACE_OS::WChar	WChar
typedef ACE_INT16	Short
typedef ACE_UINT16	UShort
typedef ACE_INT32	Long
typedef ACE_UINT32	ULong
typedef ACE_UINT64	ULongLong
typedef long long	LongLong
enum	{   OCTET_SIZE = 1, SHORT_SIZE = 2, LONG_SIZE = 4, LONGLONG_SIZE = 8,   LONGDOUBLE_SIZE = 16, OCTET_ALIGN = 1, SHORT_ALIGN = 2, LONG_ALIGN = 4,   LONGLONG_ALIGN = 8, LONGDOUBLE_ALIGN = 8, MAX_ALIGNMENT = 8, DEFAULT_BUFSIZE = ACE_DEFAULT_CDR_BUFSIZE,   EXP_GROWTH_MAX = ACE_DEFAULT_CDR_EXP_GROWTH_MAX, LINEAR_GROWTH_CHUNK = ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK }
Static Public Methods
void	swap_2 (const char *orig, char *target)
void	swap_4 (const char *orig, char *target)
void	swap_8 (const char *orig, char *target)
void	swap_16 (const char *orig, char *target)
void	swap_2_array (const char *orig, char *target, size_t length)
void	swap_4_array (const char *orig, char *target, size_t length)
void	swap_8_array (const char *orig, char *target, size_t length)
void	swap_16_array (const char *orig, char *target, size_t length)
void	mb_align (ACE_Message_Block *mb)
	Align the message block to ACE_CDR::MAX_ALIGNMENT, set by the CORBA spec at 8 bytes. More...
size_t	first_size (size_t minsize)
size_t	next_size (size_t minsize)
	Compute not the smallest, but the second smallest buffer that will fir <minsize> bytes. More...
int	grow (ACE_Message_Block *mb, size_t minsize)
void	consolidate (ACE_Message_Block *dst, const ACE_Message_Block *src)
	Copy a message block chain into a single message block, preserving the alignment of the first message block of the original stream, not the following message blocks. More...
size_t	total_length (const ACE_Message_Block *begin, const ACE_Message_Block *end)

---

Detailed Description

Keep constants and some routines common to both Output and Input CDR streams.

Definition at line 48 of file CDR_Base.h.

---

Member Typedef Documentation

typedef u_char ACE_CDR::Boolean

Definition at line 166 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_boolean, ACE_OutputCDR::append_string, ACE_OutputCDR::append_wstring, ACE_OutputCDR::from_boolean::from_boolean, ACE_OutputCDR::from_string::from_string, ACE_OutputCDR::from_wstring::from_wstring, operator<<, operator>>, ACE_InputCDR::read_boolean, ACE_InputCDR::read_boolean_array, ACE_InputCDR::skip_wstring, ACE_InputCDR::to_boolean::to_boolean, ACE_OutputCDR::write_boolean, and ACE_OutputCDR::write_boolean_array.

typedef char ACE_CDR::Char

Definition at line 170 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_char, ACE_OutputCDR::append_string, ACE_OutputCDR::from_char::from_char, ACE_OutputCDR::from_string::from_string, operator<<, operator>>, ACE_InputCDR::read_char, ACE_InputCDR::read_char_array, ACE_InputCDR::read_string, ACE_InputCDR::skip_char, ACE_InputCDR::to_char::to_char, ACE_InputCDR::to_string::to_string, ACE_OutputCDR::write_char, ACE_OutputCDR::write_char_array, and ACE_OutputCDR::write_string.

typedef ACE_INT32 ACE_CDR::Long

Definition at line 174 of file CDR_Base.h. Referenced by ACE_InputCDR::ACE_InputCDR, ACE_OutputCDR::append_long, operator<<, operator>>, ACE_InputCDR::read_long, ACE_InputCDR::read_long_array, ACE_InputCDR::skip_long, ACE_OutputCDR::write_long, and ACE_OutputCDR::write_long_array.

typedef long long ACE_CDR::LongLong

Definition at line 191 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_longlong, operator<<, operator>>, ACE_InputCDR::read_longlong, ACE_InputCDR::read_longlong_array, ACE_InputCDR::skip_longlong, ACE_OutputCDR::write_longlong, and ACE_OutputCDR::write_longlong_array.

typedef u_char ACE_CDR::Octet

Definition at line 169 of file CDR_Base.h. Referenced by ACE_InputCDR::ACE_InputCDR, ACE_OutputCDR::ACE_OutputCDR, ACE_OutputCDR::append_octet, ACE_InputCDR::exchange_data_blocks, ACE_OutputCDR::from_octet::from_octet, ACE_InputCDR::get_version, ACE_OutputCDR::get_version, operator<<, ACE_WChar_Codeset_Translator::read_1, ACE_Char_Codeset_Translator::read_1, ACE_InputCDR::read_1, ACE_InputCDR::read_boolean, ACE_InputCDR::read_char, ACE_InputCDR::read_octet, ACE_InputCDR::read_octet_array, ACE_InputCDR::read_wchar, ACE_InputCDR::read_wchar_array_i, ACE_InputCDR::set_version, ACE_OutputCDR::set_version, ACE_InputCDR::skip_boolean, ACE_InputCDR::skip_char, ACE_InputCDR::skip_octet, ACE_InputCDR::skip_wchar, ACE_InputCDR::to_octet::to_octet, ACE_WChar_Codeset_Translator::write_1, ACE_Char_Codeset_Translator::write_1, ACE_OutputCDR::write_1, ACE_OutputCDR::write_boolean, ACE_OutputCDR::write_char, ACE_OutputCDR::write_octet, ACE_OutputCDR::write_octet_array, ACE_OutputCDR::write_wchar, and ACE_OutputCDR::write_wchar_array_i.

typedef ACE_INT16 ACE_CDR::Short

Definition at line 172 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_short, operator<<, operator>>, ACE_InputCDR::read_short, ACE_InputCDR::read_short_array, ACE_InputCDR::read_wchar, ACE_InputCDR::read_wstring, ACE_InputCDR::skip_short, ACE_InputCDR::skip_wchar, ACE_InputCDR::skip_wstring, ACE_OutputCDR::write_short, ACE_OutputCDR::write_short_array, ACE_OutputCDR::write_wchar, and ACE_OutputCDR::write_wstring.

typedef ACE_UINT32 ACE_CDR::ULong

Definition at line 175 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_ulong, ACE_OutputCDR::from_string::from_string, ACE_OutputCDR::from_wstring::from_wstring, ACE_Codeset_Registry::get_max_bytes, ACE_Codeset_Registry::get_max_bytes_i, ACE_Codeset_Registry::is_compatible, ACE_Codeset_Registry::is_compatible_i, ACE_Codeset_Registry::locale_to_registry, ACE_Codeset_Registry::locale_to_registry_i, operator<<, operator>>, ACE_WChar_Codeset_Translator::read_4, ACE_InputCDR::read_4, ACE_WChar_Codeset_Translator::read_array, ACE_Char_Codeset_Translator::read_array, ACE_InputCDR::read_array, ACE_InputCDR::read_boolean_array, ACE_InputCDR::read_char_array, ACE_InputCDR::read_double_array, ACE_InputCDR::read_float, ACE_InputCDR::read_float_array, ACE_InputCDR::read_long, ACE_InputCDR::read_long_array, ACE_InputCDR::read_longdouble_array, ACE_InputCDR::read_longlong_array, ACE_InputCDR::read_octet_array, ACE_InputCDR::read_short_array, ACE_InputCDR::read_string, ACE_InputCDR::read_ulong, ACE_InputCDR::read_ulong_array, ACE_InputCDR::read_ulonglong_array, ACE_InputCDR::read_ushort_array, ACE_InputCDR::read_wchar, ACE_InputCDR::read_wchar_array, ACE_InputCDR::read_wchar_array_i, ACE_InputCDR::read_wstring, ACE_Codeset_Registry::registry_to_locale, ACE_Codeset_Registry::registry_to_locale_i, ACE_InputCDR::skip_float, ACE_InputCDR::skip_long, ACE_InputCDR::skip_string, ACE_InputCDR::skip_ulong, ACE_InputCDR::skip_wchar, ACE_InputCDR::skip_wstring, ACE_InputCDR::to_string::to_string, ACE_InputCDR::to_wstring::to_wstring, ACE_WChar_Codeset_Translator::write_4, ACE_OutputCDR::write_4, ACE_WChar_Codeset_Translator::write_array, ACE_Char_Codeset_Translator::write_array, ACE_OutputCDR::write_array, ACE_OutputCDR::write_boolean_array, ACE_OutputCDR::write_char_array, ACE_OutputCDR::write_double_array, ACE_OutputCDR::write_float, ACE_OutputCDR::write_float_array, ACE_OutputCDR::write_long, ACE_OutputCDR::write_long_array, ACE_OutputCDR::write_longdouble_array, ACE_OutputCDR::write_longlong_array, ACE_OutputCDR::write_octet_array, ACE_OutputCDR::write_octet_array_mb, ACE_OutputCDR::write_short_array, ACE_OutputCDR::write_string, ACE_OutputCDR::write_ulong, ACE_OutputCDR::write_ulong_array, ACE_OutputCDR::write_ulonglong_array, ACE_OutputCDR::write_ushort_array, ACE_OutputCDR::write_wchar, ACE_OutputCDR::write_wchar_array, ACE_OutputCDR::write_wchar_array_i, and ACE_OutputCDR::write_wstring.

typedef ACE_UINT64 ACE_CDR::ULongLong

Definition at line 176 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_ulonglong, operator<<, operator>>, ACE_InputCDR::read_8, ACE_InputCDR::read_double, ACE_InputCDR::read_longlong, ACE_InputCDR::read_ulonglong, ACE_InputCDR::read_ulonglong_array, ACE_InputCDR::skip_double, ACE_InputCDR::skip_longlong, ACE_InputCDR::skip_ulonglong, ACE_OutputCDR::write_8, ACE_OutputCDR::write_double, ACE_OutputCDR::write_longlong, ACE_OutputCDR::write_ulonglong, and ACE_OutputCDR::write_ulonglong_array.

typedef ACE_UINT16 ACE_CDR::UShort

Definition at line 173 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_ushort, ACE_Codeset_Registry::is_compatible_i, ACE_Codeset_Registry::locale_to_registry, ACE_Codeset_Registry::locale_to_registry_i, operator<<, operator>>, ACE_WChar_Codeset_Translator::read_2, ACE_InputCDR::read_2, ACE_InputCDR::read_short, ACE_InputCDR::read_ushort, ACE_InputCDR::read_ushort_array, ACE_InputCDR::read_wchar, ACE_InputCDR::read_wchar_array_i, ACE_Codeset_Registry::registry_to_locale, ACE_Codeset_Registry::registry_to_locale_i, ACE_InputCDR::skip_short, ACE_InputCDR::skip_ushort, ACE_InputCDR::skip_wchar, ACE_WChar_Codeset_Translator::write_2, ACE_OutputCDR::write_2, ACE_OutputCDR::write_short, ACE_OutputCDR::write_ushort, ACE_OutputCDR::write_ushort_array, ACE_OutputCDR::write_wchar, and ACE_OutputCDR::write_wchar_array_i.

typedef ACE_OS::WChar ACE_CDR::WChar

Definition at line 171 of file CDR_Base.h. Referenced by ACE_OutputCDR::append_wchar, ACE_OutputCDR::append_wstring, ACE_OutputCDR::from_wchar::from_wchar, ACE_OutputCDR::from_wstring::from_wstring, operator<<, operator>>, ACE_InputCDR::read_wchar, ACE_InputCDR::read_wchar_array, ACE_InputCDR::read_wchar_array_i, ACE_InputCDR::read_wstring, ACE_InputCDR::skip_wchar, ACE_InputCDR::to_wchar::to_wchar, ACE_InputCDR::to_wstring::to_wstring, ACE_OutputCDR::write_wchar, ACE_OutputCDR::write_wchar_array, ACE_OutputCDR::write_wchar_array_i, and ACE_OutputCDR::write_wstring.

---

Member Enumeration Documentation

anonymous enum

Enumeration values: OCTET_SIZE  SHORT_SIZE  LONG_SIZE  LONGLONG_SIZE  LONGDOUBLE_SIZE  OCTET_ALIGN  SHORT_ALIGN  LONG_ALIGN  LONGLONG_ALIGN  LONGDOUBLE_ALIGN  Note: the CORBA LongDouble alignment requirements do not match its size... MAX_ALIGNMENT  Maximal CDR 1.1 alignment: "quad precision" FP (i.e. "CDR::Long double", size as above). DEFAULT_BUFSIZE  The default buffer size. Todo: We want to add options to control this default value, so this constant should be read as the default default value ;-) EXP_GROWTH_MAX  The buffer size grows exponentially until it reaches this size; afterwards it grows linearly using the next constant. LINEAR_GROWTH_CHUNK  Once exponential growth is ruled out the buffer size increases in chunks of this size, note that this constants have the same value right now, but it does not need to be so. Definition at line 56 of file CDR_Base.h. { // Note that some of these get reused as part of the standard // binary format: unsigned is the same size as its signed cousin, // float is LONG_SIZE, and double is LONGLONG_SIZE. OCTET_SIZE = 1, SHORT_SIZE = 2, LONG_SIZE = 4, LONGLONG_SIZE = 8, LONGDOUBLE_SIZE = 16, OCTET_ALIGN = 1, SHORT_ALIGN = 2, LONG_ALIGN = 4, LONGLONG_ALIGN = 8, /// @note the CORBA LongDouble alignment requirements do not /// match its size... LONGDOUBLE_ALIGN = 8, /// Maximal CDR 1.1 alignment: "quad precision" FP (i.e. "CDR::Long /// double", size as above). MAX_ALIGNMENT = 8, /// The default buffer size. /** * @todo We want to add options to control this * default value, so this constant should be read as the default * default value ;-) */ DEFAULT_BUFSIZE = ACE_DEFAULT_CDR_BUFSIZE, /// The buffer size grows exponentially until it reaches this size; /// afterwards it grows linearly using the next constant EXP_GROWTH_MAX = ACE_DEFAULT_CDR_EXP_GROWTH_MAX, /// Once exponential growth is ruled out the buffer size increases /// in chunks of this size, note that this constants have the same /// value right now, but it does not need to be so. LINEAR_GROWTH_CHUNK = ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK };

---

Member Function Documentation

void ACE_CDR::consolidate (  ACE_Message_Block *    dst, const ACE_Message_Block *    src )  [static]

Copy a message block chain into a single message block, preserving the alignment of the first message block of the original stream, not the following message blocks. Definition at line 506 of file CDR_Base.cpp. References ACE_Message_Block::cont, ACE_Message_Block::copy, first_size, ACE_Message_Block::length, MAX_ALIGNMENT, ACE_Message_Block::rd_ptr, ACE_Message_Block::size, total_length, and ACE_Message_Block::wr_ptr. Referenced by ACE_InputCDR::reset. { if (src == 0) return; size_t newsize = ACE_CDR::first_size (ACE_CDR::total_length (src, 0) + ACE_CDR::MAX_ALIGNMENT); dst->size (newsize); // We must copy the contents of <src> into the new buffer, but // respecting the alignment. ptrdiff_t srcalign = ptrdiff_t(src->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; ptrdiff_t dstalign = ptrdiff_t(dst->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; int offset = srcalign - dstalign; if (offset < 0) offset += ACE_CDR::MAX_ALIGNMENT; dst->rd_ptr (offset); dst->wr_ptr (dst->rd_ptr ()); for (const ACE_Message_Block* i = src; i != 0; i = i->cont ()) { dst->copy (i->rd_ptr (), i->length ()); } }

ACE_INLINE size_t ACE_CDR::first_size (  size_t    minsize )  [static]

Compute the size of the smallest buffer that can contain at least <minsize> bytes. To understand how a "best fit" is computed look at the algorithm in the code. Basically the buffers grow exponentially, up to a certain point, then the buffer size grows linearly. The advantage of this algorithm is that is rapidly grows to a large value, but does not explode at the end. Definition at line 162 of file CDR_Base.inl. References DEFAULT_BUFSIZE, EXP_GROWTH_MAX, and LINEAR_GROWTH_CHUNK. Referenced by consolidate, grow, and next_size. { if (minsize == 0) return ACE_CDR::DEFAULT_BUFSIZE; size_t newsize = ACE_CDR::DEFAULT_BUFSIZE; while (newsize < minsize) { if (newsize < ACE_CDR::EXP_GROWTH_MAX) { // We grow exponentially at the beginning, this is fast and // reduces the number of allocations. newsize *= 2; } else { // but continuing with exponential growth can result in over // allocations and easily yield an allocation failure. // So we grow linearly when the buffer is too big. newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; } } return newsize; }

int ACE_CDR::grow (  ACE_Message_Block *    mb, size_t    minsize )  [static]

Increase the capacity of mb to contain at least <minsize> bytes. If <minsize> is zero the size is increased by an amount at least large enough to contain any of the basic IDL types. Return -1 on failure, 0 on success. Definition at line 464 of file CDR_Base.cpp. References ACE_Data_Block::clone_nocopy, ACE_Message_Block::clr_self_flags, ACE_Message_Block::copy, ACE_Message_Block::data_block, ACE_Message_Block::DONT_DELETE, ACE_Data_Block::duplicate, first_size, ACE_Message_Block::length, MAX_ALIGNMENT, mb_align, ACE_Message_Block::rd_ptr, ACE_Data_Block::size, ACE_Message_Block::size, and ACE_Message_Block::wr_ptr. Referenced by ACE_InputCDR::grow. { size_t newsize = ACE_CDR::first_size (minsize + ACE_CDR::MAX_ALIGNMENT); if (newsize <= mb->size ()) return 0; ACE_Data_Block *db = mb->data_block ()->clone_nocopy (); if (db->size (newsize) == -1) return -1; ACE_Message_Block tmp (db); ACE_CDR::mb_align (&tmp); tmp.copy (mb->rd_ptr (), mb->length()); mb->data_block (tmp.data_block ()->duplicate ()); mb->rd_ptr (tmp.rd_ptr ()); mb->wr_ptr (tmp.wr_ptr ()); // Remove the DONT_DELETE flags from mb mb->clr_self_flags (ACE_Message_Block::DONT_DELETE); return 0; }

ACE_INLINE void ACE_CDR::mb_align (  ACE_Message_Block *    mb )  [static]

Align the message block to ACE_CDR::MAX_ALIGNMENT, set by the CORBA spec at 8 bytes. Definition at line 153 of file CDR_Base.inl. References ACE_ptr_align_binary, ACE_Message_Block::base, MAX_ALIGNMENT, ACE_Message_Block::rd_ptr, and ACE_Message_Block::wr_ptr. Referenced by ACE_InputCDR::ACE_InputCDR, ACE_OutputCDR::ACE_OutputCDR, ACE_InputCDR::clone_from, ACE_InputCDR::grow, grow, ACE_OutputCDR::reset, and ACE_InputCDR::steal_contents. { char *start = ACE_ptr_align_binary (mb->base (), ACE_CDR::MAX_ALIGNMENT); mb->rd_ptr (start); mb->wr_ptr (start); }

ACE_INLINE size_t ACE_CDR::next_size (  size_t    minsize )  [static]

Compute not the smallest, but the second smallest buffer that will fir <minsize> bytes. Definition at line 188 of file CDR_Base.inl. References EXP_GROWTH_MAX, first_size, and LINEAR_GROWTH_CHUNK. Referenced by ACE_OutputCDR::grow_and_adjust. { size_t newsize = ACE_CDR::first_size (minsize); if (newsize == minsize) { // If necessary increment the size if (newsize < ACE_CDR::EXP_GROWTH_MAX) newsize *= 2; else newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; } return newsize; }

ACE_INLINE void ACE_CDR::swap_16 (  const char *    orig, char *    target )  [static]

Definition at line 146 of file CDR_Base.inl. References swap_8. Referenced by ACE_InputCDR::read_16, swap_16_array, and ACE_OutputCDR::write_16. { swap_8 (orig + 8, target); swap_8 (orig, target + 8); }

void ACE_CDR::swap_16_array (  const char *    orig, char *    target, size_t    length )  [static]

Definition at line 450 of file CDR_Base.cpp. References swap_16. Referenced by ACE_InputCDR::read_array, and ACE_OutputCDR::write_array. { // ACE_ASSERT(n > 0); The caller checks that n > 0 const char* const end = orig + 16*n; while (orig < end) { swap_16(orig, target); orig += 16; target += 16; } }

ACE_INLINE void ACE_CDR::swap_2 (  const char *    orig, char *    target )  [static]

Do byte swapping for each basic IDL type size. There exist only routines to put byte, halfword (2 bytes), word (4 bytes), doubleword (8 bytes) and quadword (16 byte); because those are the IDL basic type sizes. Definition at line 48 of file CDR_Base.inl. Referenced by ACE_InputCDR::read_2, ACE_InputCDR::read_wchar_array_i, swap_2_array, ACE_OutputCDR::write_2, and ACE_OutputCDR::write_wchar_array_i. { #if defined(ACE_HAS_PENTIUM) # if defined(__GNUG__) unsigned short a = *ACE_reinterpret_cast(const unsigned short*, orig); asm( "rolw $8, %0" : "=r" (a) : "0" (a) ); *ACE_reinterpret_cast(unsigned short*, target) = a; # elif (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov ebx, orig; __asm mov ecx, target; __asm mov ax, [ebx]; __asm rol ax, 8; __asm mov [ecx], ax; # else // For CISC Platforms this is faster than shift/masks. target[1] = orig[0]; target[0] = orig[1]; # endif #else register ACE_UINT16 usrc = * ACE_reinterpret_cast(const ACE_UINT16*, orig); register ACE_UINT16* udst = ACE_reinterpret_cast(ACE_UINT16*, target); *udst = (usrc << 8) | (usrc >> 8); #endif /* ACE_HAS_PENTIUM */ }

void ACE_CDR::swap_2_array (  const char *    orig, char *    target, size_t    length )  [static]

Definition at line 21 of file CDR_Base.cpp. References ACE_ptr_align_binary, and swap_2. Referenced by ACE_InputCDR::read_array, and ACE_OutputCDR::write_array. { // ACE_ASSERT(n > 0); The caller checks that n > 0 // Later, we try to read in 32 or 64 bit chunks, // so make sure we don't do that for unaligned addresses. #if ACE_SIZEOF_LONG == 8 const char* const o8 = ACE_ptr_align_binary(orig, 8); while (orig < o8 && n > 0) { ACE_CDR::swap_2 (orig, target); orig += 2; target += 2; --n; } #else const char* const o4 = ACE_ptr_align_binary(orig, 4); // this is an _if_, not a _while_. The mistmatch can only be by 2. if (orig != o4) { ACE_CDR::swap_2 (orig, target); orig += 2; target += 2; --n; } #endif if (n == 0) return; // // Loop unrolling. Here be dragons. // // (n & (~3)) is the greatest multiple of 4 not bigger than n. // In the while loop ahead, orig will move over the array by 8 byte // increments (4 elements of 2 bytes). // end marks our barrier for not falling outside. const char* const end = orig + 2*(n & (~3)); // See if we're aligned for writting in 64 or 32 bit chunks... #if ACE_SIZEOF_LONG == 8 if (target == ACE_ptr_align_binary(target, 8)) #else if (target == ACE_ptr_align_binary(target, 4)) #endif { while (orig < end) { #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__) unsigned int a = * ACE_reinterpret_cast(const unsigned int*, orig); unsigned int b = * ACE_reinterpret_cast(const unsigned int*, orig + 4); asm( "bswap %1" : "=r" (a) : "0" (a) ); asm( "bswap %1" : "=r" (b) : "0" (b) ); asm( "rol $16, %1" : "=r" (a) : "0" (a) ); asm( "rol $16, %1" : "=r" (b) : "0" (b) ); * ACE_reinterpret_cast(unsigned int*, target) = a; * ACE_reinterpret_cast(unsigned int*, target + 4) = b; #elif defined(ACE_HAS_PENTIUM) \ && (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov ecx, orig; __asm mov edx, target; __asm mov eax, [ecx]; __asm mov ebx, 4[ecx]; __asm bswap eax; __asm bswap ebx; __asm rol eax, 16; __asm rol ebx, 16; __asm mov [edx], eax; __asm mov 4[edx], ebx; #elif ACE_SIZEOF_LONG == 8 // 64 bit architecture. register unsigned long a = * ACE_reinterpret_cast(const unsigned long*, orig); register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8; register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8; a = (a1 | a2); * ACE_reinterpret_cast(unsigned long*, target) = a; #else register ACE_UINT32 a = * ACE_reinterpret_cast(const ACE_UINT32*, orig); register ACE_UINT32 b = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4); register ACE_UINT32 a1 = (a & 0x00ff00ffU) << 8; register ACE_UINT32 b1 = (b & 0x00ff00ffU) << 8; register ACE_UINT32 a2 = (a & 0xff00ff00U) >> 8; register ACE_UINT32 b2 = (b & 0xff00ff00U) >> 8; a = (a1 | a2); b = (b1 | b2); * ACE_reinterpret_cast(ACE_UINT32*, target) = a; * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b; #endif orig += 8; target += 8; } } else { // We're out of luck. We have to write in 2 byte chunks. while (orig < end) { #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__) unsigned int a = * ACE_reinterpret_cast(const unsigned int*, orig); unsigned int b = * ACE_reinterpret_cast(const unsigned int*, orig + 4); asm( "bswap %1" : "=r" (a) : "0" (a) ); asm( "bswap %1" : "=r" (b) : "0" (b) ); // We're little endian. * ACE_reinterpret_cast(unsigned short*, target + 2) = (unsigned short) (a & 0xffff); * ACE_reinterpret_cast(unsigned short*, target + 6) = (unsigned short) (b & 0xffff); asm( "shrl $16, %1" : "=r" (a) : "0" (a) ); asm( "shrl $16, %1" : "=r" (b) : "0" (b) ); * ACE_reinterpret_cast(unsigned short*, target + 0) = (unsigned short) (a & 0xffff); * ACE_reinterpret_cast(unsigned short*, target + 4) = (unsigned short) (b & 0xffff); #elif defined(ACE_HAS_PENTIUM) \ && (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov ecx, orig; __asm mov edx, target; __asm mov eax, [ecx]; __asm mov ebx, 4[ecx]; __asm bswap eax; __asm bswap ebx; // We're little endian. __asm mov 2[edx], ax; __asm mov 6[edx], bx; __asm shr eax, 16; __asm shr ebx, 16; __asm mov 0[edx], ax; __asm mov 4[edx], bx; #elif ACE_SIZEOF_LONG == 8 // 64 bit architecture. register unsigned long a = * ACE_reinterpret_cast(const unsigned long*, orig); register unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8; register unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8; a = (a1 | a2); ACE_UINT16 b1 = ACE_static_cast(ACE_UINT16, (a >> 48)); ACE_UINT16 b2 = ACE_static_cast(ACE_UINT16, ((a >> 32) & 0xffff)); ACE_UINT16 b3 = ACE_static_cast(ACE_UINT16, ((a >> 16) & 0xffff)); ACE_UINT16 b4 = ACE_static_cast(ACE_UINT16, (a & 0xffff)); #if defined(ACE_LITTLE_ENDIAN) * ACE_reinterpret_cast(ACE_UINT16*, target) = b4; * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b3; * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b2; * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b1; #else * ACE_reinterpret_cast(ACE_UINT16*, target) = b1; * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = b2; * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = b3; * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = b4; #endif #else register ACE_UINT32 a = * ACE_reinterpret_cast(const ACE_UINT32*, orig); register ACE_UINT32 b = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4); register ACE_UINT32 a1 = (a & 0x00ff00ff) << 8; register ACE_UINT32 b1 = (b & 0x00ff00ff) << 8; register ACE_UINT32 a2 = (a & 0xff00ff00) >> 8; register ACE_UINT32 b2 = (b & 0xff00ff00) >> 8; a = (a1 | a2); b = (b1 | b2); ACE_UINT32 c1 = ACE_static_cast(ACE_UINT16, (a >> 16)); ACE_UINT32 c2 = ACE_static_cast(ACE_UINT16, (a & 0xffff)); ACE_UINT32 c3 = ACE_static_cast(ACE_UINT16, (b >> 16)); ACE_UINT32 c4 = ACE_static_cast(ACE_UINT16, (b & 0xffff)); #if defined(ACE_LITTLE_ENDIAN) * ACE_reinterpret_cast(ACE_UINT16*, target) = c2; * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c1; * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c4; * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c3; #else * ACE_reinterpret_cast(ACE_UINT16*, target) = c1; * ACE_reinterpret_cast(ACE_UINT16*, target + 2) = c2; * ACE_reinterpret_cast(ACE_UINT16*, target + 4) = c3; * ACE_reinterpret_cast(ACE_UINT16*, target + 6) = c4; #endif #endif orig += 8; target += 8; } } // (n & 3) == (n % 4). switch (n&3) { case 3: ACE_CDR::swap_2 (orig, target); orig += 2; target += 2; case 2: ACE_CDR::swap_2 (orig, target); orig += 2; target += 2; case 1: ACE_CDR::swap_2 (orig, target); } }

ACE_INLINE void ACE_CDR::swap_4 (  const char *    orig, char *    target )  [static]

Definition at line 76 of file CDR_Base.inl. Referenced by ACE_InputCDR::read_4, swap_4_array, and ACE_OutputCDR::write_4. { #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__) // We have ACE_HAS_PENTIUM, so we know the sizeof's. register unsigned int j = *ACE_reinterpret_cast(const unsigned int*, orig); asm ("bswap %1" : "=r" (j) : "0" (j)); *ACE_reinterpret_cast(unsigned int*, target) = j; #elif defined(ACE_HAS_PENTIUM) \ && (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov ebx, orig; __asm mov ecx, target; __asm mov eax, [ebx]; __asm bswap eax; __asm mov [ecx], eax; #else register ACE_UINT32 x = * ACE_reinterpret_cast(const ACE_UINT32*, orig); x = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24); * ACE_reinterpret_cast(ACE_UINT32*, target) = x; #endif }

void ACE_CDR::swap_4_array (  const char *    orig, char *    target, size_t    length )  [static]

Definition at line 243 of file CDR_Base.cpp. References ACE_ptr_align_binary, and swap_4. Referenced by ACE_InputCDR::read_array, and ACE_OutputCDR::write_array. { // ACE_ASSERT(n > 0); The caller checks that n > 0 #if ACE_LONG_SIZE == 8 // Later, we read from *orig in 64 bit chunks, // so make sure we don't generate unaligned readings. const char* const o8 = ACE_ptr_align_binary(orig, 8); // The mistmatch can only be by 4. if (orig != o8) { ACE_CDR::swap_4 (orig, target); orig += 4; target += 4; --n; } #endif if (n == 0) return; // // Loop unrolling. Here be dragons. // // (n & (~3)) is the greatest multiple of 4 not bigger than n. // In the while loop, orig will move over the array by 16 byte // increments (4 elements of 4 bytes). // ends marks our barrier for not falling outside. const char* const end = orig + 4*(n & (~3)); #if ACE_LONG_SIZE == 8 // 64 bits architecture. // See if we can write in 8 byte chunks. if (target == ACE_ptr_align_binary(target, 8)) { while (orig < end) { register unsigned long a = * ACE_reinterpret_cast(const long*, orig); register unsigned long b = * ACE_reinterpret_cast(const long*, orig + 8); register unsigned long a84 = (a & 0x000000ff000000ffL) << 24; register unsigned long b84 = (b & 0x000000ff000000ffL) << 24; register unsigned long a73 = (a & 0x0000ff000000ff00L) << 8; register unsigned long b73 = (b & 0x0000ff000000ff00L) << 8; register unsigned long a62 = (a & 0x00ff000000ff0000L) >> 8; register unsigned long b62 = (b & 0x00ff000000ff0000L) >> 8; register unsigned long a51 = (a & 0xff000000ff000000L) >> 24; register unsigned long b51 = (b & 0xff000000ff000000L) >> 24; a = (a84 | a73 | a62 | a51); b = (b84 | b73 | b62 | b51); * ACE_reinterpret_cast(long*, target) = a; * ACE_reinterpret_cast(long*, target + 8) = b; orig += 16; target += 16; } } else { // We are out of luck, we have to write in 4 byte chunks. while (orig < end) { register unsigned long a = * ACE_reinterpret_cast(const long*, orig); register unsigned long b = * ACE_reinterpret_cast(const long*, orig + 8); register unsigned long a84 = (a & 0x000000ff000000ffL) << 24; register unsigned long b84 = (b & 0x000000ff000000ffL) << 24; register unsigned long a73 = (a & 0x0000ff000000ff00L) << 8; register unsigned long b73 = (b & 0x0000ff000000ff00L) << 8; register unsigned long a62 = (a & 0x00ff000000ff0000L) >> 8; register unsigned long b62 = (b & 0x00ff000000ff0000L) >> 8; register unsigned long a51 = (a & 0xff000000ff000000L) >> 24; register unsigned long b51 = (b & 0xff000000ff000000L) >> 24; a = (a84 | a73 | a62 | a51); b = (b84 | b73 | b62 | b51); ACE_UINT32 c1 = ACE_static_cast(ACE_UINT32, (a >> 32)); ACE_UINT32 c2 = ACE_static_cast(ACE_UINT32, (a & 0xffffffff)); ACE_UINT32 c3 = ACE_static_cast(ACE_UINT32, (b >> 32)); ACE_UINT32 c4 = ACE_static_cast(ACE_UINT32, (b & 0xffffffff)); #if defined(ACE_LITTLE_ENDIAN) * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c2; * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c1; * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c4; * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c3; #else * ACE_reinterpret_cast(ACE_UINT32*, target + 0) = c1; * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = c2; * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c3; * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = c4; #endif orig += 16; target += 16; } } #else /* ACE_LONG_SIZE != 8 */ while (orig < end) { #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__) register unsigned int a = *ACE_reinterpret_cast(const unsigned int*, orig); register unsigned int b = *ACE_reinterpret_cast(const unsigned int*, orig + 4); register unsigned int c = *ACE_reinterpret_cast(const unsigned int*, orig + 8); register unsigned int d = *ACE_reinterpret_cast(const unsigned int*, orig + 12); asm ("bswap %1" : "=r" (a) : "0" (a)); asm ("bswap %1" : "=r" (b) : "0" (b)); asm ("bswap %1" : "=r" (c) : "0" (c)); asm ("bswap %1" : "=r" (d) : "0" (d)); *ACE_reinterpret_cast(unsigned int*, target) = a; *ACE_reinterpret_cast(unsigned int*, target + 4) = b; *ACE_reinterpret_cast(unsigned int*, target + 8) = c; *ACE_reinterpret_cast(unsigned int*, target + 12) = d; #elif defined(ACE_HAS_PENTIUM) \ && (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov eax, orig __asm mov esi, target __asm mov edx, [eax] __asm mov ecx, 4[eax] __asm mov ebx, 8[eax] __asm mov eax, 12[eax] __asm bswap edx __asm bswap ecx __asm bswap ebx __asm bswap eax __asm mov [esi], edx __asm mov 4[esi], ecx __asm mov 8[esi], ebx __asm mov 12[esi], eax #else register ACE_UINT32 a = * ACE_reinterpret_cast(const ACE_UINT32*, orig); register ACE_UINT32 b = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4); register ACE_UINT32 c = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 8); register ACE_UINT32 d = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 12); // Expect the optimizer reordering this A LOT. // We leave it this way for clarity. a = (a << 24) | ((a & 0xff00) << 8) | ((a & 0xff0000) >> 8) | (a >> 24); b = (b << 24) | ((b & 0xff00) << 8) | ((b & 0xff0000) >> 8) | (b >> 24); c = (c << 24) | ((c & 0xff00) << 8) | ((c & 0xff0000) >> 8) | (c >> 24); d = (d << 24) | ((d & 0xff00) << 8) | ((d & 0xff0000) >> 8) | (d >> 24); * ACE_reinterpret_cast(ACE_UINT32*, target) = a; * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = b; * ACE_reinterpret_cast(ACE_UINT32*, target + 8) = c; * ACE_reinterpret_cast(ACE_UINT32*, target + 12) = d; #endif orig += 16; target += 16; } #endif /* ACE_LONG_SIZE == 8 */ // (n & 3) == (n % 4). switch (n&3) { case 3: ACE_CDR::swap_4 (orig, target); orig += 4; target += 4; case 2: ACE_CDR::swap_4 (orig, target); orig += 4; target += 4; case 1: ACE_CDR::swap_4 (orig, target); } }

ACE_INLINE void ACE_CDR::swap_8 (  const char *    orig, char *    target )  [static]

Definition at line 100 of file CDR_Base.inl. Referenced by ACE_InputCDR::read_8, swap_16, swap_8_array, and ACE_OutputCDR::write_8. { #if defined(ACE_HAS_PENTIUM) && defined(__GNUG__) register unsigned int i = *ACE_reinterpret_cast(const unsigned int*, orig); register unsigned int j = *ACE_reinterpret_cast(const unsigned int*, orig + 4); asm ("bswap %1" : "=r" (i) : "0" (i)); asm ("bswap %1" : "=r" (j) : "0" (j)); *ACE_reinterpret_cast(unsigned int*, target + 4) = i; *ACE_reinterpret_cast(unsigned int*, target) = j; #elif defined(ACE_HAS_PENTIUM) \ && (defined(_MSC_VER) || defined(__BORLANDC__)) \ && !defined(ACE_LACKS_INLINE_ASSEMBLY) __asm mov ecx, orig; __asm mov edx, target; __asm mov eax, [ecx]; __asm mov ebx, 4[ecx]; __asm bswap eax; __asm bswap ebx; __asm mov 4[edx], eax; __asm mov [edx], ebx; #elif ACE_SIZEOF_LONG == 8 // 64 bit architecture. register unsigned long x = * ACE_reinterpret_cast(const unsigned long*, orig); register unsigned long x84 = (x & 0x000000ff000000ffUL) << 24; register unsigned long x73 = (x & 0x0000ff000000ff00UL) << 8; register unsigned long x62 = (x & 0x00ff000000ff0000UL) >> 8; register unsigned long x51 = (x & 0xff000000ff000000UL) >> 24; x = (x84 | x73 | x62 | x51); x = (x << 32) | (x >> 32); *ACE_reinterpret_cast(unsigned long*, target) = x; #else register ACE_UINT32 x = * ACE_reinterpret_cast(const ACE_UINT32*, orig); register ACE_UINT32 y = * ACE_reinterpret_cast(const ACE_UINT32*, orig + 4); x = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24); y = (y << 24) | ((y & 0xff00) << 8) | ((y & 0xff0000) >> 8) | (y >> 24); * ACE_reinterpret_cast(ACE_UINT32*, target) = y; * ACE_reinterpret_cast(ACE_UINT32*, target + 4) = x; #endif }

void ACE_CDR::swap_8_array (  const char *    orig, char *    target, size_t    length )  [static]

Definition at line 436 of file CDR_Base.cpp. References swap_8. Referenced by ACE_InputCDR::read_array, and ACE_OutputCDR::write_array. { // ACE_ASSERT(n > 0); The caller checks that n > 0 const char* const end = orig + 8*n; while (orig < end) { swap_8(orig, target); orig += 8; target += 8; } }

size_t ACE_CDR::total_length (  const ACE_Message_Block *    begin, const ACE_Message_Block *    end )  [static]

Definition at line 493 of file CDR_Base.cpp. References ACE_Message_Block::cont, and ACE_Message_Block::length. Referenced by consolidate, and ACE_OutputCDR::total_length. { 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; }

---

The documentation for this class was generated from the following files:

• CDR_Base.h
• CDR_Base.cpp
• CDR_Base.inl

---