a_util::memory Namespace Reference

Serves as component for memory access and management. More...

Classes
class	BitSerializer
	Bit Serializer Class. More...
class	MemoryBuffer
	Memory buffer class to encapsulate and manage raw contiguously memory. More...
class	StackPtr

Enumerations
enum	Endianess { bit_little_endian = 1 , bit_big_endian = 2 }
	Enum describing the endianess.

Functions
template<typename T, std::size_t StackSize, std::size_t Alignment>
void	swap (StackPtr< T, StackSize, Alignment > &lhs, StackPtr< T, StackSize, Alignment > &rhs)
template<typename T, std::size_t StackSize, std::size_t Alignment>
bool	operator!= (const StackPtr< T, StackSize, Alignment > &lhs, const StackPtr< T, StackSize, Alignment > &rhs)
template<typename T, std::size_t StackSize = sizeof(T), std::size_t Alignment = alignof(std::size_t), typename... Args>
constexpr auto	makeStackPtr (Args &&... args) -> StackPtr< T, StackSize, Alignment >
template<typename T, std::size_t StackSize, std::size_t Alignment>
bool	operator== (const StackPtr< T, StackSize, Alignment > &lhs, const StackPtr< T, StackSize, Alignment > &rhs)
bool	copy (void *dest, std::size_t dest_size, const void *source, std::size_t bytes_to_copy)
bool	copy (void *dest, const void *source, std::size_t bytes_to_copy)
bool	copy (MemoryBuffer &buffer, const void *source, std::size_t bytes_to_copy)
bool	set (void *dest, std::size_t dest_size, std::uint8_t value, std::size_t bytes_to_set)
bool	set (void *dest, std::uint8_t value, std::size_t bytes_to_set)
bool	set (MemoryBuffer &buffer, std::uint8_t value, std::size_t bytes_to_set)
bool	zero (void *dest, std::size_t dest_size, std::size_t bytes_to_zero)
bool	zero (void *dest, std::size_t bytes_to_zero)
bool	zero (MemoryBuffer &buffer, std::size_t bytes_to_zero)
int	compare (const void *buf1, std::size_t buf1_size, const void *buf2, std::size_t buf2_size)
bool	isZero (const void *buffer, std::size_t buffer_size)
bool	swapEndianess (bool value)
std::int8_t	swapEndianess (std::int8_t value)
std::uint8_t	swapEndianess (std::uint8_t value)
std::int16_t	swapEndianess (std::int16_t value)
std::uint16_t	swapEndianess (std::uint16_t value)
std::int32_t	swapEndianess (std::int32_t value)
std::uint32_t	swapEndianess (std::uint32_t value)
std::int64_t	swapEndianess (std::int64_t value)
std::uint64_t	swapEndianess (std::uint64_t value)
bool	operator== (const MemoryBuffer &lhs, const MemoryBuffer &rhs)
bool	operator!= (const MemoryBuffer &lhs, const MemoryBuffer &rhs)
template<class T, class... Args>
_Unique_if< T >::_Single_object	make_unique (Args &&... args)
template<class T>
_Unique_if< T >::_Unknown_bound	make_unique (size_t n)
template<class T, class... Args>
_Unique_if< T >::_Known_bound	make_unique (Args &&...)=delete
Endianess	get_platform_endianess ()

Detailed Description

Serves as component for memory access and management.

Function Documentation

compare()

int a_util::memory::compare	(	const void *	buf1,
		std::size_t	buf1_size,
		const void *	buf2,
		std::size_t	buf2_size )

Portable safe memcmp

Parameters

[in]	buf1	First buffer to compare
[in]	buf1_size	Available bytes in the first memory buffer
[in]	buf2	Second buffer to compare
[in]	buf2_size	Available bytes in the second memory buffer

Return values

<0	buf1 is less than buf2
>0	buf1 is greater than buf2
0	both buffers are equal

Exceptions

std::invalid_argument

if either of the buffers is a nullptr or the sizes are different

copy() [1/3]

bool a_util::memory::copy	(	MemoryBuffer &	buffer,
		const void *	source,
		std::size_t	bytes_to_copy )

Copies a buffer into a MemoryBuffer instance, allocating memory if neccessary

Parameters

[out]	buffer	Destination memory buffer
[in]	source	Pointer to source buffer
[in]	bytes_to_copy	Number of bytes to copy from the source buffer

Return values

true	if successful, false if source is nullptr or allocation fails

copy() [2/3]

bool a_util::memory::copy	(	void *	dest,
		const void *	source,
		std::size_t	bytes_to_copy )

Portable memcopy

Parameters

[out]	dest	Pointer to destination buffer
[in]	source	Pointer to source buffer
[in]	bytes_to_copy	Number of bytes to copy from source buffer to dest buffer

Return values

true	if copying is sucessful, false if either of the pointer arguments is nullptr

copy() [3/3]

bool a_util::memory::copy	(	void *	dest,
		std::size_t	dest_size,
		const void *	source,
		std::size_t	bytes_to_copy )

Portable safe memcopy

Parameters

[out]	dest	Pointer to destination buffer
[in]	dest_size	Available bytes in dest
[in]	source	Pointer to source buffer
[in]	bytes_to_copy	Number of bytes to copy from source buffer to dest buffer

Return values

true	if copying was successful
false	if either of the pointer arguments is nullptr or bytes_to_copy > dest_size

get_platform_endianess()

Endianess a_util::memory::get_platform_endianess

(

)

Returns the endianess of the platform

Returns

See Endianess

isZero()

bool a_util::memory::isZero	(	const void *	buffer,
		std::size_t	buffer_size )

Check whether the given memory range is entirely zero-initialized

Parameters

[in]	buffer	Pointer to beginning of buffer to check for zero-initialized values
[in]	buffer_size	Size of the buffer

Return values

true	if all values of buffer are zero-initialized, false otherwise

make_unique() [1/3]

template<class T, class... Args>

_Unique_if< T >::_Single_object a_util::memory::make_unique

(

Args &&...

args

)

Compatibility to C++14 std::make_unique for non-array types

Template Parameters

T	Type to create
Args	Arguments types matching constructor argument types of type T

Parameters

[in]

args

List of arguments passed to the constructor of type T

Returns

Object of non-array type T

Copyright

Stephan T. Lavavej (stl@m.nosp@m.icro.nosp@m.soft..nosp@m.com) via C++ standard proposal JTC1/SC22/WG21 N3656

Note

Define A_UTIL_ENABLE_MAKE_UNIQUE in case the platform check mistakenly identifies the existance of std::make_unique

make_unique() [2/3]

template<class T, class... Args>

_Unique_if< T >::_Known_bound a_util::memory::make_unique ( Args && ... )

delete

Compatibility to C++14 std::make_unique to disallow construction of arrays of known bound

Template Parameters

T	Type of array of known bound
Args	Ignored

Copyright

Stephan T. Lavavej (stl@m.nosp@m.icro.nosp@m.soft..nosp@m.com) via C++ standard proposal JTC1/SC22/WG21 N3656

Note

Define A_UTIL_ENABLE_MAKE_UNIQUE in case the platform check mistakenly identifies the existance of std::make_unique

make_unique() [3/3]

template<class T>

_Unique_if< T >::_Unknown_bound a_util::memory::make_unique

(

size_t

n

)

Compatibility to C++14 std::make_unique for array types

Template Parameters

T	Type to create an array of unknown bound

Parameters

[in]

n

Size of the array

Returns

Array of unknown bound type T

Copyright

Stephan T. Lavavej (stl@m.nosp@m.icro.nosp@m.soft..nosp@m.com) via C++ standard proposal JTC1/SC22/WG21 N3656

Note

Define A_UTIL_ENABLE_MAKE_UNIQUE in case the platform check mistakenly identifies the existance of std::make_unique

makeStackPtr()

template<typename T, std::size_t StackSize = sizeof(T), std::size_t Alignment = alignof(std::size_t), typename... Args>

auto a_util::memory::makeStackPtr ( Args &&... args ) -> StackPtr<T, StackSize, Alignment>

inlineconstexpr

Create a new StackPtr

Template Parameters

Args	Types matching the argument list for construction of type T
T	The storaged type - must be default and move constructible
StackSize	Size of the stack to allocate - must at least be the sizeof the object of type T.
Alignment	Alignment of the storage

Parameters

[in]

args

Forwarded to constructor of type T

Returns

StackPtr managing instantiated object of type T

operator!=() [1/2]

bool a_util::memory::operator!=	(	const MemoryBuffer &	lhs,
		const MemoryBuffer &	rhs )

Compare content of the managed memory of two memory buffer objects for inequality

Parameters

[in]	lhs	Left-hand side object
[in]	rhs	Right-hand side object

Returns

true if the memory content is not the same, false otherwise.

operator!=() [2/2]

template<typename T, std::size_t StackSize, std::size_t Alignment>

bool a_util::memory::operator!= ( const StackPtr< T, StackSize, Alignment > & lhs, const StackPtr< T, StackSize, Alignment > & rhs )

inline

Compare for inequality

Template Parameters

T	Managed type
StackSize	Size the managed type occupies
Alignment	Byte alignment of the storage

Parameters

[in]	lhs	Left hand side object
[in]	rhs	Right hand side object

Returns

true if both objects are inequal, false otherwise

operator==()

bool a_util::memory::operator==	(	const MemoryBuffer &	lhs,
		const MemoryBuffer &	rhs )

Compare content of the managed memory of two memory buffer objects for equality

Parameters

[in]	lhs	Left-hand side object
[in]	rhs	Right-hand side object

Returns

true if the memory content is the same, false otherwise.

set() [1/3]

bool a_util::memory::set	(	MemoryBuffer &	buffer,
		std::uint8_t	value,
		std::size_t	bytes_to_set )

memset for a MemoryBuffer instance, allocating memory if neccessary

Parameters

[out]	buffer	Destination memory buffer
[in]	bytes_to_set	Number of bytes to set at the destination
[in]	value	Byte value assigned to the buffer

Return values

true	if successful, false if memory allocation fails

set() [2/3]

bool a_util::memory::set	(	void *	dest,
		std::size_t	dest_size,
		std::uint8_t	value,
		std::size_t	bytes_to_set )

Portable safe memset

Parameters

[out]	dest	Pointer to destination buffer
[in]	dest_size	Available bytes in the destination memory buffer
[in]	value	Byte value assigned to the buffer
[in]	bytes_to_set	Number of bytes to set at the destination

Return values

true	if successful, false if dest is nullptr or bytes_to_set > dest_size

set() [3/3]

bool a_util::memory::set	(	void *	dest,
		std::uint8_t	value,
		std::size_t	bytes_to_set )

Portable memset

Parameters

[out]	dest	Pointer to destination buffer
[in]	value	Byte value assigned to the buffer
[in]	bytes_to_set	Number of bytes to set at the destination

Return values

true	if sucessful, false if dest is nullptr

swap()

template<typename T, std::size_t StackSize, std::size_t Alignment>

void a_util::memory::swap ( StackPtr< T, StackSize, Alignment > & lhs, StackPtr< T, StackSize, Alignment > & rhs )

inline

Swap storages of two objects of type StackPtr

Template Parameters

T	The storaged type
StackSize	Size of allocated storage size
Alignment	Alignment of the storage

Parameters

[in,out]	lhs	Left hand side object
[in,out]	rhs	Right hand side object

Note

The storages are swapped byte-by-byte, so depending on the StackSize this operation might be very time consuming.

swapEndianess() [1/9]

bool a_util::memory::swapEndianess

(

bool

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [2/9]

std::int16_t a_util::memory::swapEndianess

(

std::int16_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [3/9]

std::int32_t a_util::memory::swapEndianess

(

std::int32_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [4/9]

std::int64_t a_util::memory::swapEndianess

(

std::int64_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [5/9]

std::int8_t a_util::memory::swapEndianess

(

std::int8_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [6/9]

std::uint16_t a_util::memory::swapEndianess

(

std::uint16_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [7/9]

std::uint32_t a_util::memory::swapEndianess

(

std::uint32_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [8/9]

std::uint64_t a_util::memory::swapEndianess

(

std::uint64_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

swapEndianess() [9/9]

std::uint8_t a_util::memory::swapEndianess

(

std::uint8_t

value

)

Swap the byte order of parameter value

Return values

value

with its byte order swapped

zero() [1/3]

bool a_util::memory::zero	(	MemoryBuffer &	buffer,
		std::size_t	bytes_to_zero )

memzero for a MemoryBuffer instance, allocating memory if neccessary

Parameters

[out]	buffer	Destination memory buffer
[in]	bytes_to_zero	Number of bytes to zero-assign

Return values

true	if succesful, false if memory allocation fails

zero() [2/3]

bool a_util::memory::zero	(	void *	dest,
		std::size_t	bytes_to_zero )

Portable memzero

Parameters

[out]	dest	Pointer to destination buffer
[in]	bytes_to_zero	Number of bytes to zero-assign

Return values

true	if successful, false if dest is nullptr

zero() [3/3]

bool a_util::memory::zero	(	void *	dest,
		std::size_t	dest_size,
		std::size_t	bytes_to_zero )

Portable safe memzero

Parameters

[out]	dest	Pointer to the destination buffer
[in]	dest_size	Available bytes in the destination memory buffer
[in]	bytes_to_zero	Number of bytes to zero-assign

Return values

true	if successful, false if dest is nullptr or bytes_to_zero > dest_size