ACE_OutputCDR Class Reference

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>

Collaboration diagram for ACE_OutputCDR:

[legend]

List of all members.

Public Member Functions
	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)
	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)
	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)
	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)
	~ACE_OutputCDR (void)
	destructor
bool	good_bit (void) const
	Returns false if an error has ocurred.
void	reset (void)
	Reuse the CDR stream to write on the old buffer.
size_t	total_length (void) const
	Add the length of each message block in the chain.
const ACE_Message_Block *	begin (void) const
const ACE_Message_Block *	end (void) const
	Return the last message in the chain that is is use.
const ACE_Message_Block *	current (void) const
	Return the <current_> message block in chain.
int	consolidate (void)
	Replace the message block chain with a single message block.
const char *	buffer (void) const
size_t	length (void) const
int	align_write_ptr (size_t alignment)
ACE_Char_Codeset_Translator *	char_translator (void) const
	Access the codeset translators. They can be null!
ACE_WChar_Codeset_Translator *	wchar_translator (void) const
void	char_translator (ACE_Char_Codeset_Translator *)
	Set the char codeset translator.
void	wchar_translator (ACE_WChar_Codeset_Translator *)
	Set the wchar codeset translator.
size_t	current_alignment (void) const
void	current_alignment (size_t current_alignment)
int	adjust (size_t size, char *&buf)
int	adjust (size_t size, size_t align, char *&buf)
bool	do_byte_swap (void) const
int	byte_order (void) const
void	reset_byte_order (int byte_order)
void	set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor)
	set GIOP version info
void	get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor)
	Set the underlying GIOP version..
Write operations
Return 0 on failure and 1 on success.
ACE_CDR::Boolean	write_boolean (ACE_CDR::Boolean x)
ACE_CDR::Boolean	write_char (ACE_CDR::Char x)
ACE_CDR::Boolean	write_wchar (ACE_CDR::WChar x)
ACE_CDR::Boolean	write_octet (ACE_CDR::Octet x)
ACE_CDR::Boolean	write_short (ACE_CDR::Short x)
ACE_CDR::Boolean	write_ushort (ACE_CDR::UShort x)
ACE_CDR::Boolean	write_long (ACE_CDR::Long x)
ACE_CDR::Boolean	write_ulong (ACE_CDR::ULong x)
ACE_CDR::Boolean	write_longlong (const ACE_CDR::LongLong &x)
ACE_CDR::Boolean	write_ulonglong (const ACE_CDR::ULongLong &x)
ACE_CDR::Boolean	write_float (ACE_CDR::Float x)
ACE_CDR::Boolean	write_double (const ACE_CDR::Double &x)
ACE_CDR::Boolean	write_longdouble (const ACE_CDR::LongDouble &x)
ACE_CDR::Boolean	write_string (const ACE_CDR::Char *x)
	For string we offer methods that accept a precomputed length.
ACE_CDR::Boolean	write_string (ACE_CDR::ULong len, const ACE_CDR::Char *x)
ACE_CDR::Boolean	write_string (const ACE_CString &x)
ACE_CDR::Boolean	write_wstring (const ACE_CDR::WChar *x)
ACE_CDR::Boolean	write_wstring (ACE_CDR::ULong length, const ACE_CDR::WChar *x)
ACE_CDR::Boolean	write_boolean_array (const ACE_CDR::Boolean *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_char_array (const ACE_CDR::Char *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_wchar_array (const ACE_CDR::WChar *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_octet_array (const ACE_CDR::Octet *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_short_array (const ACE_CDR::Short *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_ushort_array (const ACE_CDR::UShort *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_long_array (const ACE_CDR::Long *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_ulong_array (const ACE_CDR::ULong *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_longlong_array (const ACE_CDR::LongLong *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_ulonglong_array (const ACE_CDR::ULongLong *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_float_array (const ACE_CDR::Float *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_double_array (const ACE_CDR::Double *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_longdouble_array (const ACE_CDR::LongDouble *x, ACE_CDR::ULong length)
ACE_CDR::Boolean	write_octet_array_mb (const ACE_Message_Block *mb)
Placeholder/replace operations
Facilitates writing a placeholder into a CDR stream to be replaced later with a different value. Note: An example use for this facility is: ACE_OutputCDR strm; ... // insert values... char *pos = strm.write_long_placeholder (); ... // insert more values ACE_CDR::Long real_val; // Somehow assign the "correct" value strm.replace (real_val, pos); // Replace earlier placeholder
char *	write_long_placeholder (void)
char *	write_short_placeholder (void)
ACE_CDR::Boolean	replace (ACE_CDR::Long x, char *loc)
ACE_CDR::Boolean	replace (ACE_CDR::Short x, char *loc)
ACE_CDR::Boolean	append_boolean (ACE_InputCDR &)
ACE_CDR::Boolean	append_char (ACE_InputCDR &)
ACE_CDR::Boolean	append_wchar (ACE_InputCDR &)
ACE_CDR::Boolean	append_octet (ACE_InputCDR &)
ACE_CDR::Boolean	append_short (ACE_InputCDR &)
ACE_CDR::Boolean	append_ushort (ACE_InputCDR &)
ACE_CDR::Boolean	append_long (ACE_InputCDR &)
ACE_CDR::Boolean	append_ulong (ACE_InputCDR &)
ACE_CDR::Boolean	append_longlong (ACE_InputCDR &)
ACE_CDR::Boolean	append_ulonglong (ACE_InputCDR &)
ACE_CDR::Boolean	append_float (ACE_InputCDR &)
ACE_CDR::Boolean	append_double (ACE_InputCDR &)
ACE_CDR::Boolean	append_longdouble (ACE_InputCDR &)
ACE_CDR::Boolean	append_wstring (ACE_InputCDR &)
ACE_CDR::Boolean	append_string (ACE_InputCDR &)
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
Classes
struct	from_boolean
struct	from_char
struct	from_octet
struct	from_string
struct	from_wchar
struct	from_wstring

---

Detailed Description

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:

• 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_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.

Parameters:

	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.

Note:

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

ACE_INLINE ACE_OutputCDR::~ACE_OutputCDR

(

void

)

destructor

ACE_OutputCDR::ACE_OutputCDR

(

const ACE_OutputCDR &

rhs

)

[private]

disallow copying...

---

Member Function Documentation

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_boolean

(

ACE_CDR::Boolean

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_char

(

ACE_CDR::Char

x

)

ACE_CDR::Boolean ACE_OutputCDR::write_wchar

(

ACE_CDR::WChar

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_octet

(

ACE_CDR::Octet

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_short

(

ACE_CDR::Short

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ushort

(

ACE_CDR::UShort

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_long

(

ACE_CDR::Long

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ulong

(

ACE_CDR::ULong

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_longlong

(

const ACE_CDR::LongLong &

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ulonglong

(

const ACE_CDR::ULongLong &

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_float

(

ACE_CDR::Float

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_double

(

const ACE_CDR::Double &

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_longdouble

(

const ACE_CDR::LongDouble &

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_string

(

const ACE_CDR::Char *

x

)

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
	)

ACE_CDR::Boolean ACE_OutputCDR::write_string

(

const ACE_CString &

x

)

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_wstring

(

const ACE_CDR::WChar *

x

)

ACE_CDR::Boolean ACE_OutputCDR::write_wstring	(	ACE_CDR::ULong	length,
		const ACE_CDR::WChar *	x
	)

ACE_CDR::Boolean ACE_OutputCDR::write_boolean_array	(	const ACE_CDR::Boolean *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_char_array	(	const ACE_CDR::Char *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_wchar_array	(	const ACE_CDR::WChar *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_octet_array	(	const ACE_CDR::Octet *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_short_array	(	const ACE_CDR::Short *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ushort_array	(	const ACE_CDR::UShort *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_long_array	(	const ACE_CDR::Long *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ulong_array	(	const ACE_CDR::ULong *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_longlong_array	(	const ACE_CDR::LongLong *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_ulonglong_array	(	const ACE_CDR::ULongLong *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_float_array	(	const ACE_CDR::Float *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_double_array	(	const ACE_CDR::Double *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::write_longdouble_array	(	const ACE_CDR::LongDouble *	x,
		ACE_CDR::ULong	length
	)

Note:

the portion written starts at <x> and ends at <x + length>. The length is *NOT* stored into the CDR stream.

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

Return values:

Pointer

to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated.

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.

Return values:

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

Parameters:

	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.

See also:

write_long_placeholder(), write_short_placeholder ()

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.

Return values:

Pointer

to the placeholder; 0 if there is not enough space in the stream and memory could not be allocated.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_boolean

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_char

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_wchar

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_octet

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_short

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ushort

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_long

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ulong

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_longlong

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_ulonglong

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_float

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_double

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_longdouble

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_wstring

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE ACE_CDR::Boolean ACE_OutputCDR::append_string

(

ACE_InputCDR &

stream

)

Return 0 on failure and 1 on success.

ACE_INLINE bool ACE_OutputCDR::good_bit

(

void

)

const

Returns false if an error has ocurred.

Note:

The only expected error is to run out of memory.

ACE_INLINE void ACE_OutputCDR::reset

(

void

)

Reuse the CDR stream to write on the old buffer.

ACE_INLINE size_t ACE_OutputCDR::total_length

(

void

)

const

Add the length of each message block in the chain.

ACE_INLINE const ACE_Message_Block * ACE_OutputCDR::begin

(

void

)

const

Return the start of the message block chain for this CDR stream.

Note:

The complete CDR stream is represented by a chain of message blocks.

ACE_INLINE const ACE_Message_Block * ACE_OutputCDR::end

(

void

)

const

Return the last message in the chain that is is use.

ACE_INLINE const ACE_Message_Block * ACE_OutputCDR::current

(

void

)

const

Return the <current_> message block in chain.

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.

Note:

The only expected error is to run out of memory.

ACE_INLINE const char * ACE_OutputCDR::buffer

(

void

)

const

Access the underlying buffer (read only).

Note:

This method only returns a pointer to the first block in the chain.

ACE_INLINE size_t ACE_OutputCDR::length

(

void

)

const

Return the size of first message block in the block chain.

Note:

This method only returns information about the first block in the chain.

ACE_INLINE int ACE_OutputCDR::align_write_ptr

(

size_t

alignment

)

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.

ACE_INLINE ACE_Char_Codeset_Translator * ACE_OutputCDR::char_translator

(

void

)

const

Access the codeset translators. They can be null!

ACE_INLINE ACE_WChar_Codeset_Translator * ACE_OutputCDR::wchar_translator

(

void

)

const

ACE_INLINE void ACE_OutputCDR::char_translator

(

ACE_Char_Codeset_Translator *

ctran

)

Set the char codeset translator.

ACE_INLINE void ACE_OutputCDR::wchar_translator

(

ACE_WChar_Codeset_Translator *

wctran

)

Set the wchar codeset translator.

void ACE_OutputCDR::wchar_maxbytes

(

size_t

max_bytes

)

[static]

set the global size of serialized wchars. This may be different than the size of a wchar_t.

size_t ACE_OutputCDR::wchar_maxbytes

(

void

)

[static]

access the serialized size of wchars.

ACE_INLINE size_t ACE_OutputCDR::current_alignment

(

void

)

const

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()!

ACE_INLINE void ACE_OutputCDR::current_alignment

(

size_t

current_alignment

)

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

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.

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

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

ACE_INLINE bool ACE_OutputCDR::do_byte_swap

(

void

)

const

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.

ACE_INLINE int ACE_OutputCDR::byte_order

(

void

)

const

Returns the byte order this stream is marshaling data in. Will be one of the values in ACE_CDR::Byte_Order.

ACE_INLINE void ACE_OutputCDR::reset_byte_order

(

int

byte_order

)

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.

ACE_INLINE void ACE_OutputCDR::set_version	(	ACE_CDR::Octet	major,
		ACE_CDR::Octet	minor
	)

set GIOP version info

ACE_INLINE void ACE_OutputCDR::get_version	(	ACE_CDR::Octet &	major,
		ACE_CDR::Octet &	minor
	)

Set the underlying GIOP version..

ACE_Message_Block * ACE_OutputCDR::find

(

char *

loc

)

[private]

ACE_OutputCDR& ACE_OutputCDR::operator=

(

const ACE_OutputCDR &

rhs

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_1

(

const ACE_CDR::Octet *

x

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_2

(

const ACE_CDR::UShort *

x

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_4

(

const ACE_CDR::ULong *

x

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_8

(

const ACE_CDR::ULongLong *

x

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_16

(

const ACE_CDR::LongDouble *

x

)

[private]

ACE_CDR::Boolean ACE_OutputCDR::write_array	(	const void *	x,
		size_t	size,
		size_t	align,
		ACE_CDR::ULong	length
	)			[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.

ACE_CDR::Boolean ACE_OutputCDR::write_wchar_array_i	(	const ACE_CDR::WChar *	x,
		ACE_CDR::ULong	length
	)			[private]

int ACE_OutputCDR::grow_and_adjust	(	size_t	size,
		size_t	align,
		char *&	buf
	)			[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 + size>.

---

Friends And Related Function Documentation

friend class ACE_Char_Codeset_Translator [friend]

The Codeset translators need access to some private members to efficiently marshal arrays For reading from an output CDR stream.

friend class ACE_WChar_Codeset_Translator [friend]

friend class ACE_InputCDR [friend]

---

Member Data Documentation

ACE_Message_Block ACE_OutputCDR::start_ [private]

The start of the chain of message blocks.

ACE_Message_Block* ACE_OutputCDR::current_ [private]

The current block in the chain where we are writing.

size_t ACE_OutputCDR::current_alignment_ [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.

bool ACE_OutputCDR::current_is_writable_ [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.

bool ACE_OutputCDR::do_byte_swap_ [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

bool ACE_OutputCDR::good_bit_ [private]

Set to false when an error ocurrs.

size_t const ACE_OutputCDR::memcpy_tradeoff_ [private]

Break-even point for copying.

ACE_CDR::Octet ACE_OutputCDR::major_version_ [protected]

GIOP version information.

ACE_CDR::Octet ACE_OutputCDR::minor_version_ [protected]

ACE_Char_Codeset_Translator* ACE_OutputCDR::char_translator_ [protected]

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

ACE_WChar_Codeset_Translator* ACE_OutputCDR::wchar_translator_ [protected]

ACE_BEGIN_VERSIONED_NAMESPACE_DECL size_t ACE_OutputCDR::wchar_maxbytes_ = sizeof (ACE_CDR::WChar) [static, protected]

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.

---

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

• CDR_Stream.h
• CDR_Stream.cpp
• CDR_Stream.inl