Classes | Typedefs | Functions | Variables
absl::hash_internal Namespace Reference

Classes

struct  AggregateBarrier
 
class  CityHashState
 
struct  ContainerAsVector
 
struct  ContainerAsVector< std::tuple< T... > >
 
struct  ContainerAsVector< std::tuple<> >
 
struct  DefaultEquals
 
struct  EqVisitor
 
struct  ExpandVisitor
 
struct  Hash
 
struct  HashImpl
 
struct  HashSelect
 
class  HashStateBase
 
struct  is_hashable
 
struct  is_uniquely_represented
 
struct  is_uniquely_represented< bool >
 
struct  is_uniquely_represented< CustomHashType< Tags... >, typename EnableIfContained< InvokeTag::kUniquelyRepresented, Tags... >::type >
 
struct  is_uniquely_represented< Integral, typename std::enable_if< std::is_integral< Integral >::value >::type >
 
struct  is_uniquely_represented< unsigned char >
 
struct  MakeTypeSet
 
struct  MakeTypeSet< T, Ts... >
 
struct  OdrUse
 
struct  PoisonedHash
 
struct  PrintVisitor
 
struct  RunOnStartup
 
class  SpyHashStateImpl
 
struct  TypeSet
 
struct  VariantVisitor
 

Typedefs

using SpyHashState = SpyHashStateImpl< void >
 
typedef std::pair< uint64_t, uint64_t > uint128
 
template<typename... T>
using VariantForTypes = typename MakeTypeSet< const typename std::decay< T >::type *... >::template apply< absl::variant >
 

Functions

template<typename H , typename B >
std::enable_if< std::is_same< B, bool >::value, H >::type AbslHashValue (H hash_state, B value)
 
template<typename T , typename U , typename = absl::enable_if_t<!std::is_same<T, U>::value>, int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
void AbslHashValue (SpyHashStateImpl< T >, const U &)
 
template<typename H , typename Enum >
std::enable_if< std::is_enum< Enum >::value, H >::type AbslHashValue (H hash_state, Enum e)
 
template<typename H , typename Float >
std::enable_if< std::is_same< Float, float >::value||std::is_same< Float, double >::value, H >::type AbslHashValue (H hash_state, Float value)
 
template<typename H , typename LongDouble >
std::enable_if< std::is_same< LongDouble, long double >::value, H >::type AbslHashValue (H hash_state, LongDouble value)
 
template<typename H , typename T >
AbslHashValue (H hash_state, T *ptr)
 
template<typename H >
AbslHashValue (H hash_state, std::nullptr_t)
 
template<typename H , typename T1 , typename T2 >
std::enable_if< is_hashable< T1 >::value &&is_hashable< T2 >::value, H >::type AbslHashValue (H hash_state, const std::pair< T1, T2 > &p)
 
template<typename H , typename... Ts>
std::enable_if< absl::conjunction< is_hashable< Ts >... >::value, H >::type AbslHashValue (H hash_state, const std::tuple< Ts... > &t)
 
template<typename H , typename T , typename D >
AbslHashValue (H hash_state, const std::unique_ptr< T, D > &ptr)
 
template<typename H , typename T >
AbslHashValue (H hash_state, const std::shared_ptr< T > &ptr)
 
template<typename H >
AbslHashValue (H hash_state, absl::string_view str)
 
template<typename H , typename T , size_t N>
std::enable_if< is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::array< T, N > &array)
 
template<typename H , typename T , typename Allocator >
std::enable_if< is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::deque< T, Allocator > &deque)
 
template<typename H , typename T , typename Allocator >
std::enable_if< is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::forward_list< T, Allocator > &list)
 
template<typename H , typename T , typename Allocator >
std::enable_if< is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::list< T, Allocator > &list)
 
template<typename H , typename T , typename Allocator >
std::enable_if< is_hashable< T >::value &&!std::is_same< T, bool >::value, H >::type AbslHashValue (H hash_state, const std::vector< T, Allocator > &vector)
 
template<typename H , typename Key , typename T , typename Compare , typename Allocator >
std::enable_if< is_hashable< Key >::value &&is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::map< Key, T, Compare, Allocator > &map)
 
template<typename H , typename Key , typename T , typename Compare , typename Allocator >
std::enable_if< is_hashable< Key >::value &&is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const std::multimap< Key, T, Compare, Allocator > &map)
 
template<typename H , typename Key , typename Compare , typename Allocator >
std::enable_if< is_hashable< Key >::value, H >::type AbslHashValue (H hash_state, const std::set< Key, Compare, Allocator > &set)
 
template<typename H , typename Key , typename Compare , typename Allocator >
std::enable_if< is_hashable< Key >::value, H >::type AbslHashValue (H hash_state, const std::multiset< Key, Compare, Allocator > &set)
 
template<typename H , typename T >
std::enable_if< is_hashable< T >::value, H >::type AbslHashValue (H hash_state, const absl::optional< T > &opt)
 
template<typename H , typename... T>
std::enable_if< conjunction< is_hashable< T >... >::value, H >::type AbslHashValue (H hash_state, const absl::variant< T... > &v)
 
uint32_t CityHash32 (const char *s, size_t len)
 
uint64_t CityHash64 (const char *s, size_t len)
 
uint64_t CityHash64WithSeed (const char *s, size_t len, uint64_t seed)
 
uint64_t CityHash64WithSeeds (const char *s, size_t len, uint64_t seed0, uint64_t seed1)
 
static uint32_t Fetch32 (const char *p)
 
static uint64_t Fetch64 (const char *p)
 
static uint32_t fmix (uint32_t h)
 
uint64_t Hash128to64 (const uint128 &x)
 
static uint32_t Hash32Len0to4 (const char *s, size_t len)
 
static uint32_t Hash32Len13to24 (const char *s, size_t len)
 
static uint32_t Hash32Len5to12 (const char *s, size_t len)
 
template<typename H , typename T >
hash_bytes (H hash_state, const T &value)
 
template<typename H , typename T >
std::enable_if< is_uniquely_represented< T >::value, H >::type hash_range_or_bytes (H hash_state, const T *data, size_t size)
 
template<typename H , typename T >
std::enable_if<!is_uniquely_represented< T >::value, H >::type hash_range_or_bytes (H hash_state, const T *data, size_t size)
 
template<typename H , typename Tuple , size_t... Is>
hash_tuple (H hash_state, const Tuple &t, absl::index_sequence< Is... >)
 
static uint64_t HashLen0to16 (const char *s, size_t len)
 
static uint64_t HashLen16 (uint64_t u, uint64_t v)
 
static uint64_t HashLen16 (uint64_t u, uint64_t v, uint64_t mul)
 
static uint64_t HashLen17to32 (const char *s, size_t len)
 
static uint64_t HashLen33to64 (const char *s, size_t len)
 
static uint32_t Mur (uint32_t a, uint32_t h)
 
static uint64_t Rotate (uint64_t val, int shift)
 
static uint32_t Rotate32 (uint32_t val, int shift)
 
void setup ()
 
static uint64_t ShiftMix (uint64_t val)
 
 TEST (CityHashTest, Unchanging)
 
void TestUnchanging (const uint64_t *expected, int offset, int len)
 
uint64_t Uint128High64 (const uint128 &x)
 
uint64_t Uint128Low64 (const uint128 &x)
 
template<typename Container , typename Eq >
ABSL_MUST_USE_RESULT testing::AssertionResult VerifyTypeImplementsAbslHashCorrectly (const Container &values, Eq equals)
 
static std::pair< uint64_t, uint64_t > WeakHashLen32WithSeeds (uint64_t w, uint64_t x, uint64_t y, uint64_t z, uint64_t a, uint64_t b)
 
static std::pair< uint64_t, uint64_t > WeakHashLen32WithSeeds (const char *s, uint64_t a, uint64_t b)
 

Variables

static const uint32_t c1 = 0xcc9e2d51
 
static const uint32_t c2 = 0x1b873593
 
static char data [kDataSize]
 
static const uint64_t k0 = 0xc3a5c85c97cb3127ULL
 
static const uint64_t k0 = 0xc3a5c85c97cb3127ULL
 
static const uint64_t k1 = 0xb492b66fbe98f273ULL
 
static const uint64_t k2 = 0x9ae16a3b2f90404fULL
 
static const int kDataSize = 1 << 20
 
static const uint64_t kSeed0 = 1234567
 
static const uint64_t kSeed1 = k0
 
static const int kTestSize = 300
 
static const uint64_t testdata [kTestSize][4]
 

Typedef Documentation

Definition at line 211 of file spy_hash_state.h.

typedef std::pair<uint64_t, uint64_t> absl::hash_internal::uint128

Definition at line 55 of file city.h.

template<typename... T>
using absl::hash_internal::VariantForTypes = typedef typename MakeTypeSet< const typename std::decay<T>::type*...>::template apply<absl::variant>

Definition at line 299 of file hash_testing.h.

Function Documentation

template<typename H , typename B >
std::enable_if<std::is_same<B, bool>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
value 
)

Definition at line 204 of file internal/hash.h.

template<typename T , typename U , typename = absl::enable_if_t<!std::is_same<T, U>::value>, int = RunOnStartup<SpyHashStateImpl<T>::SetDirectAbslHashValueError>::run>
void absl::hash_internal::AbslHashValue ( SpyHashStateImpl< T >  ,
const U &   
)
template<typename H , typename Enum >
std::enable_if<std::is_enum<Enum>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
Enum  e 
)

Definition at line 212 of file internal/hash.h.

template<typename H , typename Float >
std::enable_if<std::is_same<Float, float>::value || std::is_same<Float, double>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
Float  value 
)

Definition at line 227 of file internal/hash.h.

template<typename H , typename LongDouble >
std::enable_if<std::is_same<LongDouble, long double>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
LongDouble  value 
)

Definition at line 238 of file internal/hash.h.

template<typename H , typename T >
H absl::hash_internal::AbslHashValue ( hash_state,
T *  ptr 
)

Definition at line 269 of file internal/hash.h.

template<typename H >
H absl::hash_internal::AbslHashValue ( hash_state,
std::nullptr_t   
)

Definition at line 280 of file internal/hash.h.

template<typename H , typename T1 , typename T2 >
std::enable_if<is_hashable<T1>::value && is_hashable<T2>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::pair< T1, T2 > &  p 
)

Definition at line 299 of file internal/hash.h.

template<typename H , typename... Ts>
std::enable_if<absl::conjunction<is_hashable<Ts>...>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::tuple< Ts... > &  t 
)

Definition at line 321 of file internal/hash.h.

template<typename H , typename T , typename D >
H absl::hash_internal::AbslHashValue ( hash_state,
const std::unique_ptr< T, D > &  ptr 
)

Definition at line 332 of file internal/hash.h.

template<typename H , typename T >
H absl::hash_internal::AbslHashValue ( hash_state,
const std::shared_ptr< T > &  ptr 
)

Definition at line 338 of file internal/hash.h.

template<typename H >
H absl::hash_internal::AbslHashValue ( hash_state,
absl::string_view  str 
)

Definition at line 360 of file internal/hash.h.

template<typename H , typename T , size_t N>
std::enable_if<is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::array< T, N > &  array 
)

Definition at line 372 of file internal/hash.h.

template<typename H , typename T , typename Allocator >
std::enable_if<is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::deque< T, Allocator > &  deque 
)

Definition at line 380 of file internal/hash.h.

template<typename H , typename T , typename Allocator >
std::enable_if<is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::forward_list< T, Allocator > &  list 
)

Definition at line 392 of file internal/hash.h.

template<typename H , typename T , typename Allocator >
std::enable_if<is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::list< T, Allocator > &  list 
)

Definition at line 404 of file internal/hash.h.

template<typename H , typename T , typename Allocator >
std::enable_if<is_hashable<T>::value && !std::is_same<T, bool>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::vector< T, Allocator > &  vector 
)

Definition at line 419 of file internal/hash.h.

template<typename H , typename Key , typename T , typename Compare , typename Allocator >
std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::map< Key, T, Compare, Allocator > &  map 
)

Definition at line 434 of file internal/hash.h.

template<typename H , typename Key , typename T , typename Compare , typename Allocator >
std::enable_if<is_hashable<Key>::value && is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::multimap< Key, T, Compare, Allocator > &  map 
)

Definition at line 446 of file internal/hash.h.

template<typename H , typename Key , typename Compare , typename Allocator >
std::enable_if<is_hashable<Key>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::set< Key, Compare, Allocator > &  set 
)

Definition at line 456 of file internal/hash.h.

template<typename H , typename Key , typename Compare , typename Allocator >
std::enable_if<is_hashable<Key>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const std::multiset< Key, Compare, Allocator > &  set 
)

Definition at line 466 of file internal/hash.h.

template<typename H , typename T >
std::enable_if<is_hashable<T>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const absl::optional< T > &  opt 
)

Definition at line 480 of file internal/hash.h.

template<typename H , typename... T>
std::enable_if<conjunction<is_hashable<T>...>::value, H>::type absl::hash_internal::AbslHashValue ( hash_state,
const absl::variant< T... > &  v 
)

Definition at line 499 of file internal/hash.h.

uint32_t absl::hash_internal::CityHash32 ( const char *  s,
size_t  len 
)

Definition at line 123 of file city.cc.

uint64_t absl::hash_internal::CityHash64 ( const char *  s,
size_t  len 
)

Definition at line 296 of file city.cc.

uint64_t absl::hash_internal::CityHash64WithSeed ( const char *  s,
size_t  len,
uint64_t  seed 
)

Definition at line 334 of file city.cc.

uint64_t absl::hash_internal::CityHash64WithSeeds ( const char *  s,
size_t  len,
uint64_t  seed0,
uint64_t  seed1 
)

Definition at line 338 of file city.cc.

static uint32_t absl::hash_internal::Fetch32 ( const char *  p)
static

Definition at line 47 of file city.cc.

static uint64_t absl::hash_internal::Fetch64 ( const char *  p)
static

Definition at line 43 of file city.cc.

static uint32_t absl::hash_internal::fmix ( uint32_t  h)
static

Definition at line 61 of file city.cc.

uint64_t absl::hash_internal::Hash128to64 ( const uint128 x)
inline

Definition at line 77 of file city.h.

static uint32_t absl::hash_internal::Hash32Len0to4 ( const char *  s,
size_t  len 
)
static

Definition at line 104 of file city.cc.

static uint32_t absl::hash_internal::Hash32Len13to24 ( const char *  s,
size_t  len 
)
static

Definition at line 92 of file city.cc.

static uint32_t absl::hash_internal::Hash32Len5to12 ( const char *  s,
size_t  len 
)
static

Definition at line 115 of file city.cc.

template<typename H , typename T >
H absl::hash_internal::hash_bytes ( hash_state,
const T &  value 
)

Definition at line 185 of file internal/hash.h.

template<typename H , typename T >
std::enable_if<is_uniquely_represented<T>::value, H>::type absl::hash_internal::hash_range_or_bytes ( hash_state,
const T *  data,
size_t  size 
)

Definition at line 523 of file internal/hash.h.

template<typename H , typename T >
std::enable_if<!is_uniquely_represented<T>::value, H>::type absl::hash_internal::hash_range_or_bytes ( hash_state,
const T *  data,
size_t  size 
)

Definition at line 531 of file internal/hash.h.

template<typename H , typename Tuple , size_t... Is>
H absl::hash_internal::hash_tuple ( hash_state,
const Tuple &  t,
absl::index_sequence< Is... >   
)

Definition at line 308 of file internal/hash.h.

static uint64_t absl::hash_internal::HashLen0to16 ( const char *  s,
size_t  len 
)
static

Definition at line 216 of file city.cc.

static uint64_t absl::hash_internal::HashLen16 ( uint64_t  u,
uint64_t  v 
)
static

Definition at line 202 of file city.cc.

static uint64_t absl::hash_internal::HashLen16 ( uint64_t  u,
uint64_t  v,
uint64_t  mul 
)
static

Definition at line 206 of file city.cc.

static uint64_t absl::hash_internal::HashLen17to32 ( const char *  s,
size_t  len 
)
static

Definition at line 243 of file city.cc.

static uint64_t absl::hash_internal::HashLen33to64 ( const char *  s,
size_t  len 
)
static

Definition at line 275 of file city.cc.

static uint32_t absl::hash_internal::Mur ( uint32_t  a,
uint32_t  h 
)
static

Definition at line 82 of file city.cc.

static uint64_t absl::hash_internal::Rotate ( uint64_t  val,
int  shift 
)
static

Definition at line 195 of file city.cc.

static uint32_t absl::hash_internal::Rotate32 ( uint32_t  val,
int  shift 
)
static

Definition at line 70 of file city.cc.

void absl::hash_internal::setup ( )

Definition at line 34 of file city_test.cc.

static uint64_t absl::hash_internal::ShiftMix ( uint64_t  val)
static

Definition at line 200 of file city.cc.

absl::hash_internal::TEST ( CityHashTest  ,
Unchanging   
)

Definition at line 583 of file city_test.cc.

void absl::hash_internal::TestUnchanging ( const uint64_t *  expected,
int  offset,
int  len 
)

Definition at line 575 of file city_test.cc.

uint64_t absl::hash_internal::Uint128High64 ( const uint128 x)
inline

Definition at line 58 of file city.h.

uint64_t absl::hash_internal::Uint128Low64 ( const uint128 x)
inline

Definition at line 57 of file city.h.

template<typename Container , typename Eq >
ABSL_MUST_USE_RESULT testing::AssertionResult absl::hash_internal::VerifyTypeImplementsAbslHashCorrectly ( const Container &  values,
Eq  equals 
)

Definition at line 187 of file hash_testing.h.

static std::pair<uint64_t, uint64_t> absl::hash_internal::WeakHashLen32WithSeeds ( uint64_t  w,
uint64_t  x,
uint64_t  y,
uint64_t  z,
uint64_t  a,
uint64_t  b 
)
static

Definition at line 255 of file city.cc.

static std::pair<uint64_t, uint64_t> absl::hash_internal::WeakHashLen32WithSeeds ( const char *  s,
uint64_t  a,
uint64_t  b 
)
static

Definition at line 268 of file city.cc.

Variable Documentation

const uint32_t absl::hash_internal::c1 = 0xcc9e2d51
static

Definition at line 57 of file city.cc.

const uint32_t absl::hash_internal::c2 = 0x1b873593
static

Definition at line 58 of file city.cc.

char absl::hash_internal::data[kDataSize]
static

Definition at line 31 of file city_test.cc.

const uint64_t absl::hash_internal::k0 = 0xc3a5c85c97cb3127ULL
static

Definition at line 25 of file city_test.cc.

const uint64_t absl::hash_internal::k0 = 0xc3a5c85c97cb3127ULL
static

Definition at line 52 of file city.cc.

const uint64_t absl::hash_internal::k1 = 0xb492b66fbe98f273ULL
static

Definition at line 53 of file city.cc.

const uint64_t absl::hash_internal::k2 = 0x9ae16a3b2f90404fULL
static

Definition at line 54 of file city.cc.

const int absl::hash_internal::kDataSize = 1 << 20
static

Definition at line 28 of file city_test.cc.

const uint64_t absl::hash_internal::kSeed0 = 1234567
static

Definition at line 26 of file city_test.cc.

const uint64_t absl::hash_internal::kSeed1 = k0
static

Definition at line 27 of file city_test.cc.

const int absl::hash_internal::kTestSize = 300
static

Definition at line 29 of file city_test.cc.

const uint64_t absl::hash_internal::testdata[kTestSize][4]
static

Definition at line 48 of file city_test.cc.



abseil_cpp
Author(s):
autogenerated on Wed Jun 19 2019 19:19:59