ACE
6.1.1
|
A CDR stream for demarshalling CDR-encoded data. More...
#include <CDR_Stream.h>
A CDR stream for demarshalling CDR-encoded data.
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:
ACE_InputCDR::ACE_InputCDR | ( | const char * | buf, |
size_t | bufsiz, | ||
int | byte_order = ACE_CDR::BYTE_ORDER_NATIVE , |
||
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_NATIVE , |
||
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_NATIVE , |
||
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_NATIVE , |
||
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_NATIVE , |
||
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.
Transfer the contents from <rhs> to a new CDR.
ACE_InputCDR::~ACE_InputCDR | ( | void | ) | [inline] |
Destructor.
int ACE_InputCDR::adjust | ( | size_t | size, |
char *& | buf | ||
) | [inline] |
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.
int ACE_InputCDR::adjust | ( | size_t | size, |
size_t | align, | ||
char *& | buf | ||
) | [inline] |
As above, but now the size and alignment requirements may be different.
int ACE_InputCDR::align_read_ptr | ( | size_t | alignment | ) | [inline] |
Utility function to allow the user more flexibility. Skips up to the nearest alignment-byte boundary. Argument MUST be a power of 2.
int ACE_InputCDR::byte_order | ( | void | ) | const [inline] |
If do_byte_swap()
returns false
, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER.
ACE_Char_Codeset_Translator * ACE_InputCDR::char_translator | ( | void | ) | const [inline] |
Access the codeset translators. They can be nil!
void ACE_InputCDR::char_translator | ( | ACE_Char_Codeset_Translator * | ctran | ) | [inline] |
Set the codeset translators.
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.
bool ACE_InputCDR::do_byte_swap | ( | void | ) | const [inline] |
If true
then this stream is writing in non-native byte order. This is only meaningful if ACE_ENABLE_SWAP_ON_WRITE is defined.
char * ACE_InputCDR::end | ( | void | ) | [inline, 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.
void ACE_InputCDR::get_version | ( | ACE_CDR::Octet & | major, |
ACE_CDR::Octet & | minor | ||
) | [inline] |
Set the underlying GIOP version..
bool ACE_InputCDR::good_bit | ( | void | ) | const [inline] |
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
size_t ACE_InputCDR::length | ( | void | ) | const [inline] |
Return how many bytes are left in the stream.
ACE_InputCDR & ACE_InputCDR::operator= | ( | const ACE_InputCDR & | rhs | ) |
char * ACE_InputCDR::rd_ptr | ( | void | ) | [inline] |
Returns the current position for the rd_ptr
.
void ACE_InputCDR::rd_ptr | ( | size_t | offset | ) | [inline, private] |
Move the rd_ptr ahead by offset bytes.
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_CDR::Boolean ACE_InputCDR::read_boolean | ( | ACE_CDR::Boolean & | x | ) | [inline] |
Return false
on failure and true
on success.
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_char | ( | ACE_CDR::Char & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_char_array | ( | ACE_CDR::Char * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_double | ( | ACE_CDR::Double & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_double_array | ( | ACE_CDR::Double * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_float | ( | ACE_CDR::Float & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_float_array | ( | ACE_CDR::Float * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_long | ( | ACE_CDR::Long & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_long_array | ( | ACE_CDR::Long * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_longdouble | ( | ACE_CDR::LongDouble & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_longdouble_array | ( | ACE_CDR::LongDouble * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_longlong | ( | ACE_CDR::LongLong & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_longlong_array | ( | ACE_CDR::LongLong * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_octet | ( | ACE_CDR::Octet & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_octet_array | ( | ACE_CDR::Octet * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_short | ( | ACE_CDR::Short & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_short_array | ( | ACE_CDR::Short * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
The buffer x must be large enough to contain length elements. Return false
on failure and true
on success.
Return false
on failure and true
on success.
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_ulong | ( | ACE_CDR::ULong & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_ulong_array | ( | ACE_CDR::ULong * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_ulonglong | ( | ACE_CDR::ULongLong & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_ulonglong_array | ( | ACE_CDR::ULongLong * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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_ushort | ( | ACE_CDR::UShort & | x | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_ushort_array | ( | ACE_CDR::UShort * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
The buffer x must be large enough to contain length elements. Return false
on failure and true
on success.
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::read_wchar_array | ( | ACE_CDR::WChar * | x, |
ACE_CDR::ULong | length | ||
) | [inline] |
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.
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.
void ACE_InputCDR::reset_byte_order | ( | int | byte_order | ) | [inline] |
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).
void ACE_InputCDR::set_version | ( | ACE_CDR::Octet | major, |
ACE_CDR::Octet | minor | ||
) | [inline] |
Set the underlying GIOP version..
ACE_CDR::Boolean ACE_InputCDR::skip_boolean | ( | void | ) | [inline] |
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.
false
on failure and true
on success. ACE_CDR::Boolean ACE_InputCDR::skip_char | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_double | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_float | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_long | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_longdouble | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_longlong | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_octet | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_short | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_ulong | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_ulonglong | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_ushort | ( | void | ) | [inline] |
Return false
on failure and true
on success.
ACE_CDR::Boolean ACE_InputCDR::skip_wchar | ( | void | ) |
Return false
on failure and true
on success.
The next field must be a string, this method skips it. It is useful in parsing a TypeCode.
false
on failure and true
on success. const ACE_Message_Block * ACE_InputCDR::start | ( | void | ) | const [inline] |
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_WChar_Codeset_Translator * ACE_InputCDR::wchar_translator | ( | void | ) | const [inline] |
void ACE_InputCDR::wchar_translator | ( | ACE_WChar_Codeset_Translator * | wctran | ) | [inline] |
char * ACE_InputCDR::wr_ptr | ( | void | ) | [inline] |
Returns the current position for the wr_ptr
.
friend class ACE_Char_Codeset_Translator [friend] |
friend class ACE_WChar_Codeset_Translator [friend] |
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.