|
struct | all_ones |
|
struct | all_ones< 0 > |
|
struct | basic_functions |
|
struct | basic_functions< 32 > |
|
struct | bit_in_unit_byte_reverser |
| bit_in_unit_byte_reverser transforms the sequence of bits in each byte of the input unit into reversed sequence of bits in each byte of the output unit. The function reverse is recursively invoked and the parameter k is used to track the number of already processed input bytes. The recursion ends, when all input bytes have been processed, i.e. when k == UnitBits. More...
|
|
struct | bit_in_unit_byte_reverser< UnitBits, UnitBits > |
|
struct | bit_in_unit_reverser |
| bit_in_unit_reverser transforms the sequence of bits in each unit of the input value into reversed sequence of bytes in each unit of the output value. The function reverse is recursively invoked and the parameter k is used to track the number of already processed input units. The recursion ends, when all input units have been processed, i.e. when k == InputBits. More...
|
|
struct | bit_in_unit_reverser< InputBits, UnitBits, InputBits > |
|
struct | bit_reverser |
| bit_reverser reverses the sequence of bits in each unit of the given value, if InputEndianness and OutputEndianness endiannesses have different bit orders, and does nothing, otherwise. More...
|
|
struct | bit_reverser< InputEndianness, OutputEndianness, UnitBits, false > |
| This bit_reverser deals with the case of the endiannesses with different order of bits and invokes bit_in_unit_reverser which reverses bits in each unit of the input value. More...
|
|
struct | bit_reverser< InputEndianness, OutputEndianness, UnitBits, true > |
| This bit_reverser is a dummy and deals with the case of the endiannesses with the same order of bits. More...
|
|
struct | build_indices |
|
struct | build_indices< 0 > |
|
struct | byte_in_unit_reverser |
| byte_in_unit_reverser transforms the sequence of bytes in each unit of the input value into reversed sequence of bytes in each unit of the output value. The function reverse is recursively invoked and the parameter k is used to track the number of already processed input units. The recursion ends, when all input units have been processed, i.e. when k == InputBits. More...
|
|
struct | byte_in_unit_reverser< InputBits, UnitBits, InputBits > |
|
struct | can_memcpy |
| can_memcpy trait is derived from host_can_memcpy trait and is invoked depending on data endianness. Note that there is a single endianness template parameter since otherwise we have to transform data in accordance with endianness conversion rules. More...
|
|
struct | can_memcpy< stream_endian::host_unit< UnitBits >, InputBits, OutputBits, InT, OutT > |
|
struct | derived_range |
|
struct | encode_holder |
|
struct | encoded_range |
|
struct | endian_shift |
|
struct | endian_shift< stream_endian::big_unit_big_bit< UnitBits >, WordBits > |
|
struct | endian_shift< stream_endian::big_unit_little_bit< UnitBits >, WordBits > |
|
struct | endian_shift< stream_endian::little_unit_big_bit< UnitBits >, WordBits > |
|
struct | endian_shift< stream_endian::little_unit_little_bit< UnitBits >, WordBits > |
|
struct | exploder |
| exploder forms a sequence of output values represented in OutputEndianness endianness from an input value represented in InputEndianness endianness. The function explode is invoked recursively, and the parameter k is used to track the number of already processed output values derived from the input value. The recursion ends when all elements the input value can hold have already been processed, i.e. when k == InputBits. More...
|
|
struct | exploder< Endian< UnitBits >, InputBits, OutputBits, InputBits > |
|
struct | exploder< Endian< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder< InputEndian< UnitBits >, OutputEndian< UnitBits >, InputBits, OutputBits, InputBits > |
|
struct | exploder< InputEndian< UnitBits >, OutputEndian< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder_shift |
| exploder_shift trait is used to determine whether the output elements are splitted from an input element in reverse order. Since the input and output types are integral now, this trait contains the shift indicating the position of output element derived from the input element when k output bits have already been processed. More...
|
|
struct | exploder_shift< InputEndianness, UnitBits, InputBits, OutputBits, k, false > |
|
struct | exploder_shift< InputEndianness, UnitBits, InputBits, OutputBits, k, true > |
|
struct | exploder_step |
| exploder_step obtains an output value represented in OutputEndianness endianness from an input value represented in InputEndianness endianness when k output bits have already been processed. It uses unit_reverser and bit_reverser to deal with the order of units and bits in the output value, respectively. Shift constant is determined by the exploder_shift trait. More...
|
|
struct | exploder_step< stream_endian::big_unit_big_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder_step< stream_endian::big_unit_little_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder_step< stream_endian::host_unit< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder_step< stream_endian::little_unit_big_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | exploder_step< stream_endian::little_unit_little_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | host_can_memcpy |
| The group of traits below is used to determine the possibility of fast data copy. By fast data copy we mean that the data is stored contiguously in the memory, so it can be copied faster byte-by-byte. Currently, fast data copy is implemented by memcpy function call. More...
|
|
struct | imploder |
| imploder processes a sequence of input values represented in InputEndianness endianness into an output value represented in OutputEndianness endianness. The function implode is invoked recursively, and the parameter k is used to track the number of already processed input values packed into the output value. The recursion ends when all elements the output value can hold have already been processed, i.e. when k == OutputBits. More...
|
|
struct | imploder< Endian< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder< Endian< UnitBits >, InputBits, OutputBits, OutputBits > |
|
struct | imploder< InputEndian< UnitBits >, OutputEndian< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder< InputEndian< UnitBits >, OutputEndian< UnitBits >, InputBits, OutputBits, OutputBits > |
|
struct | imploder_shift |
| imploder_shift trait is used to determine whether the input elements are packed into an output element in reverse order. Since the input and output types are integral now, this trait contains the shift indicating the position of input element in the output element when k input bits have already been processed. More...
|
|
struct | imploder_shift< OutputEndianness, UnitBits, InputBits, OutputBits, k, false > |
|
struct | imploder_shift< OutputEndianness, UnitBits, InputBits, OutputBits, k, true > |
|
struct | imploder_step |
| imploder_step packs an input value represented in InputEndianness endianness into an output value represented in OutputEndianness endianness when k input bits have already been processed. It uses unit_reverser and bit_reverser to deal with the order of units and bits in the input value, respectively. Shift constant is determined by the imploder_shift trait. More...
|
|
struct | imploder_step< stream_endian::big_unit_big_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder_step< stream_endian::big_unit_little_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder_step< stream_endian::host_unit< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder_step< stream_endian::little_unit_big_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | imploder_step< stream_endian::little_unit_little_bit< UnitBits >, InputBits, OutputBits, k > |
|
struct | indices |
|
struct | injector |
|
struct | is_big_bit |
| The group of traits below is used to determine the order of bits defined by the endianness. More...
|
|
struct | is_big_unit |
| The group of traits below is used to determine the order of units defined by the endianness. More...
|
|
struct | is_block_cipher |
|
struct | is_codec |
|
struct | is_complex |
|
struct | is_complex< std::complex< T > > |
|
struct | is_container |
|
struct | is_curve |
|
struct | is_curve_group |
|
struct | is_extended_field |
|
struct | is_field |
|
struct | is_hash |
|
struct | is_iterator |
|
struct | is_kdf |
|
struct | is_little_bit |
| Trait to determine whether the order of bits defined by Endianness endianness is little. More...
|
|
struct | is_little_unit |
| Trait to determine whether the order of units defined by Endianness endianness is little. More...
|
|
struct | is_mac |
|
struct | is_passhash |
|
struct | is_range |
|
struct | is_same_bit |
| Trait to determine whether the orders of bits defined by Endianness1 endianness and Endianness2 endianness are the same. More...
|
|
struct | is_same_unit |
| Trait to determine whether the orders of units defined by Endianness1 endianness and Endianness2 endianness are the same. More...
|
|
struct | largest_prime |
|
struct | outvalue_helper |
| outvalue_helper trait is used to determine the output value type. If OutBits is not an exact power of two for which the type uint_t is defined, the type with the least power of two bits greater than OutBits is taken. Due to current exploder struct definition, this case is possible, when OutputBits is a factor of UnitBits less than UnitBits, and UnitBits is no more than CHAR_BIT. More...
|
|
struct | outvalue_helper< OutIter, OutBits, void > |
|
struct | packer |
| This packer deals with arbitrary input and output (but not bool) data elements. More...
|
|
struct | packer< InputEndianness, OutputEndianness, InputValueBits, OutputValueBits, bool, bool > |
| This packer deals with bool input and output data elements. More...
|
|
struct | packer< InputEndianness, OutputEndianness, InputValueBits, OutputValueBits, bool, OutputType > |
| This packer deals with bool input data and arbitrary (but not bool) output data elements. More...
|
|
struct | packer< InputEndianness, OutputEndianness, InputValueBits, OutputValueBits, InputType, bool > |
| This packer deals with arbitrary (but not bool) input data and bool output data elements. More...
|
|
struct | real_packer |
| Real_packer is used to transform input data divided into chunks of the bit size InputValueBits represented in input endianness (InputEndianness) into output data (of the same bit length) divided into chunks of the bit size OutputValueBits represented in output endianness (OutputEndianness). More...
|
|
struct | real_packer< Endianness, Bits, Bits, false, false > |
|
struct | real_packer< Endianness, Endianness, ValueBits, ValueBits, InputType, OutputType, true, false, false > |
| This real_packer deals with the case of equal sizes (i.e. InputValueBits == OutputValueBits) and same endianness representations (i.e., speaking informally, InputEndianness == OutputEndianness). It packs input elements with ValueBits size represented in Endianness endianness into output elements with the same ValueBits size represented in the same Endianness endianness. More...
|
|
struct | real_packer< Endianness, InputBits, OutputBits, false, true > |
|
struct | real_packer< Endianness, InputBits, OutputBits, true, false > |
|
struct | real_packer< InputEndian< UnitBits >, OutputEndian< UnitBits >, ValueBits, ValueBits, InputType, OutputType, false, false, false > |
| This real_packer deals with the case of equal sizes (i.e. InputValueBits == OutputValueBits) and different endianness representations (or, speaking informally, InputEndianness != OutputEndianness). It invokes functions which pack input elements with ValueBits size represented in InputEndianness endianness into output elements with the same ValueBits size represented in another OutputEndianness endianness. More...
|
|
struct | real_packer< InputEndianness, OutputEndianness, InputValueBits, OutputValueBits, InputType, OutputType, SameEndianness, false, true > |
| This real_packer deals with case InputValueBits > OutputValueBits and invokes explode function, which, in its turn, packs input elements with InputValueBits size represented in InputEndianness endianness into output elements with OutputValueBits size represented in OutputEndianness endianness. More...
|
|
struct | real_packer< InputEndianness, OutputEndianness, InputValueBits, OutputValueBits, InputType, OutputType, SameEndianness, true, false > |
| This real_packer deals with case InputValueBits < OutputValueBits and invokes implode function, which, in its turn, packs input elements with InputValueBits size represented in InputEndianness endianness into output elements with OutputValueBits size represented in OutputEndianness endianness. More...
|
|
struct | remove_complex |
|
struct | remove_complex< std::complex< T > > |
|
struct | state_adder |
|
struct | transform_iterator_gen |
|
struct | unbounded_shifter |
|
struct | unbounded_shifter< 0, T > |
|
struct | unit_reverser |
| unit_reverser reverses the sequence of units in the given value, if InputEndianness and OutputEndianness endiannesses have different unit orders, and does nothing, otherwise. More...
|
|
struct | unit_reverser< InputEndianness, OutputEndianness, UnitBits, typename std::enable_if< is_same_unit< InputEndianness, OutputEndianness, UnitBits >::value >::type > |
| This unit_reverser is a dummy and deals with the case of the endiannesses with the same order of units. More...
|
|
struct | unit_reverser< InputEndianness, OutputEndianness, UnitBits, typename std::enable_if<!is_same_unit< InputEndianness, OutputEndianness, UnitBits >::value &&(UnitBits > CHAR_BIT)>::type > |
| This unit_reverser deals with the case of UnitBits > CHAR_BIT. To reverse the order of units, first, it reverses the byte order in an input value, and then, it invokes byte_in_unit_reverser to reverse the byte order in each unit of the input value. More...
|
|
struct | unit_reverser< InputEndianness, OutputEndianness, UnitBits, typename std::enable_if<!is_same_unit< InputEndianness, OutputEndianness, UnitBits >::value &&UnitBits==CHAR_BIT >::type > |
| This unit_reverser deals with the case of UnitBits == CHAR_BIT. This case is special since it is sufficient to reverse the order of bytes in an input value. More...
|
|
struct | unwrap_reference |
|
struct | unwrap_reference< std::reference_wrapper< U > > |
|
struct | word_injector |
|
struct | word_injector< stream_endian::big_unit_big_bit< UnitBits >, WordBits, BlockWords, BlockBits > |
|
struct | word_injector< stream_endian::big_unit_little_bit< UnitBits >, WordBits, BlockWords, BlockBits > |
|
struct | word_injector< stream_endian::little_unit_big_bit< UnitBits >, WordBits, BlockWords, BlockBits > |
|
struct | word_injector< stream_endian::little_unit_little_bit< UnitBits >, WordBits, BlockWords, BlockBits > |
|
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (begin) |
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (decode) |
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (decrypt) |
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (encode) |
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (encrypt) |
|
| BOOST_TTI_HAS_MEMBER_FUNCTION (end) |
|
template<std::size_t DigestBits> |
digest< DigestBits/4+1 > | c_str (const boost::container::small_vector< octet_type, DigestBits/octet_bits > &d) |
|
template<std::size_t DigestBits> |
digest< DigestBits/4+1 > | c_str (const digest< DigestBits > &d) |
|
template<std::size_t DigestBits> |
std::array< char, DigestBits/4+1 > | c_str (const static_digest< DigestBits > &d) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (10, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (11, 8) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (12, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (13, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (14, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (15, 18) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (16, 14) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (17, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (18, 4) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (19, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (2, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (20, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (21, 8) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (22, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (23, 14) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (24, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (25, 38) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (26, 4) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (27, 38) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (28, 56) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (29, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (3, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (30, 34) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (31, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (32, 4) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (4, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (5, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (6, 2) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (7, 0) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (8, 4) |
|
| CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET (9, 2) |
|
template<size_t type_bits, typename T > |
T | high_bits (T x, size_t shift) |
|
template<size_t type_bits, typename T > |
T | high_bits (T x, std::size_t shift) |
|
template<int Shift, typename T > |
T | low_bits (T x) |
|
template<size_t Shift, std::size_t TypeBits, typename T > |
T | low_bits (T x) |
|
template<size_t type_bits, typename T > |
T | low_bits (T x, size_t shift) |
|
template<size_t type_bits, typename T > |
T | low_bits (T x, std::size_t shift) |
|
template<std::size_t... I, typename InputIterator , typename Array = std::array<ValueType<InputIterator>, sizeof...(I)>> |
Array | make_array (InputIterator first, indices< I... >) |
|
template<class SinglePassRange , class UnaryFunction > |
encoded_range< UnaryFunction, const SinglePassRange > | operator| (const SinglePassRange &r, const encode_holder< UnaryFunction > &f) |
|
template<class SinglePassRange , class UnaryFunction > |
derived_range< UnaryFunction, const SinglePassRange > | operator| (const SinglePassRange &r, const encode_holder< UnaryFunction > &f) |
|
template<class SinglePassRange , class UnaryFunction > |
encoded_range< UnaryFunction, SinglePassRange > | operator| (SinglePassRange &r, const encode_holder< UnaryFunction > &f) |
|
template<class SinglePassRange , class UnaryFunction > |
derived_range< UnaryFunction, SinglePassRange > | operator| (SinglePassRange &r, const encode_holder< UnaryFunction > &f) |
|
template<typename Endianness , int OutValueBits, typename InputType , typename Backend , expression_template_option ExpressionTemplates> |
void | pack (const InputType &in, number< Backend, ExpressionTemplates > &out) |
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputType , typename OutputType > |
void | pack (const InputType &in, OutputType &out) |
| Packs immutable data referenced by in into data referenced by out. More...
|
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputType , typename OutputType > |
void | pack (const InputType &in, OutputType &out) |
|
template<typename Endianness , int OutValueBits, typename OutputType , typename Backend , expression_template_option ExpressionTemplates> |
void | pack (const number< Backend, ExpressionTemplates > &in, OutputType &out) |
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename InCatT , typename OutputIterator , typename = typename std::enable_if<nil::crypto3::detail::is_iterator<InputIterator>::value>::type, typename = typename std::enable_if<nil::crypto3::detail::is_iterator<OutputIterator>::value>::type> |
void | pack (InputIterator first, InputIterator last, InCatT, OutputIterator out) |
| Packs elements from the range [first, last) into elements starting from out. Works for input containers meeting InCatT category requirements and output containers meeting OutputIterator requirements. More...
|
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator , typename Backend , expression_template_option ExpressionTemplates> |
void | pack (InputIterator first, InputIterator last, number< Backend, ExpressionTemplates > &out) |
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator , typename = typename std::enable_if<nil::crypto3::detail::is_iterator<OutputIterator>::value>::type> |
void | pack (InputIterator first, InputIterator last, OutputIterator out) |
| Generic function that chooses pack function depending on input iterator category. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputType , typename = typename std::enable_if<!std::is_arithmetic<OutputType>::value>::type> |
void | pack (InputIterator first, InputIterator last, OutputType &out) |
| Packs elements from range [first, last) into data referenced by out with non-arithmetic value type. More...
|
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator , typename OutputType , typename = typename std::enable_if<!std::is_arithmetic<OutputType>::value>::type> |
void | pack (InputIterator first, InputIterator last, OutputType &out) |
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack (InputIterator first, InputIterator last, std::random_access_iterator_tag, OutputIterator out) |
| Packs elements from the range [first, last) into elements starting from out. Works for input containers meeting RandomAccessIterator requirements. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename InCatT , typename OutputIterator , typename OutCatT > |
void | pack (InputIterator in_first, InputIterator in_last, InCatT, OutputIterator out, OutputIterator, OutCatT) |
| Packs elements from the range [first, last) into elements starting from out. Works for input containers meeting InCatT category requirements and output containers meeting OutCatT category requirements. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack (InputIterator in_first, InputIterator in_last, OutputIterator out_first, OutputIterator out_last) |
| Generic function that chooses pack function depending on input and output iterator category. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack (InputIterator in_first, InputIterator in_last, std::random_access_iterator_tag, OutputIterator out_first, OutputIterator out_last, std::random_access_iterator_tag) |
| Packs elements from the range [first, last) into elements starting from out. Works for input and output containers meeting RandomAccessIterator requirements. More...
|
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename CatT1 , typename InputIterator2 , typename = typename std::enable_if<detail::is_iterator<InputIterator1>::value>::type, typename = typename std::enable_if<detail::is_iterator<InputIterator2>::value>::type> |
void | pack (InputIterator1 b1, InputIterator1 e1, CatT1, InputIterator2 b2) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename CatT1 , typename InputIterator2 , typename CatT2 > |
void | pack (InputIterator1 b1, InputIterator1 e1, CatT1, InputIterator2 b2, InputIterator2, CatT2) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 , typename = typename std::enable_if<detail::is_iterator<InputIterator2>::value>::type> |
void | pack (InputIterator1 b1, InputIterator1 e1, InputIterator2 b2) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 > |
void | pack (InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 > |
void | pack (InputIterator1 b1, InputIterator1 e1, std::random_access_iterator_tag, InputIterator2 b2) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 > |
void | pack (InputIterator1 b1, InputIterator1 e1, std::random_access_iterator_tag, InputIterator2 b2, InputIterator2 e2, std::random_access_iterator_tag) |
|
template<typename InputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputRange , typename OutputIterator > |
void | pack_from (const InputRange &r, OutputIterator out) |
| Packs elements from range [first, last) represented in InputEndianness endianness into elements starting from out represented in machine-dependent endianness. More...
|
|
template<typename InputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack_from (InputIterator first, InputIterator last, OutputIterator out) |
| Packs elements from range [first, last) represented in InputEndianness endianness into elements starting from out represented in machine-dependent endianness. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack_n (InputIterator in, std::size_t in_n, OutputIterator out) |
| Packs in_n input elements starting from in into output elements beginning from out. More...
|
|
template<typename InputEndianness , typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack_n (InputIterator in, std::size_t in_n, OutputIterator out, std::size_t out_n) |
| Packs in_n input elements starting from in into in_out elements beginning from out. More...
|
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 > |
void | pack_n (InputIterator1 in, size_t in_n, InputIterator2 out) |
|
template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 > |
void | pack_n (InputIterator1 in, size_t in_n, InputIterator2 out, size_t out_n) |
|
template<typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputRange , typename OutputIterator > |
void | pack_to (const InputRange &r, OutputIterator out) |
| Packs elements from range [first, last) represented in machine-dependent endianness into elements starting from out represented in OutputEndianness endianness. More...
|
|
template<typename OutputEndianness , std::size_t InputValueBits, std::size_t OutputValueBits, typename InputIterator , typename OutputIterator > |
void | pack_to (InputIterator first, InputIterator last, OutputIterator out) |
| Packs elements from range [first, last) represented in machine-dependent endianness into elements starting from out represented in OutputEndianness endianness. More...
|
|
size_t | padding_for_alignment (size_t n, size_t alignment) |
|
template<size_t LIMBS, min_weight_polynomial P> |
void | poly_double (uint8_t out[], const uint8_t in[]) |
|
template<size_t LIMBS, min_weight_polynomial P, typename InputIterator > |
void | poly_double_le (uint8_t out[], InputIterator first, InputIterator last) |
|
template<typename T , typename U > |
constexpr T | pow (T x, U n) |
|
bool | ptr_in_pool (const void *pool_ptr, size_t poolsize, const void *buf_ptr, size_t bufsize) |
|
template<typename UnitType , int UnitBits = sizeof(UnitType) * CHAR_BIT, typename std::enable_if<(UnitBits > CHAR_BIT), int >::type = 0> |
void | reverse_bits (UnitType &unit) |
| The functions listed below deal with bit reversal in a unit. More...
|
|
void | reverse_byte (byte_type &b) |
| This function reverses bit order in the byte b depending on the machine word size. The underlying algorithms used in this function are described in http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits and in http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith64BitsDiv . More...
|
|
template<typename InputRange1 , typename InputRange2 , typename OutputIterator > |
constexpr OutputIterator | strxor (const InputRange1 &in1, const InputRange2 &in2, OutputIterator out) |
|
template<typename InputIterator1 , typename InputIterator2 , typename OutputIterator > |
constexpr std::enable_if< std::is_same< typename std::iterator_traits< InputIterator1 >::value_type, typename std::iterator_traits< InputIterator2 >::value_type >::value &&std::is_same< typename std::iterator_traits< InputIterator1 >::value_type, typename std::iterator_traits< OutputIterator >::value_type >::value, OutputIterator >::type | strxor (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator out) |
|
template<std::size_t DigestBits, typename OutputIterator > |
OutputIterator | to_ascii (const boost::container::small_vector< octet_type, DigestBits/octet_bits > &d, OutputIterator it) |
|
template<std::size_t DigestBits, typename OutputIterator > |
OutputIterator | to_ascii (const digest< DigestBits > &d, OutputIterator it) |
|
template<std::size_t DigestBits, typename OutputIterator > |
OutputIterator | to_ascii (const static_digest< DigestBits > &d, OutputIterator it) |
|
template<int Shift, typename T > |
T | unbounded_shl (T x) |
|
template<typename T > |
T | unbounded_shl (T x, std::size_t n) |
|
template<int Shift, typename T > |
T | unbounded_shr (T x) |
|
template<typename T > |
T | unbounded_shr (T x, std::size_t n) |
|