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

#include <Serializer.h>

Collaboration diagram for OpenDDS::DCPS::Serializer:

[legend]

Classes
struct	FromBoundedString

struct	RdState

struct	ScopedAlignmentContext

struct	ToBoundedString

Public Types
enum	ConstructionStatus { ConstructionSuccessful, ElementConstructionFailure, BoundConstructionFailure }

typedef ACE_CDR::Char (	StrAllocate) (ACE_CDR::ULong)

typedef void(*	StrFree) (ACE_CDR::Char *)

typedef ACE_CDR::WChar (	WStrAllocate) (ACE_CDR::ULong)

typedef void(*	WStrFree) (ACE_CDR::WChar *)

Public Member Functions
	Serializer (ACE_Message_Block *chain, const Encoding &encoding)

	Serializer (ACE_Message_Block *chain, Encoding::Kind kind, Endianness endianness=ENDIAN_NATIVE)

	Serializer (ACE_Message_Block *chain, Encoding::Kind kind, bool swap_bytes)

virtual	~Serializer ()

const Encoding &	encoding () const

void	encoding (const Encoding &value)

void	swap_bytes (bool do_swap)

bool	swap_bytes () const

Endianness	endianness () const

void	endianness (Endianness value)

Encoding::Alignment	alignment () const

void	alignment (Encoding::Alignment value)

void	reset_alignment ()
	Reset alignment as if a new instance were created. More...

bool	good_bit () const

size_t	length () const
	Number of bytes left to read in message block chain. More...

size_t	read_string (ACE_CDR::Char *&dest, StrAllocate str_alloc=0, StrFree str_free=0)

void	free_string (ACE_CDR::Char *str, StrFree str_free=0)

size_t	read_string (ACE_CDR::WChar *&dest, WStrAllocate str_alloc=0, WStrFree str_free=0)

void	free_string (ACE_CDR::WChar *str, WStrFree str_free=0)

bool	skip (size_t n, int size=1)

ACE_Message_Block *	trim (size_t n) const

const char *	pos_rd () const

const char *	pos_wr () const

size_t	rpos () const
	Examine the logical reading position of the stream. More...

size_t	wpos () const
	Examine the logical writing position of the stream. More...

ACE_Message_Block *	current () const

void	buffer_read (char *dest, size_t size, bool swap)
	Read from the chain into a destination buffer. More...

bool	align_r (size_t alignment)

bool	align_w (size_t alignment)

bool	read_parameter_id (unsigned &id, size_t &size, bool &must_understand)

bool	write_parameter_id (const unsigned id, size_t size, bool must_understand=false)

bool	write_list_end_parameter_id ()

bool	skip_delimiter ()

bool	read_delimiter (size_t &size)

bool	write_delimiter (size_t size)

ConstructionStatus	get_construction_status () const

void	set_construction_status (ConstructionStatus cs)

template<typename T >
bool	peek_helper (ACE_Message_Block *const block, size_t bytes, T &t)

template<typename T >
bool	peek (T &t)

bool	peek (ACE_CDR::ULong &t)

RdState	rdstate () const

void	rdstate (const RdState &state)


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 Attributes
static const ACE_CDR::ULong	emheader_must_understand = 1U << 31U

static const ACE_CDR::ULong	MEMBER_ID_MAX = 0x0FFFFFFF
	Maximum value for member id. More...

static const ACE_CDR::ULong	MEMBER_ID_MASK = MEMBER_ID_MAX


static const ACE_CDR::UShort	pid_extended = 0x3f01

static const ACE_CDR::UShort	pid_list_end = 0x3f02

static const ACE_CDR::UShort	pid_impl_extension = 0x8000

static const ACE_CDR::UShort	pid_must_understand = 0x4000

Private Member Functions
void	buffer_write (const char *src, size_t size, bool swap)
	Write to the chain from a source buffer. More...

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

size_t	dowrite (const char *dest, size_t size, bool swap, size_t offset)
	Implementation of the actual write to the chain. More...

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

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


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

Static Private Member Functions
static unsigned char	offset (char *index, size_t start, size_t align)

Private Attributes
ACE_Message_Block *	current_
	Currently active message block in chain. More...

Encoding	encoding_
	Encoding Settings. More...

bool	swap_bytes_
	Indicates whether bytes will be swapped for this stream. More...

bool	good_bit_
	Indicates the current state of the stream abstraction. More...

ConstructionStatus	construction_status_
	The way to judge whether tryconstruct trim is able to be properly done. More...

unsigned char	align_rshift_

unsigned char	align_wshift_

size_t	rpos_
	Logical reading position of the stream. More...

size_t	wpos_
	Logical writing position of the stream. More...

Static Private Attributes
static const char	ALIGN_PAD [Encoding::ALIGN_MAX] = {0}
	Buffer that is copied for zero padding. More...

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::Float x)

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

OpenDDS_Dcps_Export bool	operator<< (Serializer &s, ACE_CDR::LongDouble 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 String &x)

OpenDDS_Dcps_Export bool	operator<< (Serializer &s, FromBoundedString< char > 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::Float &x)

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

OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ACE_CDR::LongDouble &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, String &x)

OpenDDS_Dcps_Export bool	operator>> (Serializer &s, ToBoundedString< char > 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 369 of file Serializer.h.

Member Typedef Documentation

◆ StrAllocate

typedef ACE_CDR::Char*(* OpenDDS::DCPS::Serializer::StrAllocate) (ACE_CDR::ULong)

Definition at line 437 of file Serializer.h.

◆ StrFree

typedef void(* OpenDDS::DCPS::Serializer::StrFree) (ACE_CDR::Char *)

Definition at line 438 of file Serializer.h.

◆ WStrAllocate

typedef ACE_CDR::WChar*(* OpenDDS::DCPS::Serializer::WStrAllocate) (ACE_CDR::ULong)

Definition at line 439 of file Serializer.h.

◆ WStrFree

typedef void(* OpenDDS::DCPS::Serializer::WStrFree) (ACE_CDR::WChar *)

Definition at line 440 of file Serializer.h.

Member Enumeration Documentation

◆ ConstructionStatus

enum OpenDDS::DCPS::Serializer::ConstructionStatus

Enumerator
ConstructionSuccessful
ElementConstructionFailure
BoundConstructionFailure

Definition at line 742 of file Serializer.h.

                           {
     ConstructionSuccessful,
     ElementConstructionFailure,
     BoundConstructionFailure
   };

Constructor & Destructor Documentation

◆ Serializer() [1/3]

OpenDDS::DCPS::Serializer::Serializer	(	ACE_Message_Block *	chain,
		const Encoding &	encoding
	)

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.

This constructor is meant for using a specific predefined encoding scheme.

Definition at line 352 of file Serializer.cpp.

References encoding(), and reset_alignment().

   : current_(chain)
   , good_bit_(true)
   , construction_status_(ConstructionSuccessful)
   , align_rshift_(0)
   , align_wshift_(0)
   , rpos_(0)
   , wpos_(0)
 {
   encoding(enc);
   reset_alignment();
 }

◆ Serializer() [2/3]

OpenDDS::DCPS::Serializer::Serializer	(	ACE_Message_Block *	chain,
		Encoding::Kind	kind,
		Endianness	endianness = `ENDIAN_NATIVE`
	)

More convenient version of the constructor above if you don't need to reuse the Encoding object.

Definition at line 365 of file Serializer.cpp.

References encoding(), and reset_alignment().

   : current_(chain)
   , good_bit_(true)
   , construction_status_(ConstructionSuccessful)
   , align_rshift_(0)
   , align_wshift_(0)
   , rpos_(0)
   , wpos_(0)
 {
   encoding(Encoding(kind, endianness));
   reset_alignment();
 }

◆ Serializer() [3/3]

OpenDDS::DCPS::Serializer::Serializer	(	ACE_Message_Block *	chain,
		Encoding::Kind	kind,
		bool	swap_bytes
	)

Equivalent to: Serializer(chain, kind, swap_bytes ? ENDIAN_NONNATIVE : ENDIAN_NATIVE)

Definition at line 379 of file Serializer.cpp.

References encoding(), and reset_alignment().

   : current_(chain)
   , good_bit_(true)
   , construction_status_(ConstructionSuccessful)
   , align_rshift_(0)
   , align_wshift_(0)
   , rpos_(0)
   , wpos_(0)
 {
   encoding(Encoding(kind, swap_bytes));
   reset_alignment();
 }

◆ ~Serializer()

OpenDDS::DCPS::Serializer::~Serializer ( )

virtual

Definition at line 393 of file Serializer.cpp.

394 {

395 }

Member Function Documentation

◆ align_cont_r()

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

References ACE_INLINE, OpenDDS::STUN::encoding(), and OpenDDS::DCPS::Encoding::max_align().

 {
   const size_t max_align = encoding().max_align();
   const size_t thisblock =
     max_align ? (ptrdiff_t(current_->rd_ptr()) - align_rshift_) % max_align : 0;
 
   current_ = current_->cont();
 
   if (current_ && max_align) {
     align_rshift_ = offset(current_->rd_ptr(), thisblock, max_align);
   }
 }

◆ align_cont_w()

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

References ACE_INLINE, OpenDDS::STUN::encoding(), and OpenDDS::DCPS::Encoding::max_align().

 {
   const size_t max_align = encoding().max_align();
   const size_t thisblock =
     max_align ? (ptrdiff_t(current_->wr_ptr()) - align_wshift_) % max_align : 0;
 
   current_ = current_->cont();
 
   if (current_ && max_align) {
     align_wshift_ = offset(current_->wr_ptr(), thisblock, max_align);
   }
 }

◆ align_r()

ACE_INLINE bool 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 813 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), OpenDDS::STUN::encoding(), and OpenDDS::DCPS::Encoding::max_align().

Referenced by OpenDDS::DCPS::operator>>(), read_parameter_id(), and OpenDDS::DCPS::RtpsUdpReceiveStrategy::sec_submsg_to_octets().

 {
   if (!alignment()) {
     return true;
   }
   if (!current_) {
     good_bit_ = false;
     return false;
   }
   al = (std::min)(al, encoding().max_align());
   const size_t len =
     (al - ptrdiff_t(current_->rd_ptr()) + align_rshift_) % al;
 
   return skip(static_cast<ACE_CDR::UShort>(len));
 }

◆ align_w()

ACE_INLINE bool 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 830 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), OpenDDS::STUN::encoding(), OpenDDS::DCPS::Encoding::max_align(), and OpenDDS::DCPS::Encoding::zero_init_padding().

Referenced by OpenDDS::Security::CryptoBuiltInImpl::encode_rtps_message(), OpenDDS::Security::CryptoBuiltInImpl::encode_submessage(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::RtpsUdpDataLink::submsgs_to_msgblock(), and write_parameter_id().

 {
   if (!alignment()) {
     return true;
   }
   if (!current_) {
     good_bit_ = false;
     return false;
   }
   al = (std::min)(al, encoding().max_align());
   size_t len =
     (al - ptrdiff_t(current_->wr_ptr()) + align_wshift_) % al;
   while (len) {
     if (!current_) {
       good_bit_ = false;
       break;
     }
     const size_t cur_spc = current_->space();
     if (cur_spc <= len) {
       len -= cur_spc;
       if (encoding().zero_init_padding()) {
         smemcpy(current_->wr_ptr(), ALIGN_PAD, cur_spc);
       }
       current_->wr_ptr(cur_spc);
       wpos_ += cur_spc;
       align_cont_w();
     } else {
       if (encoding().zero_init_padding()) {
         smemcpy(current_->wr_ptr(), ALIGN_PAD, len);
       }
       current_->wr_ptr(len);
       wpos_ += len;
       break;
     }
   }
   return good_bit_;
 }

◆ alignment() [1/2]

ACE_INLINE Encoding::Alignment OpenDDS::DCPS::Serializer::alignment ( ) const

Definition at line 417 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), and OpenDDS::STUN::encoding().

 {
   return encoding().alignment();
 }

◆ alignment() [2/2]

ACE_INLINE void OpenDDS::DCPS::Serializer::alignment ( Encoding::Alignment value )

Definition at line 423 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), OpenDDS::STUN::encoding(), and encoding_.

 {
   Encoding enc = encoding_;
   enc.alignment(value);
   encoding(enc);
 }

◆ buffer_read()

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

References ACE_INLINE.

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

 {
   size_t offset = 0;
 
   while (size > offset) {
     offset = doread(dest, size, swap, offset);
   }
 }

◆ buffer_write()

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

References ACE_INLINE.

Referenced by OpenDDS::DCPS::operator<<().

 {
   size_t offset = 0;
 
   while (size > offset) {
     offset = dowrite(src, size, swap, offset);
   }
 }

◆ current()

ACE_Message_Block* OpenDDS::DCPS::Serializer::current ( void ) const

inline

Definition at line 480 of file Serializer.h.

References OpenDDS_Dcps_Export, and OpenDDS::DCPS::operator<<().

Referenced by peek(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_aggregated_member().

   {
     return current_;
   }

◆ doread()

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

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), and OpenDDS::STUN::encoding().

 {
   //
   // Ensure we work only with buffer data.
   //
   if (current_ == 0) {
     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 = 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
     ? swapcpy(dest + remainder, current_->rd_ptr(), initial)
     : smemcpy(dest + offset, current_->rd_ptr(), initial);
   current_->rd_ptr(initial);
 
   // Update the logical reading position in the stream.
   rpos_ += 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 (current_->length() == 0) {
     if (encoding().alignment()) {
       align_cont_r();
     } else {
       current_ = current_->cont();
     }
   }
 
   //
   // Return the current location in the read.
   //
   return offset + initial;
 }

◆ dowrite()

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

References ACE_INLINE, OpenDDS::DCPS::Encoding::alignment(), and OpenDDS::STUN::encoding().

 {
   //
   // Ensure we work only with buffer data.
   //
   if (current_ == 0) {
     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 = 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
     ? swapcpy(current_->wr_ptr(), src + remainder, initial)
     : smemcpy(current_->wr_ptr(), src + offset, initial);
   current_->wr_ptr(initial);
 
   // Update the logical writing position in the stream.
   wpos_ += 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 (current_->space() == 0) {
     if (encoding().alignment()) {
       align_cont_w();
     } else {
       current_ = current_->cont();
     }
   }
 
   //
   // Return the current location in the write.
   //
   return offset + initial;
 }

◆ encoding() [1/2]

ACE_INLINE const Encoding & OpenDDS::DCPS::Serializer::encoding ( ) const

Definition at line 199 of file Serializer.inl.

References ACE_INLINE, and encoding_.

 {
   return encoding_;
 }

◆ encoding() [2/2]

ACE_INLINE void OpenDDS::DCPS::Serializer::encoding ( const Encoding & value )

Definition at line 205 of file Serializer.inl.

References ACE_INLINE, encoding_, OpenDDS::DCPS::ENDIAN_NATIVE, OpenDDS::DCPS::Encoding::endianness(), and value.

 {
   encoding_ = value;
   swap_bytes_ = value.endianness() != ENDIAN_NATIVE;
 }

◆ endianness() [1/2]

ACE_INLINE Endianness OpenDDS::DCPS::Serializer::endianness ( ) const

Definition at line 220 of file Serializer.inl.

References ACE_INLINE, and encoding_.

Referenced by OpenDDS::Security::CryptoBuiltInImpl::decode_rtps_message(), and OpenDDS::Security::CryptoBuiltInImpl::decode_submessage().

 {
   return encoding_.endianness();
 }

◆ endianness() [2/2]

ACE_INLINE void OpenDDS::DCPS::Serializer::endianness ( Endianness value )

Definition at line 212 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), and OpenDDS::DCPS::Encoding::endianness().

 {
   Encoding enc = encoding();
   enc.endianness(value);
   encoding(enc);
 }

◆ free_string() [1/2]

void OpenDDS::DCPS::Serializer::free_string	(	ACE_CDR::Char *	str,
		StrFree	str_free = `0`
	)

Definition at line 589 of file Serializer.cpp.

References CORBA::string_free(), and FACE::string_free().

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

 {
   if (str_free == 0) {
 #ifdef OPENDDS_UTIL_BUILD
     str_free = string_free;
 #else
     str_free = CORBA::string_free;
 #endif
   }
   str_free(str);
 }

◆ free_string() [2/2]

void OpenDDS::DCPS::Serializer::free_string	(	ACE_CDR::WChar *	str,
		WStrFree	str_free = `0`
	)

Definition at line 675 of file Serializer.cpp.

References wstring_free(), and CORBA::wstring_free().

 {
   if (str_free == 0) {
 #ifdef OPENDDS_UTIL_BUILD
     str_free = wstring_free;
 #else
     str_free = CORBA::wstring_free;
 #endif
   }
   str_free(str);
 }

◆ get_construction_status()

ACE_INLINE Serializer::ConstructionStatus OpenDDS::DCPS::Serializer::get_construction_status ( ) const

Definition at line 1745 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::DCPS::DataReaderImpl_T< DynamicSample >::dds_demarshal().

 {
   return construction_status_;
 }

◆ good_bit()

ACE_INLINE bool OpenDDS::DCPS::Serializer::good_bit ( void ) const

Definition at line 431 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::Security::CryptoBuiltInImpl::decode_submessage(), OpenDDS::Security::CryptoBuiltInImpl::encode_rtps_message(), OpenDDS::Security::CryptoBuiltInImpl::encode_serialized_payload(), OpenDDS::Security::CryptoBuiltInImpl::encode_submessage(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), OpenDDS::FaceTypes::operator>>(), and trim().

 {
   return good_bit_;
 }

◆ length()

ACE_INLINE size_t OpenDDS::DCPS::Serializer::length ( void ) const

Number of bytes left to read in message block chain.

Definition at line 437 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::XTypes::DynamicSample::deserialize(), OpenDDS::Security::CryptoBuiltInImpl::encode_rtps_message(), OpenDDS::Security::CryptoBuiltInImpl::encode_serialized_payload(), OpenDDS::Security::CryptoBuiltInImpl::encode_submessage(), OpenDDS::RTPS::MessageParser::hasNextSubmessage(), OpenDDS::STUN::operator>>(), OpenDDS::DCPS::operator>>(), OpenDDS::RTPS::MessageParser::parseSubmessageHeader(), read_string(), OpenDDS::RTPS::MessageParser::skipSubmessageContent(), OpenDDS::RTPS::MessageParser::skipToNextSubmessage(), and trim().

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

◆ offset()

ACE_INLINE unsigned char OpenDDS::DCPS::Serializer::offset	(	char *	index,
		size_t	start,
		size_t	align
	)

staticprivate

Definition at line 869 of file Serializer.inl.

References ACE_INLINE.

Referenced by reset_alignment(), and OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore().

 {
   return static_cast<unsigned char>((ptrdiff_t(index) - start) % align);
 }

◆ peek() [1/2]

template<typename T >

bool OpenDDS::DCPS::Serializer::peek ( T & t )

inline

Definition at line 783 of file Serializer.h.

Referenced by read_parameter_id().

   {
     // save
     const size_t rpos = rpos_;
     const unsigned char align_rshift = align_rshift_;
     ACE_Message_Block* const current = current_;
 
     // read
     if (!peek_helper(current_, 0, t)) {
       return false;
     }
 
     // reset
     current_ = current;
     align_rshift_ = align_rshift;
     rpos_ = rpos;
     return true;
   }

◆ peek() [2/2]

bool OpenDDS::DCPS::Serializer::peek ( ACE_CDR::ULong & t )

Definition at line 423 of file Serializer.cpp.

References align_rshift_, current(), current_, peek_helper(), rpos(), rpos_, and OpenDDS::DCPS::uint32_cdr_size.

 {
   // save
   const size_t rpos = rpos_;
   const unsigned char align_rshift = align_rshift_;
   ACE_Message_Block* const current = current_;
 
   // read
   if (!peek_helper(current_, 2 * uint32_cdr_size, t)) {
     return false;
   }
 
   // reset
   current_ = current;
   align_rshift_ = align_rshift;
   rpos_ = rpos;
   return true;
 }

◆ peek_helper()

template<typename T >

bool OpenDDS::DCPS::Serializer::peek_helper	(	ACE_Message_Block *const	block,
		size_t	bytes,
		T &	t
	)

inline

Definition at line 768 of file Serializer.h.

References ACE_Message_Block::cont(), ACE_Message_Block::length(), and ACE_Message_Block::rd_ptr().

Referenced by peek().

   {
     bool result = false;
     char* const rd_ptr = block->rd_ptr();
     const size_t length = block->length();
     if (!block->cont() || length == 0 || (bytes != 0 && bytes <= length)) {
       result = *this >> t;
     } else {
       result = peek_helper(block->cont(), bytes - length, t);
     }
     block->rd_ptr(rd_ptr);
     return result;
   }

◆ pos_rd()

const char* OpenDDS::DCPS::Serializer::pos_rd ( ) const

inline

Definition at line 471 of file Serializer.h.

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

ACE_Message_Block::rd_ptr

char * rd_ptr(void) const

OpenDDS::DCPS::Serializer::current_

ACE_Message_Block * current_

Currently active message block in chain.

Definition: Serializer.h:864

◆ pos_wr()

const char* OpenDDS::DCPS::Serializer::pos_wr ( ) const

inline

Definition at line 472 of file Serializer.h.

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

ACE_Message_Block::wr_ptr

char * wr_ptr(void) const

OpenDDS::DCPS::Serializer::current_

ACE_Message_Block * current_

Currently active message block in chain.

Definition: Serializer.h:864

◆ rdstate() [1/2]

ACE_INLINE Serializer::RdState OpenDDS::DCPS::Serializer::rdstate ( void ) const

Definition at line 1757 of file Serializer.inl.

References ACE_INLINE, and state.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::DynamicDataXcdrReadImpl(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::setup_stream(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_aggregated_member().

 {
   RdState state(align_rshift_, rpos_);
   return state;
 }

◆ rdstate() [2/2]

ACE_INLINE void OpenDDS::DCPS::Serializer::rdstate ( const RdState & state )

Definition at line 1764 of file Serializer.inl.

References OpenDDS::DCPS::Serializer::RdState::align_rshift, OPENDDS_END_VERSIONED_NAMESPACE_DECL, and OpenDDS::DCPS::Serializer::RdState::rpos.

 {
   align_rshift_ = state.align_rshift;
   rpos_ = state.rpos;
 }

◆ read_array() [1/2]

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

References ACE_INLINE.

Referenced by read_string().

 {
   read_array(x, size, length, swap_bytes_);
 }

◆ read_array() [2/2]

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

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

References ACE_INLINE.

 {
   if (!swap || size == 1) {
     //
     // No swap, copy direct.  This silently corrupts the data if there is
     // padding in the buffer.
     //
     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) {
       buffer_read(x, size, true);
       x += size;
     }
   }
 }

◆ read_boolean_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 533 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::boolean_cdr_size.

 {
   read_array(reinterpret_cast<char*>(x), boolean_cdr_size, length);
   return good_bit();
 }

◆ read_char_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 540 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::char8_cdr_size.

Referenced by read_string().

 {
   read_array(reinterpret_cast<char*>(x), char8_cdr_size, length);
   return good_bit();
 }

◆ read_delimiter()

ACE_INLINE bool OpenDDS::DCPS::Serializer::read_delimiter ( size_t & size )

Read a delimiter used for XCDR2 delimited data.

Returns true if successful and size will be set to the size of the CDR value excluding the delimiter.

Definition at line 912 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), OpenDDS::DCPS::Encoding::xcdr_version(), and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_item_count(), OpenDDS::DCPS::operator>>(), OpenDDS::XTypes::read_empty_xcdr2_nonfinal(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_all(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_collection_member(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_map_element(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_struct_member().

 {
   if (encoding().xcdr_version() == Encoding::XCDR_VERSION_2) {
     ACE_CDR::ULong dheader;
     if (*this >> dheader) {
       size = dheader;
       return true;
     }
   }
   return false;
 }

◆ read_double_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 651 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float64_cdr_size.

 {
   if (!align_r(float64_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), float64_cdr_size, length);
   return good_bit();
 }

◆ read_float_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 641 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float32_cdr_size.

 {
   if (!align_r(float32_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), float32_cdr_size, length);
   return good_bit();
 }

◆ read_long_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 601 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int32_cdr_size.

Referenced by OpenDDS::DCPS::operator>>().

 {
   if (!align_r(int32_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), int32_cdr_size, length);
   return good_bit();
 }

◆ read_longdouble_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 661 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float128_cdr_size.

 {
   if (!align_r(float128_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), float128_cdr_size, length);
   return good_bit();
 }

◆ read_longlong_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 621 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int64_cdr_size.

 {
   if (!align_r(int64_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), int64_cdr_size, length);
   return good_bit();
 }

◆ read_octet_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 558 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::byte_cdr_size, OpenDDS::DCPS::int8_cdr_size, and OpenDDS::DCPS::uint8_cdr_size.

Referenced by OpenDDS::XTypes::DynamicSample::deserialize(), OpenDDS::DCPS::RtpsUdpSendStrategy::encode_rtps_message(), OpenDDS::DCPS::TransportHeader::init(), OpenDDS::STUN::operator>>(), and OpenDDS::DCPS::operator>>().

 {
   read_array(reinterpret_cast<char*>(x), byte_cdr_size, length);
   return good_bit();
 }

◆ read_parameter_id()

bool OpenDDS::DCPS::Serializer::read_parameter_id	(	unsigned &	id,
		size_t &	size,
		bool &	must_understand
	)

Read a XCDR parameter ID used in XCDR parameter lists.

Returns true if successful.

Definition at line 707 of file Serializer.cpp.

References align_r(), emheader_must_understand, encoding(), peek(), pid_extended, reset_alignment(), skip(), OpenDDS::DCPS::uint32_cdr_size, OpenDDS::DCPS::xcdr1_pid_alignment, OpenDDS::DCPS::Encoding::xcdr_version(), OpenDDS::DCPS::Encoding::XCDR_VERSION_1, and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_complex_value(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_item_count(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_member_id_at_index(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_value_from_union(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_values_from_union(), OpenDDS::DCPS::operator>>(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::read_discriminator(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_struct_member().

 {
   const Encoding::XcdrVersion xcdr = encoding().xcdr_version();
   if (xcdr == Encoding::XCDR_VERSION_1) {
     // Get the "short" id and size
     if (!align_r(xcdr1_pid_alignment)) {
       return false;
     }
     ACE_CDR::UShort pid;
     if (!(*this >> pid)) {
       return false;
     }
     const ACE_CDR::UShort short_id = pid & 0x3fff;
     ACE_CDR::UShort short_size;
     if (!(*this >> short_size)) {
       return false;
     }
 
     // TODO(iguessthislldo): handle PID flags
     must_understand = false; // Placeholder
 
     // If extended, get the "long" id and size
     if (short_id == pid_extended) {
       ACE_CDR::ULong long_id, long_size;
       if (!(*this >> long_id) || !(*this >> long_size)) {
         return false;
       }
       const unsigned short_size_left = short_size - 8;
       if (short_size_left) {
         skip(short_size_left);
       }
       id = long_id;
       size = long_size;
     } else {
       id = short_id;
       size = short_size;
     }
 
     reset_alignment();
   } else if (xcdr == Encoding::XCDR_VERSION_2) {
     ACE_CDR::ULong emheader;
     if (!(*this >> emheader)) {
       return false;
     }
 
     must_understand = emheader & emheader_must_understand;
 
     // Get Size
     const unsigned short lc = (emheader >> 28) & 0x7;
     if (lc < 4) {
       size = size_t(1) << lc;
     } else {
       ACE_CDR::ULong next_int;
       if (lc == 4 ? !(*this >> next_int) : !peek(next_int)) {
         return false;
       }
       switch (lc) {
       case 4:
         size = next_int;
         break;
       case 5:
         size = uint32_cdr_size + next_int;
         break;
       case 6:
         size = uint32_cdr_size + next_int * 4;
         break;
       case 7:
         size = uint32_cdr_size + next_int * 8;
         break;
       }
     }
     id = emheader & 0xfffffff;
   }
 
   return true;
 }

◆ read_short_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 581 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int16_cdr_size.

 {
   if (!align_r(int16_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), int16_cdr_size, length);
   return good_bit();
 }

◆ read_string() [1/2]

size_t OpenDDS::DCPS::Serializer::read_string	(	ACE_CDR::Char *&	dest,
		StrAllocate	str_alloc = `0`,
		StrFree	str_free = `0`
	)

Definition at line 520 of file Serializer.cpp.

References current_, free_string(), good_bit_, length(), read_char_array(), CORBA::string_alloc(), and FACE::string_alloc().

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

 {
   if (str_alloc == 0) {
 #ifdef OPENDDS_UTIL_BUILD
     str_alloc = string_alloc;
 #else
     str_alloc = CORBA::string_alloc;
 #endif
   }
 
   //
   // Ensure no bad values leave the routine.
   //
   free_string(dest, str_free);
   dest = 0;
 
   //
   // Extract the string length.
   //
   ACE_CDR::ULong length; // includes the null
   if (!(*this >> length)) {
     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 (current_ && length <= current_->total_length()) {
 
     dest = str_alloc(length - 1);
 
     if (dest == 0) {
       good_bit_ = false;
 
     } else {
       //
       // Extract the string.
       //
       read_char_array(dest, length);
 
       if (good_bit_ && dest[length - 1]) {
         // If the last byte was not a 0 it's not a valid CDR string
         good_bit_ = false;
       }
     }
 
     if (!good_bit_) {
       free_string(dest, str_free);
       dest = 0;
     }
 
   } else {
     good_bit_ = false;
   }
 
   return length - 1;
 }

◆ read_string() [2/2]

size_t OpenDDS::DCPS::Serializer::read_string	(	ACE_CDR::WChar *&	dest,
		WStrAllocate	str_alloc = `0`,
		WStrFree	str_free = `0`
	)

Definition at line 603 of file Serializer.cpp.

References buffer_read(), OpenDDS::DCPS::char16_cdr_size, current_, free_string(), good_bit_, length(), read_array(), swap_bytes(), wstring_alloc(), and CORBA::wstring_alloc().

 {
   if (str_alloc == 0) {
 #ifdef OPENDDS_UTIL_BUILD
     str_alloc = wstring_alloc;
 #else
     str_alloc = CORBA::wstring_alloc;
 #endif
   }
 
   //
   // Ensure no bad values leave the routine.
   //
   free_string(dest, str_free);
   dest = 0;
 
   //
   // Extract the string size.
   //
   ACE_CDR::ULong bytecount;
   if (!(*this >> bytecount)) {
     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 (current_ && bytecount <= current_->total_length()) {
     length = bytecount / char16_cdr_size;
     dest = str_alloc(length);
 
     if (dest == 0) {
       good_bit_ = false;
       return 0;
     }
 
 #if ACE_SIZEOF_WCHAR == 2
     read_array(reinterpret_cast<char*>(dest), char16_cdr_size, length, swap_bytes());
 #else
     for (size_t i = 0; i < length && good_bit_; ++i) {
       ACE_UINT16 as_utf16;
       buffer_read(reinterpret_cast<char*>(&as_utf16), char16_cdr_size, swap_bytes());
       if (good_bit_) {
         dest[i] = as_utf16;
       }
     }
 #endif
 
     if (good_bit_) {
       //
       // Null terminate the string.
       //
       dest[length] = L'\0';
     } else {
       free_string(dest, str_free);
       dest = 0;
       length = 0;
     }
 
   } else {
     good_bit_ = false;
   }
 
   return length;
 }

◆ read_ulong_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 611 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint32_cdr_size.

Referenced by OpenDDS::DCPS::operator>>().

 {
   if (!align_r(uint32_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), uint32_cdr_size, length);
   return good_bit();
 }

◆ read_ulonglong_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 631 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint64_cdr_size.

 {
   if (!align_r(uint64_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), uint64_cdr_size, length);
   return good_bit();
 }

◆ read_ushort_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 591 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint16_cdr_size.

 {
   if (!align_r(uint16_cdr_size)) {
     return false;
   }
   read_array(reinterpret_cast<char*>(x), uint16_cdr_size, length);
   return good_bit();
 }

◆ read_wchar_array()

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

Read basic IDL types arrays The buffer x must be large enough to contain length elements. Return false on failure and true on success.

Definition at line 547 of file Serializer.inl.

References ACE_INLINE.

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

◆ reset_alignment()

void OpenDDS::DCPS::Serializer::reset_alignment ( )

Reset alignment as if a new instance were created.

Definition at line 443 of file Serializer.cpp.

References OpenDDS::DCPS::align(), align_rshift_, align_wshift_, current_, encoding(), OpenDDS::DCPS::Encoding::max_align(), offset(), ACE_Message_Block::rd_ptr(), and ACE_Message_Block::wr_ptr().

Referenced by OpenDDS::RTPS::Sedp::SecurityReader::data_received_i(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), read_parameter_id(), OpenDDS::DCPS::Serializer::ScopedAlignmentContext::ScopedAlignmentContext(), Serializer(), and write_parameter_id().

 {
   const ptrdiff_t align = encoding().max_align();
   if (current_ && align) {
     align_rshift_ = offset(current_->rd_ptr(), 0, align);
     align_wshift_ = offset(current_->wr_ptr(), 0, align);
   }
 }

◆ rpos()

size_t OpenDDS::DCPS::Serializer::rpos ( ) const

inline

Examine the logical reading position of the stream.

Definition at line 475 of file Serializer.h.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_item_count(), OpenDDS::DCPS::operator>>(), peek(), OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_map_element(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_struct_member().

475 { return rpos_; }

OpenDDS::DCPS::Serializer::rpos_

size_t rpos_

Logical reading position of the stream.

Definition: Serializer.h:891

◆ set_construction_status()

ACE_INLINE void OpenDDS::DCPS::Serializer::set_construction_status ( ConstructionStatus cs )

Definition at line 1751 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::DCPS::operator>>().

 {
   construction_status_ = cs;
 }

◆ skip()

ACE_INLINE bool OpenDDS::DCPS::Serializer::skip	(	size_t	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 443 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), and OpenDDS::DCPS::Encoding::max_align().

 {
   if (size > 1 && !align_r((std::min)(size_t(size), encoding().max_align()))) {
     return false;
   }
 
   for (size_t len = static_cast<size_t>(n * size); len;) {
     if (!current_) {
       good_bit_ = false;
       return false;
     }
     const size_t cur_len = current_->length();
     if (cur_len <= len) {
       len -= cur_len;
       current_->rd_ptr(current_->wr_ptr());
       align_cont_r();
     } else {
       current_->rd_ptr(len);
       break;
     }
   }
 
   if (good_bit_) {
     rpos_ += n * size;
   }
   return good_bit();
 }

◆ skip_delimiter()

ACE_INLINE bool OpenDDS::DCPS::Serializer::skip_delimiter ( )

Skip a delimiter used for XCDR2 delimited data.

Returns true if successful

Definition at line 903 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), OpenDDS::DCPS::uint32_cdr_size, OpenDDS::DCPS::Encoding::xcdr_version(), and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

Referenced by OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_complex_value(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_item_count(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_member_id_at_index(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_union_selected_member(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::get_value_from_union(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::read_values(), OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_array_element(), and OpenDDS::XTypes::DynamicDataXcdrReadImpl::skip_to_sequence_element().

 {
   if (encoding().xcdr_version() == Encoding::XCDR_VERSION_2) {
     return skip(uint32_cdr_size);
   }
   return true;
 }

◆ smemcpy()

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

References ACE_OS::memcpy(), and OPENDDS_ASSERT.

 {
   OPENDDS_ASSERT(from);
   (void) ACE_OS::memcpy(to, from, n);
 }

◆ swap_bytes() [1/2]

ACE_INLINE void OpenDDS::DCPS::Serializer::swap_bytes ( bool do_swap )

Definition at line 403 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), encoding_, OpenDDS::DCPS::ENDIAN_NATIVE, OpenDDS::DCPS::ENDIAN_NONNATIVE, and OpenDDS::DCPS::Encoding::endianness().

Referenced by OpenDDS::Security::CryptoBuiltInImpl::authtag(), OpenDDS::Security::CryptoBuiltInImpl::decode_submessage(), OpenDDS::RTPS::Spdp::SpdpTransport::handle_input(), OpenDDS::DCPS::TransportHeader::init(), OpenDDS::DCPS::DataSampleHeader::init(), OpenDDS::DCPS::operator<<(), OpenDDS::DCPS::operator>>(), and OpenDDS::RTPS::MessageParser::parseSubmessageHeader().

 {
   Encoding enc = encoding_;
   enc.endianness(do_swap ? ENDIAN_NONNATIVE : ENDIAN_NATIVE);
   encoding(enc);
 }

◆ swap_bytes() [2/2]

ACE_INLINE bool OpenDDS::DCPS::Serializer::swap_bytes ( ) const

Definition at line 411 of file Serializer.inl.

References ACE_INLINE.

Referenced by read_string().

 {
   return swap_bytes_;
 }

◆ swapcpy()

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

References good_bit_.

 {
   // 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:
     good_bit_ = false;
   }
 }

◆ trim()

ACE_Message_Block * OpenDDS::DCPS::Serializer::trim ( size_t n ) const

Return a duplicated Message Block (chain) which starts at the current read position (rpos) and extends for n bytes. This can be used to treat a subset of the original message as if it was itself a full message, for example the SerializedPayload or the Parameter value inside a ParameterList. The returned object should be release()'d (use Message_Block_Ptr)

Definition at line 688 of file Serializer.cpp.

References ACE_Message_Block::cont(), current_, dup(), ACE_Message_Block::duplicate(), good_bit(), ACE_Message_Block::length(), length(), and ACE_Message_Block::release().

 {
   if (!good_bit() || !current_ || n > length()) {
     return 0;
   }
   Message_Block_Ptr dup(current_->duplicate());
   ACE_Message_Block* i = dup.get();
   for (size_t remain = n; i && remain; i = i->cont()) {
     if (i->length() >= remain) {
       i->wr_ptr(i->rd_ptr() + remain);
       ACE_Message_Block::release(i->cont());
       i->cont(0);
       break;
     }
     remain -= i->length();
   }
   return dup.release();
 }

◆ wpos()

size_t OpenDDS::DCPS::Serializer::wpos ( ) const

inline

Examine the logical writing position of the stream.

Definition at line 478 of file Serializer.h.

Referenced by OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore().

478 { return wpos_; }

OpenDDS::DCPS::Serializer::wpos_

size_t wpos_

Logical writing position of the stream.

Definition: Serializer.h:894

◆ write_array() [1/2]

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

References ACE_INLINE.

Referenced by OpenDDS::DCPS::operator<<().

 {
   write_array(x, size, length, swap_bytes_);
 }

◆ write_array() [2/2]

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

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

References ACE_INLINE.

 {
   if (!swap || size == 1) {
     //
     // No swap, copy direct.
     //
     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) {
       buffer_write(x, size, true);
       x += size;
     }
   }
 }

◆ write_boolean_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 671 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::boolean_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   write_array(reinterpret_cast<const char*>(x), boolean_cdr_size, length);
   return good_bit();
 }

◆ write_char_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 679 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::char8_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   write_array(reinterpret_cast<const char*>(x), char8_cdr_size, length);
   return good_bit();
 }

◆ write_delimiter()

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_delimiter ( size_t size )

Write a delimiter used for XCDR2 delimited data.

Size is assumed to include the delimiter as serialized_size would return. Returns true if successful.

Definition at line 925 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), OpenDDS::DCPS::uint32_cdr_size, OpenDDS::DCPS::Encoding::xcdr_version(), and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

 {
   if (encoding().xcdr_version() == Encoding::XCDR_VERSION_2) {
     return *this << static_cast<ACE_CDR::ULong>(size - uint32_cdr_size);
   }
   return true;
 }

◆ write_double_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 792 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float64_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(float64_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), float64_cdr_size, length);
   return good_bit();
 }

◆ write_float_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 782 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float32_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(float32_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), float32_cdr_size, length);
   return good_bit();
 }

◆ write_list_end_parameter_id()

ACE_INLINE bool OpenDDS::DCPS::Serializer::write_list_end_parameter_id ( )

Write the parameter ID that marks the end of XCDR1 parameter lists.

Returns true if successful.

Definition at line 934 of file Serializer.inl.

References ACE_INLINE, OpenDDS::STUN::encoding(), OpenDDS::DCPS::xcdr1_pid_alignment, OpenDDS::DCPS::Encoding::xcdr_version(), and OpenDDS::DCPS::Encoding::XCDR_VERSION_1.

 {
   if (encoding().xcdr_version() == Encoding::XCDR_VERSION_1) {
     return align_w(xcdr1_pid_alignment) && *this << pid_list_end && *this << ACE_CDR::UShort(0);
   }
   return true;
 }

◆ write_long_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 740 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int32_cdr_size.

Referenced by OpenDDS::DCPS::operator<<(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_enum_array_as_ints_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_enum_sequence_as_ints_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(int32_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), int32_cdr_size, length);
   return good_bit();
 }

◆ write_longdouble_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 802 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::float128_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(float128_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), float128_cdr_size, length);
   return good_bit();
 }

◆ write_longlong_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 760 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int64_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(int64_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), int64_cdr_size, length);
   return good_bit();
 }

◆ write_octet_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 697 of file Serializer.inl.

References ACE_INLINE, OpenDDS::DCPS::byte_cdr_size, OpenDDS::DCPS::int8_cdr_size, and OpenDDS::DCPS::uint8_cdr_size.

Referenced by OpenDDS::Security::CryptoBuiltInImpl::encode_rtps_message(), OpenDDS::Security::CryptoBuiltInImpl::encode_serialized_payload(), OpenDDS::Security::CryptoBuiltInImpl::encode_submessage(), OpenDDS::DCPS::RtpsUdpSendStrategy::marshal_transport_header(), OpenDDS::DCPS::operator<<(), OpenDDS::STUN::operator<<(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array(), and OpenDDS::DCPS::ReceivedDataSample::write_data().

 {
   write_array(reinterpret_cast<const char*>(x), byte_cdr_size, length);
   return good_bit();
 }

◆ write_parameter_id()

bool OpenDDS::DCPS::Serializer::write_parameter_id	(	const unsigned	id,
		size_t	size,
		bool	must_understand = `false`
	)

Write a XCDR parameter ID used in XCDR parameter lists.

Returns true if successful.

Definition at line 784 of file Serializer.cpp.

References align_w(), emheader_must_understand, encoding(), MEMBER_ID_MAX, OPENDDS_END_VERSIONED_NAMESPACE_DECL, pid_extended, pid_impl_extension, pid_must_understand, reset_alignment(), OpenDDS::DCPS::xcdr1_pid_alignment, OpenDDS::DCPS::Encoding::xcdr_version(), OpenDDS::DCPS::Encoding::XCDR_VERSION_1, and OpenDDS::DCPS::Encoding::XCDR_VERSION_2.

 {
   if (static_cast<ACE_CDR::ULong>(id) > MEMBER_ID_MAX) {
     return false;
   }
 
   const Encoding::XcdrVersion xcdr = encoding().xcdr_version();
   if (xcdr == Encoding::XCDR_VERSION_1) {
     if (!align_w(xcdr1_pid_alignment)) {
       return false;
     }
 
     // Determine if we need to use a short or long PID
     const bool long_pid = id > (1 << 14) || size > (1 << 16);
 
     // Write the short part of the PID
     /*
      * TODO(iguessthislldo): Control when to use "must understand" and "impl
      * extension"?
      *
      * The XTypes CDR rules seem to imply they're alway here but that doesn't
      * sound quite right.
      *
      * Also see TODOs above and the TODO below.
      */
     const ACE_CDR::UShort pid_id =
       pid_impl_extension + pid_must_understand +
       (long_pid ? pid_extended : static_cast<ACE_CDR::UShort>(id));
     if (!(*this << pid_id)) {
       return false;
     }
     const ACE_CDR::UShort pid_size = long_pid ? 8 : ACE_CDR::UShort(size);
     if (!(*this << pid_size)) {
       return false;
     }
 
     // If PID is long, write the extended/long part.
     if (long_pid && (
           !(*this << static_cast<ACE_CDR::ULong>(id)) ||
           !(*this << static_cast<ACE_CDR::ULong>(size)))) {
       return false;
     }
 
     reset_alignment();
   } else if (xcdr == Encoding::XCDR_VERSION_2) {
     // Compute Length Code, write EM Header and NEXTINT
     const ACE_CDR::ULong lc = (size == 1 ? 0 : size == 2 ? 1 : size == 4 ? 2 : size == 8 ? 3 : 4);
     const ACE_CDR::ULong emheader = (lc << 28) | id | (must_understand ? emheader_must_understand : 0);
     if (!(*this << emheader)) {
       return false;
     }
     if (lc == 4) {
       return *this << ACE_CDR::ULong(size);
     }
   }
   return true;
 }

◆ write_short_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 720 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::int16_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_enum_array_as_ints_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_enum_sequence_as_ints_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(int16_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), int16_cdr_size, length);
   return good_bit();
 }

◆ write_ulong_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 750 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint32_cdr_size.

Referenced by OpenDDS::DCPS::operator<<(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_array_as_uints_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_sequence_as_uints_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(uint32_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), uint32_cdr_size, length);
   return good_bit();
 }

◆ write_ulonglong_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 771 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint64_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_array_as_uints_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_sequence_as_uints_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(uint64_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), uint64_cdr_size, length);
   return good_bit();
 }

◆ write_ushort_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 730 of file Serializer.inl.

References ACE_INLINE, and OpenDDS::DCPS::uint16_cdr_size.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_array_as_uints_i(), OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_bitmask_sequence_as_uints_i(), and OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

 {
   if (!align_w(uint16_cdr_size)) {
     return false;
   }
   write_array(reinterpret_cast<const char*>(x), uint16_cdr_size, length);
   return good_bit();
 }

◆ write_wchar_array()

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

Array write operations Note: the portion written starts at x and ends at x + length. The length is NOT stored into the CDR stream.

Definition at line 686 of file Serializer.inl.

References ACE_INLINE.

Referenced by OpenDDS::XTypes::DynamicDataImpl::DataContainer::serialize_primitive_array().

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

Friends And Related Function Documentation

◆ operator<< [1/20]

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

friend

Definition at line 951 of file Serializer.inl.

 {
   s.buffer_write(reinterpret_cast<char*>(&x), char8_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [2/20]

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

friend

Definition at line 958 of file Serializer.inl.

 {
   if (!s.align_w(int16_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [3/20]

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

friend

Definition at line 968 of file Serializer.inl.

 {
   if (!s.align_w(uint16_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [4/20]

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

friend

Definition at line 978 of file Serializer.inl.

 {
   if (!s.align_w(int32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [5/20]

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

friend

Definition at line 988 of file Serializer.inl.

 {
   if (!s.align_w(uint32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [6/20]

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

friend

Definition at line 998 of file Serializer.inl.

 {
   if (!s.align_w(int64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), int64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [7/20]

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

friend

Definition at line 1008 of file Serializer.inl.

 {
   if (!s.align_w(uint64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), uint64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [8/20]

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

friend

Definition at line 1018 of file Serializer.inl.

 {
   if (!s.align_w(float32_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [9/20]

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

friend

Definition at line 1028 of file Serializer.inl.

 {
   if (!s.align_w(float64_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [10/20]

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

friend

Definition at line 1038 of file Serializer.inl.

 {
   if (!s.align_w(float128_cdr_size)) {
     return false;
   }
   s.buffer_write(reinterpret_cast<char*>(&x), float128_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator<< [11/20]

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

friend

Definition at line 1048 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>(std::strlen(x));
     s << stringlen;
     s.buffer_write(reinterpret_cast<const char*>(x), stringlen, false);
 
   } else {
     s << ACE_CDR::ULong(0);
   }
 
   return s.good_bit();
 }

◆ operator<< [12/20]

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

friend

Definition at line 1065 of file Serializer.inl.

 {
   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 * char16_cdr_size);
 
 #if ACE_SIZEOF_WCHAR == 2
     s.write_array(reinterpret_cast<const char*>(x), char16_cdr_size, length,
       s.swap_bytes());
 #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), char16_cdr_size,
         s.swap_bytes());
     }
 #endif
   } else {
     s << ACE_CDR::ULong(0);
   }
 
   return s.good_bit();
 }

◆ operator<< [13/20]

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

friend

Definition at line 1107 of file Serializer.inl.

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

◆ operator<< [14/20]

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

friend

Definition at line 1114 of file Serializer.inl.

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

◆ operator<< [15/20]

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

friend

Definition at line 1121 of file Serializer.inl.

 {
   if (!s.align_w(char16_cdr_size)) {
     return false;
   }
 #if ACE_SIZEOF_WCHAR == 2
   s.buffer_write(reinterpret_cast<char*>(&x.val_), char16_cdr_size, s.swap_bytes());
 #else
   const ACE_UINT16 as_utf16 = static_cast<ACE_UINT16>(x.val_);
   if (as_utf16 != x.val_) { // not currently handling surrogates
     if (DCPS_debug_level) {
       ACE_ERROR((LM_ERROR, ACE_TEXT("(%P|%t) ")
         ACE_TEXT("operator<<(Serializer&, ACE_OutputCDR::from_wchar): ")
         ACE_TEXT("failure to convert UTF-32 to UTF-16.\n")));
     }
     s.good_bit_ = false;
   } else {
     s.buffer_write(reinterpret_cast<const char*>(&as_utf16), char16_cdr_size,
       s.swap_bytes());
   }
 #endif
   return s.good_bit();
 }

◆ operator<< [16/20]

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

friend

Definition at line 1172 of file Serializer.inl.

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

◆ operator<< [17/20]

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

friend

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

◆ operator<< [18/20]

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

friend

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

◆ operator<< [19/20]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		const String &	x
	)

friend

Definition at line 1146 of file Serializer.inl.

 {
   return s << x.c_str();
 }

◆ operator<< [20/20]

OpenDDS_Dcps_Export bool operator<<	(	Serializer &	s,
		Serializer::FromBoundedString< char >	x
	)

friend

Definition at line 1152 of file Serializer.inl.

 {
   return (x.bound_ == 0 || x.str_.size() <= x.bound_) && s << x.str_;
 }

◆ operator>> [1/20]

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

friend

Definition at line 1227 of file Serializer.inl.

 {
   s.buffer_read(reinterpret_cast<char*>(&x), char8_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [2/20]

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

friend

Definition at line 1234 of file Serializer.inl.

 {
   if (!s.align_r(int16_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [3/20]

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

friend

Definition at line 1244 of file Serializer.inl.

 {
   if (!s.align_r(uint16_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint16_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [4/20]

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

friend

Definition at line 1254 of file Serializer.inl.

 {
   if (!s.align_r(int32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [5/20]

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

friend

Definition at line 1264 of file Serializer.inl.

 {
   if (!s.align_r(uint32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [6/20]

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

friend

Definition at line 1274 of file Serializer.inl.

 {
   if (!s.align_r(int64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), int64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [7/20]

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

friend

Definition at line 1284 of file Serializer.inl.

 {
   if (!s.align_r(uint64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), uint64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [8/20]

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

friend

Definition at line 1294 of file Serializer.inl.

 {
   if (!s.align_r(float32_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float32_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [9/20]

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

friend

Definition at line 1304 of file Serializer.inl.

 {
   if (!s.align_r(float64_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float64_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [10/20]

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

friend

Definition at line 1314 of file Serializer.inl.

 {
   if (!s.align_r(float128_cdr_size)) {
     return false;
   }
   s.buffer_read(reinterpret_cast<char*>(&x), float128_cdr_size, s.swap_bytes());
   return s.good_bit();
 }

◆ operator>> [11/20]

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

friend

Definition at line 1324 of file Serializer.inl.

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

◆ operator>> [12/20]

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

friend

Definition at line 1331 of file Serializer.inl.

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

◆ operator>> [13/20]

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

friend

Definition at line 1354 of file Serializer.inl.

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

◆ operator>> [14/20]

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

friend

Definition at line 1361 of file Serializer.inl.

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

◆ operator>> [15/20]

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

friend

Definition at line 1368 of file Serializer.inl.

 {
   if (!s.align_r(char16_cdr_size)) {
     return false;
   }
 #if ACE_SIZEOF_WCHAR == 2
   s.buffer_read(reinterpret_cast<char*>(&x.ref_), char16_cdr_size,
     s.swap_bytes());
 #else
   ACE_UINT16 as_utf16;
   s.buffer_read(reinterpret_cast<char*>(&as_utf16), char16_cdr_size,
     s.swap_bytes());
   x.ref_ = as_utf16;
 #endif
   return s.good_bit();
 }

◆ operator>> [16/20]

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

friend

Definition at line 1386 of file Serializer.inl.

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

◆ operator>> [17/20]

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

friend

Definition at line 1393 of file Serializer.inl.

 {
   const size_t length = s.read_string(const_cast<char*&>(x.val_));
   if (s.good_bit() && (x.bound_ != 0) && (length > x.bound_)) {
     s.set_construction_status(Serializer::BoundConstructionFailure);
     return false;
   }
   return s.good_bit();
 }

◆ operator>> [18/20]

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

friend

Definition at line 1404 of file Serializer.inl.

 {
   const size_t length = s.read_string(const_cast<ACE_CDR::WChar*&>(x.val_));
   if (s.good_bit() && (x.bound_ != 0) && (length > x.bound_)) {
     s.set_construction_status(Serializer::BoundConstructionFailure);
     return false;
   }
   return s.good_bit();
 }

◆ operator>> [19/20]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		String &	x
	)

friend

Definition at line 1431 of file Serializer.inl.

 {
   char* buf = 0;
   const size_t length = s.read_string(buf);
   if (!s.good_bit()) {
     return false;
   }
   x.assign(buf, length);
   s.free_string(buf);
   return true;
 }

◆ operator>> [20/20]

OpenDDS_Dcps_Export bool operator>>	(	Serializer &	s,
		Serializer::ToBoundedString< char >	x
	)

friend

Definition at line 1444 of file Serializer.inl.

 {
   if (s >> x.str_) {
     if ((x.bound_ != 0) && (x.str_.size() > x.bound_)) {
       s.set_construction_status(Serializer::BoundConstructionFailure);
       return false;
     }
     return true;
   }
   return false;
 }

Member Data Documentation

◆ ALIGN_PAD

const char OpenDDS::DCPS::Serializer::ALIGN_PAD = {0}

staticprivate

Buffer that is copied for zero padding.

Definition at line 897 of file Serializer.h.

Referenced by OpenDDS::DCPS::Encoding::to_string().

◆ align_rshift_

unsigned char OpenDDS::DCPS::Serializer::align_rshift_

private

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

Definition at line 882 of file Serializer.h.

Referenced by peek(), reset_alignment(), and OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore().

◆ align_wshift_

unsigned char OpenDDS::DCPS::Serializer::align_wshift_

private

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

Definition at line 888 of file Serializer.h.

Referenced by reset_alignment(), and OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore().

◆ construction_status_

ConstructionStatus OpenDDS::DCPS::Serializer::construction_status_

private

The way to judge whether tryconstruct trim is able to be properly done.

Definition at line 876 of file Serializer.h.

◆ current_

ACE_Message_Block* OpenDDS::DCPS::Serializer::current_

private

Currently active message block in chain.

Definition at line 864 of file Serializer.h.

Referenced by peek(), read_string(), reset_alignment(), OpenDDS::DCPS::Serializer::ScopedAlignmentContext::restore(), and trim().

◆ emheader_must_understand

const ACE_CDR::ULong OpenDDS::DCPS::Serializer::emheader_must_understand = 1U << 31U

static

Definition at line 384 of file Serializer.h.

Referenced by read_parameter_id(), and write_parameter_id().

◆ encoding_

Encoding OpenDDS::DCPS::Serializer::encoding_

private

Encoding Settings.

Definition at line 867 of file Serializer.h.

◆ good_bit_

bool OpenDDS::DCPS::Serializer::good_bit_

private

Indicates the current state of the stream abstraction.

Definition at line 873 of file Serializer.h.

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

◆ MEMBER_ID_MASK

const ACE_CDR::ULong OpenDDS::DCPS::Serializer::MEMBER_ID_MASK = MEMBER_ID_MAX

static

Definition at line 388 of file Serializer.h.

Referenced by OpenDDS::XTypes::hash_member_name_to_id().

◆ MEMBER_ID_MAX

const ACE_CDR::ULong OpenDDS::DCPS::Serializer::MEMBER_ID_MAX = 0x0FFFFFFF

static

Maximum value for member id.

Definition at line 387 of file Serializer.h.

Referenced by invalid_option(), and write_parameter_id().

◆ pid_extended

const ACE_CDR::UShort OpenDDS::DCPS::Serializer::pid_extended = 0x3f01

static

Flags and reserved ids used in parameter list ids.

Definition at line 373 of file Serializer.h.

Referenced by read_parameter_id(), and write_parameter_id().

◆ pid_impl_extension

const ACE_CDR::UShort OpenDDS::DCPS::Serializer::pid_impl_extension = 0x8000

static

Flags and reserved ids used in parameter list ids.

Definition at line 379 of file Serializer.h.

Referenced by write_parameter_id().

◆ pid_list_end

const ACE_CDR::UShort OpenDDS::DCPS::Serializer::pid_list_end = 0x3f02

static

Note that this is different than OpenDDS::RTPS::PID_SENTINEL(0x0001). See XTypes 1.3 Table 34 for details.

Definition at line 378 of file Serializer.h.

◆ pid_must_understand

const ACE_CDR::UShort OpenDDS::DCPS::Serializer::pid_must_understand = 0x4000

static

Flags and reserved ids used in parameter list ids.

Definition at line 380 of file Serializer.h.

Referenced by write_parameter_id().

◆ rpos_

size_t OpenDDS::DCPS::Serializer::rpos_

private

Logical reading position of the stream.

Definition at line 891 of file Serializer.h.

Referenced by peek().

◆ swap_bytes_

bool OpenDDS::DCPS::Serializer::swap_bytes_

private

Indicates whether bytes will be swapped for this stream.

Definition at line 870 of file Serializer.h.

◆ wpos_

size_t OpenDDS::DCPS::Serializer::wpos_

private

Logical writing position of the stream.

Definition at line 894 of file Serializer.h.

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

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ StrAllocate

◆ StrFree

◆ WStrAllocate

◆ WStrFree

Member Enumeration Documentation

◆ ConstructionStatus

Constructor & Destructor Documentation

◆ Serializer() [1/3]

◆ Serializer() [2/3]

◆ Serializer() [3/3]

◆ ~Serializer()

Member Function Documentation

◆ align_cont_r()

◆ align_cont_w()

◆ align_r()

◆ align_w()

◆ alignment() [1/2]

◆ alignment() [2/2]

◆ buffer_read()

◆ buffer_write()

◆ current()

◆ doread()

◆ dowrite()

◆ encoding() [1/2]

◆ encoding() [2/2]

◆ endianness() [1/2]

◆ endianness() [2/2]

◆ free_string() [1/2]

◆ free_string() [2/2]

◆ get_construction_status()

◆ good_bit()

◆ length()

◆ offset()

◆ peek() [1/2]

◆ peek() [2/2]

◆ peek_helper()

◆ pos_rd()

◆ pos_wr()

◆ rdstate() [1/2]

◆ rdstate() [2/2]

◆ read_array() [1/2]

◆ read_array() [2/2]

◆ read_boolean_array()

◆ read_char_array()

◆ read_delimiter()

◆ read_double_array()

◆ read_float_array()

◆ read_long_array()

◆ read_longdouble_array()

◆ read_longlong_array()

◆ read_octet_array()

◆ read_parameter_id()

◆ read_short_array()

◆ read_string() [1/2]

◆ read_string() [2/2]

◆ read_ulong_array()

◆ read_ulonglong_array()

◆ read_ushort_array()

◆ read_wchar_array()

◆ reset_alignment()

◆ rpos()

◆ set_construction_status()

◆ skip()

◆ skip_delimiter()

◆ smemcpy()

◆ swap_bytes() [1/2]

◆ swap_bytes() [2/2]

◆ swapcpy()

◆ trim()