Classes | Typedefs | Functions
mn::internal Namespace Reference

Classes

struct  atomic_flag
 
struct  can_apply
 
struct  can_apply< Z, void_t< Z< Ts... > >, Ts... >
 
struct  res_of
 
struct  res_of< G(Args...), void_t< invoke_t< G, Args... > > >
 
struct  alignof_helper
 
struct  type_with_alignment
 
struct  type_with_alignment< 1 >
 
struct  type_with_alignment< 2 >
 
struct  type_with_alignment< 4 >
 
struct  type_with_alignment< 8 >
 
struct  type_with_alignment< 16 >
 
struct  type_with_alignment< 32 >
 
struct  type_with_alignment< 64 >
 
union  max_align
 
struct  in_place_type_tag
 
struct  in_place_index_tag
 
struct  in_place_type
 

Typedefs

template<typename From , typename To >
using try_convert = decltype(To{declval< From >()})
 
template<class G , class... Args>
using invoke_t = decltype(declval< G >()(declval< Args >()...))
 

Functions

template<typename T >
result_type rjenkins_hash (const T &t)
 Implementation of hasher. Works for keys that can be converted to 32-bit integer with extract_int_key_value. More...
 
result_type rjenkins_hash_string (const char *strValue)
 
template<typename TIter >
constexpr iterator_traits< TIter >::difference_type distance (TIter first, TIter last, mn::random_access_iterator_tag)
 
template<typename TIter >
constexpr iterator_traits< TIter >::difference_type distance (TIter first, TIter last, mn::input_iterator_tag)
 
template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void advance (TIter &iter, TDistance d, mn::random_access_iterator_tag)
 
template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void advance (TIter &iter, TDistance d, mn::bidirectional_iterator_tag)
 
template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void advance (TIter &iter, TDistance d, mn::input_iterator_tag)
 
struct __attribute__ ((aligned(1))) aligned1
 
struct __attribute__ ((aligned(2))) aligned2
 
struct __attribute__ ((aligned(4))) aligned4
 
struct __attribute__ ((aligned(8))) aligned8
 
struct __attribute__ ((aligned(16))) aligned16
 
struct __attribute__ ((aligned(32))) aligned32
 
struct __attribute__ ((aligned(64))) aligned64
 
void quick_sort (T *data, long low, long high, TPredicate pred)
 
void down_heap (T *data, size_t k, size_t n, TPredicate pred)
 
void shell_sort (T *data, size_t n, TPredicate pred)
 
void copy_n (const T *first, mn::size_t n, T *result, int_to_type< false >)
 
void copy_n (const T *first, mn::size_t n, T *result, int_to_type< true >)
 
void copy (const T *first, const T *last, T *result, int_to_type< false >)
 
void copy (const T *first, const T *last, T *result, int_to_type< true >)
 
void move_n (const T *from, mn::size_t n, T *result, int_to_type< false >)
 
void move_n (const T *first, mn::size_t n, T *result, int_to_type< true >)
 
void move (const T *first, const T *last, T *result, int_to_type< false >)
 
void move (const T *first, const T *last, T *result, int_to_type< true >)
 
void copy_construct_n (const T *first, mn::size_t n, T *result, int_to_type< false >)
 
void copy_construct_n (const T *first, mn::size_t n, T *result, int_to_type< true >)
 
void destruct_n (T *first, mn::size_t n, int_to_type< false >)
 
void destruct_n (T *, mn::size_t, int_to_type< true >)
 
void destruct (T *mem, int_to_type< false >)
 
void destruct (T *, int_to_type< true >)
 
void construct (T *mem, int_to_type< false >)
 
void construct (T *, int_to_type< true >)
 
void copy_construct (T *mem, const T &orig, int_to_type< false >)
 
void copy_construct (T *mem, const T &orig, int_to_type< true >)
 
void construct_n (T *to, mn::size_t count, int_to_type< false >)
 
void construct_n (T *, int, int_to_type< true >)
 
void test_ordering (TIter first, TIter last, const TPred &pred)
 
bool debug_pred (const TPred &pred, const T1 &a, const T2 &b)
 
int32_t get_new_uniqid ()
 

Class Documentation

◆ mn::internal::res_of

struct mn::internal::res_of

template<class Sig, class = void>
struct mn::internal::res_of< Sig, class >

◆ mn::internal::alignof_helper

struct mn::internal::alignof_helper

template<typename T>
struct mn::internal::alignof_helper< T >

Class Members
char x
T y

◆ mn::internal::type_with_alignment

struct mn::internal::type_with_alignment

template<size_t N>
struct mn::internal::type_with_alignment< N >

Class Members
typedef char err_invalid_alignment

◆ mn::internal::type_with_alignment< 1 >

struct mn::internal::type_with_alignment< 1 >
Class Members
aligned1 type

◆ mn::internal::type_with_alignment< 2 >

struct mn::internal::type_with_alignment< 2 >
Class Members
aligned2 type

◆ mn::internal::type_with_alignment< 4 >

struct mn::internal::type_with_alignment< 4 >
Class Members
aligned4 type

◆ mn::internal::type_with_alignment< 8 >

struct mn::internal::type_with_alignment< 8 >
Class Members
aligned8 type

◆ mn::internal::type_with_alignment< 16 >

struct mn::internal::type_with_alignment< 16 >
Class Members
aligned16 type

◆ mn::internal::type_with_alignment< 32 >

struct mn::internal::type_with_alignment< 32 >
Class Members
aligned32 type

◆ mn::internal::type_with_alignment< 64 >

struct mn::internal::type_with_alignment< 64 >
Class Members
aligned64 type

◆ mn::internal::max_align

union mn::internal::max_align
Class Members
char c
double d
float f
int i
long l
long long ll
short s

◆ mn::internal::in_place_type_tag

struct mn::internal::in_place_type_tag

◆ mn::internal::in_place_index_tag

struct mn::internal::in_place_index_tag

◆ mn::internal::in_place_type

struct mn::internal::in_place_type

Typedef Documentation

◆ invoke_t

template<class G , class... Args>
using mn::internal::invoke_t = typedef decltype(declval<G>()(declval<Args>()...))

◆ try_convert

template<typename From , typename To >
using mn::internal::try_convert = typedef decltype(To{declval<From>()})

Function Documentation

◆ __attribute__() [1/7]

struct mn::internal::__attribute__ ( (aligned(1))  )

◆ __attribute__() [2/7]

struct mn::internal::__attribute__ ( (aligned(16))  )

◆ __attribute__() [3/7]

struct mn::internal::__attribute__ ( (aligned(2))  )

◆ __attribute__() [4/7]

struct mn::internal::__attribute__ ( (aligned(32))  )

◆ __attribute__() [5/7]

struct mn::internal::__attribute__ ( (aligned(4))  )

◆ __attribute__() [6/7]

struct mn::internal::__attribute__ ( (aligned(64))  )

◆ __attribute__() [7/7]

struct mn::internal::__attribute__ ( (aligned(8))  )

◆ advance() [1/3]

template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void mn::internal::advance ( TIter &  iter,
TDistance  d,
mn::bidirectional_iterator_tag   
)
constexpr

◆ advance() [2/3]

template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void mn::internal::advance ( TIter &  iter,
TDistance  d,
mn::input_iterator_tag   
)
constexpr

◆ advance() [3/3]

template<typename TIter , typename TDistance = typename iterator_traits<TIter>::difference_type>
constexpr void mn::internal::advance ( TIter &  iter,
TDistance  d,
mn::random_access_iterator_tag   
)
constexpr

◆ construct() [1/2]

void mn::internal::construct ( T *  ,
int_to_type< true >   
)
inline

◆ construct() [2/2]

void mn::internal::construct ( T *  mem,
int_to_type< false >   
)

◆ construct_n() [1/2]

void mn::internal::construct_n ( T *  ,
int  ,
int_to_type< true >   
)
inline

◆ construct_n() [2/2]

void mn::internal::construct_n ( T *  to,
mn::size_t  count,
int_to_type< false >   
)

◆ copy() [1/2]

void mn::internal::copy ( const T *  first,
const T *  last,
T *  result,
int_to_type< false >   
)

◆ copy() [2/2]

void mn::internal::copy ( const T *  first,
const T *  last,
T *  result,
int_to_type< true >   
)

◆ copy_construct() [1/2]

void mn::internal::copy_construct ( T *  mem,
const T &  orig,
int_to_type< false >   
)
inline

◆ copy_construct() [2/2]

void mn::internal::copy_construct ( T *  mem,
const T &  orig,
int_to_type< true >   
)
inline

◆ copy_construct_n() [1/2]

void mn::internal::copy_construct_n ( const T *  first,
mn::size_t  n,
T *  result,
int_to_type< false >   
)

◆ copy_construct_n() [2/2]

void mn::internal::copy_construct_n ( const T *  first,
mn::size_t  n,
T *  result,
int_to_type< true >   
)

◆ copy_n() [1/2]

void mn::internal::copy_n ( const T *  first,
mn::size_t  n,
T *  result,
int_to_type< false >   
)

◆ copy_n() [2/2]

void mn::internal::copy_n ( const T *  first,
mn::size_t  n,
T *  result,
int_to_type< true >   
)

◆ debug_pred()

bool mn::internal::debug_pred ( const TPred &  pred,
const T1 &  a,
const T2 &  b 
)
inline

◆ destruct() [1/2]

void mn::internal::destruct ( T *  ,
int_to_type< true >   
)
inline

◆ destruct() [2/2]

void mn::internal::destruct ( T *  mem,
int_to_type< false >   
)

◆ destruct_n() [1/2]

void mn::internal::destruct_n ( T *  ,
mn::size_t  ,
int_to_type< true >   
)
inline

◆ destruct_n() [2/2]

void mn::internal::destruct_n ( T *  first,
mn::size_t  n,
int_to_type< false >   
)

◆ distance() [1/2]

template<typename TIter >
constexpr iterator_traits<TIter>::difference_type mn::internal::distance ( TIter  first,
TIter  last,
mn::input_iterator_tag   
)
constexpr

◆ distance() [2/2]

template<typename TIter >
constexpr iterator_traits<TIter>::difference_type mn::internal::distance ( TIter  first,
TIter  last,
mn::random_access_iterator_tag   
)
constexpr

◆ down_heap()

void mn::internal::down_heap ( T *  data,
size_t  k,
size_t  n,
TPredicate  pred 
)

◆ get_new_uniqid()

int32_t mn::internal::get_new_uniqid ( )
inline

◆ move() [1/2]

void mn::internal::move ( const T *  first,
const T *  last,
T *  result,
int_to_type< false >   
)
inline

◆ move() [2/2]

void mn::internal::move ( const T *  first,
const T *  last,
T *  result,
int_to_type< true >   
)
inline

◆ move_n() [1/2]

void mn::internal::move_n ( const T *  first,
mn::size_t  n,
T *  result,
int_to_type< true >   
)
inline

◆ move_n() [2/2]

void mn::internal::move_n ( const T *  from,
mn::size_t  n,
T *  result,
int_to_type< false >   
)
inline

◆ quick_sort()

void mn::internal::quick_sort ( T *  data,
long  low,
long  high,
TPredicate  pred 
)

◆ rjenkins_hash()

template<typename T >
result_type mn::internal::rjenkins_hash ( const T &  t)

Implementation of hasher. Works for keys that can be converted to 32-bit integer with extract_int_key_value.

Note
Algorithm by Robert Jenkins. (see http://www.cris.com/~Ttwang/tech/inthash.htm).

◆ rjenkins_hash_string()

result_type mn::internal::rjenkins_hash_string ( const char *  strValue)
inline

◆ shell_sort()

void mn::internal::shell_sort ( T *  data,
size_t  n,
TPredicate  pred 
)

◆ test_ordering()

void mn::internal::test_ordering ( TIter  first,
TIter  last,
const TPred &  pred 
)