sysio::fixed_bytes< Size > Class Template Reference

#include <fixed_bytes.hpp>

Public Types
typedef uint128_t	word_t

Public Member Functions
constexpr	fixed_bytes ()
	fixed_bytes (const std::array< word_t, num_words()> &arr)
template<typename Word , size_t NumWords, typename Enable = typename std::enable_if<std::is_integral<Word>::value && std::is_unsigned<Word>::value && !std::is_same<Word, bool>::value && std::less<size_t>{}(sizeof(Word), sizeof(word_t))>::type>
	fixed_bytes (const std::array< Word, NumWords > &arr)
template<typename Word , size_t NumWords, typename Enable = typename std::enable_if<std::is_integral<Word>::value && std::is_unsigned<Word>::value && !std::is_same<Word, bool>::value && std::less<size_t>{}(sizeof(Word), sizeof(word_t))>::type>
	fixed_bytes (const Word(&arr)[NumWords])
const auto &	get_array () const
auto	data ()
auto	size () const
std::array< uint8_t, Size >	extract_as_byte_array () const
void	print () const

Static Public Member Functions
static constexpr size_t	num_words ()
static constexpr size_t	padded_bytes ()
template<typename FirstWord , typename... Rest>
static fixed_bytes< Size >	make_from_word_sequence (typename std::enable_if< std::is_integral< FirstWord >::value &&std::is_unsigned< FirstWord >::value &&!std::is_same< FirstWord, bool >::value &&sizeof(FirstWord)<=sizeof(word_t) &&all_true<(std::is_same< FirstWord, Rest >::value)... >::value, FirstWord >::type first_word, Rest... rest)

Detailed Description

template<size_t Size>
class sysio::fixed_bytes< Size >

Fixed size byte array sorted lexicographically

Template Parameters

Size	- Size of the fixed_bytes object

Definition at line 57 of file fixed_bytes.hpp.

Member Typedef Documentation

word_t

template<size_t Size>

uint128_t sysio::fixed_bytes< Size >::word_t

Definition at line 96 of file fixed_bytes.hpp.

Constructor & Destructor Documentation

fixed_bytes() [1/4]

template<size_t Size>

sysio::fixed_bytes< Size >::fixed_bytes ( )

inlineconstexpr

Default constructor to fixed_bytes object which initializes all bytes to zero

Definition at line 113 of file fixed_bytes.hpp.

: _data() {}

fixed_bytes() [2/4]

template<size_t Size>

sysio::fixed_bytes< Size >::fixed_bytes ( const std::array< word_t, num_words()> & arr )

inline

Constructor to fixed_bytes object from std::array of num_words() word_t types

Parameters

arr

data

Definition at line 120 of file fixed_bytes.hpp.

         {
           std::copy(arr.begin(), arr.end(), _data.begin());
         }

fixed_bytes() [3/4]

template<size_t Size>

template<typename Word , size_t NumWords, typename Enable = typename std::enable_if<std::is_integral<Word>::value && std::is_unsigned<Word>::value && !std::is_same<Word, bool>::value && std::less<size_t>{}(sizeof(Word), sizeof(word_t))>::type>

sysio::fixed_bytes< Size >::fixed_bytes ( const std::array< Word, NumWords > & arr )

inline

Constructor to fixed_bytes object from std::array of Word types smaller in size than word_t

Parameters

arr	- Source data

Definition at line 135 of file fixed_bytes.hpp.

         {
            static_assert( sizeof(word_t) == (sizeof(word_t)/sizeof(Word)) * sizeof(Word),
                           "size of the backing word size is not divisible by the size of the array element" );
            static_assert( sizeof(Word) * NumWords <= Size, "too many words supplied to fixed_bytes constructor" );
 
            set_from_word_sequence<Word, NumWords>(arr.data(), arr.data() + arr.size(), *this);
         }

fixed_bytes() [4/4]

template<size_t Size>

template<typename Word , size_t NumWords, typename Enable = typename std::enable_if<std::is_integral<Word>::value && std::is_unsigned<Word>::value && !std::is_same<Word, bool>::value && std::less<size_t>{}(sizeof(Word), sizeof(word_t))>::type>

sysio::fixed_bytes< Size >::fixed_bytes ( const Word(&) arr[NumWords] )

inline

Constructor to fixed_bytes object from fixed-sized C array of Word types smaller in size than word_t

Parameters

arr	- Source data

Definition at line 154 of file fixed_bytes.hpp.

         {
            static_assert( sizeof(word_t) == (sizeof(word_t)/sizeof(Word)) * sizeof(Word),
                           "size of the backing word size is not divisible by the size of the array element" );
            static_assert( sizeof(Word) * NumWords <= Size, "too many words supplied to fixed_bytes constructor" );
 
            set_from_word_sequence<Word, NumWords>(arr, arr + NumWords, *this);
         }

Member Function Documentation

data()

template<size_t Size>

auto sysio::fixed_bytes< Size >::data ( )

inline

Get the underlying data of the contained std::array

Definition at line 200 of file fixed_bytes.hpp.

{ return _data.data(); }

extract_as_byte_array()

template<size_t Size>

std::array< uint8_t, Size > sysio::fixed_bytes< Size >::extract_as_byte_array ( ) const

inline

Extract the contained data as an array of bytes

Returns

- the extracted data as array of bytes

Definition at line 222 of file fixed_bytes.hpp.

                                                              {
            std::array<uint8_t, Size> arr;
 
            const size_t num_sub_words = sizeof(word_t);
 
            auto arr_itr  = arr.begin();
            auto data_itr = _data.begin();
 
            for( size_t counter = _data.size(); counter > 0; --counter, ++data_itr ) {
               size_t sub_words_left = num_sub_words;
 
               auto temp_word = *data_itr;
               if( counter == 1 ) { // If last word in _data array...
                  sub_words_left -= padded_bytes();
                  temp_word >>= 8*padded_bytes();
               }
               for( ; sub_words_left > 0; --sub_words_left ) {
                  *(arr_itr + sub_words_left - 1) = static_cast<uint8_t>(temp_word & 0xFF);
                  temp_word >>= 8;
               }
               arr_itr += num_sub_words;
            }
 
            return arr;
         }

Here is the call graph for this function:

Here is the caller graph for this function:

get_array()

template<size_t Size>

const auto & sysio::fixed_bytes< Size >::get_array ( ) const

inline

Get the contained std::array

Definition at line 195 of file fixed_bytes.hpp.

{ return _data; }

Here is the caller graph for this function:

make_from_word_sequence()

template<size_t Size>

template<typename FirstWord , typename... Rest>

static fixed_bytes< Size > sysio::fixed_bytes< Size >::make_from_word_sequence ( typename std::enable_if< std::is_integral< FirstWord >::value &&std::is_unsigned< FirstWord >::value &&!std::is_same< FirstWord, bool >::value &&sizeof(FirstWord)<=sizeof(word_t) &&all_true<(std::is_same< FirstWord, Rest >::value)... >::value, FirstWord >::type first_word, Rest... rest )

inlinestatic

Create a new fixed_bytes object from a sequence of words

Template Parameters

FirstWord	- The type of the first word in the sequence
Rest	- The type of the remaining words in the sequence

Parameters

first_word	- The first word in the sequence
rest	- The remaining words in the sequence

Definition at line 174 of file fixed_bytes.hpp.

         {
            static_assert( sizeof(word_t) == (sizeof(word_t)/sizeof(FirstWord)) * sizeof(FirstWord),
                           "size of the backing word size is not divisible by the size of the words supplied as arguments" );
            static_assert( sizeof(FirstWord) * (1 + sizeof...(Rest)) <= Size, "too many words supplied to make_from_word_sequence" );
 
            fixed_bytes<Size> key;
            std::array<FirstWord, 1+sizeof...(Rest)> arr{{ first_word, rest... }};
            set_from_word_sequence<FirstWord, 1+sizeof...(Rest)>(arr.data(), arr.data() + arr.size(), key);
            return key;
         }

num_words()

template<size_t Size>

static constexpr size_t sysio::fixed_bytes< Size >::num_words ( )

inlinestaticconstexpr

Get number of words contained in this fixed_bytes object. A word is defined to be 16 bytes in size

Definition at line 102 of file fixed_bytes.hpp.

{ return (Size + sizeof(word_t) - 1) / sizeof(word_t); }

Here is the caller graph for this function:

padded_bytes()

template<size_t Size>

static constexpr size_t sysio::fixed_bytes< Size >::padded_bytes ( )

inlinestaticconstexpr

Get number of padded bytes contained in this fixed_bytes object. Padded bytes are the remaining bytes inside the fixed_bytes object after all the words are allocated

Definition at line 108 of file fixed_bytes.hpp.

{ return num_words() * sizeof(word_t) - Size; }

Here is the call graph for this function:

Here is the caller graph for this function:

print()

template<size_t Size>

void sysio::fixed_bytes< Size >::print ( ) const

inline

Prints fixed_bytes as a hexidecimal string

Parameters

val	to be printed

Definition at line 253 of file fixed_bytes.hpp.

                                  {
            auto arr = extract_as_byte_array();
            printhex(static_cast<const void*>(arr.data()), arr.size());
         }

Here is the call graph for this function:

size()

template<size_t Size>

auto sysio::fixed_bytes< Size >::size ( ) const

inline

Get the size of the contained std::array

Definition at line 214 of file fixed_bytes.hpp.

{ return _data.size(); }

---

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

• libraries/chain/include/sysio/chain/fixed_bytes.hpp