asmgrader::ByteArray< Size > Class Template Reference

#include <byte_array.hpp>

Public Types
using	value_type = std::byte
using	allocator_type = std::allocator<std::byte>
using	size_type = std::size_t
using	difference_type = std::ptrdiff_t
using	reference = value_type&
using	const_reference = const value_type&
using	pointer = value_type*
using	const_pointer = const value_type*
using	iterator = std::array<std::byte, Size>::iterator
using	const_iterator = std::array<std::byte, Size>::const_iterator
using	reverse_iterator = std::array<std::byte, Size>::reverse_iterator
using	const_reverse_iterator = std::array<std::byte, Size>::const_reverse_iterator

Public Member Functions
auto	begin ()
auto	begin () const
auto	cbegin () const
auto	end ()
auto	end () const
auto	cend () const
std::size_t	size () const
template<typename T > requires requires(T rng, std::size_t size, std::byte byte) { { rng.resize(size) }; { std::to_integer<T::value_type>(byte) }; }
constexpr T	to () const
	T should be a stdlib-compatible container type where std::byte is convertible to T::value_type.

Static Public Member Functions
template<ranges::range Range>
static constexpr ByteArray	bit_cast_range (Range &&range)
template<typename... Ts>
static constexpr ByteArray	bit_cast (const Ts &... args)

Public Attributes
std::array< std::byte, Size >	data

Member Typedef Documentation

allocator_type

template<std::size_t Size>

using asmgrader::ByteArray< Size >::allocator_type = std::allocator<std::byte>

const_iterator

template<std::size_t Size>

using asmgrader::ByteArray< Size >::const_iterator = std::array<std::byte, Size>::const_iterator

const_pointer

template<std::size_t Size>

using asmgrader::ByteArray< Size >::const_pointer = const value_type*

const_reference

template<std::size_t Size>

using asmgrader::ByteArray< Size >::const_reference = const value_type&

const_reverse_iterator

template<std::size_t Size>

using asmgrader::ByteArray< Size >::const_reverse_iterator = std::array<std::byte, Size>::const_reverse_iterator

difference_type

template<std::size_t Size>

using asmgrader::ByteArray< Size >::difference_type = std::ptrdiff_t

iterator

template<std::size_t Size>

using asmgrader::ByteArray< Size >::iterator = std::array<std::byte, Size>::iterator

pointer

template<std::size_t Size>

using asmgrader::ByteArray< Size >::pointer = value_type*

reference

template<std::size_t Size>

using asmgrader::ByteArray< Size >::reference = value_type&

reverse_iterator

template<std::size_t Size>

using asmgrader::ByteArray< Size >::reverse_iterator = std::array<std::byte, Size>::reverse_iterator

size_type

template<std::size_t Size>

using asmgrader::ByteArray< Size >::size_type = std::size_t

value_type

template<std::size_t Size>

using asmgrader::ByteArray< Size >::value_type = std::byte

Member Function Documentation

begin() [1/2]

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::begin ( )

inline

begin() [2/2]

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::begin ( ) const

inline

bit_cast()

template<std::size_t Size>

template<typename... Ts>

static constexpr ByteArray asmgrader::ByteArray< Size >::bit_cast ( const Ts &... args )

inlinestaticconstexpr

bit_cast_range()

template<std::size_t Size>

template<ranges::range Range>

static constexpr ByteArray asmgrader::ByteArray< Size >::bit_cast_range ( Range && range )

inlinestaticconstexpr

cbegin()

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::cbegin ( ) const

inline

cend()

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::cend ( ) const

inline

end() [1/2]

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::end ( )

inline

end() [2/2]

template<std::size_t Size>

auto asmgrader::ByteArray< Size >::end ( ) const

inline

size()

template<std::size_t Size>

std::size_t asmgrader::ByteArray< Size >::size ( ) const

inline

to()

template<std::size_t Size>

template<typename T >
requires requires(T rng, std::size_t size, std::byte byte) { { rng.resize(size) }; { std::to_integer<T::value_type>(byte) }; }

T asmgrader::ByteArray< Size >::to ( ) const

inlineconstexpr

T should be a stdlib-compatible container type where std::byte is convertible to T::value_type.

Member Data Documentation

data

template<std::size_t Size>

std::array<std::byte, Size> asmgrader::ByteArray< Size >::data

---

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

• include/asmgrader/common/byte_array.hpp