#include <bslx_marshallingutil.h>

Public Types
enum	{ k_SIZEOF_INT64 = 8, k_SIZEOF_INT56 = 7, k_SIZEOF_INT48 = 6, k_SIZEOF_INT40 = 5, k_SIZEOF_INT32 = 4, k_SIZEOF_INT24 = 3, k_SIZEOF_INT16 = 2, k_SIZEOF_INT8 = 1, k_SIZEOF_FLOAT64 = 8, k_SIZEOF_FLOAT32 = 4 }
Static Public Member Functions
static void	putInt64 (char *buffer, bsls::Types::Int64 value)
static void	putInt56 (char *buffer, bsls::Types::Int64 value)
static void	putInt48 (char *buffer, bsls::Types::Int64 value)
static void	putInt40 (char *buffer, bsls::Types::Int64 value)
static void	putInt32 (char *buffer, int value)
static void	putInt24 (char *buffer, int value)
static void	putInt16 (char *buffer, int value)
static void	putInt8 (char *buffer, int value)
static void	putFloat64 (char *buffer, double value)
static void	putFloat32 (char *buffer, float value)
static void	getInt64 (bsls::Types::Int64 variable, const char buffer)
static void	getUint64 (bsls::Types::Uint64 variable, const char buffer)
static void	getInt56 (bsls::Types::Int64 variable, const char buffer)
static void	getUint56 (bsls::Types::Uint64 variable, const char buffer)
static void	getInt48 (bsls::Types::Int64 variable, const char buffer)
static void	getUint48 (bsls::Types::Uint64 variable, const char buffer)
static void	getInt40 (bsls::Types::Int64 variable, const char buffer)
static void	getUint40 (bsls::Types::Uint64 variable, const char buffer)
static void	getInt32 (int variable, const char buffer)
static void	getUint32 (unsigned int variable, const char buffer)
static void	getInt24 (int variable, const char buffer)
static void	getUint24 (unsigned int variable, const char buffer)
static void	getInt16 (short variable, const char buffer)
static void	getUint16 (unsigned short variable, const char buffer)
static void	getInt8 (char variable, const char buffer)
static void	getInt8 (signed char variable, const char buffer)
static void	getInt8 (unsigned char variable, const char buffer)
static void	getFloat64 (double variable, const char buffer)
static void	getFloat32 (float variable, const char buffer)
static void	putArrayInt64 (char buffer, const bsls::Types::Int64 values, int numValues)
static void	putArrayInt64 (char buffer, const bsls::Types::Uint64 values, int numValues)
static void	putArrayInt56 (char buffer, const bsls::Types::Int64 values, int numValues)
static void	putArrayInt56 (char buffer, const bsls::Types::Uint64 values, int numValues)
static void	putArrayInt48 (char buffer, const bsls::Types::Int64 values, int numValues)
static void	putArrayInt48 (char buffer, const bsls::Types::Uint64 values, int numValues)
static void	putArrayInt40 (char buffer, const bsls::Types::Int64 values, int numValues)
static void	putArrayInt40 (char buffer, const bsls::Types::Uint64 values, int numValues)
static void	putArrayInt32 (char buffer, const int values, int numValues)
static void	putArrayInt32 (char buffer, const unsigned int values, int numValues)
static void	putArrayInt24 (char buffer, const int values, int numValues)
static void	putArrayInt24 (char buffer, const unsigned int values, int numValues)
static void	putArrayInt16 (char buffer, const short values, int numValues)
static void	putArrayInt16 (char buffer, const unsigned short values, int numValues)
static void	putArrayInt8 (char buffer, const char values, int numValues)
static void	putArrayInt8 (char buffer, const signed char values, int numValues)
static void	putArrayInt8 (char buffer, const unsigned char values, int numValues)
static void	putArrayFloat64 (char buffer, const double values, int numValues)
static void	putArrayFloat32 (char buffer, const float values, int numValues)
static void	getArrayInt64 (bsls::Types::Int64 variables, const char buffer, int numVariables)
static void	getArrayUint64 (bsls::Types::Uint64 variables, const char buffer, int numVariables)
static void	getArrayInt56 (bsls::Types::Int64 variables, const char buffer, int numVariables)
static void	getArrayUint56 (bsls::Types::Uint64 variables, const char buffer, int numVariables)
static void	getArrayInt48 (bsls::Types::Int64 variables, const char buffer, int numVariables)
static void	getArrayUint48 (bsls::Types::Uint64 variables, const char buffer, int numVariables)
static void	getArrayInt40 (bsls::Types::Int64 variables, const char buffer, int numVariables)
static void	getArrayUint40 (bsls::Types::Uint64 variables, const char buffer, int numVariables)
static void	getArrayInt32 (int variables, const char buffer, int numVariables)
static void	getArrayUint32 (unsigned int variables, const char buffer, int numVariables)
static void	getArrayInt24 (int variables, const char buffer, int numVariables)
static void	getArrayUint24 (unsigned int variables, const char buffer, int numVariables)
static void	getArrayInt16 (short variables, const char buffer, int numVariables)
static void	getArrayUint16 (unsigned short variables, const char buffer, int numVariables)
static void	getArrayInt8 (char variables, const char buffer, int numVariables)
static void	getArrayInt8 (signed char variables, const char buffer, int numVariables)
static void	getArrayInt8 (unsigned char variables, const char buffer, int numVariables)
static void	getArrayFloat64 (double variables, const char buffer, int numVariables)
static void	getArrayFloat32 (float variables, const char buffer, int numVariables)

Detailed Description

This struct provides a namespace for a suite of functions that facilitate the marshalling of values, and C-style arrays of values, of the fundamental integral and floating-point types in a data-independent, platform-neutral representation.

See Component bslx_marshallingutil

Member Enumeration Documentation

anonymous enum

Enumerate the platform-independent sizes (in bytes) of data types in wire format. Note that the wire format size may differ from the size in memory.

Enumerator:

k_SIZEOF_INT64
k_SIZEOF_INT56
k_SIZEOF_INT48
k_SIZEOF_INT40
k_SIZEOF_INT32
k_SIZEOF_INT24
k_SIZEOF_INT16
k_SIZEOF_INT8
k_SIZEOF_FLOAT64
k_SIZEOF_FLOAT32

Member Function Documentation

static void bslx::MarshallingUtil::putInt64	(	char *	buffer,
		bsls::Types::Int64	value
	)			`[static]`

Load into the specified buffer the eight-byte, two's complement integer (in network byte order) comprised of the least-significant eight bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 64-bit values.

static void bslx::MarshallingUtil::putInt56	(	char *	buffer,
		bsls::Types::Int64	value
	)			`[static]`

Load into the specified buffer the seven-byte, two's complement integer (in network byte order) comprised of the least-significant seven bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 64-bit values.

static void bslx::MarshallingUtil::putInt48	(	char *	buffer,
		bsls::Types::Int64	value
	)			`[static]`

Load into the specified buffer the six-byte, two's complement integer (in network byte order) comprised of the least-significant six bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 64-bit values.

static void bslx::MarshallingUtil::putInt40	(	char *	buffer,
		bsls::Types::Int64	value
	)			`[static]`

Load into the specified buffer the five-byte, two's complement integer (in network byte order) comprised of the least-significant five bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 64-bit values.

static void bslx::MarshallingUtil::putInt32	(	char *	buffer,
		int	value
	)			`[static]`

Load into the specified buffer the four-byte, two's complement integer (in network byte order) comprised of the least-significant four bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 32-bit values, and signed and unsigned 16- and 8-bit values.

static void bslx::MarshallingUtil::putInt24	(	char *	buffer,
		int	value
	)			`[static]`

Load into the specified buffer the three-byte, two's complement integer (in network byte order) comprised of the least-significant three bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 32-bit values, and signed and unsigned 16- and 8-bit values.

static void bslx::MarshallingUtil::putInt16	(	char *	buffer,
		int	value
	)			`[static]`

Load into the specified buffer the two-byte, two's complement integer (in network byte order) comprised of the least-significant two bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 32-bit values, and signed and unsigned 16- and 8-bit values.

static void bslx::MarshallingUtil::putInt8	(	char *	buffer,
		int	value
	)			`[static]`

Load into the specified buffer the one-byte, two's complement integer comprised of the least-significant one byte of the specified value. The behavior is undefined unless buffer has sufficient capacity. Note that this function applies equally to unsigned 32-bit values, and signed and unsigned 16- and 8-bit values.

static void bslx::MarshallingUtil::putFloat64	(	char *	buffer,
		double	value
	)			`[static]`

Load into the specified buffer the eight-byte IEEE double-precision floating-point number (in network byte order) comprised of the most-significant eight bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that for non-conforming platforms, this operation may be lossy.

static void bslx::MarshallingUtil::putFloat32	(	char *	buffer,
		float	value
	)			`[static]`

Load into the specified buffer the four-byte IEEE single-precision floating-point number (in network byte order) comprised of the most-significant four bytes of the specified value (in host byte order). The behavior is undefined unless buffer has sufficient capacity. Note that for non-conforming platforms, this operation may be lossy.

static void bslx::MarshallingUtil::getInt64	(	bsls::Types::Int64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the eight-byte, two's complement integer (in host byte order) comprised of the initial eight bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint64	(	bsls::Types::Uint64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the eight-byte, two's complement unsigned integer (in host byte order) comprised of the initial eight bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt56	(	bsls::Types::Int64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the seven-byte, two's complement integer (in host byte order) comprised of the initial seven bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint56	(	bsls::Types::Uint64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the seven-byte, two's complement unsigned integer (in host byte order) comprised of the initial seven bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt48	(	bsls::Types::Int64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the six-byte, two's complement integer (in host byte order) comprised of the initial six bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint48	(	bsls::Types::Uint64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the six-byte, two's complement unsigned integer (in host byte order) comprised of the initial six bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt40	(	bsls::Types::Int64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the five-byte, two's complement integer (in host byte order) comprised of the initial five bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint40	(	bsls::Types::Uint64 *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the five-byte, two's complement unsigned integer (in host byte order) comprised of the initial five bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt32	(	int *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the four-byte, two's complement integer (in host byte order) comprised of the initial four bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint32	(	unsigned int *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the four-byte, two's complement unsigned integer (in host byte order) comprised of the initial four bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt24	(	int *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the three-byte, two's complement integer (in host byte order) comprised of the initial three bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint24	(	unsigned int *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the three-byte, two's complement unsigned integer (in host byte order) comprised of the initial three bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt16	(	short *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the two-byte, two's complement integer (in host byte order) comprised of the initial two bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be sign-extended.

static void bslx::MarshallingUtil::getUint16	(	unsigned short *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the two-byte, two's complement unsigned integer (in host byte order) comprised of the initial two bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents. Note that the value will be zero-extended.

static void bslx::MarshallingUtil::getInt8	(	char *	variable,
		const char *	buffer
	)			`[static]`

static void bslx::MarshallingUtil::getInt8	(	signed char *	variable,
		const char *	buffer
	)			`[static]`

static void bslx::MarshallingUtil::getInt8	(	unsigned char *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the one-byte, two's complement integer comprised of the initial one byte of the specified buffer. The behavior is undefined unless buffer has sufficient contents.

static void bslx::MarshallingUtil::getFloat64	(	double *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the eight-byte IEEE double-precision floating-point number (in host byte order) comprised of the initial eight bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents.

static void bslx::MarshallingUtil::getFloat32	(	float *	variable,
		const char *	buffer
	)			`[static]`

Load into the specified variable the four-byte IEEE single-precision floating-point number (in host byte order) comprised of the initial four bytes of the specified buffer (in network byte order). The behavior is undefined unless buffer has sufficient contents.

static void bslx::MarshallingUtil::putArrayInt64	(	char *	buffer,
		const bsls::Types::Int64 *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt64	(	char *	buffer,
		const bsls::Types::Uint64 *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive eight-byte, two's complement integers (in network byte order) comprised of the least-significant eight bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt56	(	char *	buffer,
		const bsls::Types::Int64 *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt56	(	char *	buffer,
		const bsls::Types::Uint64 *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive seven-byte, two's complement integers (in network byte order) comprised of the least-significant seven bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt48	(	char *	buffer,
		const bsls::Types::Int64 *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt48	(	char *	buffer,
		const bsls::Types::Uint64 *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive six-byte, two's complement integers (in network byte order) comprised of the least-significant six bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt40	(	char *	buffer,
		const bsls::Types::Int64 *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt40	(	char *	buffer,
		const bsls::Types::Uint64 *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive five-byte, two's complement integers (in network byte order) comprised of the least-significant five bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt32	(	char *	buffer,
		const int *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt32	(	char *	buffer,
		const unsigned int *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive four-byte, two's complement integers (in network byte order) comprised of the least-significant four bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt24	(	char *	buffer,
		const int *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt24	(	char *	buffer,
		const unsigned int *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive three-byte, two's complement integers (in network byte order) comprised of the least-significant three bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt16	(	char *	buffer,
		const short *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt16	(	char *	buffer,
		const unsigned short *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive two-byte, two's complement integers (in network byte order) comprised of the least-significant two bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayInt8	(	char *	buffer,
		const char *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt8	(	char *	buffer,
		const signed char *	values,
		int	numValues
	)			`[static]`

static void bslx::MarshallingUtil::putArrayInt8	(	char *	buffer,
		const unsigned char *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive one-byte, two's complement integers comprised of the one byte of each of the specified numValues leading entries in the specified values. The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues.

static void bslx::MarshallingUtil::putArrayFloat64	(	char *	buffer,
		const double *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive eight-byte IEEE double-precision floating-point numbers (in network byte order) comprised of the most-significant eight bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues. Note that for non-conforming platforms, this operation may be lossy.

static void bslx::MarshallingUtil::putArrayFloat32	(	char *	buffer,
		const float *	values,
		int	numValues
	)			`[static]`

Load into the specified buffer the consecutive four-byte IEEE single-precision floating-point numbers (in network byte order) comprised of the most-significant four bytes of each of the specified numValues leading entries in the specified values (in host byte order). The behavior is undefined unless buffer has sufficient capacity, values has sufficient contents, and 0 <= numValues. Note that for non-conforming platforms, this operation may be lossy.

static void bslx::MarshallingUtil::getArrayInt64	(	bsls::Types::Int64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive eight-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading eight-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint64	(	bsls::Types::Uint64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive eight-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading eight-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt56	(	bsls::Types::Int64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive seven-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading seven-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint56	(	bsls::Types::Uint64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive seven-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading seven-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt48	(	bsls::Types::Int64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive six-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading six-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint48	(	bsls::Types::Uint64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive six-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading six-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt40	(	bsls::Types::Int64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive five-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading five-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint40	(	bsls::Types::Uint64 *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive five-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading five-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt32	(	int *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive four-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading four-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint32	(	unsigned int *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive four-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading four-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt24	(	int *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive three-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading three-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint24	(	unsigned int *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive three-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading three-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt16	(	short *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive two-byte, two's complement integers (in host byte order) comprised of each of the specified numVariables leading two-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be sign-extended.

static void bslx::MarshallingUtil::getArrayUint16	(	unsigned short *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive two-byte, two's complement unsigned integers (in host byte order) comprised of each of the specified numVariables leading two-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables. Note that each of the values will be zero-extended.

static void bslx::MarshallingUtil::getArrayInt8	(	char *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

static void bslx::MarshallingUtil::getArrayInt8	(	signed char *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

static void bslx::MarshallingUtil::getArrayInt8	(	unsigned char *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive one-byte, two's complement integers comprised of each of the specified numVariables leading one-byte sequences in the specified buffer. The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables.

static void bslx::MarshallingUtil::getArrayFloat64	(	double *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive eight-byte IEEE double-precision floating-point numbers (in host byte order) comprised of each of the specified numVariables leading eight-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables.

static void bslx::MarshallingUtil::getArrayFloat32	(	float *	variables,
		const char *	buffer,
		int	numVariables
	)			`[static]`

Load into the specified variables the consecutive four-byte IEEE single-precision floating-point numbers (in host byte order) comprised of each of the specified numVariables leading four-byte sequences in the specified buffer (in network byte order). The behavior is undefined unless variables has sufficient capacity, buffer has sufficient contents, and 0 <= numVariables.

The documentation for this struct was generated from the following file:

bslx_marshallingutil.h

bslx::MarshallingUtil Struct Reference

Public Types

Static Public Member Functions

Detailed Description

Member Enumeration Documentation

Member Function Documentation