Algorithms are meant to provide hashing interface similar to STL algorithms' one. More...

+ Collaboration diagram for Algorithms:

Functions

template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< HashAccumulator > > nil::crypto3::hash (const SinglePassRange &r)
 
template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type & nil::crypto3::hash (const SinglePassRange &rng, HashAccumulator &sh)
 
template<typename Hash , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type nil::crypto3::hash (const SinglePassRange &rng, OutputIterator out)
 
template<typename Hasher , typename SinglePassRange , typename OutputIterator , typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
OutputIterator nil::crypto3::pbkdf::hash (const SinglePassRange &rng, OutputIterator out, StreamHash sh=StreamHash())
 
template<typename Hasher , typename SinglePassRange , typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
detail::hash< Hasher, SinglePassRange > nil::crypto3::pbkdf::hash (const SinglePassRange &rng, StreamHash sh=StreamHash())
 
template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< typename std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type > > nil::crypto3::hash (InputIterator first, InputIterator last)
 
template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type & nil::crypto3::hash (InputIterator first, InputIterator last, HashAccumulator &sh)
 
template<typename Hash , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type nil::crypto3::hash (InputIterator first, InputIterator last, OutputIterator out)
 
template<typename Hasher , typename InputIterator , typename OutputIterator , typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
OutputIterator nil::crypto3::pbkdf::hash (InputIterator first, InputIterator last, OutputIterator out, StreamHash sh=StreamHash())
 
template<typename Hasher , typename InputIterator , typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
detail::hash< Hasher, InputIterator > nil::crypto3::pbkdf::hash (InputIterator first, InputIterator last, StreamHash sh=StreamHash())
 
template<typename Hash , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type nil::crypto3::hash (std::initializer_list< T > list, OutputIterator out)
 
template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl< hashes::detail::value_hash_impl< HashAccumulator > > nil::crypto3::hash (std::initializer_list< T > r)
 
template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashAccumulator >::value, HashAccumulator >::type & nil::crypto3::hash (std::initializer_list< T > rng, HashAccumulator &sh)
 
template<typename CurveGroup , typename Params , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< HashingAccumulator > > nil::crypto3::to_curve (const SinglePassRange &r)
 
template<typename CurveGroup , typename Params , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type & nil::crypto3::to_curve (const SinglePassRange &rng, HashingAccumulator &sh)
 
template<typename CurveGroup , typename Params , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type nil::crypto3::to_curve (const SinglePassRange &rng, OutputIterator out)
 
template<typename CurveGroup , typename Params , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< typename std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type > > nil::crypto3::to_curve (InputIterator first, InputIterator last)
 
template<typename CurveGroup , typename Params , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type & nil::crypto3::to_curve (InputIterator first, InputIterator last, HashingAccumulator &sh)
 
template<typename CurveGroup , typename Params , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set< OutputIterator >::value, OutputIterator >::type nil::crypto3::to_curve (InputIterator first, InputIterator last, OutputIterator out)
 
template<typename CurveGroup , typename Params , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator< OutputIterator >::value, OutputIterator >::type nil::crypto3::to_curve (std::initializer_list< T > list, OutputIterator out)
 
template<typename CurveGroup , typename Params , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl< hashes::detail::value_to_curve_impl< HashingAccumulator > > nil::crypto3::to_curve (std::initializer_list< T > r)
 
template<typename CurveGroup , typename Params , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if< boost::accumulators::detail::is_accumulator_set< HashingAccumulator >::value, HashingAccumulator >::type & nil::crypto3::to_curve (std::initializer_list< T > rng, HashingAccumulator &sh)
 

Detailed Description

Algorithms are meant to provide hashing interface similar to STL algorithms' one.

Algorithms are meant to provide hashing to curve interface similar to STL algorithms' one.

Function Documentation

◆ hash() [1/13]

template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl<hashes::detail::value_hash_impl<HashAccumulator> > nil::crypto3::hash ( const SinglePassRange &  r)
Template Parameters
Hash
SinglePassRange
HashAccumulator
Parameters
r
Returns

◆ hash() [2/13]

template<typename Hash , typename SinglePassRange , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashAccumulator>::value, HashAccumulator>::type& nil::crypto3::hash ( const SinglePassRange &  rng,
HashAccumulator &  sh 
)
Template Parameters
Hash
SinglePassRange
HashAccumulator
Parameters
rng
sh
Returns

◆ hash() [3/13]

template<typename Hash , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator<OutputIterator>::value, OutputIterator>::type nil::crypto3::hash ( const SinglePassRange &  rng,
OutputIterator  out 
)
Template Parameters
Hash
SinglePassRange
OutputIterator
Parameters
rng
out
Returns

◆ hash() [4/13]

template<typename Hasher , typename SinglePassRange , typename OutputIterator , typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
OutputIterator nil::crypto3::pbkdf::hash ( const SinglePassRange &  rng,
OutputIterator  out,
StreamHash  sh = StreamHash() 
)
Template Parameters
Hasher
SinglePassRange
OutputIterator
StreamHash
Parameters
rng
out
sh
Returns

◆ hash() [5/13]

template<typename Hasher , typename SinglePassRange , typename StreamHash = detail::range_stream_hash_traits<Hasher, SinglePassRange>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
detail::hash<Hasher, SinglePassRange> nil::crypto3::pbkdf::hash ( const SinglePassRange &  rng,
StreamHash  sh = StreamHash() 
)
Template Parameters
Hasher
SinglePassRange
StreamHash
Parameters
rng
sh
Returns

◆ hash() [6/13]

template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl<hashes::detail::value_hash_impl<typename std::enable_if< boost::accumulators::detail::is_accumulator_set<HashAccumulator>::value, HashAccumulator>::type> > nil::crypto3::hash ( InputIterator  first,
InputIterator  last 
)
Template Parameters
Hash
InputIterator
HashAccumulator
Parameters
first
last
Returns

◆ hash() [7/13]

template<typename Hash , typename InputIterator , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashAccumulator>::value, HashAccumulator>::type& nil::crypto3::hash ( InputIterator  first,
InputIterator  last,
HashAccumulator &  sh 
)
Template Parameters
Hash
InputIterator
HashAccumulator
Parameters
first
last
sh
Returns

◆ hash() [8/13]

template<typename Hash , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set<OutputIterator>::value, OutputIterator>::type nil::crypto3::hash ( InputIterator  first,
InputIterator  last,
OutputIterator  out 
)
Template Parameters
Hash
InputIterator
OutputIterator
Parameters
first
last
out
Returns

◆ hash() [9/13]

template<typename Hasher , typename InputIterator , typename OutputIterator , typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
OutputIterator nil::crypto3::pbkdf::hash ( InputIterator  first,
InputIterator  last,
OutputIterator  out,
StreamHash  sh = StreamHash() 
)
Template Parameters
Hasher
InputIterator
OutputIterator
StreamHash
Parameters
first
last
out
sh
Returns

◆ hash() [10/13]

template<typename Hasher , typename InputIterator , typename StreamHash = detail::iterator_stream_hash_traits<Hasher, InputIterator>, typename = typename std::enable_if<detail::is_stream_hash<StreamHash>::value>::type>
detail::hash<Hasher, InputIterator> nil::crypto3::pbkdf::hash ( InputIterator  first,
InputIterator  last,
StreamHash  sh = StreamHash() 
)
Template Parameters
Hasher
InputIterator
StreamHash
Parameters
first
last
sh
Returns

◆ hash() [11/13]

template<typename Hash , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator<OutputIterator>::value, OutputIterator>::type nil::crypto3::hash ( std::initializer_list< T >  list,
OutputIterator  out 
)
Template Parameters
Hash
T
OutputIterator
Parameters
rng
out
Returns

◆ hash() [12/13]

template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
hashes::detail::range_hash_impl<hashes::detail::value_hash_impl<HashAccumulator> > nil::crypto3::hash ( std::initializer_list< T >  r)
Template Parameters
Hash
T
HashAccumulator
Parameters
r
Returns

◆ hash() [13/13]

template<typename Hash , typename T , typename HashAccumulator = accumulator_set<Hash>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashAccumulator>::value, HashAccumulator>::type& nil::crypto3::hash ( std::initializer_list< T >  rng,
HashAccumulator &  sh 
)
Template Parameters
Hash
T
HashAccumulator
Parameters
rng
sh
Returns

◆ to_curve() [1/9]

template<typename CurveGroup , typename Params , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl<hashes::detail::value_to_curve_impl<HashingAccumulator> > nil::crypto3::to_curve ( const SinglePassRange &  r)
Template Parameters
CurveGroup
SinglePassRange
HashingAccumulator
Parameters
r
Returns

◆ to_curve() [2/9]

template<typename CurveGroup , typename Params , typename SinglePassRange , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashingAccumulator>::value, HashingAccumulator>::type& nil::crypto3::to_curve ( const SinglePassRange &  rng,
HashingAccumulator &  sh 
)
Template Parameters
CurveGroup
SinglePassRange
HashingAccumulator
Parameters
rng
sh
Returns

◆ to_curve() [3/9]

template<typename CurveGroup , typename Params , typename SinglePassRange , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator<OutputIterator>::value, OutputIterator>::type nil::crypto3::to_curve ( const SinglePassRange &  rng,
OutputIterator  out 
)
Template Parameters
CurveGroup
SinglePassRange
OutputIterator
Parameters
rng
out
Returns

◆ to_curve() [4/9]

template<typename CurveGroup , typename Params , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl<hashes::detail::value_to_curve_impl<typename std::enable_if< boost::accumulators::detail::is_accumulator_set<HashingAccumulator>::value, HashingAccumulator>::type> > nil::crypto3::to_curve ( InputIterator  first,
InputIterator  last 
)
Template Parameters
CurveGroup
InputIterator
HashingAccumulator
Parameters
first
last
Returns

◆ to_curve() [5/9]

template<typename CurveGroup , typename Params , typename InputIterator , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashingAccumulator>::value, HashingAccumulator>::type& nil::crypto3::to_curve ( InputIterator  first,
InputIterator  last,
HashingAccumulator &  sh 
)
Template Parameters
CurveGroup
InputIterator
HashingAccumulator
Parameters
first
last
sh
Returns

◆ to_curve() [6/9]

template<typename CurveGroup , typename Params , typename InputIterator , typename OutputIterator >
std::enable_if<!boost::accumulators::detail::is_accumulator_set<OutputIterator>::value, OutputIterator>::type nil::crypto3::to_curve ( InputIterator  first,
InputIterator  last,
OutputIterator  out 
)
Template Parameters
CurveGroup
InputIterator
OutputIterator
Parameters
first
last
out
Returns

◆ to_curve() [7/9]

template<typename CurveGroup , typename Params , typename T , typename OutputIterator >
std::enable_if<::nil::crypto3::detail::is_iterator<OutputIterator>::value, OutputIterator>::type nil::crypto3::to_curve ( std::initializer_list< T >  list,
OutputIterator  out 
)
Template Parameters
CurveGroup
T
OutputIterator
Parameters
rng
out
Returns

◆ to_curve() [8/9]

template<typename CurveGroup , typename Params , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
hashes::detail::range_to_curve_impl<hashes::detail::value_to_curve_impl<HashingAccumulator> > nil::crypto3::to_curve ( std::initializer_list< T >  r)
Template Parameters
CurveGroup
T
HashingAccumulator
Parameters
r
Returns

◆ to_curve() [9/9]

template<typename CurveGroup , typename Params , typename T , typename HashingAccumulator = hashing_to_curve_accumulator_set<hashes::h2c<CurveGroup, Params>>>
std::enable_if<boost::accumulators::detail::is_accumulator_set<HashingAccumulator>::value, HashingAccumulator>::type& nil::crypto3::to_curve ( std::initializer_list< T >  rng,
HashingAccumulator &  sh 
)
Template Parameters
CurveGroup
T
HashingAccumulator
Parameters
rng
sh
Returns