nil::crypto3::detail Namespace Reference

Classes

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 >
 

Typedefs

template<std::size_t N>
using BuildIndices = typename build_indices< N >::type
 
typedef boost::uint_t< CHAR_BIT >::exact byte_type
 
template<typename T >
using remove_complex_t = typename remove_complex< T >::type
 
template<typename Iterator >
using ValueType = typename std::iterator_traits< Iterator >::value_type
 

Enumerations

enum class  min_weight_polynomial : uint64_t {
  P64 = 0x1B , P128 = 0x87 , P192 = 0x87 , P256 = 0x425 ,
  P512 = 0x125 , P1024 = 0x80043 , P64 = 0x1B , P128 = 0x87 ,
  P192 = 0x87 , P256 = 0x425 , P512 = 0x125 , P1024 = 0x80043
}
 
enum class  min_weight_polynomial : uint64_t {
  P64 = 0x1B , P128 = 0x87 , P192 = 0x87 , P256 = 0x425 ,
  P512 = 0x125 , P1024 = 0x80043 , P64 = 0x1B , P128 = 0x87 ,
  P192 = 0x87 , P256 = 0x425 , P512 = 0x125 , P1024 = 0x80043
}
 

Functions

 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 >
high_bits (T x, size_t shift)
 
template<size_t type_bits, typename T >
high_bits (T x, std::size_t shift)
 
template<int Shift, typename T >
low_bits (T x)
 
template<size_t Shift, std::size_t TypeBits, typename T >
low_bits (T x)
 
template<size_t type_bits, typename T >
low_bits (T x, size_t shift)
 
template<size_t type_bits, typename 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)
 
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 >
unbounded_shl (T x)
 
template<typename T >
unbounded_shl (T x, std::size_t n)
 
template<int Shift, typename T >
unbounded_shr (T x)
 
template<typename T >
unbounded_shr (T x, std::size_t n)
 

Variables

template<typename T >
constexpr bool is_complex_v = is_complex<T>::value
 

Typedef Documentation

◆ BuildIndices

template<std::size_t N>
using nil::crypto3::detail::BuildIndices = typedef typename build_indices<N>::type

◆ byte_type

typedef boost::uint_t< CHAR_BIT >::exact nil::crypto3::detail::byte_type

◆ remove_complex_t

template<typename T >
using nil::crypto3::detail::remove_complex_t = typedef typename remove_complex<T>::type

◆ ValueType

template<typename Iterator >
using nil::crypto3::detail::ValueType = typedef typename std::iterator_traits<Iterator>::value_type

Enumeration Type Documentation

◆ min_weight_polynomial [1/2]

Enumerator
P64 
P128 
P192 
P256 
P512 
P1024 
P64 
P128 
P192 
P256 
P512 
P1024 

◆ min_weight_polynomial [2/2]

Enumerator
P64 
P128 
P192 
P256 
P512 
P1024 
P64 
P128 
P192 
P256 
P512 
P1024 

Function Documentation

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [1/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( begin  )

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [2/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( decode  )

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [3/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( decrypt  )

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [4/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( encode  )

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [5/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( encrypt  )

◆ BOOST_TTI_HAS_MEMBER_FUNCTION() [6/6]

nil::crypto3::detail::BOOST_TTI_HAS_MEMBER_FUNCTION ( end  )

◆ c_str() [1/3]

template<std::size_t DigestBits>
digest< DigestBits/4+1 > nil::crypto3::detail::c_str ( const boost::container::small_vector< octet_type, DigestBits/octet_bits > &  d)

◆ c_str() [2/3]

template<std::size_t DigestBits>
digest< DigestBits/4+1 > nil::crypto3::detail::c_str ( const digest< DigestBits > &  d)

◆ c_str() [3/3]

template<std::size_t DigestBits>
std::array< char, DigestBits/4+1 > nil::crypto3::detail::c_str ( const static_digest< DigestBits > &  d)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [1/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 10  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [2/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 11  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [3/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 12  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [4/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 13  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [5/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 14  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [6/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 15  ,
18   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [7/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 16  ,
14   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [8/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 17  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [9/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 18  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [10/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 19  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [11/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [12/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 20  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [13/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 21  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [14/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 22  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [15/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 23  ,
14   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [16/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 24  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [17/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 25  ,
38   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [18/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 26  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [19/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 27  ,
38   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [20/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 28  ,
56   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [21/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 29  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [22/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [23/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 30  ,
34   
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [24/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 31  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [25/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( 32  ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [26/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [27/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [28/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [29/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [30/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET() [31/31]

nil::crypto3::detail::CRYPTO3_HASH_DEFINE_LARGEST_PRIME_BY_OFFSET ( ,
 
)

◆ high_bits() [1/2]

template<size_t type_bits, typename T >
T nil::crypto3::detail::high_bits ( x,
size_t  shift 
)

◆ high_bits() [2/2]

template<size_t type_bits, typename T >
T nil::crypto3::detail::high_bits ( x,
std::size_t  shift 
)

◆ low_bits() [1/4]

template<int Shift, typename T >
T nil::crypto3::detail::low_bits ( x)

◆ low_bits() [2/4]

template<size_t Shift, std::size_t TypeBits, typename T >
T nil::crypto3::detail::low_bits ( x)

◆ low_bits() [3/4]

template<size_t type_bits, typename T >
T nil::crypto3::detail::low_bits ( x,
size_t  shift 
)

◆ low_bits() [4/4]

template<size_t type_bits, typename T >
T nil::crypto3::detail::low_bits ( x,
std::size_t  shift 
)

◆ make_array()

template<std::size_t... I, typename InputIterator , typename Array = std::array<ValueType<InputIterator>, sizeof...(I)>>
Array nil::crypto3::detail::make_array ( InputIterator  first,
indices< I... >   
)

◆ operator|() [1/4]

template<class SinglePassRange , class UnaryFunction >
encoded_range<UnaryFunction, const SinglePassRange> nil::crypto3::detail::operator| ( const SinglePassRange &  r,
const encode_holder< UnaryFunction > &  f 
)
inline

◆ operator|() [2/4]

template<class SinglePassRange , class UnaryFunction >
derived_range<UnaryFunction, const SinglePassRange> nil::crypto3::detail::operator| ( const SinglePassRange &  r,
const encode_holder< UnaryFunction > &  f 
)
inline

◆ operator|() [3/4]

template<class SinglePassRange , class UnaryFunction >
encoded_range<UnaryFunction, SinglePassRange> nil::crypto3::detail::operator| ( SinglePassRange &  r,
const encode_holder< UnaryFunction > &  f 
)
inline

◆ operator|() [4/4]

template<class SinglePassRange , class UnaryFunction >
derived_range<UnaryFunction, SinglePassRange> nil::crypto3::detail::operator| ( SinglePassRange &  r,
const encode_holder< UnaryFunction > &  f 
)
inline

◆ pack() [1/11]

template<typename Endianness , int OutValueBits, typename InputType , typename Backend , expression_template_option ExpressionTemplates>
void nil::crypto3::detail::pack ( const InputType &  in,
number< Backend, ExpressionTemplates > &  out 
)
inline

◆ pack() [2/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputType , typename OutputType >
void nil::crypto3::detail::pack ( const InputType &  in,
OutputType &  out 
)
inline

◆ pack() [3/11]

template<typename Endianness , int OutValueBits, typename OutputType , typename Backend , expression_template_option ExpressionTemplates>
void nil::crypto3::detail::pack ( const number< Backend, ExpressionTemplates > &  in,
OutputType &  out 
)
inline

◆ pack() [4/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator , typename Backend , expression_template_option ExpressionTemplates>
void nil::crypto3::detail::pack ( InputIterator  first,
InputIterator  last,
number< Backend, ExpressionTemplates > &  out 
)
inline

◆ pack() [5/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator , typename OutputType , typename = typename std::enable_if<!std::is_arithmetic<OutputType>::value>::type>
void nil::crypto3::detail::pack ( InputIterator  first,
InputIterator  last,
OutputType &  out 
)
inline

◆ pack() [6/11]

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 nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
CatT1  ,
InputIterator2  b2 
)
inline

◆ pack() [7/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename CatT1 , typename InputIterator2 , typename CatT2 >
void nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
CatT1  ,
InputIterator2  b2,
InputIterator2  ,
CatT2   
)
inline

◆ pack() [8/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 , typename = typename std::enable_if<detail::is_iterator<InputIterator2>::value>::type>
void nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
InputIterator2  b2 
)
inline

◆ pack() [9/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 >
void nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
InputIterator2  b2,
InputIterator2  e2 
)
inline

◆ pack() [10/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 >
void nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
std::random_access_iterator_tag  ,
InputIterator2  b2 
)
inline

◆ pack() [11/11]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 >
void nil::crypto3::detail::pack ( InputIterator1  b1,
InputIterator1  e1,
std::random_access_iterator_tag  ,
InputIterator2  b2,
InputIterator2  e2,
std::random_access_iterator_tag   
)
inline

◆ pack_n() [1/2]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 >
void nil::crypto3::detail::pack_n ( InputIterator1  in,
size_t  in_n,
InputIterator2  out 
)
inline

◆ pack_n() [2/2]

template<typename Endianness , int InValueBits, int OutValueBits, typename InputIterator1 , typename InputIterator2 >
void nil::crypto3::detail::pack_n ( InputIterator1  in,
size_t  in_n,
InputIterator2  out,
size_t  out_n 
)
inline

◆ padding_for_alignment()

size_t nil::crypto3::detail::padding_for_alignment ( size_t  n,
size_t  alignment 
)
inline

◆ poly_double()

template<size_t LIMBS, min_weight_polynomial P>
void nil::crypto3::detail::poly_double ( uint8_t  out[],
const uint8_t  in[] 
)

◆ poly_double_le()

template<size_t LIMBS, min_weight_polynomial P, typename InputIterator >
void nil::crypto3::detail::poly_double_le ( uint8_t  out[],
InputIterator  first,
InputIterator  last 
)

◆ ptr_in_pool()

bool nil::crypto3::detail::ptr_in_pool ( const void *  pool_ptr,
size_t  poolsize,
const void *  buf_ptr,
size_t  bufsize 
)
inline

◆ strxor() [1/2]

template<typename InputRange1 , typename InputRange2 , typename OutputIterator >
constexpr OutputIterator nil::crypto3::detail::strxor ( const InputRange1 &  in1,
const InputRange2 &  in2,
OutputIterator  out 
)
inlineconstexpr

◆ strxor() [2/2]

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 nil::crypto3::detail::strxor ( InputIterator1  first1,
InputIterator1  last1,
InputIterator2  first2,
InputIterator2  last2,
OutputIterator  out 
)
inlineconstexpr

◆ to_ascii() [1/3]

template<std::size_t DigestBits, typename OutputIterator >
OutputIterator nil::crypto3::detail::to_ascii ( const boost::container::small_vector< octet_type, DigestBits/octet_bits > &  d,
OutputIterator  it 
)

◆ to_ascii() [2/3]

template<std::size_t DigestBits, typename OutputIterator >
OutputIterator nil::crypto3::detail::to_ascii ( const digest< DigestBits > &  d,
OutputIterator  it 
)

◆ to_ascii() [3/3]

template<std::size_t DigestBits, typename OutputIterator >
OutputIterator nil::crypto3::detail::to_ascii ( const static_digest< DigestBits > &  d,
OutputIterator  it 
)

◆ unbounded_shl() [1/2]

template<int Shift, typename T >
T nil::crypto3::detail::unbounded_shl ( x)

◆ unbounded_shl() [2/2]

template<typename T >
T nil::crypto3::detail::unbounded_shl ( x,
std::size_t  n 
)

◆ unbounded_shr() [1/2]

template<int Shift, typename T >
T nil::crypto3::detail::unbounded_shr ( x)

◆ unbounded_shr() [2/2]

template<typename T >
T nil::crypto3::detail::unbounded_shr ( x,
std::size_t  n 
)

Variable Documentation

◆ is_complex_v

template<typename T >
constexpr bool nil::crypto3::detail::is_complex_v = is_complex<T>::value
constexpr