gmsh-TingyuanDoc  0.1
An Open-Source Timing-driven Analytical Mixed-size FPGA Placer
Namespaces | Classes | Typedefs | Functions
robin_hood Namespace Reference

Namespaces

 detail
 
 ROBIN_HOOD_STD
 

Classes

struct  hash
 
struct  hash< Enum, typename std::enable_if< std::is_enum< Enum >::value >::type >
 
struct  hash< std::basic_string< CharT > >
 
struct  hash< std::shared_ptr< T > >
 
struct  hash< std::unique_ptr< T > >
 
struct  hash< T * >
 
struct  is_transparent_tag
 
struct  pair
 

Typedefs

template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_flat_map = detail::Table< true, MaxLoadFactor100, Key, T, Hash, KeyEqual >
 
template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_node_map = detail::Table< false, MaxLoadFactor100, Key, T, Hash, KeyEqual >
 
template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_map = detail::Table< sizeof(robin_hood::pair< Key, T >)<=sizeof(size_t) *6 &&std::is_nothrow_move_constructible< robin_hood::pair< Key, T > >::value &&std::is_nothrow_move_assignable< robin_hood::pair< Key, T > >::value, MaxLoadFactor100, Key, T, Hash, KeyEqual >
 
template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_flat_set = detail::Table< true, MaxLoadFactor100, Key, void, Hash, KeyEqual >
 
template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_node_set = detail::Table< false, MaxLoadFactor100, Key, void, Hash, KeyEqual >
 
template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using unordered_set = detail::Table< sizeof(Key)<=sizeof(size_t) *6 &&std::is_nothrow_move_constructible< Key >::value &&std::is_nothrow_move_assignable< Key >::value, MaxLoadFactor100, Key, void, Hash, KeyEqual >
 

Functions

template<typename A , typename B >
void swap (pair< A, B > &a, pair< A, B > &b) noexcept(noexcept(std::declval< pair< A, B > & >().swap(std::declval< pair< A, B > & >())))
 
template<typename A , typename B >
constexpr bool operator== (pair< A, B > const &x, pair< A, B > const &y)
 
template<typename A , typename B >
constexpr bool operator!= (pair< A, B > const &x, pair< A, B > const &y)
 
template<typename A , typename B >
constexpr bool operator< (pair< A, B > const &x, pair< A, B > const &y) noexcept(noexcept(std::declval< A const & >()< std::declval< A const & >()) &&noexcept(std::declval< B const & >()< std::declval< B const & >()))
 
template<typename A , typename B >
constexpr bool operator> (pair< A, B > const &x, pair< A, B > const &y)
 
template<typename A , typename B >
constexpr bool operator<= (pair< A, B > const &x, pair< A, B > const &y)
 
template<typename A , typename B >
constexpr bool operator>= (pair< A, B > const &x, pair< A, B > const &y)
 
size_t hash_bytes (void const *ptr, size_t len) noexcept
 
size_t hash_int (uint64_t x) noexcept
 
 ROBIN_HOOD_HASH_INT (bool)
 
 ROBIN_HOOD_HASH_INT (char)
 
 ROBIN_HOOD_HASH_INT (signed char)
 
 ROBIN_HOOD_HASH_INT (unsigned char)
 
 ROBIN_HOOD_HASH_INT (char16_t)
 
 ROBIN_HOOD_HASH_INT (char32_t)
 
 ROBIN_HOOD_HASH_INT (wchar_t)
 
 ROBIN_HOOD_HASH_INT (short)
 
 ROBIN_HOOD_HASH_INT (unsigned short)
 
 ROBIN_HOOD_HASH_INT (int)
 
 ROBIN_HOOD_HASH_INT (unsigned int)
 
 ROBIN_HOOD_HASH_INT (long)
 
 ROBIN_HOOD_HASH_INT (long long)
 
 ROBIN_HOOD_HASH_INT (unsigned long)
 
 ROBIN_HOOD_HASH_INT (unsigned long long)
 

Typedef Documentation

◆ unordered_flat_map

template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_flat_map = typedef detail::Table<true, MaxLoadFactor100, Key, T, Hash, KeyEqual>

Definition at line 2497 of file robin_hood.h.

◆ unordered_flat_set

template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_flat_set = typedef detail::Table<true, MaxLoadFactor100, Key, void, Hash, KeyEqual>

Definition at line 2515 of file robin_hood.h.

◆ unordered_map

template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_map = typedef detail::Table<sizeof(robin_hood::pair<Key, T>) <= sizeof(size_t) * 6 && std::is_nothrow_move_constructible<robin_hood::pair<Key, T> >::value && std::is_nothrow_move_assignable<robin_hood::pair<Key, T> >::value, MaxLoadFactor100, Key, T, Hash, KeyEqual>

Definition at line 2505 of file robin_hood.h.

◆ unordered_node_map

template<typename Key , typename T , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_node_map = typedef detail::Table<false, MaxLoadFactor100, Key, T, Hash, KeyEqual>

Definition at line 2501 of file robin_hood.h.

◆ unordered_node_set

template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_node_set = typedef detail::Table<false, MaxLoadFactor100, Key, void, Hash, KeyEqual>

Definition at line 2519 of file robin_hood.h.

◆ unordered_set

template<typename Key , typename Hash = hash<Key>, typename KeyEqual = std::equal_to<Key>, size_t MaxLoadFactor100 = 80>
using robin_hood::unordered_set = typedef detail::Table<sizeof(Key) <= sizeof(size_t) * 6 && std::is_nothrow_move_constructible<Key>::value && std::is_nothrow_move_assignable<Key>::value, MaxLoadFactor100, Key, void, Hash, KeyEqual>

Definition at line 2523 of file robin_hood.h.

Function Documentation

◆ hash_bytes()

size_t robin_hood::hash_bytes ( void const *  ptr,
size_t  len 
)
inlinenoexcept

Definition at line 692 of file robin_hood.h.

Referenced by robin_hood::hash< std::basic_string< CharT > >::operator()().

Here is the caller graph for this function:

◆ hash_int()

size_t robin_hood::hash_int ( uint64_t  x)
inlinenoexcept

Definition at line 748 of file robin_hood.h.

Referenced by robin_hood::hash< T, Enable >::operator()(), robin_hood::hash< T * >::operator()(), robin_hood::hash< std::unique_ptr< T > >::operator()(), and robin_hood::hash< std::shared_ptr< T > >::operator()().

Here is the caller graph for this function:

◆ operator!=()

template<typename A , typename B >
constexpr bool robin_hood::operator!= ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexpr

Definition at line 670 of file robin_hood.h.

◆ operator<()

template<typename A , typename B >
constexpr bool robin_hood::operator< ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexprnoexcept

Definition at line 674 of file robin_hood.h.

◆ operator<=()

template<typename A , typename B >
constexpr bool robin_hood::operator<= ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexpr

Definition at line 684 of file robin_hood.h.

◆ operator==()

template<typename A , typename B >
constexpr bool robin_hood::operator== ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexpr

Definition at line 666 of file robin_hood.h.

◆ operator>()

template<typename A , typename B >
constexpr bool robin_hood::operator> ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexpr

Definition at line 680 of file robin_hood.h.

◆ operator>=()

template<typename A , typename B >
constexpr bool robin_hood::operator>= ( pair< A, B > const &  x,
pair< A, B > const &  y 
)
inlineconstexpr

Definition at line 688 of file robin_hood.h.

◆ ROBIN_HOOD_HASH_INT() [1/15]

robin_hood::ROBIN_HOOD_HASH_INT ( bool  )

◆ ROBIN_HOOD_HASH_INT() [2/15]

robin_hood::ROBIN_HOOD_HASH_INT ( char  )

◆ ROBIN_HOOD_HASH_INT() [3/15]

robin_hood::ROBIN_HOOD_HASH_INT ( char16_t  )

◆ ROBIN_HOOD_HASH_INT() [4/15]

robin_hood::ROBIN_HOOD_HASH_INT ( char32_t  )

◆ ROBIN_HOOD_HASH_INT() [5/15]

robin_hood::ROBIN_HOOD_HASH_INT ( int  )

◆ ROBIN_HOOD_HASH_INT() [6/15]

robin_hood::ROBIN_HOOD_HASH_INT ( long long  )

◆ ROBIN_HOOD_HASH_INT() [7/15]

robin_hood::ROBIN_HOOD_HASH_INT ( long  )

◆ ROBIN_HOOD_HASH_INT() [8/15]

robin_hood::ROBIN_HOOD_HASH_INT ( short  )

◆ ROBIN_HOOD_HASH_INT() [9/15]

robin_hood::ROBIN_HOOD_HASH_INT ( signed char  )

◆ ROBIN_HOOD_HASH_INT() [10/15]

robin_hood::ROBIN_HOOD_HASH_INT ( unsigned char  )

◆ ROBIN_HOOD_HASH_INT() [11/15]

robin_hood::ROBIN_HOOD_HASH_INT ( unsigned int  )

◆ ROBIN_HOOD_HASH_INT() [12/15]

robin_hood::ROBIN_HOOD_HASH_INT ( unsigned long long  )

◆ ROBIN_HOOD_HASH_INT() [13/15]

robin_hood::ROBIN_HOOD_HASH_INT ( unsigned long  )

◆ ROBIN_HOOD_HASH_INT() [14/15]

robin_hood::ROBIN_HOOD_HASH_INT ( unsigned short  )

◆ ROBIN_HOOD_HASH_INT() [15/15]

robin_hood::ROBIN_HOOD_HASH_INT ( wchar_t  )

◆ swap()

template<typename A , typename B >
void robin_hood::swap ( pair< A, B > &  a,
pair< A, B > &  b 
)
inlinenoexcept

Definition at line 660 of file robin_hood.h.