Classes | Namespaces | Macros | Functions
internal/hash.h File Reference
#include <algorithm>
#include <array>
#include <cmath>
#include <cstring>
#include <deque>
#include <forward_list>
#include <functional>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
#include "absl/base/internal/endian.h"
#include "absl/base/port.h"
#include "absl/container/fixed_array.h"
#include "absl/meta/type_traits.h"
#include "absl/numeric/int128.h"
#include "absl/strings/string_view.h"
#include "absl/types/optional.h"
#include "absl/types/variant.h"
#include "absl/utility/utility.h"
#include "absl/hash/internal/city.h"
Include dependency graph for internal/hash.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  absl::hash_internal::AggregateBarrier
 
class  absl::hash_internal::CityHashState
 
struct  absl::hash_internal::Hash< T >
 
struct  absl::hash_internal::HashImpl< T >
 
struct  absl::hash_internal::HashSelect
 
class  absl::hash_internal::HashStateBase< H >
 
struct  absl::hash_internal::HashSelect::HashValueProbe
 
struct  absl::hash_internal::is_hashable< T >
 
struct  absl::hash_internal::is_hashable< T >
 
struct  absl::hash_internal::is_uniquely_represented< T, Enable >
 
struct  absl::hash_internal::is_uniquely_represented< bool >
 
struct  absl::hash_internal::is_uniquely_represented< Integral, typename std::enable_if< std::is_integral< Integral >::value >::type >
 
struct  absl::hash_internal::is_uniquely_represented< unsigned char >
 
struct  absl::hash_internal::HashSelect::LegacyHashProbe
 
struct  absl::hash_internal::PoisonedHash
 
struct  absl::hash_internal::HashSelect::Probe< Hash, T >
 
struct  absl::hash_internal::HashSelect::State
 
struct  absl::hash_internal::HashSelect::StdHashProbe
 
struct  absl::hash_internal::HashSelect::UniquelyRepresentedProbe
 
struct  absl::hash_internal::VariantVisitor< H >
 

Namespaces

 absl
 
 absl::hash_internal
 

Macros

#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_   0
 

Functions

template<typename H , typename B >
std::enable_if< std::is_same< B, bool >::value, H >::type absl::hash_internal::AbslHashValue (H hash_state, B value)
 
template<typename H , typename Enum >
std::enable_if< std::is_enum< Enum >::value, H >::type absl::hash_internal::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 absl::hash_internal::AbslHashValue (H hash_state, Float value)
 
template<typename H , typename LongDouble >
std::enable_if< std::is_same< LongDouble, long double >::value, H >::type absl::hash_internal::AbslHashValue (H hash_state, LongDouble value)
 
template<typename H , typename T >
absl::hash_internal::AbslHashValue (H hash_state, T *ptr)
 
template<typename H >
absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::AbslHashValue (H hash_state, const std::tuple< Ts... > &t)
 
template<typename H , typename T , typename D >
absl::hash_internal::AbslHashValue (H hash_state, const std::unique_ptr< T, D > &ptr)
 
template<typename H , typename T >
absl::hash_internal::AbslHashValue (H hash_state, const std::shared_ptr< T > &ptr)
 
template<typename H >
absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::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 absl::hash_internal::AbslHashValue (H hash_state, const absl::optional< T > &opt)
 
template<typename H , typename... T>
std::enable_if< conjunction< is_hashable< T >... >::value, H >::type absl::hash_internal::AbslHashValue (H hash_state, const absl::variant< T... > &v)
 
template<typename H , typename T >
absl::hash_internal::hash_bytes (H hash_state, const T &value)
 
template<typename H , typename T >
std::enable_if< is_uniquely_represented< T >::value, H >::type absl::hash_internal::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 absl::hash_internal::hash_range_or_bytes (H hash_state, const T *data, size_t size)
 
template<typename H , typename Tuple , size_t... Is>
absl::hash_internal::hash_tuple (H hash_state, const Tuple &t, absl::index_sequence< Is... >)
 

Macro Definition Documentation

◆ ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_

#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_   0

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



abseil_cpp
Author(s):
autogenerated on Mon Feb 28 2022 21:31:22