# ACE_InputCDR Class Reference

A CDR stream for reading, i.e. for demarshalling. More...

`#include <CDR_Stream.h>`

Collaboration diagram for ACE_InputCDR:

[legend]
List of all members.

## Public Member Functions

| ACE_InputCDR (const char *buf, size_t bufsiz, int byte_order=ACE_CDR_BYTE_ORDER, ACE_CDR::Octet major_version=ACE_CDR_GIOP_MAJOR_VERSION, ACE_CDR::Octet minor_version=ACE_CDR_GIOP_MINOR_VERSION)
| ACE_InputCDR (size_t bufsiz, int byte_order=ACE_CDR_BYTE_ORDER, ACE_CDR::Octet major_version=ACE_CDR_GIOP_MAJOR_VERSION, ACE_CDR::Octet minor_version=ACE_CDR_GIOP_MINOR_VERSION)
| ACE_InputCDR (const ACE_Message_Block *data, int byte_order=ACE_CDR_BYTE_ORDER, ACE_CDR::Octet major_version=ACE_CDR_GIOP_MAJOR_VERSION, ACE_CDR::Octet minor_version=ACE_CDR_GIOP_MINOR_VERSION, ACE_Lock *lock=0)
| Create an input stream from an ACE_Message_Block.
| ACE_InputCDR (ACE_Data_Block *data, ACE_Message_Block::Message_Flags flag=0, int byte_order=ACE_CDR_BYTE_ORDER, ACE_CDR::Octet major_version=ACE_CDR_GIOP_MAJOR_VERSION, ACE_CDR::Octet minor_version=ACE_CDR_GIOP_MINOR_VERSION)
| ACE_InputCDR (ACE_Data_Block *data, ACE_Message_Block::Message_Flags flag, size_t read_pointer_position, size_t write_pointer_position, int byte_order=ACE_CDR_BYTE_ORDER, ACE_CDR::Octet major_version=ACE_CDR_GIOP_MAJOR_VERSION, ACE_CDR::Octet minor_version=ACE_CDR_GIOP_MINOR_VERSION)
| ACE_InputCDR (const ACE_InputCDR &rhs)
ACE_InputCDR & | operator= (const ACE_InputCDR &rhs)
| ACE_InputCDR (const ACE_InputCDR &rhs, size_t size, ACE_CDR::Long offset)
| ACE_InputCDR (const ACE_InputCDR &rhs, size_t size)
| ACE_InputCDR (const ACE_OutputCDR &rhs, ACE_Allocator *buffer_allocator=0, ACE_Allocator *data_block_allocator=0, ACE_Allocator *message_block_allocator=0)
| Create an input CDR from an output CDR.
| ACE_InputCDR (Transfer_Contents rhs)
| Transfer the contents from <rhs> to a new CDR.
| ~ACE_InputCDR (void)
| Destructor.
ACE_CDR::Boolean | skip_wstring (void)
ACE_CDR::Boolean | skip_string (void)
ACE_CDR::Boolean | skip_bytes (size_t n)
| Skip n bytes in the CDR stream.
bool | good_bit (void) const
| returns `false` if a problem has been detected.
const ACE_Message_Block * | start (void) const
int | grow (size_t newsize)
void | reset_byte_order (int byte_order)
void | reset (const ACE_Message_Block *data, int byte_order)
ACE_Message_Block * | steal_contents (void)
| Steal the contents from the current CDR.
void | steal_from (ACE_InputCDR &cdr)
void | exchange_data_blocks (ACE_InputCDR &cdr)
ACE_Data_Block * | clone_from (ACE_InputCDR &cdr)
void | reset_contents (void)
char * | rd_ptr (void)
| Returns the current position for the `rd_ptr`.
char * | wr_ptr (void)
| Returns the current position for the `wr_ptr`.
size_t | length (void) const
| Return how many bytes are left in the stream.
int | align_read_ptr (size_t alignment)
bool | do_byte_swap (void) const
int | byte_order (void) const
ACE_Char_Codeset_Translator * | char_translator (void) const
| Access the codeset translators. They can be nil!
ACE_WChar_Codeset_Translator * | wchar_translator (void) const
void | char_translator (ACE_Char_Codeset_Translator *)
| Set the codeset translators.
void | wchar_translator (ACE_WChar_Codeset_Translator *)
int | adjust (size_t size, char *&buf)
int | adjust (size_t size, size_t align, char *&buf)
int | set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor)
| Set the underlying GIOP version..
int | get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor)
| Set the underlying GIOP version..
Read basic IDL types
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)
Read basic IDL types arrays
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)
Skip elements
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)

## Protected Attributes

ACE_Message_Block | start_
bool | do_byte_swap_
bool | good_bit_
| set to `false` when an error occurs.
ACE_CDR::Octet | major_version_
| The GIOP versions for this stream.
ACE_CDR::Octet | minor_version_
ACE_Char_Codeset_Translator * | char_translator_
| If not nil, invoke for translation of character and string data.
ACE_WChar_Codeset_Translator * | wchar_translator_

## Private Member Functions

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)
ACE_CDR::Boolean | read_array (void *x, size_t size, size_t align, ACE_CDR::ULong length)
ACE_CDR::Boolean | read_wchar_array_i (ACE_CDR::WChar *x, ACE_CDR::ULong length)
void | rd_ptr (size_t offset)
| Move the rd_ptr ahead by <offset> bytes.
char * | end (void)
| Points to the continuation field of the current message block.

## Friends

class | ACE_Char_Codeset_Translator
class | ACE_WChar_Codeset_Translator

## Detailed Description

A CDR stream for reading, i.e. for demarshalling.

This class is based on the the CORBA spec for Java (98-02-29), java class omg.org.CORBA.portable.InputStream. It diverts in a few ways: + Operations to retrieve basic types take parameters by reference. + Operations taking arrays don't have offsets, because in C++ it is easier to describe an array starting from x+offset. + Operations return an error status, because exceptions are not widely available in C++ (yet).

## Constructor & Destructor Documentation

ACE_InputCDR::ACE_InputCDR | ( | const char * | buf,
|  | size_t | bufsiz,
|  | int | byte_order = `ACE_CDR_BYTE_ORDER`,
|  | ACE_CDR::Octet | major_version = `ACE_CDR_GIOP_MAJOR_VERSION`,
|  | ACE_CDR::Octet | minor_version = `ACE_CDR_GIOP_MINOR_VERSION`
| ) |

| Create an input stream from an arbitrary buffer. The buffer must be properly aligned because this contructor will *not* work if the buffer is aligned unproperly.See ACE_ptr_align_binary() for instructions on how to align a pointer properly and use ACE_CDR::MAX_ALIGNMENT for the correct alignment.

ACE_InputCDR::ACE_InputCDR | ( | size_t | bufsiz,
|  | int | byte_order = `ACE_CDR_BYTE_ORDER`,
|  | ACE_CDR::Octet | major_version = `ACE_CDR_GIOP_MAJOR_VERSION`,
|  | ACE_CDR::Octet | minor_version = `ACE_CDR_GIOP_MINOR_VERSION`
| ) |

| Create an empty input stream. The caller is responsible for putting the right data and providing the right alignment.

ACE_InputCDR::ACE_InputCDR | ( | const ACE_Message_Block * | data,
|  | int | byte_order = `ACE_CDR_BYTE_ORDER`,
|  | ACE_CDR::Octet | major_version = `ACE_CDR_GIOP_MAJOR_VERSION`,
|  | ACE_CDR::Octet | minor_version = `ACE_CDR_GIOP_MINOR_VERSION`,
|  | ACE_Lock * | lock = `0`
| ) |

Create an input stream from an ACE_Message_Block.

The alignment of the

- data block is carried into the new ACE_InputCDR object. This constructor either increments the
- data reference count, or copies the data (if it's a compound message block) so the caller can release the block immediately upon return.

ACE_InputCDR::ACE_InputCDR | ( | ACE_Data_Block * | data,
|  | ACE_Message_Block::Message_Flags | flag = `0`,
|  | int | byte_order = `ACE_CDR_BYTE_ORDER`,
|  | ACE_CDR::Octet | major_version = `ACE_CDR_GIOP_MAJOR_VERSION`,
|  | ACE_CDR::Octet | minor_version = `ACE_CDR_GIOP_MINOR_VERSION`
| ) |

| Create an input stream from an ACE_Data_Block. The <flag> indicates whether the <data> can be deleted by the CDR stream or not

ACE_InputCDR::ACE_InputCDR | ( | ACE_Data_Block * | data,
|  | ACE_Message_Block::Message_Flags | flag,
|  | size_t | read_pointer_position,
|  | size_t | write_pointer_position,
|  | int | byte_order = `ACE_CDR_BYTE_ORDER`,
|  | ACE_CDR::Octet | major_version = `ACE_CDR_GIOP_MAJOR_VERSION`,
|  | ACE_CDR::Octet | minor_version = `ACE_CDR_GIOP_MINOR_VERSION`
| ) |

| Create an input stream from an ACE_Data_Block. It also sets the read and write pointers at the desired positions. This would be helpful if the applications desires to create a new CDR stream from a semi-processed datablock.

ACE_InputCDR::ACE_InputCDR | ( | const ACE_InputCDR & | rhs | ) |

| These make a copy of the current stream state, but do not copy the internal buffer, so the same stream can be read multiple times efficiently.

ACE_InputCDR::ACE_InputCDR | ( | const ACE_InputCDR & | rhs,
|  | size_t | size,
|  | ACE_CDR::Long | offset
| ) |

| When interpreting indirected TypeCodes it is useful to make a "copy" of the stream starting in the new position.

ACE_InputCDR::ACE_InputCDR | ( | const ACE_InputCDR & | rhs,
|  | size_t | size
| ) |

| This creates an encapsulated stream, the first byte must be (per the spec) the byte order of the encapsulation.

ACE_InputCDR::ACE_InputCDR | ( | const ACE_OutputCDR & | rhs,
|  | ACE_Allocator * | buffer_allocator = `0`,
|  | ACE_Allocator * | data_block_allocator = `0`,
|  | ACE_Allocator * | message_block_allocator = `0`
| ) |

| Create an input CDR from an output CDR.

ACE_InputCDR::ACE_InputCDR | ( | Transfer_Contents | rhs | ) |

| Transfer the contents from <rhs> to a new CDR.

ACE_INLINE ACE_InputCDR::~ACE_InputCDR | ( | void |  | ) |

| Destructor.

## Member Function Documentation

ACE_INLINE int ACE_InputCDR::adjust | ( | size_t | size,
|  | size_t | align,
|  | char *& | buf
| ) |

| As above, but now the size and alignment requirements may be different.

ACE_INLINE int ACE_InputCDR::adjust | ( | size_t | size,
|  | char *& | buf
| ) |

| Returns (in buf) the next position in the buffer aligned to size. It advances the Message_Block `rd_ptr` past the data (i.e., `buf` `+` `size`). Sets the good_bit to `false` and returns a -1 on failure.

ACE_INLINE int ACE_InputCDR::align_read_ptr | ( | size_t | alignment | ) |

Utility function to allow the user more flexibility. Skips up to the nearest alignment-byte boundary. Argument MUST be a power of 2.

Returns:
  0 on success and -1 on failure.

ACE_INLINE int ACE_InputCDR::byte_order | ( | void |  | ) | const

| If `do_byte_swap()` returns `false`, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER.

ACE_INLINE void ACE_InputCDR::char_translator | ( | ACE_Char_Codeset_Translator * |  | ) |

| Set the codeset translators.

ACE_INLINE ACE_Char_Codeset_Translator * ACE_InputCDR::char_translator | ( | void |  | ) | const

| Access the codeset translators. They can be nil!

ACE_Data_Block * ACE_InputCDR::clone_from | ( | ACE_InputCDR & | cdr | ) |

Note:
  The caller is responsible for managing the memory of the returned ACE_Data_Block.

ACE_INLINE bool ACE_InputCDR::do_byte_swap | ( | void |  | ) | const

| If `true` then this stream is writing in non-native byte order. This is only meaningful if ACE_ENABLE_SWAP_ON_WRITE is defined.

ACE_INLINE char * ACE_InputCDR::end | ( | void |  | ) | `[private]`

| Points to the continuation field of the current message block.

void ACE_InputCDR::exchange_data_blocks | ( | ACE_InputCDR & | cdr | ) |

Note:
  We now do only with the start_ message block.

ACE_INLINE int ACE_InputCDR::get_version | ( | ACE_CDR::Octet & | major,
|  | ACE_CDR::Octet & | minor
| ) |

| Set the underlying GIOP version..

ACE_INLINE bool ACE_InputCDR::good_bit | ( | void |  | ) | const

| returns `false` if a problem has been detected.

int ACE_InputCDR::grow | ( | size_t | newsize | ) |

| Grow the internal buffer, reset `rd_ptr` to the first byte in the new buffer that is properly aligned, and set `wr_ptr` to `rd_ptr` `+` `newsize`

ACE_INLINE size_t ACE_InputCDR::length | ( | void |  | ) | const

| Return how many bytes are left in the stream.

ACE_InputCDR & ACE_InputCDR::operator= | ( | const ACE_InputCDR & | rhs | ) |

ACE_INLINE void ACE_InputCDR::rd_ptr | ( | size_t | offset | ) | `[private]`

| Move the rd_ptr ahead by <offset> bytes.

ACE_INLINE char * ACE_InputCDR::rd_ptr | ( | void |  | ) |

| Returns the current position for the `rd_ptr`.

ACE_CDR::Boolean ACE_InputCDR::read_1 | ( | ACE_CDR::Octet * | x | ) | `[private]`

ACE_CDR::Boolean ACE_InputCDR::read_16 | ( | ACE_CDR::LongDouble * | x | ) | `[private]`

ACE_CDR::Boolean ACE_InputCDR::read_2 | ( | ACE_CDR::UShort * | x | ) | `[private]`

ACE_CDR::Boolean ACE_InputCDR::read_4 | ( | ACE_CDR::ULong * | x | ) | `[private]`

ACE_CDR::Boolean ACE_InputCDR::read_8 | ( | ACE_CDR::ULongLong * | x | ) | `[private]`

ACE_CDR::Boolean ACE_InputCDR::read_array | ( | void * | x,
|  | size_t | size,
|  | size_t | align,
|  | ACE_CDR::ULong | length
| ) | `[private]`

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 designed for buffers of the basic types.

This operation uses <memcpy>; as explained above it is expected that using assignment is faster that <memcpy> for one element, but for several elements <memcpy> should be more efficient, it could be interesting to find the break even point and optimize for that case, but that would be too platform dependent.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_boolean | ( | ACE_CDR::Boolean & | x | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::read_boolean_array | ( | ACE_CDR::Boolean * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_char | ( | ACE_CDR::Char & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_char_array | ( | ACE_CDR::Char * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_double | ( | ACE_CDR::Double & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_double_array | ( | ACE_CDR::Double * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_float | ( | ACE_CDR::Float & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_float_array | ( | ACE_CDR::Float * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_long | ( | ACE_CDR::Long & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_long_array | ( | ACE_CDR::Long * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_longdouble | ( | ACE_CDR::LongDouble & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_longdouble_array | ( | ACE_CDR::LongDouble * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_longlong | ( | ACE_CDR::LongLong & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_longlong_array | ( | ACE_CDR::LongLong * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_octet | ( | ACE_CDR::Octet & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_octet_array | ( | ACE_CDR::Octet * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_short | ( | ACE_CDR::Short & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_short_array | ( | ACE_CDR::Short * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::read_string | ( | ACE_CString & | x | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::read_string | ( | ACE_CDR::Char *& | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ulong | ( | ACE_CDR::ULong & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ulong_array | ( | ACE_CDR::ULong * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ulonglong | ( | ACE_CDR::ULongLong & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ulonglong_array | ( | ACE_CDR::ULongLong * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ushort | ( | ACE_CDR::UShort & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_ushort_array | ( | ACE_CDR::UShort * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::read_wchar | ( | ACE_CDR::WChar & | x | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::read_wchar_array | ( | ACE_CDR::WChar * | x,
|  | ACE_CDR::ULong | length
| ) |

| The buffer x must be large enough to contain length elements. Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::read_wchar_array_i | ( | ACE_CDR::WChar * | x,
|  | ACE_CDR::ULong | length
| ) | `[private]`

| On those occasions when the native codeset for wchar is smaller than the size of a wchar_t, such as using UTF-16 with a 4-byte wchar_t, a special form of reading the array is needed. Actually, this should be a default translator.

ACE_CDR::Boolean ACE_InputCDR::read_wstring | ( | ACE_CDR::WChar *& | x | ) |

| Return `false` on failure and `true` on success.

void ACE_InputCDR::reset | ( | const ACE_Message_Block * | data,
|  | int | byte_order
| ) |

| Re-initialize the CDR stream, copying the contents of the chain of message_blocks starting from data.

ACE_INLINE void ACE_InputCDR::reset_byte_order | ( | int | byte_order | ) |

| After reading and partially parsing the contents the user can detect a change in the byte order, this method will let him/her change it.

void ACE_InputCDR::reset_contents | ( | void |  | ) |

| Re-initialize the CDR stream, forgetting about the old contents of the stream and allocating a new buffer (from the allocators).

ACE_INLINE int ACE_InputCDR::set_version | ( | ACE_CDR::Octet | major,
|  | ACE_CDR::Octet | minor
| ) |

| Set the underlying GIOP version..

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_boolean | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::skip_bytes | ( | size_t | n | ) |

Skip n bytes in the CDR stream.

Returns:
  `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_char | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_double | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_float | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_long | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_longdouble | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_longlong | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_octet | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_short | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::skip_string | ( | void |  | ) |

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ulong | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ulonglong | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_INLINE ACE_CDR::Boolean ACE_InputCDR::skip_ushort | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::skip_wchar | ( | void |  | ) |

| Return `false` on failure and `true` on success.

ACE_CDR::Boolean ACE_InputCDR::skip_wstring | ( | void |  | ) |

The next field must be a string, this method skips it. It is useful in parsing a TypeCode.

Returns:
  `false` on failure and `true` on success.

ACE_INLINE const ACE_Message_Block * ACE_InputCDR::start | ( | void |  | ) | const

Returns:
  The start of the message block chain for this CDR stream.

Note:
  In the current implementation the chain has length 1, but we are planning to change that.

ACE_Message_Block * ACE_InputCDR::steal_contents | ( | void |  | ) |

| Steal the contents from the current CDR.

void ACE_InputCDR::steal_from | ( | ACE_InputCDR & | cdr | ) |

| Steal the contents of cdr and make a shallow copy into this stream.

ACE_INLINE void ACE_InputCDR::wchar_translator | ( | ACE_WChar_Codeset_Translator * |  | ) |

ACE_INLINE ACE_WChar_Codeset_Translator * ACE_InputCDR::wchar_translator | ( | void |  | ) | const

ACE_INLINE char * ACE_InputCDR::wr_ptr | ( | void |  | ) |

| Returns the current position for the `wr_ptr`.

## Friends And Related Function Documentation

friend class ACE_Char_Codeset_Translator`[friend]`

| The translator need privileged access to efficiently demarshal arrays and the such

friend class ACE_WChar_Codeset_Translator`[friend]`

## Member Data Documentation

ACE_Char_Codeset_Translator* ACE_InputCDR::char_translator_`[protected]`

| If not nil, invoke for translation of character and string data.

bool ACE_InputCDR::do_byte_swap_`[protected]`

| The CDR stream byte order does not match the one on the machine, swapping is needed while reading.

bool ACE_InputCDR::good_bit_`[protected]`

| set to `false` when an error occurs.

ACE_CDR::Octet ACE_InputCDR::major_version_`[protected]`

| The GIOP versions for this stream.

ACE_CDR::Octet ACE_InputCDR::minor_version_`[protected]`

ACE_Message_Block ACE_InputCDR::start_`[protected]`

| The start of the chain of message blocks, even though in the current version the chain always has length 1.

ACE_WChar_Codeset_Translator* ACE_InputCDR::wchar_translator_`[protected]`

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

- CDR_Stream.h
- CDR_Stream.cpp
- CDR_Stream.inl