BDE 4.14.0 Production release
Loading...
Searching...
No Matches
Public Types | Static Public Member Functions | List of all members
bslx::MarshallingUtil Struct Reference

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

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
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

◆ getArrayFloat32()

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.

◆ getArrayFloat64()

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.

◆ getArrayInt16()

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.

◆ getArrayInt24()

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.

◆ getArrayInt32()

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.

◆ getArrayInt40()

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.

◆ getArrayInt48()

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.

◆ getArrayInt56()

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.

◆ getArrayInt64()

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.

◆ getArrayInt8() [1/3]

void bslx::MarshallingUtil::getArrayInt8 ( char *  variables,
const char *  buffer,
int  numVariables 
)
inlinestatic

◆ getArrayInt8() [2/3]

void bslx::MarshallingUtil::getArrayInt8 ( signed char *  variables,
const char *  buffer,
int  numVariables 
)
inlinestatic

◆ getArrayInt8() [3/3]

void bslx::MarshallingUtil::getArrayInt8 ( unsigned char *  variables,
const char *  buffer,
int  numVariables 
)
inlinestatic

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.

◆ getArrayUint16()

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.

◆ getArrayUint24()

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.

◆ getArrayUint32()

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.

◆ getArrayUint40()

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.

◆ getArrayUint48()

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.

◆ getArrayUint56()

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.

◆ getArrayUint64()

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.

◆ getFloat32()

void bslx::MarshallingUtil::getFloat32 ( float *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getFloat64()

void bslx::MarshallingUtil::getFloat64 ( double *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt16()

void bslx::MarshallingUtil::getInt16 ( short *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt24()

void bslx::MarshallingUtil::getInt24 ( int *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt32()

void bslx::MarshallingUtil::getInt32 ( int *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt40()

void bslx::MarshallingUtil::getInt40 ( bsls::Types::Int64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt48()

void bslx::MarshallingUtil::getInt48 ( bsls::Types::Int64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt56()

void bslx::MarshallingUtil::getInt56 ( bsls::Types::Int64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt64()

void bslx::MarshallingUtil::getInt64 ( bsls::Types::Int64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getInt8() [1/3]

void bslx::MarshallingUtil::getInt8 ( char *  variable,
const char *  buffer 
)
inlinestatic

◆ getInt8() [2/3]

void bslx::MarshallingUtil::getInt8 ( signed char *  variable,
const char *  buffer 
)
inlinestatic

◆ getInt8() [3/3]

void bslx::MarshallingUtil::getInt8 ( unsigned char *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint16()

void bslx::MarshallingUtil::getUint16 ( unsigned short *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint24()

void bslx::MarshallingUtil::getUint24 ( unsigned int *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint32()

void bslx::MarshallingUtil::getUint32 ( unsigned int *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint40()

void bslx::MarshallingUtil::getUint40 ( bsls::Types::Uint64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint48()

void bslx::MarshallingUtil::getUint48 ( bsls::Types::Uint64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint56()

void bslx::MarshallingUtil::getUint56 ( bsls::Types::Uint64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ getUint64()

void bslx::MarshallingUtil::getUint64 ( bsls::Types::Uint64 *  variable,
const char *  buffer 
)
inlinestatic

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.

◆ putArrayFloat32()

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.

◆ putArrayFloat64()

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.

◆ putArrayInt16() [1/2]

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

◆ putArrayInt16() [2/2]

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.

◆ putArrayInt24() [1/2]

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

◆ putArrayInt24() [2/2]

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.

◆ putArrayInt32() [1/2]

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

◆ putArrayInt32() [2/2]

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.

◆ putArrayInt40() [1/2]

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

◆ putArrayInt40() [2/2]

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.

◆ putArrayInt48() [1/2]

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

◆ putArrayInt48() [2/2]

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.

◆ putArrayInt56() [1/2]

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

◆ putArrayInt56() [2/2]

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.

◆ putArrayInt64() [1/2]

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

◆ putArrayInt64() [2/2]

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.

◆ putArrayInt8() [1/3]

void bslx::MarshallingUtil::putArrayInt8 ( char *  buffer,
const char *  values,
int  numValues 
)
inlinestatic

◆ putArrayInt8() [2/3]

void bslx::MarshallingUtil::putArrayInt8 ( char *  buffer,
const signed char *  values,
int  numValues 
)
inlinestatic

◆ putArrayInt8() [3/3]

void bslx::MarshallingUtil::putArrayInt8 ( char *  buffer,
const unsigned char *  values,
int  numValues 
)
inlinestatic

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.

◆ putFloat32()

void bslx::MarshallingUtil::putFloat32 ( char *  buffer,
float  value 
)
inlinestatic

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.

◆ putFloat64()

void bslx::MarshallingUtil::putFloat64 ( char *  buffer,
double  value 
)
inlinestatic

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.

◆ putInt16()

void bslx::MarshallingUtil::putInt16 ( char *  buffer,
int  value 
)
inlinestatic

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.

◆ putInt24()

void bslx::MarshallingUtil::putInt24 ( char *  buffer,
int  value 
)
inlinestatic

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.

◆ putInt32()

void bslx::MarshallingUtil::putInt32 ( char *  buffer,
int  value 
)
inlinestatic

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.

◆ putInt40()

void bslx::MarshallingUtil::putInt40 ( char *  buffer,
bsls::Types::Int64  value 
)
inlinestatic

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.

◆ putInt48()

void bslx::MarshallingUtil::putInt48 ( char *  buffer,
bsls::Types::Int64  value 
)
inlinestatic

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.

◆ putInt56()

void bslx::MarshallingUtil::putInt56 ( char *  buffer,
bsls::Types::Int64  value 
)
inlinestatic

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.

◆ putInt64()

void bslx::MarshallingUtil::putInt64 ( char *  buffer,
bsls::Types::Int64  value 
)
inlinestatic

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.

◆ putInt8()

void bslx::MarshallingUtil::putInt8 ( char *  buffer,
int  value 
)
inlinestatic

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.

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