ACE
6.1.6
|
A CDR stream for marshalling data, most often for transmission to another system which may or may not have the same byte order. More...
#include <CDR_Stream.h>
Classes | |
struct | from_boolean |
struct | from_char |
struct | from_octet |
struct | from_string |
struct | from_wchar |
struct | from_wstring |
Static Public Member Functions | |
static void | wchar_maxbytes (size_t max_bytes) |
static size_t | wchar_maxbytes (void) |
access the serialized size of wchars. |
Protected Attributes | |
ACE_CDR::Octet | major_version_ |
GIOP version information. | |
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_ |
Static Protected Attributes | |
static size_t | wchar_maxbytes_ = sizeof (ACE_CDR::WChar) |
Private Member Functions | |
ACE_Message_Block * | find (char *loc) |
ACE_OutputCDR (const ACE_OutputCDR &rhs) | |
disallow copying... | |
ACE_OutputCDR & | operator= (const ACE_OutputCDR &rhs) |
ACE_CDR::Boolean | write_1 (const ACE_CDR::Octet *x) |
ACE_CDR::Boolean | write_2 (const ACE_CDR::UShort *x) |
ACE_CDR::Boolean | write_4 (const ACE_CDR::ULong *x) |
ACE_CDR::Boolean | write_8 (const ACE_CDR::ULongLong *x) |
ACE_CDR::Boolean | write_16 (const ACE_CDR::LongDouble *x) |
ACE_CDR::Boolean | write_array (const void *x, size_t size, size_t align, ACE_CDR::ULong length) |
ACE_CDR::Boolean | write_wchar_array_i (const ACE_CDR::WChar *x, ACE_CDR::ULong length) |
int | grow_and_adjust (size_t size, size_t align, char *&buf) |
Private Attributes | |
ACE_Message_Block | start_ |
The start of the chain of message blocks. | |
ACE_Message_Block * | current_ |
The current block in the chain where we are writing. | |
size_t | current_alignment_ |
bool | current_is_writable_ |
bool | do_byte_swap_ |
bool | good_bit_ |
Set to false when an error ocurrs. | |
size_t const | memcpy_tradeoff_ |
Break-even point for copying. |
Friends | |
class | ACE_Char_Codeset_Translator |
class | ACE_WChar_Codeset_Translator |
class | ACE_InputCDR |
A CDR stream for marshalling data, most often for transmission to another system which may or may not have the same byte order.
This class is based on the the CORBA spec for Java (98-02-29), java class omg.org.CORBA.portable.OutputStream. It diverts in a few ways:
ACE_OutputCDR::ACE_OutputCDR | ( | size_t | size = 0 , |
int | byte_order = ACE_CDR::BYTE_ORDER_NATIVE , |
||
ACE_Allocator * | buffer_allocator = 0 , |
||
ACE_Allocator * | data_block_allocator = 0 , |
||
ACE_Allocator * | message_block_allocator = 0 , |
||
size_t | memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF , |
||
ACE_CDR::Octet | major_version = ACE_CDR_GIOP_MAJOR_VERSION , |
||
ACE_CDR::Octet | minor_version = ACE_CDR_GIOP_MINOR_VERSION |
||
) |
Default constructor; allows one to set byte ordering, allocators, and tuning information.
size | Causes constructor to preallocate size bytes; if size is 0 it allocates the default size. |
byte_order | The byte order that data will have within this object. Unless otherwise specified, the byte order will be the order native to the hardware this is executed on. To force the marshalled data to have a specific order, specify one of the values defined in ACE_CDR::Byte_Order. |
ACE_ENABLE_SWAP_ON_WRITE
config macro must be set for any local byte swapping to occur as data is inserted into an ACE_OutputCDR object. ACE_OutputCDR::ACE_OutputCDR | ( | char * | data, |
size_t | size, | ||
int | byte_order = ACE_CDR::BYTE_ORDER_NATIVE , |
||
ACE_Allocator * | buffer_allocator = 0 , |
||
ACE_Allocator * | data_block_allocator = 0 , |
||
ACE_Allocator * | message_block_allocator = 0 , |
||
size_t | memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF , |
||
ACE_CDR::Octet | giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION , |
||
ACE_CDR::Octet | giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION |
||
) |
Build a CDR stream with an initial buffer, it will not remove data, since it did not allocated it. It's important to be careful with the alignment of data. Create an output stream from an arbitrary buffer, care must be exercised with alignment, because this contructor will align if needed. In this case data will not point to the start of the output stream. begin()->rd_ptr()
points to the start of the output stream. See ACE_ptr_align_binary()
to properly align a pointer and use ACE_CDR::MAX_ALIGNMENT for the correct alignment.
ACE_OutputCDR::ACE_OutputCDR | ( | ACE_Data_Block * | data_block, |
int | byte_order = ACE_CDR::BYTE_ORDER_NATIVE , |
||
ACE_Allocator * | message_block_allocator = 0 , |
||
size_t | memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF , |
||
ACE_CDR::Octet | giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION , |
||
ACE_CDR::Octet | giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION |
||
) |
Build a CDR stream with an initial data block, it will not remove <data_block>, since it did not allocated it. It's important to be Create an output stream from an arbitrary data block, care must be exercised with alignment, because this contructor will align if needed. In this case data_block will not point to the start of the output stream. begin()->rd_ptr() points to the start off the output stream. See ACE_ptr_align_binary() to properly align a pointer and use ACE_CDR::MAX_ALIGNMENT for the correct alignment.
ACE_OutputCDR::ACE_OutputCDR | ( | ACE_Message_Block * | data, |
int | byte_order = ACE_CDR::BYTE_ORDER_NATIVE , |
||
size_t | memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF , |
||
ACE_CDR::Octet | giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION , |
||
ACE_CDR::Octet | giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION |
||
) |
Build a CDR stream with an initial Message_Block chain, it will not remove data, since it did not allocate it.
|
inline |
destructor
|
private |
disallow copying...
|
inline |
Returns (in buf) the next position in the buffer aligned to size, it advances the Message_Block wr_ptr past the data (i.e., buf + size). If necessary it grows the Message_Block buffer. Sets the good_bit to false and returns a -1 on failure.
|
inline |
As above, but now the size and alignment requirements may be different.
|
inline |
Utility function to allow the user more flexibility. Pads the stream up to the nearest <alignment>-byte boundary. Argument MUST be a power of 2. Returns 0 on success and -1 on failure.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return 0 on failure and 1 on success.
|
inline |
Return the start of the message block chain for this CDR stream.
|
inline |
Access the underlying buffer (read only).
|
inline |
Returns the byte order this stream is marshaling data in. Will be one of the values in ACE_CDR::Byte_Order.
|
inline |
Access the codeset translators. They can be null!
|
inline |
Set the char codeset translator.
int ACE_OutputCDR::consolidate | ( | void | ) |
Replace the message block chain with a single message block.
Upon successful completion, there will be a single message block containing the data from the complete message block chain.
|
inline |
Return the <current_> message block in chain.
|
inline |
Return alignment of the wr_ptr(), with respect to the start of the CDR stream. This is not the same as the alignment of current->wr_ptr()!
|
inline |
|
inline |
Returns true if this stream is writing in non-native byte order and false otherwise. For example, it would be true if either ACE_ENABLE_SWAP_ON_WRITE is defined or a specific byte order was specified for this stream.
|
inline |
Return the last message in the chain that is is use.
|
private |
|
inline |
Set the underlying GIOP version..
|
inline |
Returns false
if an error has ocurred.
|
private |
Grow the CDR stream. When it returns buf contains a pointer to memory in the CDR stream, with at least size bytes ahead of it and aligned to an <align> boundary. It moved the <wr_ptr> to <buf
|
inline |
Return the size of first message block in the block chain.
|
private |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Long | x, |
char * | loc | ||
) |
Writes a new value into a specific location. This is commonly used to update a prior "placeholder" location in the stream. The specified location is assumed to have proper CDR alignment for the type to insert. This requirement is satisfied by using one of the placeholder-writing methods to align the stream for the anticipated value and obtain the correct location. Treatment of x with repect to byte swapping is the same as for when any value is inserted.
x | The value to insert into the specified location. |
loc | The location at which to insert x. loc must be a valid position within the stream's current set of message blocks. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::ULong | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Short | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::UShort | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Boolean | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Char | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::LongLong | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::ULongLong | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Octet | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Float | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
ACE_CDR::Boolean ACE_OutputCDR::replace | ( | ACE_CDR::Double | x, |
char * | loc | ||
) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
Reuse the CDR stream to write on the old buffer.
|
inline |
For use by a gateway, which creates the output stream for the reply to the client in its native byte order, but which must send the reply in the byte order of the target's reply to the gateway.
|
inline |
set GIOP version info
|
inline |
Add the length of each message block in the chain.
|
static |
set the global size of serialized wchars. This may be different than the size of a wchar_t.
|
static |
access the serialized size of wchars.
|
inline |
|
inline |
Set the wchar codeset translator.
|
private |
|
private |
|
private |
|
private |
|
private |
|
private |
write 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.
|
inline |
For string we offer methods that accept a precomputed length.
ACE_CDR::Boolean ACE_OutputCDR::write_boolean_array | ( | const ACE_CDR::Boolean * | x, |
ACE_CDR::ULong | length | ||
) |
char * ACE_OutputCDR::write_boolean_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_char_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_double_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_float_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_long_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_longlong_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
ACE_CDR::Boolean ACE_OutputCDR::write_octet_array_mb | ( | const ACE_Message_Block * | mb | ) |
Write an octet array contained inside a MB, this can be optimized to minimize copies.
char * ACE_OutputCDR::write_octet_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
char * ACE_OutputCDR::write_short_placeholder | ( | void | ) |
Write a placeholder into the stream. The placeholder's pointer is returned so it may later be passed as the loc argument to replace (). These methods align the stream's write pointer properly prior to writing the placeholder.
Pointer | to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated. |
|
inline |
For string we offer methods that accept a precomputed length.
ACE_CDR::Boolean ACE_OutputCDR::write_string | ( | ACE_CDR::ULong | len, |
const ACE_CDR::Char * | x | ||
) |
For string we offer methods that accept a precomputed length.
ACE_CDR::Boolean ACE_OutputCDR::write_string | ( | const ACE_CString & | x | ) |
For string we offer methods that accept a precomputed length.
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
|
inline |
For string we offer methods that accept a precomputed length.
|
inline |
ACE_CDR::Boolean ACE_OutputCDR::write_wchar | ( | ACE_CDR::WChar | x | ) |
For string we offer methods that accept a precomputed length.
|
inline |
|
private |
|
inline |
For string we offer methods that accept a precomputed length.
ACE_CDR::Boolean ACE_OutputCDR::write_wstring | ( | ACE_CDR::ULong | length, |
const ACE_CDR::WChar * | x | ||
) |
For string we offer methods that accept a precomputed length.
|
friend |
The Codeset translators need access to some private members to efficiently marshal arrays For reading from an output CDR stream.
|
friend |
|
friend |
|
protected |
If not nil, invoke for translation of character and string data.
|
private |
The current block in the chain where we are writing.
|
private |
The current alignment as measured from the start of the buffer. Usually this coincides with the alignment of the buffer in memory, but, when we chain another buffer this "quasi invariant" is broken. The current_alignment is used to readjust the buffer following the stolen message block.
|
private |
Is the current block writable. When we steal a buffer from the user and just chain it into the message block we are not supposed to write on it, even if it is past the start and end of the buffer.
|
private |
If not zero swap bytes at writing so the created CDR stream byte order does not match the machine byte order. The motivation for such a beast is that in some setting a few (fast) machines can be serving hundreds of slow machines with the opposite byte order, so it makes sense (as a load balancing device) to put the responsibility in the writers. THIS IS NOT A STANDARD IN CORBA, USE AT YOUR OWN RISK
|
private |
Set to false when an error ocurrs.
|
protected |
GIOP version information.
|
private |
Break-even point for copying.
|
protected |
|
private |
The start of the chain of message blocks.
|
staticprotected |
Some wide char codesets may be defined with a maximum number of bytes that is smaller than the size of a wchar_t. This means that the CDR cannot simply memcpy a block of wchars to and from the stream, but must instead realign the bytes appropriately. In cases when wchar i/o is not allowed, such as with GIOP 1.0, or not having a native wchar codeset defined, the maxbytes is set to zero, indicating no wchar data is allowed.
|
protected |