OpenDDS::DCPS::Serializer Class Reference

Class to serialize and deserialize data for DDS. More...

#include <Serializer.h>

Collaboration diagram for OpenDDS::DCPS::Serializer:

[legend]

List of all members.

Public Types
enum	Alignment { ALIGN_NONE, ALIGN_INITIALIZE, ALIGN_CDR }
Public Member Functions
	Serializer (ACE_Message_Block *chain, bool swap_bytes=false, Alignment align=ALIGN_NONE)
virtual	~Serializer ()
void	swap_bytes (bool do_swap)
	Establish byte swapping behavior.
bool	swap_bytes () const
	Examine byte swapping behavior.
Alignment	alignment () const
	Examine alignment behavior.
void	reset_alignment ()
	Reset alignment as if a new instance were created.
bool	good_bit () const
	Examine the state of the stream abstraction.
size_t	length () const
	Number of bytes left to read in message block chain.
size_t	read_string (ACE_CDR::Char *&dest, ACE_CDR::Char *str_alloc(ACE_CDR::ULong)=CORBA::string_alloc, void str_free(ACE_CDR::Char *)=CORBA::string_free)
	Read a narrow string.
size_t	read_string (ACE_CDR::WChar *&dest, ACE_CDR::WChar *str_alloc(ACE_CDR::ULong)=CORBA::wstring_alloc, void str_free(ACE_CDR::WChar *)=CORBA::wstring_free)
	Read a wide string.
bool	skip (ACE_CDR::UShort n, int size=1)
size_t	available_r () const
void	buffer_read (char *dest, size_t size, bool swap)
	Read from the chain into a destination buffer.
int	align_r (size_t alignment)
int	align_w (size_t alignment)
bool	read_boolean_array (ACE_CDR::Boolean *x, ACE_CDR::ULong length)
bool	read_char_array (ACE_CDR::Char *x, ACE_CDR::ULong length)
bool	read_wchar_array (ACE_CDR::WChar *x, ACE_CDR::ULong length)
bool	read_octet_array (ACE_CDR::Octet *x, ACE_CDR::ULong length)
bool	read_short_array (ACE_CDR::Short *x, ACE_CDR::ULong length)
bool	read_ushort_array (ACE_CDR::UShort *x, ACE_CDR::ULong length)
bool	read_long_array (ACE_CDR::Long *x, ACE_CDR::ULong length)
bool	read_ulong_array (ACE_CDR::ULong *x, ACE_CDR::ULong length)
bool	read_longlong_array (ACE_CDR::LongLong *x, ACE_CDR::ULong length)
bool	read_ulonglong_array (ACE_CDR::ULongLong *x, ACE_CDR::ULong length)
bool	read_float_array (ACE_CDR::Float *x, ACE_CDR::ULong length)
bool	read_double_array (ACE_CDR::Double *x, ACE_CDR::ULong length)
bool	read_longdouble_array (ACE_CDR::LongDouble *x, ACE_CDR::ULong length)
bool	write_boolean_array (const ACE_CDR::Boolean *x, ACE_CDR::ULong length)
bool	write_char_array (const ACE_CDR::Char *x, ACE_CDR::ULong length)
bool	write_wchar_array (const ACE_CDR::WChar *x, ACE_CDR::ULong length)
bool	write_octet_array (const ACE_CDR::Octet *x, ACE_CDR::ULong length)
bool	write_short_array (const ACE_CDR::Short *x, ACE_CDR::ULong length)
bool	write_ushort_array (const ACE_CDR::UShort *x, ACE_CDR::ULong length)
bool	write_long_array (const ACE_CDR::Long *x, ACE_CDR::ULong length)
bool	write_ulong_array (const ACE_CDR::ULong *x, ACE_CDR::ULong length)
bool	write_longlong_array (const ACE_CDR::LongLong *x, ACE_CDR::ULong length)
bool	write_ulonglong_array (const ACE_CDR::ULongLong *x, ACE_CDR::ULong length)
bool	write_float_array (const ACE_CDR::Float *x, ACE_CDR::ULong length)
bool	write_double_array (const ACE_CDR::Double *x, ACE_CDR::ULong length)
bool	write_longdouble_array (const ACE_CDR::LongDouble *x, ACE_CDR::ULong length)
Static Public Member Functions
static bool	use_rti_serialization ()
static void	set_use_rti_serialization (bool should_use)
Static Public Attributes
static const size_t	WCHAR_SIZE = 2
static const bool	SWAP_BE = false
Private Member Functions
void	read_array (char *x, size_t size, ACE_CDR::ULong length)
void	read_array (char *x, size_t size, ACE_CDR::ULong length, bool swap)
void	buffer_write (const char *src, size_t size, bool swap)
	Write to the chain from a source buffer.
void	write_array (const char *x, size_t size, ACE_CDR::ULong length)
void	write_array (const char *x, size_t size, ACE_CDR::ULong length, bool swap)
void	smemcpy (char *to, const char *from, size_t n)
void	swapcpy (char *to, const char *from, size_t n)
size_t	doread (char *dest, size_t size, bool swap, size_t offset)
	Implementation of the actual read from the chain.
size_t	dowrite (const char *dest, size_t size, bool swap, size_t offset)
	Implementation of the actual write to the chain.
void	align_cont_r ()
	Update alignment state when a cont() chain is followed during a read.
void	align_cont_w ()
	Update alignment state when a cont() chain is followed during a write.
Private Attributes
ACE_Message_Block *	current_
	Currently active message block in chain.
bool	swap_bytes_
	Indicates whether bytes will be swapped for this stream.
bool	good_bit_
	Indicates the current state of the stream abstraction.
Alignment	alignment_
	Current alignment mode, see Alignment enum above.
unsigned char	align_rshift_
unsigned char	align_wshift_
Static Private Attributes
static const size_t	MAX_ALIGN = 8
static const char	ALIGN_PAD [MAX_ALIGN] = {0}
static bool	use_rti_serialization_
Friends
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::Char x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::Short x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::UShort x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::Long x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::ULong x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::LongLong x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::ULongLong x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::LongDouble x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::Float x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::Double x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, const ACE_CDR::Char *x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, const ACE_CDR::WChar *x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_boolean x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_char x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_wchar x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_octet x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_string x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_OutputCDR::from_wstring x)
OpenDDS_Dcps_Export bool	operator<< (Serializer &s, const std::string &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Char &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Short &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::UShort &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Long &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::ULong &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::LongLong &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::ULongLong &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::LongDouble &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Float &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Double &x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::Char *&x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::WChar *&x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_boolean x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_char x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_wchar x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_octet x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_string x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_InputCDR::to_wstring x)
OpenDDS_Dcps_Export bool	operator>> (Serializer &s, std::string &x)

---

Detailed Description

Class to serialize and deserialize data for DDS.

This class provides a mechanism to insert and extract data to and from an ACE_Message_Block chain that represents the data which can be transported on the wire to other DDS service participants.

Definition at line 41 of file Serializer.h.

---

Member Enumeration Documentation

enum OpenDDS::DCPS::Serializer::Alignment

Enumerator:

ALIGN_NONE
ALIGN_INITIALIZE
ALIGN_CDR

Definition at line 44 of file Serializer.h.

                 {
    ALIGN_NONE,           // no alignment needed
    ALIGN_INITIALIZE,     // align to CDR rules and zero-out padding
    ALIGN_CDR             // align to CDR rules with uninitialized padding
#ifdef ACE_INITIALIZE_MEMORY_BEFORE_USE
      = ALIGN_INITIALIZE  // if the above macro is set, always init padding
#endif
  };

---

Constructor & Destructor Documentation

OpenDDS::DCPS::Serializer::Serializer	(	ACE_Message_Block *	chain,
		bool	swap_bytes = false,
		Alignment	align = ALIGN_NONE
	)			[explicit]

Constructor with a message block chain. This installs the message block chain and sets the current block to the first in the chain. Memory management is the responsibility of the owner of this object, and is not performed internally. Ownership of the message block chain is retained by the owner of this object and the lifetime of the chain must be longer than the use of this object.

Bytes are swapped when either reading or writing from the message chain if the swap_bytes argument is true. It is the responsibility of the owner of this object to determine whether this should be performed or not.

Definition at line 27 of file Serializer.cpp.

  : current_(chain)
  , swap_bytes_(swap_bytes)
  , good_bit_(true)
  , alignment_(align)
  , align_rshift_(chain ? ptrdiff_t(chain->rd_ptr()) % MAX_ALIGN : 0)
  , align_wshift_(chain ? ptrdiff_t(chain->wr_ptr()) % MAX_ALIGN : 0)
{
}

OpenDDS::DCPS::Serializer::~Serializer

(

)

[virtual]

Definition at line 38 of file Serializer.cpp.

{
}

---

Member Function Documentation

ACE_INLINE void OpenDDS::DCPS::Serializer::align_cont_r

(

)

[private]

Update alignment state when a cont() chain is followed during a read.

Definition at line 564 of file Serializer.inl.

References align_rshift_, ACE_Message_Block::cont(), current_, MAX_ALIGN, and ACE_Message_Block::rd_ptr().

Referenced by doread(), and skip().

{
  const size_t thisblock =
    (ptrdiff_t(this->current_->rd_ptr()) - this->align_rshift_) % MAX_ALIGN;

  this->current_ = this->current_->cont();

  if (this->current_) {
    this->align_rshift_ =
      (ptrdiff_t(this->current_->rd_ptr()) - thisblock) % MAX_ALIGN;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::align_cont_w

(

)

[private]

Update alignment state when a cont() chain is followed during a write.

Definition at line 578 of file Serializer.inl.

References align_wshift_, ACE_Message_Block::cont(), current_, MAX_ALIGN, and ACE_Message_Block::wr_ptr().

Referenced by align_w(), and dowrite().

{
  const size_t thisblock =
    (ptrdiff_t(this->current_->wr_ptr()) - this->align_wshift_) % MAX_ALIGN;

  this->current_ = this->current_->cont();

  if (this->current_) {
    this->align_wshift_ =
      (ptrdiff_t(this->current_->wr_ptr()) - thisblock) % MAX_ALIGN;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE int OpenDDS::DCPS::Serializer::align_r

(

size_t

alignment

)

Align for reading: moves current_->rd_ptr() past the alignment padding. Alignments of 2, 4, or 8 are supported by CDR and this implementation.

Definition at line 525 of file Serializer.inl.

References align_rshift_, current_, len, ACE_Message_Block::rd_ptr(), and skip().

Referenced by OpenDDS::DCPS::operator>>(), read_double_array(), read_float_array(), read_long_array(), read_longdouble_array(), read_longlong_array(), read_short_array(), read_string(), read_ulong_array(), read_ulonglong_array(), read_ushort_array(), and skip().

{
  const size_t len =
    (al - ptrdiff_t(this->current_->rd_ptr()) + this->align_rshift_) % al;
  this->skip(static_cast<ACE_CDR::UShort>(len));
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE int OpenDDS::DCPS::Serializer::align_w

(

size_t

alignment

)

Align for writing: moves current_->wr_ptr() past the padding, possibly zero-filling the pad bytes (based on the alignment_ setting). Alignments of 2, 4, or 8 are supported by CDR and this implementation.

Definition at line 534 of file Serializer.inl.

References align_cont_w(), ALIGN_INITIALIZE, ALIGN_PAD, align_wshift_, alignment_, current_, good_bit_, len, smemcpy(), ACE_Message_Block::space(), and ACE_Message_Block::wr_ptr().

Referenced by OpenDDS::DCPS::operator<<(), write_double_array(), write_float_array(), write_long_array(), write_longdouble_array(), write_longlong_array(), write_short_array(), write_ulong_array(), write_ulonglong_array(), and write_ushort_array().

{
  size_t len =
    (al - ptrdiff_t(this->current_->wr_ptr()) + this->align_wshift_) % al;
  while (len) {
    if (!this->current_) {
      this->good_bit_ = false;
      break;
    }
    const size_t cur_spc = this->current_->space();
    if (cur_spc <= len) {
      len -= cur_spc;
      if (this->alignment_ == ALIGN_INITIALIZE) {
        this->smemcpy(this->current_->wr_ptr(), ALIGN_PAD, cur_spc);
      }
      this->current_->wr_ptr(cur_spc);
      this->align_cont_w();
    } else {
      if (this->alignment_ == ALIGN_INITIALIZE) {
        this->smemcpy(this->current_->wr_ptr(), ALIGN_PAD, len);
      }
      this->current_->wr_ptr(len);
      break;
    }
  }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE Serializer::Alignment OpenDDS::DCPS::Serializer::alignment

(

)

const

Examine alignment behavior.

Definition at line 206 of file Serializer.inl.

References alignment_.

Referenced by OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), read_double_array(), read_float_array(), read_long_array(), read_longdouble_array(), read_longlong_array(), read_short_array(), read_ulong_array(), read_ulonglong_array(), read_ushort_array(), write_double_array(), write_float_array(), write_long_array(), write_longdouble_array(), write_longlong_array(), write_short_array(), write_ulong_array(), write_ulonglong_array(), and write_ushort_array().

{
  return this->alignment_;
}

Here is the caller graph for this function:

size_t OpenDDS::DCPS::Serializer::available_r

(

)

const [inline]

Definition at line 109 of file Serializer.h.

{ return current_ ? current_->total_length() : 0; }

ACE_INLINE void OpenDDS::DCPS::Serializer::buffer_read	(	char *	dest,
		size_t	size,
		bool	swap
	)

Read from the chain into a destination buffer.

Definition at line 98 of file Serializer.inl.

References doread().

Referenced by OpenDDS::DCPS::operator>>(), read_array(), and read_string().

{
  size_t offset = 0;

  while (size > offset) {
    offset = this->doread(dest, size, swap, offset);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::buffer_write	(	const char *	src,
		size_t	size,
		bool	swap
	)			[private]

Write to the chain from a source buffer.

Definition at line 184 of file Serializer.inl.

References dowrite().

Referenced by OpenDDS::DCPS::operator<<(), and write_array().

{
  size_t offset = 0;

  while (size > offset) {
    offset = this->dowrite(src, size, swap, offset);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE size_t OpenDDS::DCPS::Serializer::doread	(	char *	dest,
		size_t	size,
		bool	swap,
		size_t	offset
	)			[private]

Implementation of the actual read from the chain.

Definition at line 25 of file Serializer.inl.

References align_cont_r(), ALIGN_NONE, alignment_, ACE_Message_Block::cont(), current_, good_bit_, len, ACE_Message_Block::length(), ACE_Message_Block::rd_ptr(), smemcpy(), and swapcpy().

Referenced by buffer_read().

{
  //
  // Ensure we work only with buffer data.
  //
  if (this->current_ == 0) {
    this->good_bit_ = false;
    return size;
  }

  //
  // Determine how much data will remain to be read after the current
  // buffer has been entirely read.
  //
  const size_t len = this->current_->length();
  const size_t remainder = (size - offset > len) ? size - offset - len : 0;

  //
  // Derive how much data we need to read from the current buffer.
  //
  const size_t initial = size - offset - remainder;

  //
  // Copy or swap the source data from the current buffer into the
  // destination.
  //
  swap
    ? this->swapcpy(dest + remainder, this->current_->rd_ptr(), initial)
    : this->smemcpy(dest + offset, this->current_->rd_ptr(), initial);
  this->current_->rd_ptr(initial);

  //   smemcpy
  //
  //   dest            b1   b2   b3        offset   remainder   initial
  //   xxxxxxxx        01   23   4567xx
  //                   ^                   0        6           2
  //   01xxxxxx        01   23   4567xx
  //                        ^              2        4           2
  //   0123xxxx        01   23   4567xx
  //                             ^         4        0           4
  //   01234567        01   23   4567xx
  //                                 ^

  //   swapcpy
  //
  //   dest            b1   b2   b3        offset   remainder   initial
  //   xxxxxxxx        01   23   4567xx
  //                   ^                   0        6           2
  //   xxxxxx10        01   23   4567xx
  //                        ^              2        4           2
  //   xxxx3210        01   23   4567xx
  //                             ^         4        0           4
  //   76543210        01   23   4567xx
  //                                 ^

  //
  // Move to the next chained block if this one is spent.
  //
  if (this->current_->length() == 0) {

    if (this->alignment_ == ALIGN_NONE) {
      this->current_ = this->current_->cont();
    } else {
      this->align_cont_r();
    }
  }
  //
  // Return the current location in the read.
  //
  return offset + initial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE size_t OpenDDS::DCPS::Serializer::dowrite	(	const char *	dest,
		size_t	size,
		bool	swap,
		size_t	offset
	)			[private]

Implementation of the actual write to the chain.

Definition at line 111 of file Serializer.inl.

References align_cont_w(), ALIGN_NONE, alignment_, ACE_Message_Block::cont(), current_, good_bit_, smemcpy(), ACE_Message_Block::space(), swapcpy(), and ACE_Message_Block::wr_ptr().

Referenced by buffer_write().

{
  //
  // Ensure we work only with buffer data.
  //
  if (this->current_ == 0) {
    this->good_bit_ = false;
    return size;
  }

  //
  // Determine how much data will remain to be written after the current
  // buffer has been entirely filled.
  //
  const size_t spc = this->current_->space();
  const size_t remainder = (size - offset > spc) ? size - offset - spc : 0;

  //
  // Derive how much data we need to write to the current buffer.
  //
  const size_t initial = size - offset - remainder;

  //
  // Copy or swap the source data into the current buffer.
  //
  swap
    ? this->swapcpy(this->current_->wr_ptr(), src + remainder, initial)
    : this->smemcpy(this->current_->wr_ptr(), src + offset, initial);
  this->current_->wr_ptr(initial);

  //   smemcpy
  //
  //   src             b1   b2   b3        offset   remainder   initial
  //   01234567        xx   xx   xxxxxx
  //                   ^                   0        6           2
  //                   01   xx   xxxxxx
  //                        ^              2        4           2
  //                   01   23   xxxxxx
  //                             ^         4        0           4
  //                   01   23   4567xx
  //                                 ^

  //   swapcpy
  //
  //   src             b1   b2   b3        offset   remainder   initial
  //   01234567        xx   xx   xxxxxx
  //                   ^                   0        6           2
  //                   76   xx   xxxxxx
  //                        ^              2        4           2
  //                   76   54   xxxxxx
  //                             ^         4        0           4
  //                   76   54   3210xx
  //                                 ^

  //
  // Move to the next chained block if this one is spent.
  //
  if (this->current_->space() == 0) {

    if (this->alignment_ == ALIGN_NONE) {
      this->current_ = this->current_->cont();
    } else {
      this->align_cont_w();
    }
  }

  //
  // Return the current location in the write.
  //
  return offset + initial;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::good_bit

(

void

)

const

Examine the state of the stream abstraction.

Definition at line 212 of file Serializer.inl.

References good_bit_.

Referenced by OpenDDS::DCPS::operator<<(), OpenDDS::FaceTypes::operator>>(), OpenDDS::DCPS::operator>>(), read_boolean_array(), read_char_array(), read_double_array(), read_float_array(), read_long_array(), read_longdouble_array(), read_longlong_array(), read_octet_array(), read_short_array(), read_ulong_array(), read_ulonglong_array(), read_ushort_array(), read_wchar_array(), skip(), write_boolean_array(), write_char_array(), write_double_array(), write_float_array(), write_long_array(), write_longdouble_array(), write_longlong_array(), write_octet_array(), write_short_array(), write_ulong_array(), write_ulonglong_array(), write_ushort_array(), and write_wchar_array().

{
  return this->good_bit_;
}

Here is the caller graph for this function:

ACE_INLINE size_t OpenDDS::DCPS::Serializer::length

(

void

)

const

Number of bytes left to read in message block chain.

Definition at line 218 of file Serializer.inl.

References current_, good_bit_, and ACE_Message_Block::total_length().

Referenced by read_string().

{
  return this->good_bit_ && this->current_ ? this->current_->total_length() : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::read_array	(	char *	x,
		size_t	size,
		ACE_CDR::ULong	length,
		bool	swap
	)			[private]

Definition at line 258 of file Serializer.inl.

References buffer_read().

{
  if (!swap || size == 1) {
    //
    // No swap, copy direct.  This silently corrupts the data if there is
    // padding in the buffer.
    //
    this->buffer_read(x, size * length, false);

  } else {
    //
    // Swapping _must_ be done at 'size' boundaries, so we need to spin
    // through the array element by element.  This silently corrupts the
    // data if there is padding in the buffer.
    //
    while (length-- > 0) {
      this->buffer_read(x, size, true);
      x += size;
    }
  }
}

Here is the call graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::read_array	(	char *	x,
		size_t	size,
		ACE_CDR::ULong	length
	)			[private]

Read an array of values from the chain. NOTE: This assumes that the buffer contains elements that are properly aligned. The buffer must have padding if the elements are not naturally aligned; or this routine should not be used.

Definition at line 252 of file Serializer.inl.

References swap_bytes_.

Referenced by read_boolean_array(), read_char_array(), read_double_array(), read_float_array(), read_long_array(), read_longdouble_array(), read_longlong_array(), read_octet_array(), read_short_array(), read_string(), read_ulong_array(), read_ulonglong_array(), and read_ushort_array().

{
  this->read_array(x, size, length, this->swap_bytes_);
}

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_boolean_array	(	ACE_CDR::Boolean *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 313 of file Serializer.inl.

References good_bit(), and read_array().

{
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Boolean), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_char_array	(	ACE_CDR::Char *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 320 of file Serializer.inl.

References good_bit(), and read_array().

Referenced by read_string().

{
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Char), length);
  return this->good_bit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_double_array	(	ACE_CDR::Double *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 401 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::Double));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Double), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_float_array	(	ACE_CDR::Float *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 393 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::Float));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Float), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_long_array	(	ACE_CDR::Long *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 361 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::Long));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Long), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_longdouble_array	(	ACE_CDR::LongDouble *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 409 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(8);
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::LongDouble), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_longlong_array	(	ACE_CDR::LongLong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 377 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::LongLong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::LongLong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_octet_array	(	ACE_CDR::Octet *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 338 of file Serializer.inl.

References good_bit(), and read_array().

Referenced by OpenDDS::DCPS::TransportHeader::init().

{
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Octet), length);
  return this->good_bit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_short_array	(	ACE_CDR::Short *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 345 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::Short));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Short), length);
  return this->good_bit();
}

Here is the call graph for this function:

size_t OpenDDS::DCPS::Serializer::read_string	(	ACE_CDR::WChar *&	dest,
		ACE_CDR::WChar *	str_allocACE_CDR::ULong = CORBA::wstring_alloc,
		void	str_freeACE_CDR::WChar * = CORBA::wstring_free
	)

Read a wide string.

Definition at line 178 of file Serializer.cpp.

References ALIGN_NONE, align_r(), alignment_, buffer_read(), current_, good_bit_, length(), read_array(), SWAP_BE, swap_bytes(), ACE_Message_Block::total_length(), and WCHAR_SIZE.

{
  this->alignment_ == ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::ULong));
  //
  // Ensure no bad values leave the routine.
  //
  str_free(dest);
  dest = 0;

  //
  // Extract the string length.
  //
  ACE_CDR::ULong bytecount = 0;
  this->buffer_read(reinterpret_cast<char*>(&bytecount),
                    sizeof(ACE_CDR::ULong), this->swap_bytes());

  if (!this->good_bit_) {
    return 0;
  }

  //
  // NOTE: Maintain the ACE implementation where the length check is
  //       done here before the allocation even though it will be
  //       checked during the actual read as well.
  //
  ACE_CDR::ULong length = 0;
  if (bytecount <= this->current_->total_length()) {
    length = bytecount / WCHAR_SIZE;
    dest = str_alloc(length);

    if (dest == 0) {
      this->good_bit_ = false;
      return 0;
    }

#if ACE_SIZEOF_WCHAR == 2
    this->read_array(reinterpret_cast<char*>(dest), WCHAR_SIZE, length, SWAP_BE);
#else
    for (size_t i = 0; i < length && this->good_bit_; ++i) {
      ACE_UINT16 as_utf16;
      this->buffer_read(reinterpret_cast<char*>(&as_utf16), WCHAR_SIZE, SWAP_BE);
      if (this->good_bit_) {
        dest[i] = as_utf16;
      }
    }
#endif

    if (this->good_bit_) {
      //
      // Null terminate the string.
      //
      dest[length] = L'\0';
    } else {
      str_free(dest);
      dest = 0;
      length = 0;
    }

  } else {
    good_bit_ = false;
  }

  return length;
}

Here is the call graph for this function:

size_t OpenDDS::DCPS::Serializer::read_string	(	ACE_CDR::Char *&	dest,
		ACE_CDR::Char *	str_allocACE_CDR::ULong = CORBA::string_alloc,
		void	str_freeACE_CDR::Char * = CORBA::string_free
	)

Read a narrow string.

Definition at line 119 of file Serializer.cpp.

References ALIGN_NONE, align_r(), alignment_, buffer_read(), current_, good_bit_, length(), read_char_array(), swap_bytes(), and ACE_Message_Block::total_length().

Referenced by OpenDDS::FaceTypes::operator>>(), and OpenDDS::DCPS::operator>>().

{
  this->alignment_ == ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::ULong));
  //
  // Ensure no bad values leave the routine.
  //
  str_free(dest);
  dest = 0;

  //
  // Extract the string length.
  //
  ACE_CDR::ULong length; // includes the null
  this->buffer_read(reinterpret_cast<char*>(&length), sizeof(ACE_CDR::ULong), this->swap_bytes());

  if (!this->good_bit_) {
    return 0;
  }

  if (length == 0) {
    // not legal CDR, but we need to accept it since other implementations may generate this
    dest = str_alloc(0);
    return 0;
  }

  //
  // NOTE: Maintain the ACE implementation where the length check is
  //       done here before the allocation even though it will be
  //       checked during the actual read as well.
  //
  if (length <= this->current_->total_length()) {

    dest = str_alloc(length - 1);

    if (dest == 0) {
      this->good_bit_ = false;

    } else {
      //
      // Extract the string.
      //
      this->read_char_array(dest, length);
    }

    if (!this->good_bit_) {
      str_free(dest);
      dest = 0;
    }

  } else {
    good_bit_ = false;
  }

  return length - 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_ulong_array	(	ACE_CDR::ULong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 369 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::ULong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::ULong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_ulonglong_array	(	ACE_CDR::ULongLong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 385 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::ULongLong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::ULongLong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_ushort_array	(	ACE_CDR::UShort *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 353 of file Serializer.inl.

References ALIGN_NONE, align_r(), alignment(), good_bit(), and read_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_r(sizeof(ACE_CDR::UShort));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::UShort), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_wchar_array	(	ACE_CDR::WChar *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 327 of file Serializer.inl.

References good_bit().

{
  for (ACE_CDR::ULong i = 0; i < length; ++i) {
    if (!((*this) >> ACE_InputCDR::to_wchar(x[i]))) {
      break;
    }
  }
  return this->good_bit();
}

Here is the call graph for this function:

void OpenDDS::DCPS::Serializer::reset_alignment

(

)

Reset alignment as if a new instance were created.

Definition at line 43 of file Serializer.cpp.

References align_rshift_, align_wshift_, current_, MAX_ALIGN, ACE_Message_Block::rd_ptr(), and ACE_Message_Block::wr_ptr().

{
  align_rshift_ = current_ ? ptrdiff_t(current_->rd_ptr()) % MAX_ALIGN : 0;
  align_wshift_ = current_ ? ptrdiff_t(current_->wr_ptr()) % MAX_ALIGN : 0;
}

Here is the call graph for this function:

void OpenDDS::DCPS::Serializer::set_use_rti_serialization

(

bool

should_use

)

[static]

Definition at line 246 of file Serializer.cpp.

References use_rti_serialization_.

Referenced by OpenDDS::DCPS::Service_Participant::load_common_configuration(), and OpenDDS::DCPS::Service_Participant::parse_args().

{
  use_rti_serialization_ = should_use;
}

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::skip	(	ACE_CDR::UShort	n,
		int	size = 1
	)

Skip the logical rd_ptr() over a given number of bytes = n * size. If alignment is enabled, skips any padding to align to 'size' before skipping the n * size bytes. This is used by the RTPS protocol to allow reading messages from future versions of the spec which may have additional optional fields.

Definition at line 224 of file Serializer.inl.

References align_cont_r(), ALIGN_NONE, align_r(), alignment_, current_, good_bit(), good_bit_, len, ACE_Message_Block::length(), MAX_ALIGN, ACE_Message_Block::rd_ptr(), and ACE_Message_Block::wr_ptr().

Referenced by align_r(), OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), and OpenDDS::DCPS::RtpsSampleHeader::init().

{
  if (size > 1 && this->alignment_ != ALIGN_NONE) {
    if (!this->current_) {
      this->good_bit_ = false;
      return false;
    }
    this->align_r(size_t(size) > MAX_ALIGN ? MAX_ALIGN : size_t(size));
  }
  for (size_t len = static_cast<size_t>(n * size); len;) {
    if (!this->current_) {
      this->good_bit_ = false;
      return false;
    }
    const size_t cur_len = this->current_->length();
    if (cur_len <= len) {
      len -= cur_len;
      this->current_->rd_ptr(this->current_->wr_ptr());
      this->align_cont_r();
    } else {
      this->current_->rd_ptr(len);
      break;
    }
  }
  return this->good_bit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void OpenDDS::DCPS::Serializer::smemcpy	(	char *	to,
		const char *	from,
		size_t	n
	)			[private]

Efficient straight copy for quad words and shorter. This is an instance method to match the swapcpy semantics.

Definition at line 50 of file Serializer.cpp.

References ACE_OS::memcpy().

Referenced by align_w(), doread(), and dowrite().

{
    (void) ACE_OS::memcpy(
      reinterpret_cast<void*>(to),
      reinterpret_cast<const void*>(from),
      n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::swap_bytes

(

)

const

Examine byte swapping behavior.

Definition at line 200 of file Serializer.inl.

References swap_bytes_.

Referenced by read_string().

{
  return this->swap_bytes_;
}

Here is the caller graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::swap_bytes

(

bool

do_swap

)

Establish byte swapping behavior.

Definition at line 194 of file Serializer.inl.

References swap_bytes_.

Referenced by OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::DCPS::TransportHeader::init(), OpenDDS::DCPS::DataSampleHeader::init(), OpenDDS::DCPS::operator<<(), and OpenDDS::DCPS::operator>>().

{
  this->swap_bytes_ = do_swap;
}

Here is the caller graph for this function:

void OpenDDS::DCPS::Serializer::swapcpy	(	char *	to,
		const char *	from,
		size_t	n
	)			[private]

Efficient swapping copy for quad words and shorter. This is an instance method to allow clearing the good_bit_ on error.

Definition at line 59 of file Serializer.cpp.

References good_bit_.

Referenced by doread(), and dowrite().

{
  // Unroll the loop...
  switch (n) {               // 2   4   8   16
  case 16:
    to[ 15] = from[ n - 16]; // x   x   x    0
    // fallthrough
  case 15:
    to[ 14] = from[ n - 15]; // x   x   x    1
    // fallthrough
  case 14:
    to[ 13] = from[ n - 14]; // x   x   x    2
    // fallthrough
  case 13:
    to[ 12] = from[ n - 13]; // x   x   x    3
    // fallthrough
  case 12:
    to[ 11] = from[ n - 12]; // x   x   x    4
    // fallthrough
  case 11:
    to[ 10] = from[ n - 11]; // x   x   x    5
    // fallthrough
  case 10:
    to[  9] = from[ n - 10]; // x   x   x    6
    // fallthrough
  case  9:
    to[  8] = from[ n -  9]; // x   x   x    7
    // fallthrough
  case  8:
    to[  7] = from[ n -  8]; // x   x   0    8
    // fallthrough
  case  7:
    to[  6] = from[ n -  7]; // x   x   1    9
    // fallthrough
  case  6:
    to[  5] = from[ n -  6]; // x   x   2   10
    // fallthrough
  case  5:
    to[  4] = from[ n -  5]; // x   x   3   11
    // fallthrough
  case  4:
    to[  3] = from[ n -  4]; // x   0   4   12
    // fallthrough
  case  3:
    to[  2] = from[ n -  3]; // x   1   5   13
    // fallthrough
  case  2:
    to[  1] = from[ n -  2]; // 0   2   6   14
    // fallthrough
  case  1:
    to[  0] = from[ n -  1]; // 1   3   7   15
    // fallthrough
  case  0:
    return;
  default:
    this->good_bit_ = false;
  }
}

Here is the caller graph for this function:

bool OpenDDS::DCPS::Serializer::use_rti_serialization

(

)

[static]

Definition at line 252 of file Serializer.cpp.

References use_rti_serialization_.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< MessageType >::dds_demarshal(), OpenDDS::DCPS::DataWriterImpl_T< MessageType >::dds_marshal(), and OpenDDS::DCPS::DataReaderImpl_T< MessageType >::lookup_instance().

{
  return use_rti_serialization_;
}

Here is the caller graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::write_array	(	const char *	x,
		size_t	size,
		ACE_CDR::ULong	length,
		bool	swap
	)			[private]

Definition at line 288 of file Serializer.inl.

References buffer_write().

{
  if (!swap || size == 1) {
    //
    // No swap, copy direct.
    //
    this->buffer_write(x, size * length, false);

  } else {
    //
    // Swapping _must_ be done at 'size' boundaries, so we need to spin
    // through the array element by element.
    // NOTE: This assumes that there is _no_ padding between the array
    //       elements.  If this is not the case, do not use this
    //       method.
    //
    while (length-- > 0) {
      this->buffer_write(x, size, true);
      x += size;
    }
  }
}

Here is the call graph for this function:

ACE_INLINE void OpenDDS::DCPS::Serializer::write_array	(	const char *	x,
		size_t	size,
		ACE_CDR::ULong	length
	)			[private]

Write an array of values to the chain. NOTE: This assumes that there is _no_ padding between the array elements. If this is not the case, do not use this method. If padding exists in the array, it will be written when _not_ swapping, and will _not_ be written when swapping, resulting in corrupted data.

Definition at line 282 of file Serializer.inl.

References swap_bytes_.

Referenced by OpenDDS::DCPS::operator<<(), write_boolean_array(), write_char_array(), write_double_array(), write_float_array(), write_long_array(), write_longdouble_array(), write_longlong_array(), write_octet_array(), write_short_array(), write_ulong_array(), write_ulonglong_array(), and write_ushort_array().

{
  this->write_array(x, size, length, this->swap_bytes_);
}

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::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.

Definition at line 417 of file Serializer.inl.

References good_bit(), and write_array().

{
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Boolean), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_char_array	(	const ACE_CDR::Char *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 425 of file Serializer.inl.

References good_bit(), and write_array().

{
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Char), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_double_array	(	const ACE_CDR::Double *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 508 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::Double));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Double), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_float_array	(	const ACE_CDR::Float *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 500 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::Float));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Float), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_long_array	(	const ACE_CDR::Long *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 466 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::Long));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Long), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_longdouble_array	(	const ACE_CDR::LongDouble *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 516 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(8);
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::LongDouble), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_longlong_array	(	const ACE_CDR::LongLong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 482 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::LongLong));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::LongLong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_octet_array	(	const ACE_CDR::Octet *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 443 of file Serializer.inl.

References good_bit(), and write_array().

Referenced by OpenDDS::DCPS::RtpsUdpSendStrategy::marshal_transport_header().

{
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Octet), length);
  return this->good_bit();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_short_array	(	const ACE_CDR::Short *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 450 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::Short));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Short), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_ulong_array	(	const ACE_CDR::ULong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 474 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::ULong));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::ULong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_ulonglong_array	(	const ACE_CDR::ULongLong *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 491 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::ULongLong));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::ULongLong), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_ushort_array	(	const ACE_CDR::UShort *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 458 of file Serializer.inl.

References ALIGN_NONE, align_w(), alignment(), good_bit(), and write_array().

{
  this->alignment() == Serializer::ALIGN_NONE ? 0 : this->align_w(sizeof(ACE_CDR::UShort));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::UShort), length);
  return this->good_bit();
}

Here is the call graph for this function:

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_wchar_array	(	const ACE_CDR::WChar *	x,
		ACE_CDR::ULong	length
	)

The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 432 of file Serializer.inl.

References good_bit().

{
  for (ACE_CDR::ULong i = 0; i < length; ++i) {
    if (!((*this) << ACE_OutputCDR::from_wchar(x[i]))) {
      break;
    }
  }
  return this->good_bit();
}

Here is the call graph for this function:

---

Friends And Related Function Documentation

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		const std::string &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_wstring	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_string	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_octet	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_wchar	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_char	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_OutputCDR::from_boolean	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		const ACE_CDR::WChar *	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		const ACE_CDR::Char *	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::Double	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::Float	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::LongDouble	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::ULongLong	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::LongLong	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::ULong	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::Long	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::UShort	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::Short	x
	)			[friend]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		ACE_CDR::Char	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		std::string &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_wstring	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_string	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_octet	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_wchar	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_char	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_InputCDR::to_boolean	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::WChar *&	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Char *&	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Double &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Float &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::LongDouble &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::ULongLong &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::LongLong &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::ULong &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Long &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::UShort &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Short &	x
	)			[friend]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		ACE_CDR::Char &	x
	)			[friend]

---

Member Data Documentation

const char OpenDDS::DCPS::Serializer::ALIGN_PAD = {0} [static, private]

Definition at line 325 of file Serializer.h.

Referenced by align_w().

unsigned char OpenDDS::DCPS::Serializer::align_rshift_ [private]

Number of bytes off of max alignment (8) that the current_ block's rd_ptr() started at.

Definition at line 318 of file Serializer.h.

Referenced by align_cont_r(), align_r(), and reset_alignment().

unsigned char OpenDDS::DCPS::Serializer::align_wshift_ [private]

Number of bytes off of max alignment (8) that the current_ block's wr_ptr() started at.

Definition at line 322 of file Serializer.h.

Referenced by align_cont_w(), align_w(), and reset_alignment().

Alignment OpenDDS::DCPS::Serializer::alignment_ [private]

Current alignment mode, see Alignment enum above.

Definition at line 314 of file Serializer.h.

Referenced by align_w(), alignment(), doread(), dowrite(), read_string(), and skip().

ACE_Message_Block* OpenDDS::DCPS::Serializer::current_ [private]

Currently active message block in chain.

Definition at line 305 of file Serializer.h.

Referenced by align_cont_r(), align_cont_w(), align_r(), align_w(), doread(), dowrite(), length(), read_string(), reset_alignment(), and skip().

bool OpenDDS::DCPS::Serializer::good_bit_ [private]

Indicates the current state of the stream abstraction.

Definition at line 311 of file Serializer.h.

Referenced by align_w(), doread(), dowrite(), good_bit(), length(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), read_string(), skip(), and swapcpy().

const size_t OpenDDS::DCPS::Serializer::MAX_ALIGN = 8 [static, private]

Definition at line 324 of file Serializer.h.

Referenced by align_cont_r(), align_cont_w(), reset_alignment(), and skip().

const bool OpenDDS::DCPS::Serializer::SWAP_BE = false [static]

Definition at line 337 of file Serializer.h.

Referenced by OpenDDS::Security::extract_participant_guid_from_cpdata(), OpenDDS::Security::SSL::hash_serialized_impl::operator()(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), and read_string().

bool OpenDDS::DCPS::Serializer::swap_bytes_ [private]

Indicates whether bytes will be swapped for this stream.

Definition at line 308 of file Serializer.h.

Referenced by read_array(), swap_bytes(), and write_array().

bool OpenDDS::DCPS::Serializer::use_rti_serialization_ [static, private]

Definition at line 326 of file Serializer.h.

Referenced by set_use_rti_serialization(), and use_rti_serialization().

const size_t OpenDDS::DCPS::Serializer::WCHAR_SIZE = 2 [static]

Definition at line 329 of file Serializer.h.

Referenced by OpenDDS::DCPS::gen_max_marshaled_size(), OpenDDS::DCPS::max_marshaled_size_wchar(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), and read_string().

---

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

• Serializer.h
• Serializer.cpp
• Serializer.inl