LIEF: Library to Instrument Executable Formats Version 1.0.0
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Functions
frozen Namespace Reference

Namespaces

namespace  bits
namespace  impl
namespace  string_literals

Classes

class  knuth_morris_pratt_searcher
class  boyer_moore_searcher
struct  elsa
struct  elsa< void >
struct  elsa< std::basic_string< CharT > >
class  map
class  map< Key, Value, 0, Compare >
class  linear_congruential_engine
class  set
class  set< Key, 0, Compare >
class  basic_string
struct  elsa< basic_string< _CharT > >
class  unordered_map
class  unordered_set

Typedefs

template<class T = void>
using anna = elsa<T>
using minstd_rand0
using minstd_rand
using default_prg_t = minstd_rand
using string = basic_string<char>
using wstring = basic_string<wchar_t>
using u16string = basic_string<char16_t>
using u32string = basic_string<char32_t>

Functions

template<class ForwardIterator, class Searcher>
ForwardIterator search (ForwardIterator first, ForwardIterator last, const Searcher &searcher)
template<std::size_t N>
constexpr knuth_morris_pratt_searcher< N - 1 > make_knuth_morris_pratt_searcher (char const (&needle)[N])
template<std::size_t N>
constexpr boyer_moore_searcher< N - 1 > make_boyer_moore_searcher (char const (&needle)[N])
template<typename String>
constexpr std::size_t hash_string (const String &value)
template<typename String>
constexpr std::size_t hash_string (const String &value, std::size_t seed)
template<typename T, typename U, typename Compare = std::less<T>>
constexpr auto make_map (bits::ignored_arg={})
template<typename T, typename U, std::size_t N>
constexpr auto make_map (std::pair< T, U > const (&items)[N])
template<typename T, typename U, std::size_t N>
constexpr auto make_map (std::array< std::pair< T, U >, N > const &items)
template<typename T, typename U, typename Compare, std::size_t N>
constexpr auto make_map (std::pair< T, U > const (&items)[N], Compare const &compare=Compare{})
template<typename T, typename U, typename Compare, std::size_t N>
constexpr auto make_map (std::array< std::pair< T, U >, N > const &items, Compare const &compare=Compare{})
template<typename T>
constexpr auto make_set (bits::ignored_arg={})
template<typename T, std::size_t N>
constexpr auto make_set (const T(&args)[N])
template<typename T, std::size_t N>
constexpr auto make_set (std::array< T, N > const &args)
template<typename T, typename Compare, std::size_t N>
constexpr auto make_set (const T(&args)[N], Compare const &compare=Compare{})
template<typename T, typename Compare, std::size_t N>
constexpr auto make_set (std::array< T, N > const &args, Compare const &compare=Compare{})
template<typename T, typename U, std::size_t N>
constexpr auto make_unordered_map (std::pair< T, U > const (&items)[N])
template<typename T, typename U, std::size_t N, typename Hasher, typename Equal>
constexpr auto make_unordered_map (std::pair< T, U > const (&items)[N], Hasher const &hash=elsa< T >{}, Equal const &equal=std::equal_to< T >{})
template<typename T, typename U, std::size_t N>
constexpr auto make_unordered_map (std::array< std::pair< T, U >, N > const &items)
template<typename T, typename U, std::size_t N, typename Hasher, typename Equal>
constexpr auto make_unordered_map (std::array< std::pair< T, U >, N > const &items, Hasher const &hash=elsa< T >{}, Equal const &equal=std::equal_to< T >{})
template<typename T, std::size_t N>
constexpr auto make_unordered_set (T const (&keys)[N])
template<typename T, std::size_t N, typename Hasher, typename Equal>
constexpr auto make_unordered_set (T const (&keys)[N], Hasher const &hash, Equal const &equal)
template<typename T, std::size_t N>
constexpr auto make_unordered_set (std::array< T, N > const &keys)
template<typename T, std::size_t N, typename Hasher, typename Equal>
constexpr auto make_unordered_set (std::array< T, N > const &keys, Hasher const &hash, Equal const &equal)

Typedef Documentation

◆ anna

template<class T = void>
using frozen::anna = elsa<T>

◆ default_prg_t

using frozen::default_prg_t = minstd_rand

◆ minstd_rand

using frozen::minstd_rand
Initial value:
linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647>
frozen::linear_congruential_engine
Definition random.h:34

◆ minstd_rand0

using frozen::minstd_rand0
Initial value:
linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647>

◆ string

using frozen::string = basic_string<char>

◆ u16string

using frozen::u16string = basic_string<char16_t>

◆ u32string

using frozen::u32string = basic_string<char32_t>

◆ wstring

using frozen::wstring = basic_string<wchar_t>

Function Documentation

◆ hash_string() [1/2]

template<typename String>
std::size_t frozen::hash_string ( const String & value)
constexpr

Referenced by frozen::elsa< basic_string< _CharT > >::operator()(), frozen::elsa< basic_string< _CharT > >::operator()(), frozen::elsa< std::basic_string< CharT > >::operator()(), and frozen::elsa< std::basic_string< CharT > >::operator()().

◆ hash_string() [2/2]

template<typename String>
std::size_t frozen::hash_string ( const String & value,
std::size_t seed )
constexpr

◆ make_boyer_moore_searcher()

template<std::size_t N>
boyer_moore_searcher< N - 1 > frozen::make_boyer_moore_searcher ( char const (&) needle[N])
constexpr

◆ make_knuth_morris_pratt_searcher()

template<std::size_t N>
knuth_morris_pratt_searcher< N - 1 > frozen::make_knuth_morris_pratt_searcher ( char const (&) needle[N])
constexpr

◆ make_map() [1/5]

template<typename T, typename U, typename Compare = std::less<T>>
auto frozen::make_map ( bits::ignored_arg = {})
constexpr

◆ make_map() [2/5]

template<typename T, typename U, std::size_t N>
auto frozen::make_map ( std::array< std::pair< T, U >, N > const & items)
constexpr

◆ make_map() [3/5]

template<typename T, typename U, typename Compare, std::size_t N>
auto frozen::make_map ( std::array< std::pair< T, U >, N > const & items,
Compare const & compare = Compare{} )
constexpr

◆ make_map() [4/5]

template<typename T, typename U, std::size_t N>
auto frozen::make_map ( std::pair< T, U > const (&) items[N])
constexpr

◆ make_map() [5/5]

template<typename T, typename U, typename Compare, std::size_t N>
auto frozen::make_map ( std::pair< T, U > const (&) items[N],
Compare const & compare = Compare{} )
constexpr

◆ make_set() [1/5]

template<typename T>
auto frozen::make_set ( bits::ignored_arg = {})
constexpr

◆ make_set() [2/5]

template<typename T, std::size_t N>
auto frozen::make_set ( const T(&) args[N])
constexpr

◆ make_set() [3/5]

template<typename T, typename Compare, std::size_t N>
auto frozen::make_set ( const T(&) args[N],
Compare const & compare = Compare{} )
constexpr

◆ make_set() [4/5]

template<typename T, std::size_t N>
auto frozen::make_set ( std::array< T, N > const & args)
constexpr

◆ make_set() [5/5]

template<typename T, typename Compare, std::size_t N>
auto frozen::make_set ( std::array< T, N > const & args,
Compare const & compare = Compare{} )
constexpr

◆ make_unordered_map() [1/4]

template<typename T, typename U, std::size_t N>
auto frozen::make_unordered_map ( std::array< std::pair< T, U >, N > const & items)
constexpr

◆ make_unordered_map() [2/4]

template<typename T, typename U, std::size_t N, typename Hasher, typename Equal>
auto frozen::make_unordered_map ( std::array< std::pair< T, U >, N > const & items,
Hasher const & hash = elsa<T>{},
Equal const & equal = std::equal_to<T>{} )
constexpr

◆ make_unordered_map() [3/4]

template<typename T, typename U, std::size_t N>
auto frozen::make_unordered_map ( std::pair< T, U > const (&) items[N])
constexpr

◆ make_unordered_map() [4/4]

template<typename T, typename U, std::size_t N, typename Hasher, typename Equal>
auto frozen::make_unordered_map ( std::pair< T, U > const (&) items[N],
Hasher const & hash = elsa<T>{},
Equal const & equal = std::equal_to<T>{} )
constexpr

◆ make_unordered_set() [1/4]

template<typename T, std::size_t N>
auto frozen::make_unordered_set ( std::array< T, N > const & keys)
constexpr

◆ make_unordered_set() [2/4]

template<typename T, std::size_t N, typename Hasher, typename Equal>
auto frozen::make_unordered_set ( std::array< T, N > const & keys,
Hasher const & hash,
Equal const & equal )
constexpr

◆ make_unordered_set() [3/4]

template<typename T, std::size_t N>
auto frozen::make_unordered_set ( T const (&) keys[N])
constexpr

◆ make_unordered_set() [4/4]

template<typename T, std::size_t N, typename Hasher, typename Equal>
auto frozen::make_unordered_set ( T const (&) keys[N],
Hasher const & hash,
Equal const & equal )
constexpr

◆ search()

template<class ForwardIterator, class Searcher>
ForwardIterator frozen::search ( ForwardIterator first,
ForwardIterator last,
const Searcher & searcher )
Generated by doxygen 1.17.0