Classes | Namespaces | Defines | Functions
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_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

namespace  absl
namespace  absl::hash_internal

Defines

#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 >
H absl::hash_internal::AbslHashValue (H hash_state, T *ptr)
template<typename H >
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 >
H absl::hash_internal::AbslHashValue (H hash_state, const std::unique_ptr< T, D > &ptr)
template<typename H , typename T >
H absl::hash_internal::AbslHashValue (H hash_state, const std::shared_ptr< T > &ptr)
template<typename H >
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 >
H 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 Tuple , size_t... Is>
H absl::hash_internal::hash_tuple (H hash_state, const Tuple &t, absl::index_sequence< Is...>)

Define Documentation

#define ABSL_HASH_INTERNAL_SUPPORT_LEGACY_HASH_   0

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


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