OpenDDS::DCPS::Serializer Class Reference

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

#include <Serializer.h>

List of all members.

Public Types
	ALIGN_NONE
	ALIGN_INITIALIZE
	ALIGN_CDR
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 swaping behavior.
bool	swap_bytes () const
	Examine byte swaping behavior.
Alignment	alignment () const
	Examine alignment behavior.
void	reset_alignment ()
	Reset aligment as if a new instance were created.
bool	good_bit () const
	Examine the state of the stream abstraction.
void	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.
void	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)
void	buffer_read (char *dest, size_t size, bool swap)
	Read from the chain into a destination buffer.
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)
int	align_r (size_t alignment)
int	align_w (size_t alignment)
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, 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)

---

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 38 of file Serializer.h.

---

Member Enumeration Documentation

enum OpenDDS::DCPS::Serializer::Alignment

Enumerator:

ALIGN_NONE
ALIGN_INITIALIZE
ALIGN_CDR

Definition at line 41 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 25 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 36 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 548 of file Serializer.inl.

References align_rshift_, current_, and MAX_ALIGN.

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;
  }
}

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 562 of file Serializer.inl.

References align_wshift_, current_, and MAX_ALIGN.

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;
  }
}

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

(

size_t

alignment

)

[private]

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 509 of file Serializer.inl.

References 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;
}

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

(

size_t

alignment

)

[private]

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 518 of file Serializer.inl.

References align_cont_w(), ALIGN_INITIALIZE, ALIGN_PAD, current_, good_bit_, and smemcpy().

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;
}

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

(

)

const

Examine alignment behavior.

Definition at line 200 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_;
}

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 92 of file Serializer.inl.

References doread().

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

{
  register size_t offset = 0;

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

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 178 of file Serializer.inl.

References dowrite().

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

{
  register size_t offset = 0;

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

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 19 of file Serializer.inl.

References align_cont_r(), ALIGN_NONE, current_, good_bit_, 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();
  register size_t remainder = (size - offset > len) ? size - offset - len : 0;

  //
  // Derive how much data we need to read from the current buffer.
  //
  register 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;
}

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 105 of file Serializer.inl.

References align_cont_w(), ALIGN_NONE, current_, good_bit_, and swapcpy().

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();
  register size_t remainder = (size - offset > spc) ? size - offset - spc : 0;

  //
  // Derive how much data we need to write to the current buffer.
  //
  register 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;
}

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

(

)

const

Examine the state of the stream abstraction.

Definition at line 206 of file Serializer.inl.

References good_bit_.

Referenced by OpenDDS::DCPS::DataSampleHeader::init(), 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(), 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_;
}

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

Definition at line 242 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;
    }
  }
}

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 236 of file Serializer.inl.

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_);
}

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 297 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();
}

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 304 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();
}

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 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::Double));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Double), length);
  return this->good_bit();
}

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 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::Float));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Float), length);
  return this->good_bit();
}

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 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::Long));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::Long), length);
  return this->good_bit();
}

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 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(8);
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::LongDouble), length);
  return this->good_bit();
}

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 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::LongLong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::LongLong), length);
  return this->good_bit();
}

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 322 of file Serializer.inl.

References good_bit(), and read_array().

Referenced by OpenDDS::DCPS::TransportHeader::init(), and OpenDDS::DCPS::UdpTransport::passive_connection().

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

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 329 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();
}

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

Definition at line 149 of file Serializer.cpp.

References ALIGN_NONE, align_r(), alignment_, buffer_read(), current_, good_bit_, read_array(), SWAP_BE, 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;
  }

  //
  // 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 (bytecount <= this->current_->total_length()) {

    const ACE_CDR::ULong length = bytecount / WCHAR_SIZE;

    dest = str_alloc(length);

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

#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;
    }
  }
}

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

Definition at line 101 of file Serializer.cpp.

References ALIGN_NONE, align_r(), alignment_, buffer_read(), current_, good_bit_, and read_char_array().

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;
  }

  //
  // 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;
    }
  }
}

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 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::ULong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::ULong), length);
  return this->good_bit();
}

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 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::ULongLong));
  this->read_array(reinterpret_cast<char*>(x), sizeof(ACE_CDR::ULongLong), length);
  return this->good_bit();
}

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 337 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();
}

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 311 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();
}

void OpenDDS::DCPS::Serializer::reset_alignment

(

)

Reset aligment as if a new instance were created.

Definition at line 41 of file Serializer.cpp.

References align_rshift_, align_wshift_, current_, and MAX_ALIGN.

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

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

void OpenDDS::DCPS::Serializer::set_use_rti_serialization

(

bool

should_use

)

[static]

Definition at line 213 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;
}

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 212 of file Serializer.inl.

References align_cont_r(), ALIGN_NONE, align_r(), current_, and MAX_ALIGN.

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

{
  if (size > 1 && this->alignment_ != ALIGN_NONE) {
    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();
}

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 48 of file Serializer.cpp.

Referenced by align_w().

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

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

(

)

const

Examine byte swaping behavior.

Definition at line 194 of file Serializer.inl.

References swap_bytes_.

{
  return this->swap_bytes_;
}

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

(

bool

do_swap

)

Establish byte swaping behavior.

Definition at line 188 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;
}

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

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

Definition at line 57 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
  case 15:
    to[ 14] = from[ n - 15]; // x   x   x    1
  case 14:
    to[ 13] = from[ n - 14]; // x   x   x    2
  case 13:
    to[ 12] = from[ n - 13]; // x   x   x    3
  case 12:
    to[ 11] = from[ n - 12]; // x   x   x    4
  case 11:
    to[ 10] = from[ n - 11]; // x   x   x    5
  case 10:
    to[  9] = from[ n - 10]; // x   x   x    6
  case  9:
    to[  8] = from[ n -  9]; // x   x   x    7
  case  8:
    to[  7] = from[ n -  8]; // x   x   0    8
  case  7:
    to[  6] = from[ n -  7]; // x   x   1    9
  case  6:
    to[  5] = from[ n -  6]; // x   x   2   10
  case  5:
    to[  4] = from[ n -  5]; // x   x   3   11
  case  4:
    to[  3] = from[ n -  4]; // x   0   4   12
  case  3:
    to[  2] = from[ n -  3]; // x   1   5   13
  case  2:
    to[  1] = from[ n -  2]; // 0   2   6   14
  case  1:
    to[  0] = from[ n -  1]; // 1   3   7   15
  case  0:
    return;
  default:
    this->good_bit_ = false;
  }
}

bool OpenDDS::DCPS::Serializer::use_rti_serialization

(

)

[static]

Definition at line 219 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_;
}

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

Definition at line 272 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;
    }
  }
}

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 266 of file Serializer.inl.

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_);
}

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 401 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();
}

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

Definition at line 409 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();
}

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

Definition at line 492 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();
}

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

Definition at line 484 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();
}

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

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::Long));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::Long), length);
  return this->good_bit();
}

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

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(8);
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::LongDouble), length);
  return this->good_bit();
}

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

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::LongLong));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::LongLong), length);
  return this->good_bit();
}

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

Definition at line 427 of file Serializer.inl.

References good_bit(), and write_array().

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

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

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

Definition at line 434 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();
}

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

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::ULong));
  this->write_array(reinterpret_cast<const char*>(x), sizeof(ACE_CDR::ULong), length);
  return this->good_bit();
}

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

Definition at line 475 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();
}

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

Definition at line 442 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();
}

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

Definition at line 416 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();
}

---

Friends And Related Function Documentation

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

Definition at line 767 of file Serializer.inl.

{
  s << x.val_;
  const ACE_CDR::ULong stringlen =
    x.bound_ ? static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x.val_)) : 0;
  return s.good_bit() && ((x.bound_ == 0) || (stringlen <= x.bound_));
}

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

Definition at line 749 of file Serializer.inl.

{
  // Include the null termination in the serialized data.
  ACE_CDR::ULong stringlen = 0;

  if (x.val_ != 0) {
    stringlen = 1 + static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x.val_));
    s << stringlen;
    s.buffer_write(reinterpret_cast<char*>(x.val_), stringlen, false);

  } else {
    s << ACE_CDR::ULong(0);
  }

  return s.good_bit() && ((x.bound_ == 0) || (stringlen - 1 <= x.bound_));
}

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

Definition at line 742 of file Serializer.inl.

{
  s.buffer_write(reinterpret_cast<char*>(&x.val_), sizeof(ACE_CDR::Octet), false);
  return s.good_bit();
}

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

Definition at line 723 of file Serializer.inl.

{
  // CDR wchar format: 1 octet for # of bytes in wchar, followed by those bytes
  static const ACE_CDR::Octet wchar_bytes = Serializer::WCHAR_SIZE;
  s.buffer_write(reinterpret_cast<const char*>(&wchar_bytes), 1, false);
#if ACE_SIZEOF_WCHAR == 2
  s.buffer_write(reinterpret_cast<char*>(&x.val_), Serializer::WCHAR_SIZE, Serializer::SWAP_BE);
#else
  const ACE_UINT16 as_utf16 = static_cast<ACE_UINT16>(x.val_);
  if (as_utf16 != x.val_) { // not currently handling surrogates
    s.good_bit_ = false;
  } else {
    s.buffer_write(reinterpret_cast<const char*>(&as_utf16), Serializer::WCHAR_SIZE, Serializer::SWAP_BE);
  }
#endif
  return s.good_bit();
}

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

Definition at line 716 of file Serializer.inl.

{
  s.buffer_write(reinterpret_cast<char*>(&x.val_), sizeof(ACE_CDR::Char), false);
  return s.good_bit();
}

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

Definition at line 709 of file Serializer.inl.

{
  s.buffer_write(reinterpret_cast<char*>(&x.val_), sizeof(ACE_CDR::Boolean), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 680 of file Serializer.inl.

{
  //NOTE: Serializing wchar/wstring uses UTF-16BE
  if (x != 0) {
    // Do not include the null terminatator in the serialized data.
    const ACE_CDR::ULong length = static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x));
    s << ACE_CDR::ULong(length * Serializer::WCHAR_SIZE);

#if ACE_SIZEOF_WCHAR == 2
    s.write_array(reinterpret_cast<const char*>(x), Serializer::WCHAR_SIZE,
                  length, Serializer::SWAP_BE);
#else
    for (size_t i = 0; i < length && s.good_bit(); ++i) {
      const ACE_UINT16 as_utf16 = static_cast<ACE_UINT16>(x[i]);
      if (as_utf16 != x[i]) { // not currently handling surrogates
        s.good_bit_ = false;
        break;
      }
      s.buffer_write(reinterpret_cast<const char*>(&as_utf16), Serializer::WCHAR_SIZE, Serializer::SWAP_BE);
    }
#endif
  } else {
    s << ACE_CDR::ULong(0);
  }

  return s.good_bit();
}

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

Definition at line 663 of file Serializer.inl.

{
  if (x != 0) {
    // Include the null termination in the serialized data.
    const ACE_CDR::ULong stringlen =
      1 + static_cast<ACE_CDR::ULong>(ACE_OS::strlen(x));
    s << stringlen;
    s.buffer_write(reinterpret_cast<const char*>(x), stringlen, false);

  } else {
    s << ACE_CDR::ULong(0);
  }

  return s.good_bit();
}

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

Definition at line 655 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::Double));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Double), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 647 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::Float));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Float), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 639 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(8);
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::LongDouble), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 631 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::ULongLong));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::ULongLong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 623 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::LongLong));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::LongLong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 615 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::ULong));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::ULong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 607 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::Long));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Long), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 599 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::UShort));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::UShort), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 591 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_w(sizeof(ACE_CDR::Short));
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Short), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 584 of file Serializer.inl.

{
  s.buffer_write(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Char), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 925 of file Serializer.inl.

{
  s.read_string(const_cast<ACE_CDR::WChar*&>(x.val_));
  return s.good_bit()
         && ((x.bound_ == 0) || (ACE_OS::strlen(x.val_) <= x.bound_));
}

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

Definition at line 917 of file Serializer.inl.

{
  s.read_string(const_cast<char*&>(x.val_));
  return s.good_bit()
         && ((x.bound_ == 0) || (ACE_OS::strlen(x.val_) <= x.bound_));
}

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

Definition at line 910 of file Serializer.inl.

{
  s.buffer_read(reinterpret_cast<char*>(&x.ref_), sizeof(ACE_CDR::Octet), false);
  return s.good_bit();
}

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

Definition at line 891 of file Serializer.inl.

{
  ACE_CDR::Octet len;
  s.buffer_read(reinterpret_cast<char*>(&len), 1, false);
  if (len != Serializer::WCHAR_SIZE) {
    s.good_bit_ = false;
  } else {
#if ACE_SIZEOF_WCHAR == 2
    s.buffer_read(reinterpret_cast<char*>(&x.ref_), Serializer::WCHAR_SIZE, Serializer::SWAP_BE);
#else
    ACE_UINT16 as_utf16;
    s.buffer_read(reinterpret_cast<char*>(&as_utf16), Serializer::WCHAR_SIZE, Serializer::SWAP_BE);
    x.ref_ = as_utf16;
#endif
  }
  return s.good_bit();
}

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

Definition at line 884 of file Serializer.inl.

{
  s.buffer_read(reinterpret_cast<char*>(&x.ref_), sizeof(ACE_CDR::Char), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 877 of file Serializer.inl.

{
  s.buffer_read(reinterpret_cast<char*>(&x.ref_), sizeof(ACE_CDR::Boolean), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 870 of file Serializer.inl.

{
  s.read_string(x);
  return s.good_bit();
}

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

Definition at line 863 of file Serializer.inl.

{
  s.read_string(x);
  return s.good_bit();
}

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

Definition at line 855 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::Double));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Double), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 847 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::Float));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Float), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 839 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(8);
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::LongDouble), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 831 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::ULongLong));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::ULongLong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 823 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::LongLong));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::LongLong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 815 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::ULong));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::ULong), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 807 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::Long));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Long), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 799 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::UShort));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::UShort), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 791 of file Serializer.inl.

{
  s.alignment() == Serializer::ALIGN_NONE ? 0 : s.align_r(sizeof(ACE_CDR::Short));
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Short), s.swap_bytes());
  return s.good_bit();
}

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

Definition at line 784 of file Serializer.inl.

{
  s.buffer_read(reinterpret_cast<char*>(&x), sizeof(ACE_CDR::Char), s.swap_bytes());
  return s.good_bit();
}

---

Member Data Documentation

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

Definition at line 299 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 292 of file Serializer.h.

Referenced by align_cont_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 296 of file Serializer.h.

Referenced by align_cont_w(), and reset_alignment().

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

Current alignment mode, see Alignment enum above.

Definition at line 288 of file Serializer.h.

Referenced by alignment(), and read_string().

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

Currently active message block in chain.

Definition at line 279 of file Serializer.h.

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

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

Indicates the current state of the stream abstraction.

Definition at line 285 of file Serializer.h.

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

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

Definition at line 298 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 311 of file Serializer.h.

Referenced by 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 282 of file Serializer.h.

Referenced by swap_bytes().

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

Definition at line 300 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 303 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

---