Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

ACE_InputCDR Class Reference

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

#include <CDR_Stream.h>

Collaboration diagram for ACE_InputCDR:

Collaboration graph
[legend]
List of all members.

Public Methods

 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)
 Create an empty input stream. The caller is responsible for putting the right data and providing the right alignment.

 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)
 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)
 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_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 (const ACE_InputCDR& rhs)
ACE_InputCDR& operator= (const ACE_InputCDR& rhs)
 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 (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 (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. Return 0 on failure and 1 on success.

int good_bit (void) const
 returns zero if a problem has been detected.

const ACE_Message_Blockstart (void) const
int grow (size_t newsize)
void reset_byte_order (int byte_order)
void 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_Message_Blocksteal_contents (void)
 Steal the contents from the current CDR.

void steal_from (ACE_InputCDR &cdr)
 Steal the contents of <cdr> and make a shallow copy into this stream.

void exchange_data_blocks (ACE_InputCDR &cdr)
 Exchange data blocks with the caller of this method. The read and write pointers are also exchanged. Note: We now do only with the start_ message block.

ACE_Data_Blockclone_from (ACE_InputCDR &cdr)
 Copy the data portion from the <cdr> to this cdr and return the data content (ie. the ACE_Data_Block) from this CDR to the caller. The caller is responsible for managing the memory of the returned ACE_Data_Block.

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

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)
int do_byte_swap (void) const
 If non-zero then this stream is writing in non-native byte order, this is only meaningful if ACE_ENABLE_SWAP_ON_WRITE is defined.

int byte_order (void) const
 If <do_byte_swap> returns 0, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER.

ACE_Char_Codeset_Translatorchar_translator (void) const
 Access the codeset translators. They can be nil!

ACE_WChar_Codeset_Translatorwchar_translator (void) const
int adjust (size_t size, char *&buf)
int adjust (size_t size, size_t align, char *&buf)
 As above, but now the size and alignment requirements may be different.

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_
 The start of the chain of message blocks, even though in the current version the chain always has length 1.

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

int good_bit_
 set to 0 when an error occurs.

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

ACE_WChar_Codeset_Translatorwchar_translator_

Private Methods

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)
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.


Private Attributes

ACE_CDR::Octet major_version_
ACE_CDR::Octet minor_version_

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 )
 

Create an input stream from an ACE_Message_Block.

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 ( 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 0 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 -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 0, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER.

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 )
 

Copy the data portion from the <cdr> to this cdr and return the data content (ie. the ACE_Data_Block) from this CDR to the caller. The caller is responsible for managing the memory of the returned ACE_Data_Block.

ACE_INLINE int ACE_InputCDR::do_byte_swap ( void ) const
 

If non-zero 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 )
 

Exchange data blocks with the caller of this method. The read and write pointers are also exchanged. Note: We now do only with the start_ message block.

ACE_INLINE int ACE_InputCDR::good_bit ( void ) const
 

returns zero 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 . 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 0 on failure and 1 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 0 on failure and 1 on success.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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 ACE_CDR::Boolean ACE_InputCDR::skip_boolean ( void )
 

Return 0 on failure and 1 on success.

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

Skip <n> bytes in the CDR stream. Return 0 on failure and 1 on success.

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

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

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

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

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

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

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

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

ACE_CDR::Boolean ACE_InputCDR::skip_string ( void )
 

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

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

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

ACE_CDR::Boolean ACE_InputCDR::skip_wchar ( void )
 

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. Return 0 on failure and 1 on success.

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

Return 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 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

class ACE_Char_Codeset_Translator [friend]
 

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

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.

int ACE_InputCDR::do_byte_swap_ [protected]
 

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

int ACE_InputCDR::good_bit_ [protected]
 

set to 0 when an error occurs.

ACE_CDR::Octet ACE_InputCDR::major_version_ [private]
 

ACE_CDR::Octet ACE_InputCDR::minor_version_ [private]
 

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:
Generated at Sat Dec 1 11:02:22 2001 for ACE by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000