#include <CDR_Stream.h>
Collaboration diagram for ACE_InputCDR:
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
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. More... | |
ACE_InputCDR (Transfer_Contents rhs) | |
Transfer the contents from <rhs> to a new CDR. More... | |
~ACE_InputCDR (void) | |
Destructor. More... | |
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. More... | |
int | good_bit (void) const |
returns zero if a problem has been detected. More... | |
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) |
Re-initialize the CDR stream, copying the contents of the chain of message_blocks starting from <data>. More... | |
ACE_Message_Block * | steal_contents (void) |
Steal the contents from the current CDR. More... | |
void | steal_from (ACE_InputCDR &cdr) |
Steal the contents of <cdr> and make a shallow copy into this stream. More... | |
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. More... | |
ACE_Data_Block * | 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. More... | |
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). More... | |
char * | rd_ptr (void) |
Returns the current position for the rd_ptr.... More... | |
char * | wr_ptr (void) |
Returns the current position for the wr_ptr.... More... | |
size_t | length (void) const |
Return how many bytes are left in the stream. More... | |
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. More... | |
int | byte_order (void) const |
If <do_byte_swap> returns 0, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER. More... | |
ACE_Char_Codeset_Translator * | char_translator (void) const |
Access the codeset translators. They can be nil! More... | |
ACE_WChar_Codeset_Translator * | wchar_translator (void) const |
void | char_translator (ACE_Char_Codeset_Translator *) |
Set the codeset translators. More... | |
void | wchar_translator (ACE_WChar_Codeset_Translator *) |
void | wchar_allowed (int) |
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. More... | |
int | set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor) |
Set the underlying GIOP version.. More... | |
int | get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor) |
Set the underlying GIOP version.. More... | |
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. More... | |
int | do_byte_swap_ |
The CDR stream byte order does not match the one on the machine, swapping is needed while reading. More... | |
int | good_bit_ |
set to 0 when an error occurs. More... | |
ACE_CDR::Octet | major_version_ |
The GIOP versions for this stream. More... | |
ACE_CDR::Octet | minor_version_ |
ACE_Char_Codeset_Translator * | char_translator_ |
If not nil, invoke for translation of character and string data. More... | |
ACE_WChar_Codeset_Translator * | wchar_translator_ |
int | wchar_allowed_ |
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. More... | |
char * | end (void) |
Points to the continuation field of the current message block. More... | |
Friends | |
class | ACE_Char_Codeset_Translator |
The translator need privileged access to efficiently demarshal arrays and the such. More... | |
class | ACE_WChar_Codeset_Translator |
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).
|
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. |
|
Create an empty input stream. The caller is responsible for putting the right data and providing the right alignment.
|
|
Create an input stream from an ACE_Message_Block. The alignment of the
|
|
Create an input stream from an ACE_Data_Block. The <flag> indicates whether the <data> can be deleted by the CDR stream or not.
|
|
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.
|
|
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. |
|
When interpreting indirected TypeCodes it is useful to make a "copy" of the stream starting in the new position.
|
|
This creates an encapsulated stream, the first byte must be (per the spec) the byte order of the encapsulation.
|
|
Create an input CDR from an output CDR.
|
|
Transfer the contents from <rhs> to a new CDR.
|
|
Destructor.
|
|
As above, but now the size and alignment requirements may be different.
|
|
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. |
|
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. |
|
If <do_byte_swap> returns 0, this returns ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER.
|
|
Set the codeset translators.
|
|
Access the codeset translators. They can be nil!
|
|
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.
|
|
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.
|
|
Points to the continuation field of the current message block.
|
|
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.
|
|
Set the underlying GIOP version..
|
|
returns zero if a problem has been detected.
|
|
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 |
|
Return how many bytes are left in the stream.
|
|
|
|
Move the rd_ptr ahead by <offset> bytes.
|
|
Returns the current position for the rd_ptr....
|
|
|
|
|
|
|
|
|
|
|
|
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. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
The buffer <x> must be large enough to contain <length> elements. Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Re-initialize the CDR stream, copying the contents of the chain of message_blocks starting from <data>.
|
|
After reading and partially parsing the contents the user can detect a change in the byte order, this method will let him change it. |
|
Re-initialize the CDR stream, forgetting about the old contents of the stream and allocating a new buffer (from the allocators).
|
|
Set the underlying GIOP version..
|
|
Return 0 on failure and 1 on success. |
|
Skip <n> bytes in the CDR stream. Return 0 on failure and 1 on success.
|
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
|
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
Return 0 on failure and 1 on success. |
|
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. |
|
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. |
|
Steal the contents from the current CDR.
|
|
Steal the contents of <cdr> and make a shallow copy into this stream.
|
|
|
|
|
|
|
|
Returns the current position for the wr_ptr....
|
|
The translator need privileged access to efficiently demarshal arrays and the such.
|
|
|
|
If not nil, invoke for translation of character and string data.
|
|
The CDR stream byte order does not match the one on the machine, swapping is needed while reading.
|
|
set to 0 when an error occurs.
|
|
The GIOP versions for this stream.
|
|
|
|
The start of the chain of message blocks, even though in the current version the chain always has length 1.
|
|
There are some situations when it is an error to attempt wchar i/o of any kind. This may be when using GIOP 1.0, or no valid NCSW defined. |
|
|