Namespaces
namespace	algorithm_internal
namespace	any_internal
namespace	ascii_internal
namespace	base_internal
namespace	big_endian
namespace	compare_internal
namespace	container_algorithm_internal
namespace	container_internal
namespace	debugging_internal
namespace	flags_internal
namespace	hash_internal
namespace	inline_variable_testing_internal
namespace	inlined_vector_internal
namespace	internal
namespace	internal_casts
namespace	little_endian
namespace	macros_internal
namespace	memory_internal
namespace	numbers_internal
namespace	optional_internal
namespace	raw_logging_internal
namespace	span_internal
namespace	str_format_internal
namespace	streamed_test
namespace	strings_internal
namespace	substitute_internal
namespace	swap_internal
namespace	synchronization_internal
namespace	test_internal
namespace	time_internal
namespace	type_traits_internal
namespace	utility_internal
namespace	variant_internal
Classes
struct	allocator_is_nothrow
struct	allocator_traits
struct	AllowEmpty
class	AlphaNum
class	any
class	bad_any_cast
class	bad_optional_access
class	bad_variant_access
class	Barrier
class	BlockingCounter
class	ByAnyChar
class	ByChar
class	ByLength
class	ByString
class	Condition
class	CondVar
struct	conjunction< T >
struct	conjunction< T, Ts...>
struct	conjunction<>
struct	Dec
struct	default_allocator_is_nothrow
struct	disjunction< T >
struct	disjunction< T, Ts...>
struct	disjunction<>
class	Duration
struct	ExpDigits
struct	FailureSignalData
struct	FailureSignalHandlerOptions
class	FixedArray
struct	FlagsUsageConfig
class	flat_hash_map
class	flat_hash_set
class	FormatCountCapture
class	FormatRawSink
struct	from_chars_result
class	HashState
struct	Hex
struct	in_place_t
class	InlinedVector
struct	integer_sequence
struct	is_copy_assignable
struct	is_move_assignable
struct	is_trivially_copy_assignable
struct	is_trivially_copy_constructible
struct	is_trivially_default_constructible
struct	is_trivially_destructible
struct	is_trivially_move_assignable
struct	is_trivially_move_constructible
class	LeakCheckDisabler
struct	monostate
struct	MuHowS
class	Mutex
class	MutexLock
class	MutexLockMaybe
struct	negation
class	node_hash_map
class	node_hash_set
class	Notification
struct	nullopt_t
class	once_flag
class	optional
class	partial_ordering
struct	pointer_traits
struct	pointer_traits< T * >
class	ReaderMutexLock
class	ReleasableMutexLock
struct	SkipEmpty
struct	SkipWhitespace
class	Span
class	string_view
class	strong_equality
class	strong_ordering
struct	SynchEvent
struct	SynchLocksHeld
struct	SynchWaitParams
class	ThreadSafeCounter
class	Time
struct	TimeConversion
class	TimeZone
class	uint128
class	UntypedFormatSpec
class	variant< T0, Tn...>
struct	variant_alternative< I, const T >
struct	variant_alternative< I, const volatile T >
struct	variant_alternative< I, variant< Types...> >
struct	variant_alternative< I, volatile T >
struct	variant_size< const T >
struct	variant_size< const volatile T >
struct	variant_size< variant< Ts...> >
struct	variant_size< volatile T >
class	weak_equality
class	weak_ordering
struct	WriterFnStruct
class	WriterMutexLock
Enumerations
enum	{ kGdbMuSpin = kMuSpin, kGdbMuEvent = kMuEvent, kGdbMuWait = kMuWait, kGdbMuWriter = kMuWriter, kGdbMuDesig = kMuDesig, kGdbMuWrWait = kMuWrWait, kGdbMuReader = kMuReader, kGdbMuLow = kMuLow }
enum	{ kGdbCvSpin = kCvSpin, kGdbCvEvent = kCvEvent, kGdbCvLow = kCvLow }
enum	chars_format { scientific = 1, fixed = 2, hex = 4, general = fixed \| scientific }
enum	ConstInitType { kConstInit }
enum	LogSeverity { kInfo = 0, kWarning = 1, kError = 2, kFatal = 3 }
enum	OnDeadlockCycle { kIgnore, kReport, kAbort }
enum	PadSpec { kNoPad = 1, kZeroPad2, kZeroPad3, kZeroPad4, kZeroPad5, kZeroPad6, kZeroPad7, kZeroPad8, kZeroPad9, kZeroPad10, kZeroPad11, kZeroPad12, kZeroPad13, kZeroPad14, kZeroPad15, kZeroPad16, kZeroPad17, kZeroPad18, kZeroPad19, kZeroPad20, kSpacePad2 = kZeroPad2 + 64, kSpacePad3, kSpacePad4, kSpacePad5, kSpacePad6, kSpacePad7, kSpacePad8, kSpacePad9, kSpacePad10, kSpacePad11, kSpacePad12, kSpacePad13, kSpacePad14, kSpacePad15, kSpacePad16, kSpacePad17, kSpacePad18, kSpacePad19, kSpacePad20 }
Functions
Duration	AbsDuration (Duration d)
template<typename Dest , typename Source , typename std::enable_if< !internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>
	ABSL_DEPRECATED ("absl::bit_cast type requirements were violated. Update the types being ""used such that they are the same size and are both TriviallyCopyable.") inline Dest bit_cast(const Source &source)
	ABSL_DEPRECATED ("absl::RegisterSymbolizer() is deprecated and will be removed ""on or after 2023-05-01") void RegisterSymbolizer(bool(fn)(const void pc
	ABSL_INTERNAL_INLINE_CONSTEXPR (size_t, variant_npos,-1)
	ABSL_INTERNAL_INLINE_CONSTEXPR (nullopt_t, nullopt, nullopt_t(optional_internal::init_t()))
	ABSL_INTERNAL_INLINE_CONSTEXPR (in_place_t, in_place,{})
	ABSL_XRAY_LOG_ARGS (1) void Mutex
static void	AbslFailureSignalHandler (int signo, siginfo_t , void ucontext)
template<typename H , typename TheT , size_t TheN, typename TheA >
H	AbslHashValue (H h, const absl::InlinedVector< TheT, TheN, TheA > &a)
strings_internal::AlphaNumFormatterImpl	AlphaNumFormatter ()
template<typename ValueType >
ValueType	any_cast (const any &operand)
template<typename ValueType >
ValueType	any_cast (any &operand)
template<typename ValueType >
ValueType	any_cast (any &&operand)
template<typename ValueType >
const ValueType *	any_cast (const any *operand) noexcept
template<typename ValueType >
ValueType *	any_cast (any *operand) noexcept
static char *	Append (char *out, const AlphaNum &x)
template<typename Functor , typename Tuple >
auto	apply (Functor &&functor, Tuple &&t)-> decltype(utility_internal
bool	ascii_isalnum (unsigned char c)
bool	ascii_isalpha (unsigned char c)
bool	ascii_isascii (unsigned char c)
bool	ascii_isblank (unsigned char c)
bool	ascii_iscntrl (unsigned char c)
bool	ascii_isdigit (unsigned char c)
bool	ascii_isgraph (unsigned char c)
bool	ascii_islower (unsigned char c)
bool	ascii_isprint (unsigned char c)
bool	ascii_ispunct (unsigned char c)
bool	ascii_isspace (unsigned char c)
bool	ascii_isupper (unsigned char c)
bool	ascii_isxdigit (unsigned char c)
char	ascii_tolower (unsigned char c)
char	ascii_toupper (unsigned char c)
void	AsciiStrToLower (std::string *s)
ABSL_MUST_USE_RESULT std::string	AsciiStrToLower (absl::string_view s)
void	AsciiStrToUpper (std::string *s)
ABSL_MUST_USE_RESULT std::string	AsciiStrToUpper (absl::string_view s)
static void	AtomicClearBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)
static void	AtomicSetBits (std::atomic< intptr_t > *pv, intptr_t bits, intptr_t wait_until_clear)
void	Base64Escape (absl::string_view src, std::string *dest)
std::string	Base64Escape (absl::string_view src)
bool	Base64Unescape (absl::string_view src, std::string *dest)
static void	BasicTests (bool notify_before_waiting, Notification *notification)
template<typename Dest , typename Source , typename std::enable_if< internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>
Dest	bit_cast (const Source &source)
std::string	BytesToHexString (absl::string_view from)
template<typename Sequence , typename T >
decay_t< T >	c_accumulate (const Sequence &sequence, T &&init)
template<typename Sequence , typename T , typename BinaryOp >
decay_t< T >	c_accumulate (const Sequence &sequence, T &&init, BinaryOp &&binary_op)
template<typename InputSequence , typename OutputIt >
OutputIt	c_adjacent_difference (const InputSequence &input, OutputIt output_first)
template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt	c_adjacent_difference (const InputSequence &input, OutputIt output_first, BinaryOp &&op)
template<typename Sequence >
container_algorithm_internal::ContainerIter < Sequence >	c_adjacent_find (Sequence &sequence)
template<typename Sequence , typename BinaryPredicate >
container_algorithm_internal::ContainerIter < Sequence >	c_adjacent_find (Sequence &sequence, BinaryPredicate &&pred)
template<typename C , typename Pred >
bool	c_all_of (const C &c, Pred &&pred)
template<typename C , typename Pred >
bool	c_any_of (const C &c, Pred &&pred)
template<typename Sequence , typename T >
bool	c_binary_search (Sequence &&sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
bool	c_binary_search (Sequence &&sequence, T &&value, Compare &&comp)
template<typename InputSequence , typename OutputIterator >
OutputIterator	c_copy (const InputSequence &input, OutputIterator output)
template<typename C , typename BidirectionalIterator >
BidirectionalIterator	c_copy_backward (const C &src, BidirectionalIterator dest)
template<typename InputSequence , typename OutputIterator , typename Pred >
OutputIterator	c_copy_if (const InputSequence &input, OutputIterator output, Pred &&pred)
template<typename C , typename Size , typename OutputIterator >
OutputIterator	c_copy_n (const C &input, Size n, OutputIterator output)
template<typename C , typename T >
container_algorithm_internal::ContainerDifferenceType < const C >	c_count (const C &c, T &&value)
template<typename C , typename Pred >
container_algorithm_internal::ContainerDifferenceType < const C >	c_count_if (const C &c, Pred &&pred)
template<typename C >
container_algorithm_internal::ContainerDifferenceType < const C >	c_distance (const C &c)
template<typename C1 , typename C2 >
bool	c_equal (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
bool	c_equal (const C1 &c1, const C2 &c2, BinaryPredicate &&pred)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIterPairType < Sequence, Sequence >	c_equal_range (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIterPairType < Sequence, Sequence >	c_equal_range (Sequence &sequence, T &&value, Compare &&comp)
template<typename C , typename T >
void	c_fill (C &c, T &&value)
template<typename C , typename Size , typename T >
void	c_fill_n (C &c, Size n, T &&value)
template<typename C , typename T >
container_algorithm_internal::ContainerIter < C >	c_find (C &c, T &&value)
template<typename Sequence1 , typename Sequence2 >
container_algorithm_internal::ContainerIter < Sequence1 >	c_find_end (Sequence1 &sequence, Sequence2 &subsequence)
template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter < Sequence1 >	c_find_end (Sequence1 &sequence, Sequence2 &subsequence, BinaryPredicate &&pred)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIter < C1 >	c_find_first_of (C1 &container, C2 &options)
template<typename C1 , typename C2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter < C1 >	c_find_first_of (C1 &container, C2 &options, BinaryPredicate &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter < C >	c_find_if (C &c, Pred &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter < C >	c_find_if_not (C &c, Pred &&pred)
template<typename C , typename Function >
decay_t< Function >	c_for_each (C &&c, Function &&f)
template<typename C , typename Generator >
void	c_generate (C &c, Generator &&gen)
template<typename C , typename Size , typename Generator >
container_algorithm_internal::ContainerIter < C >	c_generate_n (C &c, Size n, Generator &&gen)
template<typename C1 , typename C2 >
bool	c_includes (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename Compare >
bool	c_includes (const C1 &c1, const C2 &c2, Compare &&comp)
template<typename Sequence1 , typename Sequence2 , typename T >
decay_t< T >	c_inner_product (const Sequence1 &factors1, const Sequence2 &factors2, T &&sum)
template<typename Sequence1 , typename Sequence2 , typename T , typename BinaryOp1 , typename BinaryOp2 >
decay_t< T >	c_inner_product (const Sequence1 &factors1, const Sequence2 &factors2, T &&sum, BinaryOp1 &&op1, BinaryOp2 &&op2)
template<typename C >
void	c_inplace_merge (C &c, container_algorithm_internal::ContainerIter< C > middle)
template<typename C , typename Compare >
void	c_inplace_merge (C &c, container_algorithm_internal::ContainerIter< C > middle, Compare &&comp)
template<typename Sequence , typename T >
void	c_iota (Sequence &sequence, T &&value)
template<typename RandomAccessContainer >
bool	c_is_heap (const RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
bool	c_is_heap (const RandomAccessContainer &sequence, Compare &&comp)
template<typename RandomAccessContainer >
container_algorithm_internal::ContainerIter < RandomAccessContainer >	c_is_heap_until (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
container_algorithm_internal::ContainerIter < RandomAccessContainer >	c_is_heap_until (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename Pred >
bool	c_is_partitioned (const C &c, Pred &&pred)
template<typename C1 , typename C2 >
bool	c_is_permutation (const C1 &c1, const C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
bool	c_is_permutation (const C1 &c1, const C2 &c2, BinaryPredicate &&pred)
template<typename C >
bool	c_is_sorted (const C &c)
template<typename C , typename Compare >
bool	c_is_sorted (const C &c, Compare &&comp)
template<typename C >
container_algorithm_internal::ContainerIter < C >	c_is_sorted_until (C &c)
template<typename C , typename Compare >
container_algorithm_internal::ContainerIter < C >	c_is_sorted_until (C &c, Compare &&comp)
template<typename Sequence1 , typename Sequence2 >
bool	c_lexicographical_compare (Sequence1 &&sequence1, Sequence2 &&sequence2)
template<typename Sequence1 , typename Sequence2 , typename Compare >
bool	c_lexicographical_compare (Sequence1 &&sequence1, Sequence2 &&sequence2, Compare &&comp)
template<typename C , typename EqualityComparable >
bool	c_linear_search (const C &c, EqualityComparable &&value)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIter < Sequence >	c_lower_bound (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIter < Sequence >	c_lower_bound (Sequence &sequence, T &&value, Compare &&comp)
template<typename RandomAccessContainer >
void	c_make_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	c_make_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename Sequence >
container_algorithm_internal::ContainerIter < Sequence >	c_max_element (Sequence &sequence)
template<typename Sequence , typename Compare >
container_algorithm_internal::ContainerIter < Sequence >	c_max_element (Sequence &sequence, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator >
OutputIterator	c_merge (const C1 &c1, const C2 &c2, OutputIterator result)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare >
OutputIterator	c_merge (const C1 &c1, const C2 &c2, OutputIterator result, Compare &&comp)
template<typename Sequence >
container_algorithm_internal::ContainerIter < Sequence >	c_min_element (Sequence &sequence)
template<typename Sequence , typename Compare >
container_algorithm_internal::ContainerIter < Sequence >	c_min_element (Sequence &sequence, Compare &&comp)
template<typename C >
container_algorithm_internal::ContainerIterPairType < C, C >	c_minmax_element (C &c)
template<typename C , typename Compare >
container_algorithm_internal::ContainerIterPairType < C, C >	c_minmax_element (C &c, Compare &&comp)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIterPairType < C1, C2 >	c_mismatch (C1 &c1, C2 &c2)
template<typename C1 , typename C2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIterPairType < C1, C2 >	c_mismatch (C1 &c1, C2 &c2, BinaryPredicate &&pred)
template<typename C , typename OutputIterator >
OutputIterator	c_move (C &&src, OutputIterator dest)
template<typename C >
bool	c_next_permutation (C &c)
template<typename C , typename Compare >
bool	c_next_permutation (C &c, Compare &&comp)
template<typename C , typename Pred >
bool	c_none_of (const C &c, Pred &&pred)
template<typename RandomAccessContainer >
void	c_nth_element (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > nth)
template<typename RandomAccessContainer , typename Compare >
void	c_nth_element (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > nth, Compare &&comp)
template<typename RandomAccessContainer >
void	c_partial_sort (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > middle)
template<typename RandomAccessContainer , typename Compare >
void	c_partial_sort (RandomAccessContainer &sequence, container_algorithm_internal::ContainerIter< RandomAccessContainer > middle, Compare &&comp)
template<typename C , typename RandomAccessContainer >
container_algorithm_internal::ContainerIter < RandomAccessContainer >	c_partial_sort_copy (const C &sequence, RandomAccessContainer &result)
template<typename C , typename RandomAccessContainer , typename Compare >
container_algorithm_internal::ContainerIter < RandomAccessContainer >	c_partial_sort_copy (const C &sequence, RandomAccessContainer &result, Compare &&comp)
template<typename InputSequence , typename OutputIt >
OutputIt	c_partial_sum (const InputSequence &input, OutputIt output_first)
template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt	c_partial_sum (const InputSequence &input, OutputIt output_first, BinaryOp &&op)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter < C >	c_partition (C &c, Pred &&pred)
template<typename C , typename OutputIterator1 , typename OutputIterator2 , typename Pred >
std::pair< OutputIterator1, OutputIterator2 >	c_partition_copy (const C &c, OutputIterator1 out_true, OutputIterator2 out_false, Pred &&pred)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter < C >	c_partition_point (C &c, Pred &&pred)
template<typename RandomAccessContainer >
void	c_pop_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	c_pop_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C >
bool	c_prev_permutation (C &c)
template<typename C , typename Compare >
bool	c_prev_permutation (C &c, Compare &&comp)
template<typename RandomAccessContainer >
void	c_push_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	c_push_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename OutputIterator , typename T >
OutputIterator	c_remove_copy (const C &c, OutputIterator result, T &&value)
template<typename C , typename OutputIterator , typename Pred >
OutputIterator	c_remove_copy_if (const C &c, OutputIterator result, Pred &&pred)
template<typename Sequence , typename T >
void	c_replace (Sequence &sequence, const T &old_value, const T &new_value)
template<typename C , typename OutputIterator , typename T >
OutputIterator	c_replace_copy (const C &c, OutputIterator result, T &&old_value, T &&new_value)
template<typename C , typename OutputIterator , typename Pred , typename T >
OutputIterator	c_replace_copy_if (const C &c, OutputIterator result, Pred &&pred, T &&new_value)
template<typename C , typename Pred , typename T >
void	c_replace_if (C &c, Pred &&pred, T &&new_value)
template<typename Sequence >
void	c_reverse (Sequence &sequence)
template<typename C , typename OutputIterator >
OutputIterator	c_reverse_copy (const C &sequence, OutputIterator result)
template<typename C , typename Iterator = container_algorithm_internal::ContainerIter<C>>
Iterator	c_rotate (C &sequence, Iterator middle)
template<typename C , typename OutputIterator >
OutputIterator	c_rotate_copy (const C &sequence, container_algorithm_internal::ContainerIter< const C > middle, OutputIterator result)
template<typename Sequence1 , typename Sequence2 >
container_algorithm_internal::ContainerIter < Sequence1 >	c_search (Sequence1 &sequence, Sequence2 &subsequence)
template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >
container_algorithm_internal::ContainerIter < Sequence1 >	c_search (Sequence1 &sequence, Sequence2 &subsequence, BinaryPredicate &&pred)
template<typename Sequence , typename Size , typename T >
container_algorithm_internal::ContainerIter < Sequence >	c_search_n (Sequence &sequence, Size count, T &&value)
template<typename Sequence , typename Size , typename T , typename BinaryPredicate >
container_algorithm_internal::ContainerIter < Sequence >	c_search_n (Sequence &sequence, Size count, T &&value, BinaryPredicate &&pred)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_difference (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_difference (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_intersection (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_intersection (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_symmetric_difference (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_symmetric_difference (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_union (const C1 &c1, const C2 &c2, OutputIterator output)
template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator	c_set_union (const C1 &c1, const C2 &c2, OutputIterator output, Compare &&comp)
template<typename RandomAccessContainer , typename UniformRandomBitGenerator >
void	c_shuffle (RandomAccessContainer &c, UniformRandomBitGenerator &&gen)
template<typename C >
void	c_sort (C &c)
template<typename C , typename Compare >
void	c_sort (C &c, Compare &&comp)
template<typename RandomAccessContainer >
void	c_sort_heap (RandomAccessContainer &sequence)
template<typename RandomAccessContainer , typename Compare >
void	c_sort_heap (RandomAccessContainer &sequence, Compare &&comp)
template<typename C , typename Pred >
container_algorithm_internal::ContainerIter < C >	c_stable_partition (C &c, Pred &&pred)
template<typename C >
void	c_stable_sort (C &c)
template<typename C , typename Compare >
void	c_stable_sort (C &c, Compare &&comp)
template<typename C1 , typename C2 >
container_algorithm_internal::ContainerIter < C2 >	c_swap_ranges (C1 &c1, C2 &c2)
template<typename InputSequence , typename OutputIterator , typename UnaryOp >
OutputIterator	c_transform (const InputSequence &input, OutputIterator output, UnaryOp &&unary_op)
template<typename InputSequence1 , typename InputSequence2 , typename OutputIterator , typename BinaryOp >
OutputIterator	c_transform (const InputSequence1 &input1, const InputSequence2 &input2, OutputIterator output, BinaryOp &&binary_op)
template<typename C , typename OutputIterator >
OutputIterator	c_unique_copy (const C &c, OutputIterator result)
template<typename C , typename OutputIterator , typename BinaryPredicate >
OutputIterator	c_unique_copy (const C &c, OutputIterator result, BinaryPredicate &&pred)
template<typename Sequence , typename T >
container_algorithm_internal::ContainerIter < Sequence >	c_upper_bound (Sequence &sequence, T &&value)
template<typename Sequence , typename T , typename Compare >
container_algorithm_internal::ContainerIter < Sequence >	c_upper_bound (Sequence &sequence, T &&value, Compare &&comp)
template<typename Callable , typename... Args>
void	call_once (absl::once_flag &flag, Callable &&fn, Args &&...args)
Duration	Ceil (const Duration d, const Duration unit)
std::string	CEscape (absl::string_view src)
static void	CheckForMutexCorruption (intptr_t v, const char *label)
std::string	CHexEscape (absl::string_view src)
string_view	ClippedSubstr (string_view s, size_t pos, size_t n=string_view::npos)
static void	CondVarEnqueue (SynchWaitParams *waitp)
bool	ConsumePrefix (absl::string_view *str, absl::string_view expected)
bool	ConsumeSuffix (absl::string_view *str, absl::string_view expected)
absl::TimeConversion	ConvertDateTime (int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz)
template<typename To , typename Variant >
To	ConvertVariantTo (Variant &&variant)
bool	CUnescape (absl::string_view source, std::string *dest)
bool	CUnescape (absl::string_view source, std::string dest, std::string error)
static char *	CurrentStackString (char *buf, int maxlen, bool symbolize)
static absl::Time	DeadlineFromTimeout (absl::Duration timeout)
static GraphId	DeadlockCheck (Mutex *mu)
static GraphId	DebugOnlyDeadlockCheck (Mutex *mu)
static bool	DebugOnlyIsExiting ()
static void	DebugOnlyLockEnter (Mutex *mu)
static void	DebugOnlyLockEnter (Mutex *mu, GraphId id)
static void	DebugOnlyLockLeave (Mutex *mu)
int	DefaultStackUnwinder (void *pcs, int sizes, int depth, int skip, const void uc, int min_dropped_frames)
static int	Delay (int32_t c, DelayMode mode)
static void	DeleteSynchEvent (SynchEvent *e)
static PerThreadSynch *	Dequeue (PerThreadSynch head, PerThreadSynch pw)
static PerThreadSynch *	DequeueAllWakeable (PerThreadSynch head, PerThreadSynch pw, PerThreadSynch **wake_tail)
static bool	Dereference (void *arg)
template<typename Formatter >
strings_internal::DereferenceFormatterImpl < Formatter >	DereferenceFormatter (Formatter &&f)
strings_internal::DereferenceFormatterImpl < strings_internal::AlphaNumFormatterImpl >	DereferenceFormatter ()
void	DoIgnoreLeak (const void *)
Duration	DurationFromTimespec (timespec ts)
Duration	DurationFromTimeval (timeval tv)
void	EnableMutexInvariantDebugging (bool enabled)
bool	EndsWith (absl::string_view text, absl::string_view suffix)
bool	EndsWithIgnoreCase (absl::string_view text, absl::string_view suffix)
static PerThreadSynch *	Enqueue (PerThreadSynch head, SynchWaitParams waitp, intptr_t mu, int flags)
static SynchEvent *	EnsureSynchEvent (std::atomic< intptr_t > addr, const char name, intptr_t bits, intptr_t lockbit)
template<typename InputIter1 , typename InputIter2 , typename Pred >
bool	equal (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2, Pred &&pred)
template<typename InputIter1 , typename InputIter2 >
bool	equal (InputIter1 first1, InputIter1 last1, InputIter2 first2, InputIter2 last2)
bool	EqualsIgnoreCase (absl::string_view piece1, absl::string_view piece2)
static bool	EvalConditionAnnotated (const Condition cond, Mutex mu, bool locking, bool trylock, bool read_lock)
static bool	EvalConditionIgnored (Mutex mu, const Condition cond)
static bool	ExactlyOneReader (intptr_t v)
static ABSL_CONST_INIT std::atomic< GetTidType >	failed_tid (0)
double	FDivDuration (Duration num, Duration den)
TimeZone	FixedTimeZone (int seconds)
static void	FixSkip (PerThreadSynch ancestor, PerThreadSynch to_be_removed)
Duration	Floor (const Duration d, const Duration unit)
static void	ForgetSynchEvent (std::atomic< intptr_t > *addr, intptr_t bits, intptr_t lockbit)
template<typename... Args>
bool	Format (FormatRawSink raw_sink, const FormatSpec< Args...> &format, const Args &...args)
std::string	FormatCivilTime (CivilSecond c)
std::string	FormatCivilTime (CivilMinute c)
std::string	FormatCivilTime (CivilHour c)
std::string	FormatCivilTime (CivilDay c)
std::string	FormatCivilTime (CivilMonth c)
std::string	FormatCivilTime (CivilYear c)
std::string	FormatDuration (Duration d)
template<typename T >
str_format_internal::StreamedWrapper < T >	FormatStreamed (const T &v)
std::string	FormatTime (const std::string &format, absl::Time t, absl::TimeZone tz)
std::string	FormatTime (absl::Time t, absl::TimeZone tz)
std::string	FormatTime (absl::Time t)
ABSL_MUST_USE_RESULT bool	FormatUntyped (FormatRawSink raw_sink, const UntypedFormatSpec &format, absl::Span< const FormatArg > args)
template<typename T >
constexpr T &&	forward (absl::remove_reference_t< T > &t) noexcept
template<typename... Args>
int	FPrintF (std::FILE *output, const FormatSpec< Args...> &format, const Args &...args)
from_chars_result	from_chars (const char first, const char last, double &value, chars_format fmt)
from_chars_result	from_chars (const char first, const char last, float &value, chars_format fmt)
Time	FromChrono (const std::chrono::system_clock::time_point &tp)
constexpr Duration	FromChrono (const std::chrono::nanoseconds &d)
constexpr Duration	FromChrono (const std::chrono::microseconds &d)
constexpr Duration	FromChrono (const std::chrono::milliseconds &d)
constexpr Duration	FromChrono (const std::chrono::seconds &d)
constexpr Duration	FromChrono (const std::chrono::minutes &d)
constexpr Duration	FromChrono (const std::chrono::hours &d)
Time	FromCivil (CivilSecond ct, TimeZone tz)
Time	FromDateTime (int64_t year, int mon, int day, int hour, int min, int sec, TimeZone tz)
constexpr Time	FromTimeT (time_t t)
absl::Time	FromTM (const struct tm &tm, absl::TimeZone tz)
absl::Time	FromUDate (double udate)
absl::Time	FromUniversal (int64_t universal)
constexpr Time	FromUnixMicros (int64_t us)
constexpr Time	FromUnixMillis (int64_t ms)
constexpr Time	FromUnixNanos (int64_t ns)
constexpr Time	FromUnixSeconds (int64_t s)
uint16_t	gbswap_16 (uint16_t host_int)
uint32_t	gbswap_32 (uint32_t host_int)
uint64_t	gbswap_64 (uint64_t host_int)
template<class T , class... Types>
constexpr T &	get (variant< Types...> &v)
template<class T , class... Types>
constexpr T &&	get (variant< Types...> &&v)
template<class T , class... Types>
constexpr const T &	get (const variant< Types...> &v)
template<class T , class... Types>
constexpr const T &&	get (const variant< Types...> &&v)
template<std::size_t I, class... Types>
constexpr absl::add_pointer_t < variant_alternative_t< I, variant< Types...> > >	get_if (variant< Types...> *v) noexcept
template<std::size_t I, class... Types>
constexpr absl::add_pointer_t < const variant_alternative_t < I, variant< Types...> > >	get_if (const variant< Types...> *v) noexcept
int64_t	GetCurrentTimeNanos ()
template<typename T >
T	GetFlag (const absl::Flag< T > &flag)
static GraphId	GetGraphId (Mutex *mu) LOCKS_EXCLUDED(deadlock_graph_mu)
static GraphId	GetGraphIdLocked (Mutex *mu) EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu)
static PerThreadSynch *	GetPerThreadSynch (intptr_t v)
ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int	GetStackFrames (void *result, int sizes, int max_depth, int skip_count)
ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int	GetStackFramesWithContext (void *result, int sizes, int max_depth, int skip_count, const void uc, int min_dropped_frames)
ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int	GetStackTrace (void **result, int max_depth, int skip_count)
ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int	GetStackTraceWithContext (void *result, int max_depth, int skip_count, const void uc, int *min_dropped_frames)
static SynchEvent *	GetSynchEvent (const void *addr)
Weekday	GetWeekday (CivilDay cd)
int	GetYearDay (CivilDay cd)
uint32_t	gntohl (uint32_t x)
uint64_t	gntohll (uint64_t x)
uint16_t	gntohs (uint16_t x)
static GraphCycles *deadlock_graph	GUARDED_BY (deadlock_graph_mu) PT_GUARDED_BY(deadlock_graph_mu)
static struct absl::SynchEvent	GUARDED_BY (synch_event_mu)
static bool	HasBeenNotifiedInternal (const std::atomic< bool > *notified_yet)
bool	HaveLeakSanitizer ()
std::string	HexStringToBytes (absl::string_view from)
template<class T , class... Types>
constexpr bool	holds_alternative (const variant< Types...> &v) noexcept
constexpr Duration	Hours (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Hours (T n)
int64_t	IDivDuration (Duration num, Duration den, Duration *rem)
template<typename T >
T *	IgnoreLeak (T *ptr)
template<typename To >
constexpr To	implicit_cast (typename absl::internal::identity_t< To > to)
template<size_t I>
void	in_place_index (utility_internal::InPlaceIndexTag< I >)
template<typename T >
void	in_place_type (utility_internal::InPlaceTypeTag< T >)
constexpr Duration	InfiniteDuration ()
constexpr Time	InfiniteFuture ()
constexpr Time	InfinitePast ()
void	InitializeSymbolizer (const char *argv0)
void	InstallFailureSignalHandler (const FailureSignalHandlerOptions &options)
static void	InstallOneFailureHandler (FailureSignalData data, void(handler)(int, siginfo_t , void ))
static bool	IsZero (void *arg)
template<typename InputIterator , typename EqualityComparable >
bool	linear_search (InputIterator first, InputIterator last, const EqualityComparable &value)
bool	LoadTimeZone (const std::string &name, TimeZone *tz)
TimeZone	LocalTimeZone ()
static void	LockEnter (Mutex mu, GraphId id, SynchLocksHeld held_locks)
static void	LockLeave (Mutex mu, GraphId id, SynchLocksHeld held_locks)
static SynchLocksHeld *	LocksHeldAlloc ()
constexpr std::array < absl::LogSeverity, 4 >	LogSeverities ()
constexpr const char *	LogSeverityName (absl::LogSeverity s)
template<typename T , typename... Args>
any	make_any (Args &&...args)
template<typename T , typename U , typename... Args>
any	make_any (std::initializer_list< U > il, Args &&...args)
template<typename T >
constexpr optional< typename std::decay< T >::type >	make_optional (T &&v)
template<typename T , typename... Args>
constexpr optional< T >	make_optional (Args &&...args)
template<typename T , typename U , typename... Args>
constexpr optional< T >	make_optional (std::initializer_list< U > il, Args &&...args)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult < T >::scalar	make_unique (Args &&...args)
template<typename T >
memory_internal::MakeUniqueResult < T >::array	make_unique (size_t n)
template<typename T , typename... Args>
memory_internal::MakeUniqueResult < T >::invalid	make_unique (Args &&...)
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< const T >	MakeConstSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< const T >	MakeConstSpan (T begin, T end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	MakeConstSpan (const C &c) noexcept-> decltype(MakeSpan(c))
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< const T >	MakeConstSpan (const T(&array)[N]) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span< T >	MakeSpan (T *ptr, size_t size) noexcept
template<int &... ExplicitArgumentBarrier, typename T >
Span< T >	MakeSpan (T begin, T end) noexcept
template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto	MakeSpan (C &c) noexcept-> decltype(absl
template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span< T >	MakeSpan (T(&array)[N]) noexcept
constexpr uint128	MakeUint128 (uint64_t high, uint64_t low)
template<typename Delimiter >
strings_internal::MaxSplitsImpl < typename strings_internal::SelectDelimiter < Delimiter >::type >	MaxSplits (Delimiter delimiter, int limit)
static int	MaybeSetupAlternateStack ()
constexpr Duration	Microseconds (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Microseconds (T n)
constexpr Duration	Milliseconds (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Milliseconds (T n)
constexpr Duration	Minutes (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Minutes (T n)
template<typename T >
constexpr absl::remove_reference_t< T > &&	move (T &&t) noexcept
static std::pair< uint64_t, uint64_t >	Mul32 (std::pair< uint64_t, uint64_t > num, uint32_t mul)
static bool	MuSameCondition (PerThreadSynch x, PerThreadSynch y)
constexpr Duration	Nanoseconds (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Nanoseconds (T n)
CivilDay	NextWeekday (CivilDay cd, Weekday wd)
constexpr absl::LogSeverity	NormalizeLogSeverity (absl::LogSeverity s)
constexpr absl::LogSeverity	NormalizeLogSeverity (int s)
Time	Now ()
string_view	NullSafeStringView (const char *p)
bool	operator! (uint128 val)
constexpr bool	operator!= (Duration lhs, Duration rhs)
constexpr bool	operator!= (monostate, monostate) noexcept
template<typename T >
bool	operator!= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator!= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator!= (Span< T > a, const U &b)
bool	operator!= (string_view x, string_view y) noexcept
bool	operator!= (uint128 lhs, uint128 rhs)
template<typename T , typename U >
constexpr auto	operator!= (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
template<typename T >
constexpr bool	operator!= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator!= (nullopt_t, const optional< T > &x) noexcept
constexpr bool	operator!= (Time lhs, Time rhs)
template<typename T , typename U >
constexpr auto	operator!= (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator!= (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveNotEqualT < Types...>	operator!= (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator!= (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
uint128	operator% (uint128 lhs, uint128 rhs)
Duration	operator% (Duration lhs, Duration rhs)
constexpr chars_format	operator& (chars_format lhs, chars_format rhs)
uint128	operator& (uint128 lhs, uint128 rhs)
chars_format &	operator&= (chars_format &lhs, chars_format rhs)
template<typename T >
Duration	operator* (Duration lhs, T rhs)
template<typename T >
Duration	operator* (T lhs, Duration rhs)
uint128	operator* (uint128 lhs, uint128 rhs)
Duration	operator+ (Duration lhs, Duration rhs)
uint128	operator+ (uint128 lhs, uint128 rhs)
Time	operator+ (Time lhs, Duration rhs)
Time	operator+ (Duration lhs, Time rhs)
constexpr Duration	operator- (Duration d)
Duration	operator- (Duration lhs, Duration rhs)
uint128	operator- (uint128 lhs, uint128 rhs)
uint128	operator- (uint128 val)
Time	operator- (Time lhs, Duration rhs)
Duration	operator- (Time lhs, Time rhs)
uint128	operator/ (uint128 lhs, uint128 rhs)
template<typename T >
Duration	operator/ (Duration lhs, T rhs)
int64_t	operator/ (Duration lhs, Duration rhs)
constexpr bool	operator< (Duration lhs, Duration rhs)
constexpr bool	operator< (monostate, monostate) noexcept
template<typename T >
bool	operator< (Span< T > a, Span< T > b)
bool	operator< (string_view x, string_view y) noexcept
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator< (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator< (Span< T > a, const U &b)
bool	operator< (uint128 lhs, uint128 rhs)
template<typename T , typename U >
constexpr auto	operator< (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
template<typename T >
constexpr bool	operator< (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	operator< (nullopt_t, const optional< T > &x) noexcept
constexpr bool	operator< (Time lhs, Time rhs)
template<typename T , typename U >
constexpr auto	operator< (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator< (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveLessThanT < Types...>	operator< (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator< (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
std::ostream &	operator<< (std::ostream &os, absl::LogSeverity s)
std::ostream &	operator<< (std::ostream &o, string_view piece)
std::ostream &	operator<< (std::ostream &os, uint128 v)
uint128	operator<< (uint128 lhs, int amount)
std::ostream &	operator<< (std::ostream &os, Duration d)
std::ostream &	operator<< (std::ostream &os, Time t)
constexpr bool	operator<= (Duration lhs, Duration rhs)
constexpr bool	operator<= (monostate, monostate) noexcept
bool	operator<= (string_view x, string_view y) noexcept
bool	operator<= (uint128 lhs, uint128 rhs)
template<typename T >
bool	operator<= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator<= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator<= (Span< T > a, const U &b)
template<typename T , typename U >
constexpr auto	operator<= (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
template<typename T >
constexpr bool	operator<= (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator<= (nullopt_t, const optional< T > &) noexcept
constexpr bool	operator<= (Time lhs, Time rhs)
template<typename T , typename U >
constexpr auto	operator<= (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator<= (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveLessThanOrEqualT < Types...>	operator<= (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator<= (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
constexpr bool	operator== (Duration lhs, Duration rhs)
constexpr bool	operator== (monostate, monostate) noexcept
template<typename T >
bool	operator== (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator== (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator== (Span< T > a, const U &b)
bool	operator== (string_view x, string_view y) noexcept
bool	operator== (uint128 lhs, uint128 rhs)
template<typename T , typename U >
constexpr auto	operator== (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
template<typename T >
constexpr bool	operator== (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator== (nullopt_t, const optional< T > &x) noexcept
constexpr bool	operator== (Time lhs, Time rhs)
template<typename T , typename U >
constexpr auto	operator== (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator== (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveEqualT < Types...>	operator== (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator== (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
constexpr bool	operator> (Duration lhs, Duration rhs)
constexpr bool	operator> (monostate, monostate) noexcept
bool	operator> (string_view x, string_view y) noexcept
template<typename T >
bool	operator> (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator> (const U &a, Span< T > b)
bool	operator> (uint128 lhs, uint128 rhs)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator> (Span< T > a, const U &b)
template<typename T , typename U >
constexpr auto	operator> (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
constexpr bool	operator> (Time lhs, Time rhs)
template<typename T >
constexpr bool	operator> (const optional< T > &x, nullopt_t) noexcept
template<typename T >
constexpr bool	operator> (nullopt_t, const optional< T > &) noexcept
template<typename T , typename U >
constexpr auto	operator> (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator> (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveGreaterThanT < Types...>	operator> (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator> (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
constexpr bool	operator>= (Duration lhs, Duration rhs)
constexpr bool	operator>= (monostate, monostate) noexcept
bool	operator>= (string_view x, string_view y) noexcept
bool	operator>= (uint128 lhs, uint128 rhs)
template<typename T >
bool	operator>= (Span< T > a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator>= (const U &a, Span< T > b)
template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>
bool	operator>= (Span< T > a, const U &b)
template<typename T , typename U >
constexpr auto	operator>= (const optional< T > &x, const optional< U > &y)-> decltype(optional_internal
constexpr bool	operator>= (Time lhs, Time rhs)
template<typename T >
constexpr bool	operator>= (const optional< T > &, nullopt_t) noexcept
template<typename T >
constexpr bool	operator>= (nullopt_t, const optional< T > &x) noexcept
template<typename T , typename U >
constexpr auto	operator>= (const optional< T > &x, const U &v)-> decltype(optional_internal
template<typename T , typename U >
constexpr auto	operator>= (const U &v, const optional< T > &x)-> decltype(optional_internal
template<typename... Types>
constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT < Types...>	operator>= (const variant< Types...> &a, const variant< Types...> &b)
template<typename T , size_t N, typename A >
bool	operator>= (const absl::InlinedVector< T, N, A > &a, const absl::InlinedVector< T, N, A > &b)
uint128	operator>> (uint128 lhs, int amount)
constexpr chars_format	operator^ (chars_format lhs, chars_format rhs)
uint128	operator^ (uint128 lhs, uint128 rhs)
chars_format &	operator^= (chars_format &lhs, chars_format rhs)
constexpr chars_format	operator\| (chars_format lhs, chars_format rhs)
uint128	operator\| (uint128 lhs, uint128 rhs)
chars_format &	operator\|= (chars_format &lhs, chars_format rhs)
constexpr chars_format	operator~ (chars_format arg)
uint128	operator~ (uint128 val)
template<typename FirstFormatter , typename SecondFormatter >
strings_internal::PairFormatterImpl < FirstFormatter, SecondFormatter >	PairFormatter (FirstFormatter f1, absl::string_view sep, SecondFormatter f2)
strings_internal::PairFormatterImpl < strings_internal::AlphaNumFormatterImpl, strings_internal::AlphaNumFormatterImpl >	PairFormatter (absl::string_view sep)
std::vector< char * >	ParseCommandLine (int argc, char *argv[])
bool	ParseDuration (const std::string &dur_string, Duration *d)
bool	ParseFlag (const std::string &text, absl::Time t, std::string error)
template<typename T >
bool	ParseFlag (absl::string_view input, T dst, std::string error)
bool	ParseFlag (const std::string &text, Duration dst, std::string )
bool	ParseTime (const std::string &format, const std::string &input, absl::Time time, std::string err)
bool	ParseTime (const std::string &format, const std::string &input, absl::TimeZone tz, absl::Time time, std::string err)
static void	PortableSleepForSeconds (int seconds)
static void	PostSynchEvent (void *obj, int ev)
static std::pair< uint64_t, uint64_t >	PowFive (uint64_t num, int expfive)
CivilDay	PrevWeekday (CivilDay cd, Weekday wd)
template<typename... Args>
int	PrintF (const FormatSpec< Args...> &format, const Args &...args)
static void	RaiseToDefaultHandler (int signo)
static void	RaiseToPreviousHandler (int signo)
template<typename T >
auto	RawPtr (T &&ptr)-> decltype(std
std::nullptr_t	RawPtr (std::nullptr_t)
void	RegisterCondVarTracer (void(fn)(const char msg, const void *cv))
void	RegisterLivePointers (const void *, size_t)
void	RegisterMutexProfiler (void(*fn)(int64_t wait_timestamp))
void	RegisterMutexTracer (void(fn)(const char msg, const void *obj, int64_t wait_cycles))
void	RegisterSymbolizer (bool(fn)(const void pc, char *out, int out_size))
void	RegisterSymbolizer (bool()(const void , char *, int))
void	RemoveExtraAsciiWhitespace (std::string *str)
template<typename ForwardIterator >
ForwardIterator	rotate (ForwardIterator first, ForwardIterator middle, ForwardIterator last)
static void	RunWorker (int i, ThreadSafeCounter ready_counter, Notification notification, ThreadSafeCounter *done_counter)
constexpr Duration	Seconds (int64_t n)
template<typename T , time_internal::EnableIfFloat< T > = 0>
Duration	Seconds (T n)
template<typename T >
void	SetFlag (absl::Flag< T > *flag, const T &v)
template<typename T , typename V >
void	SetFlag (absl::Flag< T > *flag, const V &v)
void	SetFlagsUsageConfig (FlagsUsageConfig usage_config)
void	SetMutexDeadlockDetectionMode (OnDeadlockCycle mode)
void	SetStackUnwinder (Unwinder w)
void	SetStackUnwinder (int(unwinder)(void pcs, int sizes, int max_depth, int skip_count, const void uc, int min_dropped_frames))
static bool	SetupAlternateStackOnce ()
template<typename T , typename D >
std::shared_ptr< T >	ShareUniquePtr (std::unique_ptr< T, D > &&ptr)
bool	SimpleAtob (absl::string_view str, bool *out)
bool	SimpleAtod (absl::string_view str, double *out)
bool	SimpleAtof (absl::string_view str, float *out)
template<typename int_type >
ABSL_MUST_USE_RESULT bool	SimpleAtoi (absl::string_view s, int_type *out)
strings_internal::AlphaNumBuffer < numbers_internal::kSixDigitsToBufferSize >	SixDigits (double d)
static PerThreadSynch *	Skip (PerThreadSynch *x)
void	SleepFor (absl::Duration duration)
template<typename... Args>
int	SNPrintF (char *output, std::size_t size, const FormatSpec< Args...> &format, const Args &...args)
static ExpDigits	SplitToSix (const double value)
static char *	StackString (void *pcs, int n, char buf, int maxlen, bool symbolize)
bool	StartsWith (absl::string_view text, absl::string_view prefix)
bool	StartsWithIgnoreCase (absl::string_view text, absl::string_view prefix)
	static_assert (PerThreadSynch::kAlignment > kMuLow,"PerThreadSynch::kAlignment must be greater than kMuLow")
	static_assert (PerThreadSynch::kAlignment > kCvLow,"PerThreadSynch::kAlignment must be greater than kCvLow")
void	StrAppend (std::string *dest, const AlphaNum &a)
void	StrAppend (std::string *dest, const AlphaNum &a, const AlphaNum &b)
void	StrAppend (std::string *dest, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c)
void	StrAppend (std::string *dest, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d)
void	StrAppend (std::string *)
template<typename... AV>
void	StrAppend (std::string *dest, const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AV &...args)
template<typename... Args>
std::string &	StrAppendFormat (std::string *dst, const FormatSpec< Args...> &format, const Args &...args)
std::string	StrCat (const AlphaNum &a, const AlphaNum &b)
std::string	StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c)
std::string	StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d)
ABSL_MUST_USE_RESULT std::string	StrCat ()
ABSL_MUST_USE_RESULT std::string	StrCat (const AlphaNum &a)
template<typename... AV>
ABSL_MUST_USE_RESULT std::string	StrCat (const AlphaNum &a, const AlphaNum &b, const AlphaNum &c, const AlphaNum &d, const AlphaNum &e, const AV &...args)
bool	StrContains (absl::string_view haystack, absl::string_view needle)
template<typename... Args>
ABSL_MUST_USE_RESULT str_format_internal::Streamable	StreamFormat (const FormatSpec< Args...> &format, const Args &...args)
strings_internal::StreamFormatterImpl	StreamFormatter ()
template<typename... Args>
ABSL_MUST_USE_RESULT std::string	StrFormat (const FormatSpec< Args...> &format, const Args &...args)
ABSL_MUST_USE_RESULT absl::string_view	StripAsciiWhitespace (absl::string_view str)
void	StripAsciiWhitespace (std::string *str)
ABSL_MUST_USE_RESULT absl::string_view	StripLeadingAsciiWhitespace (absl::string_view str)
void	StripLeadingAsciiWhitespace (std::string *str)
ABSL_MUST_USE_RESULT absl::string_view	StripPrefix (absl::string_view str, absl::string_view prefix)
ABSL_MUST_USE_RESULT absl::string_view	StripSuffix (absl::string_view str, absl::string_view suffix)
ABSL_MUST_USE_RESULT absl::string_view	StripTrailingAsciiWhitespace (absl::string_view str)
void	StripTrailingAsciiWhitespace (std::string *str)
template<typename Iterator , typename Formatter >
std::string	StrJoin (Iterator start, Iterator end, absl::string_view sep, Formatter &&fmt)
template<typename Range , typename Formatter >
std::string	StrJoin (const Range &range, absl::string_view separator, Formatter &&fmt)
template<typename T , typename Formatter >
std::string	StrJoin (std::initializer_list< T > il, absl::string_view separator, Formatter &&fmt)
template<typename... T, typename Formatter >
std::string	StrJoin (const std::tuple< T...> &value, absl::string_view separator, Formatter &&fmt)
template<typename Iterator >
std::string	StrJoin (Iterator start, Iterator end, absl::string_view separator)
template<typename Range >
std::string	StrJoin (const Range &range, absl::string_view separator)
template<typename T >
std::string	StrJoin (std::initializer_list< T > il, absl::string_view separator)
template<typename... T>
std::string	StrJoin (const std::tuple< T...> &value, absl::string_view separator)
ABSL_MUST_USE_RESULT std::string	StrReplaceAll (absl::string_view s, std::initializer_list< std::pair< absl::string_view, absl::string_view >> replacements)
std::string	StrReplaceAll (absl::string_view s, strings_internal::FixedMapping replacements)
int	StrReplaceAll (strings_internal::FixedMapping replacements, std::string *target)
template<typename StrToStrMapping >
std::string	StrReplaceAll (absl::string_view s, const StrToStrMapping &replacements)
int	StrReplaceAll (std::initializer_list< std::pair< absl::string_view, absl::string_view >> replacements, std::string *target)
template<typename StrToStrMapping >
int	StrReplaceAll (const StrToStrMapping &replacements, std::string *target)
template<typename Delimiter >
strings_internal::Splitter < typename strings_internal::SelectDelimiter < Delimiter >::type, AllowEmpty >	StrSplit (strings_internal::ConvertibleToStringView text, Delimiter d)
template<typename Delimiter , typename Predicate >
strings_internal::Splitter < typename strings_internal::SelectDelimiter < Delimiter >::type, Predicate >	StrSplit (strings_internal::ConvertibleToStringView text, Delimiter d, Predicate p)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7, const substitute_internal::Arg &a8)
ABSL_MUST_USE_RESULT std::string	Substitute (absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7, const substitute_internal::Arg &a8, const substitute_internal::Arg &a9)
void	SubstituteAndAppend (std::string *output, absl::string_view format)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7, const substitute_internal::Arg &a8)
void	SubstituteAndAppend (std::string *output, absl::string_view format, const substitute_internal::Arg &a0, const substitute_internal::Arg &a1, const substitute_internal::Arg &a2, const substitute_internal::Arg &a3, const substitute_internal::Arg &a4, const substitute_internal::Arg &a5, const substitute_internal::Arg &a6, const substitute_internal::Arg &a7, const substitute_internal::Arg &a8, const substitute_internal::Arg &a9)
void	swap (any &x, any &y) noexcept
template<typename... Ts, absl::enable_if_t< absl::conjunction< std::is_move_constructible< Ts >..., type_traits_internal::IsSwappable< Ts >...>::value, int > = 0>
void	swap (variant< Ts...> &v, variant< Ts...> &w) noexcept(noexcept(v.swap(w)))
template<typename T , typename std::enable_if< std::is_move_constructible< T >::value &&type_traits_internal::IsSwappable< T >::value, bool >::type = false>
void	swap (optional< T > &a, optional< T > &b) noexcept(noexcept(a.swap(b)))
template<typename T , size_t N, typename A >
void	swap (absl::InlinedVector< T, N, A > &a, absl::InlinedVector< T, N, A > &b) noexcept(noexcept(a.swap(b)))
bool	Symbolize (const void pc, char out, int out_size)
static SynchLocksHeld *	Synch_GetAllLocks ()
static PerThreadSynch *	Synch_GetPerThread ()
static PerThreadSynch *	Synch_GetPerThreadAnnotated (Mutex *mu)
	TEST (NotificationTest, SanityTest)
absl::Time	TimeFromTimespec (timespec ts)
absl::Time	TimeFromTimeval (timeval tv)
std::chrono::hours	ToChronoHours (Duration d)
std::chrono::microseconds	ToChronoMicroseconds (Duration d)
std::chrono::milliseconds	ToChronoMilliseconds (Duration d)
std::chrono::minutes	ToChronoMinutes (Duration d)
std::chrono::nanoseconds	ToChronoNanoseconds (Duration d)
std::chrono::seconds	ToChronoSeconds (Duration d)
std::chrono::system_clock::time_point	ToChronoTime (absl::Time t)
CivilDay	ToCivilDay (Time t, TimeZone tz)
CivilHour	ToCivilHour (Time t, TimeZone tz)
CivilMinute	ToCivilMinute (Time t, TimeZone tz)
CivilMonth	ToCivilMonth (Time t, TimeZone tz)
CivilSecond	ToCivilSecond (Time t, TimeZone tz)
CivilYear	ToCivilYear (Time t, TimeZone tz)
double	ToDoubleHours (Duration d)
double	ToDoubleMicroseconds (Duration d)
double	ToDoubleMilliseconds (Duration d)
double	ToDoubleMinutes (Duration d)
double	ToDoubleNanoseconds (Duration d)
double	ToDoubleSeconds (Duration d)
int64_t	ToInt64Hours (Duration d)
int64_t	ToInt64Microseconds (Duration d)
int64_t	ToInt64Milliseconds (Duration d)
int64_t	ToInt64Minutes (Duration d)
int64_t	ToInt64Nanoseconds (Duration d)
int64_t	ToInt64Seconds (Duration d)
timespec	ToTimespec (Time t)
timespec	ToTimespec (Duration d)
time_t	ToTimeT (Time t)
timeval	ToTimeval (Time t)
timeval	ToTimeval (Duration d)
struct tm	ToTM (absl::Time t, absl::TimeZone tz)
double	ToUDate (Time t)
int64_t	ToUniversal (absl::Time t)
int64_t	ToUnixMicros (Time t)
int64_t	ToUnixMillis (Time t)
int64_t	ToUnixNanos (Time t)
int64_t	ToUnixSeconds (Time t)
Duration	Trunc (Duration d, Duration unit)
static bool	TryAcquireWithSpinning (std::atomic< intptr_t > *mu)
constexpr uint64_t	Uint128High64 (uint128 v)
constexpr uint64_t	Uint128Low64 (uint128 v)
constexpr uint128	Uint128Max ()
constexpr Time	UniversalEpoch ()
constexpr Time	UnixEpoch ()
std::string	UnparseFlag (absl::Time t)
template<typename T >
std::string	UnparseFlag (const T &v)
std::string	UnparseFlag (Duration d)
static void	UnrefSynchEvent (SynchEvent *e)
void	UnRegisterLivePointers (const void *, size_t)
TimeZone	UTCTimeZone ()
std::string	Utf8SafeCEscape (absl::string_view src)
std::string	Utf8SafeCHexEscape (absl::string_view src)
template<int &... ExplicitBarrier, typename Container >
ABSL_MUST_USE_RESULT testing::AssertionResult	VerifyTypeImplementsAbslHashCorrectly (const Container &values)
template<int &... ExplicitBarrier, typename Container , typename Eq >
ABSL_MUST_USE_RESULT testing::AssertionResult	VerifyTypeImplementsAbslHashCorrectly (const Container &values, Eq equals)
template<int & ..., typename T >
ABSL_MUST_USE_RESULT testing::AssertionResult	VerifyTypeImplementsAbslHashCorrectly (std::initializer_list< T > values)
template<int & ..., typename T , typename Eq >
ABSL_MUST_USE_RESULT testing::AssertionResult	VerifyTypeImplementsAbslHashCorrectly (std::initializer_list< T > values, Eq equals)
template<typename Visitor , typename... Variants>
variant_internal::VisitResult < Visitor, Variants...>	visit (Visitor &&vis, Variants &&...vars)
template<typename T >
std::weak_ptr< T >	WeakenPtr (const std::shared_ptr< T > &ptr)
void	WebSafeBase64Escape (absl::string_view src, std::string *dest)
std::string	WebSafeBase64Escape (absl::string_view src)
bool	WebSafeBase64Unescape (absl::string_view src, std::string *dest)
template<typename T >
std::unique_ptr< T >	WrapUnique (T *ptr)
static void	WriteFailureInfo (int signo, void ucontext, void(writerfn)(const char *))
static void	WriterFnWrapper (const char data, void arg)
static void	WriteSignalMessage (int signo, void(writerfn)(const char ))
static ABSL_ATTRIBUTE_NOINLINE void	WriteStackTrace (void ucontext, bool symbolize_stacktrace, void(writerfn)(const char , void ), void *writerfn_arg)
static void	WriteToStderr (const char *data)
constexpr Duration	ZeroDuration ()
Variables
static absl::base_internal::SpinLock	deadlock_graph_mu (absl::base_internal::kLinkerInitialized)
struct {
int absl::flags
const char * absl::msg
}	event_properties []
static ABSL_CONST_INIT FailureSignalData	failure_signal_data []
static ABSL_CONST_INIT FailureSignalHandlerOptions	fsh_options
struct absl::SynchWaitParams	GUARDED_BY [kNSynchEvent]
static const intptr_t	ignore_waiting_writers []
static const intptr_t	kCvEvent = 0x0002L
static const intptr_t	kCvLow = 0x0003L
static const intptr_t	kCvSpin = 0x0001L
static constexpr bool	kDebugMode = true
static const Mutex::MuHow	kExclusive = &kExclusiveS
static const MuHowS	kExclusiveS
static constexpr auto	kFixedArrayUseDefault = static_cast<size_t>(-1)
static const intptr_t	kMuDesig = 0x0002L
static const intptr_t	kMuEvent = 0x0010L
static const int	kMuHasBlocked = 0x01
static const intptr_t	kMuHigh = ~kMuLow
static const int	kMuIsCond = 0x02
static const intptr_t	kMuLow = 0x00ffL
static const intptr_t	kMuOne = 0x0100
static const intptr_t	kMuReader = 0x0001L
static const intptr_t	kMuSpin = 0x0040L
static const intptr_t	kMuWait = 0x0004L
static const intptr_t	kMuWriter = 0x0008L
static const intptr_t	kMuWrWait = 0x0020L
static const uint32_t	kNSynchEvent = 1031
static PerThreadSynch *const	kPerThreadSynchNull
static const Mutex::MuHow	kShared = &kSharedS
static const MuHowS	kSharedS
const uint128	kuint128max
char *	out
char int	out_size
const char	RFC1123_full [] = "%a, %d %b %E4Y %H:%M:%S %z"
const char	RFC1123_no_wday [] = "%d %b %E4Y %H:%M:%S %z"
const char	RFC3339_full [] = "%Y-%m-%dT%H:%M:%E*S%Ez"
const char	RFC3339_sec [] = "%Y-%m-%dT%H:%M:%S%Ez"
static absl::base_internal::SpinLock	synch_event_mu (absl::base_internal::kLinkerInitialized)
static const intptr_t	zap_desig_waker []

Enumeration Type Documentation

anonymous enum

Enumerator:

kGdbMuSpin
kGdbMuEvent
kGdbMuWait
kGdbMuWriter
kGdbMuDesig
kGdbMuWrWait
kGdbMuReader
kGdbMuLow

Definition at line 631 of file mutex.cc.

anonymous enum

Enumerator:

kGdbCvSpin
kGdbCvEvent
kGdbCvLow

Definition at line 2410 of file mutex.cc.

enum absl::chars_format

Enumerator:

scientific
fixed
hex
general

Definition at line 26 of file charconv.h.

enum absl::ConstInitType

Enumerator:

kConstInit

Definition at line 66 of file const_init.h.

enum absl::LogSeverity

Enumerator:

kInfo
kWarning
kError
kFatal

Definition at line 28 of file log_severity.h.

enum absl::OnDeadlockCycle

Enumerator:

kIgnore
kReport
kAbort

Definition at line 1027 of file mutex.h.

enum absl::PadSpec

Enumerator:

kNoPad
kZeroPad2
kZeroPad3
kZeroPad4
kZeroPad5
kZeroPad6
kZeroPad7
kZeroPad8
kZeroPad9
kZeroPad10
kZeroPad11
kZeroPad12
kZeroPad13
kZeroPad14
kZeroPad15
kZeroPad16
kZeroPad17
kZeroPad18
kZeroPad19
kZeroPad20
kSpacePad2
kSpacePad3
kSpacePad4
kSpacePad5
kSpacePad6
kSpacePad7
kSpacePad8
kSpacePad9
kSpacePad10
kSpacePad11
kSpacePad12
kSpacePad13
kSpacePad14
kSpacePad15
kSpacePad16
kSpacePad17
kSpacePad18
kSpacePad19
kSpacePad20

Definition at line 83 of file str_cat.h.

Function Documentation

Duration absl::AbsDuration ( Duration d ) [inline]

Definition at line 291 of file time.h.

template<typename Dest , typename Source , typename std::enable_if< !internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>

absl::ABSL_DEPRECATED ( "absl::bit_cast type requirements were violated. Update the types being ""used such that they are the same size and are both TriviallyCopyable." ) const

Definition at line 168 of file casts.h.

absl::ABSL_DEPRECATED ( "absl::RegisterSymbolizer() is deprecated and will be removed ""on or after 2023-05-01" ) const

absl::ABSL_INTERNAL_INLINE_CONSTEXPR	(	size_t	,
		variant_npos	,
		-	1
	)

absl::ABSL_INTERNAL_INLINE_CONSTEXPR	(	nullopt_t	,
		nullopt	,
		nullopt_t(optional_internal::init_t())
	)

absl::ABSL_INTERNAL_INLINE_CONSTEXPR	(	in_place_t	,
		in_place
	)

absl::ABSL_XRAY_LOG_ARGS ( 1 )

Definition at line 1107 of file mutex.cc.

static void absl::AbslFailureSignalHandler	(	int	signo,
		siginfo_t *	,
		void *	ucontext
	)		`[static]`

Definition at line 304 of file failure_signal_handler.cc.

template<typename H , typename TheT , size_t TheN, typename TheA >

H absl::AbslHashValue	(	H	h,
		const absl::InlinedVector< TheT, TheN, TheA > &	a
	)

Definition at line 1294 of file inlined_vector.h.

strings_internal::AlphaNumFormatterImpl absl::AlphaNumFormatter ( ) [inline]

Definition at line 101 of file str_join.h.

template<typename ValueType >

ValueType absl::any_cast ( const any & operand )

Definition at line 479 of file any.h.

template<typename ValueType >

ValueType absl::any_cast ( any & operand )

Definition at line 493 of file any.h.

template<typename ValueType >

ValueType absl::any_cast ( any && operand )

Definition at line 507 of file any.h.

template<typename ValueType >

const T * absl::any_cast ( const any * operand )

Definition at line 517 of file any.h.

template<typename ValueType >

T * absl::any_cast ( any * operand )

Definition at line 526 of file any.h.

static char* absl::Append	(	char *	out,
		const AlphaNum &	x
	)		`[static]`

Definition at line 88 of file str_cat.cc.

template<typename Functor , typename Tuple >

auto absl::apply	(	Functor &&	functor,
		Tuple &&	t
	)

Definition at line 287 of file utility.h.

bool absl::ascii_isalnum ( unsigned char c ) [inline]

Definition at line 85 of file ascii.h.

bool absl::ascii_isalpha ( unsigned char c ) [inline]

Definition at line 78 of file ascii.h.

bool absl::ascii_isascii ( unsigned char c ) [inline]

Definition at line 155 of file ascii.h.

bool absl::ascii_isblank ( unsigned char c ) [inline]

Definition at line 107 of file ascii.h.

bool absl::ascii_iscntrl ( unsigned char c ) [inline]

Definition at line 114 of file ascii.h.

bool absl::ascii_isdigit ( unsigned char c ) [inline]

Definition at line 130 of file ascii.h.

bool absl::ascii_isgraph ( unsigned char c ) [inline]

Definition at line 140 of file ascii.h.

bool absl::ascii_islower ( unsigned char c ) [inline]

Definition at line 150 of file ascii.h.

bool absl::ascii_isprint ( unsigned char c ) [inline]

Definition at line 135 of file ascii.h.

bool absl::ascii_ispunct ( unsigned char c ) [inline]

Definition at line 100 of file ascii.h.

bool absl::ascii_isspace ( unsigned char c ) [inline]

Definition at line 93 of file ascii.h.

bool absl::ascii_isupper ( unsigned char c ) [inline]

Definition at line 145 of file ascii.h.

bool absl::ascii_isxdigit ( unsigned char c ) [inline]

Definition at line 122 of file ascii.h.

char absl::ascii_tolower ( unsigned char c ) [inline]

Definition at line 161 of file ascii.h.

char absl::ascii_toupper ( unsigned char c ) [inline]

Definition at line 179 of file ascii.h.

void absl::AsciiStrToLower ( std::string * s )

Definition at line 157 of file ascii.cc.

ABSL_MUST_USE_RESULT std::string absl::AsciiStrToLower ( absl::string_view s ) [inline]

Definition at line 169 of file ascii.h.

void absl::AsciiStrToUpper ( std::string * s )

Definition at line 163 of file ascii.cc.

ABSL_MUST_USE_RESULT std::string absl::AsciiStrToUpper ( absl::string_view s ) [inline]

Definition at line 187 of file ascii.h.

static void absl::AtomicClearBits	(	std::atomic< intptr_t > *	pv,
		intptr_t	bits,
		intptr_t	wait_until_clear
	)		`[static]`

Definition at line 191 of file mutex.cc.

static void absl::AtomicSetBits	(	std::atomic< intptr_t > *	pv,
		intptr_t	bits,
		intptr_t	wait_until_clear
	)		`[static]`

Definition at line 175 of file mutex.cc.

void absl::Base64Escape	(	absl::string_view	src,
		std::string *	dest
	)

Definition at line 1089 of file escaping.cc.

std::string absl::Base64Escape ( absl::string_view src )

Definition at line 1099 of file escaping.cc.

bool absl::Base64Unescape	(	absl::string_view	src,
		std::string *	dest
	)

Definition at line 1081 of file escaping.cc.

static void absl::BasicTests	(	bool	notify_before_waiting,
		Notification *	notification
	)		`[static]`

Definition at line 68 of file notification_test.cc.

template<typename Dest , typename Source , typename std::enable_if< internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>

Dest absl::bit_cast ( const Source & source ) [inline]

Definition at line 154 of file casts.h.

std::string absl::BytesToHexString ( absl::string_view from )

Definition at line 1121 of file escaping.cc.

template<typename Sequence , typename T >

decay_t<T> absl::c_accumulate	(	const Sequence &	sequence,
		T &&	init
	)

Definition at line 1604 of file container.h.

template<typename Sequence , typename T , typename BinaryOp >

decay_t<T> absl::c_accumulate	(	const Sequence &	sequence,
		T &&	init,
		BinaryOp &&	binary_op
	)

Definition at line 1613 of file container.h.

template<typename InputSequence , typename OutputIt >

OutputIt absl::c_adjacent_difference	(	const InputSequence &	input,
		OutputIt	output_first
	)

Definition at line 1658 of file container.h.

template<typename InputSequence , typename OutputIt , typename BinaryOp >

OutputIt absl::c_adjacent_difference	(	const InputSequence &	input,
		OutputIt	output_first,
		BinaryOp &&	op
	)

Definition at line 1668 of file container.h.

template<typename Sequence >

container_algorithm_internal::ContainerIter<Sequence> absl::c_adjacent_find ( Sequence & sequence )

Definition at line 286 of file container.h.

template<typename Sequence , typename BinaryPredicate >

container_algorithm_internal::ContainerIter<Sequence> absl::c_adjacent_find	(	Sequence &	sequence,
		BinaryPredicate &&	pred
	)

Definition at line 295 of file container.h.

template<typename C , typename Pred >

bool absl::c_all_of	(	const C &	c,
		Pred &&	pred
	)

Definition at line 158 of file container.h.

template<typename C , typename Pred >

bool absl::c_any_of	(	const C &	c,
		Pred &&	pred
	)

Definition at line 169 of file container.h.

template<typename Sequence , typename T >

bool absl::c_binary_search	(	Sequence &&	sequence,
		T &&	value
	)

Definition at line 1072 of file container.h.

template<typename Sequence , typename T , typename Compare >

bool absl::c_binary_search	(	Sequence &&	sequence,
		T &&	value,
		Compare &&	comp
	)

Definition at line 1081 of file container.h.

template<typename InputSequence , typename OutputIterator >

OutputIterator absl::c_copy	(	const InputSequence &	input,
		OutputIterator	output
	)

Definition at line 466 of file container.h.

template<typename C , typename BidirectionalIterator >

BidirectionalIterator absl::c_copy_backward	(	const C &	src,
		BidirectionalIterator	dest
	)

Definition at line 497 of file container.h.

template<typename InputSequence , typename OutputIterator , typename Pred >

OutputIterator absl::c_copy_if	(	const InputSequence &	input,
		OutputIterator	output,
		Pred &&	pred
	)

Definition at line 485 of file container.h.

template<typename C , typename Size , typename OutputIterator >

OutputIterator absl::c_copy_n	(	const C &	input,
		Size	n,
		OutputIterator	output
	)

Definition at line 476 of file container.h.

template<typename C , typename T >

container_algorithm_internal::ContainerDifferenceType<const C> absl::c_count	(	const C &	c,
		T &&	value
	)

Definition at line 307 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerDifferenceType<const C> absl::c_count_if	(	const C &	c,
		Pred &&	pred
	)

Definition at line 319 of file container.h.

template<typename C >

container_algorithm_internal::ContainerDifferenceType<const C> absl::c_distance ( const C & c )

Definition at line 143 of file container.h.

template<typename C1 , typename C2 >

bool absl::c_equal	(	const C1 &	c1,
		const C2 &	c2
	)

Definition at line 367 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >

bool absl::c_equal	(	const C1 &	c1,
		const C2 &	c2,
		BinaryPredicate &&	pred
	)

Definition at line 377 of file container.h.

template<typename Sequence , typename T >

container_algorithm_internal::ContainerIterPairType<Sequence, Sequence> absl::c_equal_range	(	Sequence &	sequence,
		T &&	value
	)

Definition at line 1050 of file container.h.

template<typename Sequence , typename T , typename Compare >

container_algorithm_internal::ContainerIterPairType<Sequence, Sequence> absl::c_equal_range	(	Sequence &	sequence,
		T &&	value,
		Compare &&	comp
	)

Definition at line 1060 of file container.h.

template<typename C , typename T >

void absl::c_fill	(	C &	c,
		T &&	value
	)

Definition at line 608 of file container.h.

template<typename C , typename Size , typename T >

void absl::c_fill_n	(	C &	c,
		Size	n,
		T &&	value
	)

Definition at line 618 of file container.h.

template<typename C , typename T >

container_algorithm_internal::ContainerIter<C> absl::c_find	(	C &	c,
		T &&	value
	)

Definition at line 202 of file container.h.

template<typename Sequence1 , typename Sequence2 >

container_algorithm_internal::ContainerIter<Sequence1> absl::c_find_end	(	Sequence1 &	sequence,
		Sequence2 &	subsequence
	)

Definition at line 236 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >

container_algorithm_internal::ContainerIter<Sequence1> absl::c_find_end	(	Sequence1 &	sequence,
		Sequence2 &	subsequence,
		BinaryPredicate &&	pred
	)

Definition at line 247 of file container.h.

template<typename C1 , typename C2 >

container_algorithm_internal::ContainerIter<C1> absl::c_find_first_of	(	C1 &	container,
		C2 &	options
	)

Definition at line 261 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >

container_algorithm_internal::ContainerIter<C1> absl::c_find_first_of	(	C1 &	container,
		C2 &	options,
		BinaryPredicate &&	pred
	)

Definition at line 272 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerIter<C> absl::c_find_if	(	C &	c,
		Pred &&	pred
	)

Definition at line 213 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerIter<C> absl::c_find_if_not	(	C &	c,
		Pred &&	pred
	)

Definition at line 224 of file container.h.

template<typename C , typename Function >

decay_t<Function> absl::c_for_each	(	C &&	c,
		Function &&	f
	)

Definition at line 191 of file container.h.

template<typename C , typename Generator >

void absl::c_generate	(	C &	c,
		Generator &&	gen
	)

Definition at line 628 of file container.h.

template<typename C , typename Size , typename Generator >

container_algorithm_internal::ContainerIter<C> absl::c_generate_n	(	C &	c,
		Size	n,
		Generator &&	gen
	)

Definition at line 640 of file container.h.

template<typename C1 , typename C2 >

bool absl::c_includes	(	const C1 &	c1,
		const C2 &	c2
	)

Definition at line 1144 of file container.h.

template<typename C1 , typename C2 , typename Compare >

bool absl::c_includes	(	const C1 &	c1,
		const C2 &	c2,
		Compare &&	comp
	)

Definition at line 1154 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename T >

decay_t<T> absl::c_inner_product	(	const Sequence1 &	factors1,
		const Sequence2 &	factors2,
		T &&	sum
	)

Definition at line 1630 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename T , typename BinaryOp1 , typename BinaryOp2 >

decay_t<T> absl::c_inner_product	(	const Sequence1 &	factors1,
		const Sequence2 &	factors2,
		T &&	sum,
		BinaryOp1 &&	op1,
		BinaryOp2 &&	op2
	)

Definition at line 1643 of file container.h.

template<typename C >

void absl::c_inplace_merge	(	C &	c,
		container_algorithm_internal::ContainerIter< C >	middle
	)

Definition at line 1121 of file container.h.

template<typename C , typename Compare >

void absl::c_inplace_merge	(	C &	c,
		container_algorithm_internal::ContainerIter< C >	middle,
		Compare &&	comp
	)

Definition at line 1130 of file container.h.

template<typename Sequence , typename T >

void absl::c_iota	(	Sequence &	sequence,
		T &&	value
	)

Definition at line 1589 of file container.h.

template<typename RandomAccessContainer >

bool absl::c_is_heap ( const RandomAccessContainer & sequence )

Definition at line 1400 of file container.h.

template<typename RandomAccessContainer , typename Compare >

bool absl::c_is_heap	(	const RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1408 of file container.h.

template<typename RandomAccessContainer >

container_algorithm_internal::ContainerIter<RandomAccessContainer> absl::c_is_heap_until ( RandomAccessContainer & sequence )

Definition at line 1420 of file container.h.

template<typename RandomAccessContainer , typename Compare >

container_algorithm_internal::ContainerIter<RandomAccessContainer> absl::c_is_heap_until	(	RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1429 of file container.h.

template<typename C , typename Pred >

bool absl::c_is_partitioned	(	const C &	c,
		Pred &&	pred
	)

Definition at line 767 of file container.h.

template<typename C1 , typename C2 >

bool absl::c_is_permutation	(	const C1 &	c1,
		const C2 &	c2
	)

Definition at line 390 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >

bool absl::c_is_permutation	(	const C1 &	c1,
		const C2 &	c2,
		BinaryPredicate &&	pred
	)

Definition at line 400 of file container.h.

template<typename C >

bool absl::c_is_sorted ( const C & c )

Definition at line 878 of file container.h.

template<typename C , typename Compare >

bool absl::c_is_sorted	(	const C &	c,
		Compare &&	comp
	)

Definition at line 886 of file container.h.

template<typename C >

container_algorithm_internal::ContainerIter<C> absl::c_is_sorted_until ( C & c )

Definition at line 951 of file container.h.

template<typename C , typename Compare >

container_algorithm_internal::ContainerIter<C> absl::c_is_sorted_until	(	C &	c,
		Compare &&	comp
	)

Definition at line 959 of file container.h.

template<typename Sequence1 , typename Sequence2 >

bool absl::c_lexicographical_compare	(	Sequence1 &&	sequence1,
		Sequence2 &&	sequence2
	)

Definition at line 1518 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename Compare >

bool absl::c_lexicographical_compare	(	Sequence1 &&	sequence1,
		Sequence2 &&	sequence2,
		Compare &&	comp
	)

Definition at line 1529 of file container.h.

template<typename C , typename EqualityComparable >

bool absl::c_linear_search	(	const C &	c,
		EqualityComparable &&	value
	)

Definition at line 128 of file container.h.

template<typename Sequence , typename T >

container_algorithm_internal::ContainerIter<Sequence> absl::c_lower_bound	(	Sequence &	sequence,
		T &&	value
	)

Definition at line 1003 of file container.h.

template<typename Sequence , typename T , typename Compare >

container_algorithm_internal::ContainerIter<Sequence> absl::c_lower_bound	(	Sequence &	sequence,
		T &&	value,
		Compare &&	comp
	)

Definition at line 1013 of file container.h.

template<typename RandomAccessContainer >

void absl::c_make_heap ( RandomAccessContainer & sequence )

Definition at line 1362 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_make_heap	(	RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1370 of file container.h.

template<typename Sequence >

container_algorithm_internal::ContainerIter<Sequence> absl::c_max_element ( Sequence & sequence )

Definition at line 1467 of file container.h.

template<typename Sequence , typename Compare >

container_algorithm_internal::ContainerIter<Sequence> absl::c_max_element	(	Sequence &	sequence,
		Compare &&	comp
	)

Definition at line 1476 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator >

OutputIterator absl::c_merge	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	result
	)

Definition at line 1097 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare >

OutputIterator absl::c_merge	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	result,
		Compare &&	comp
	)

Definition at line 1107 of file container.h.

template<typename Sequence >

container_algorithm_internal::ContainerIter<Sequence> absl::c_min_element ( Sequence & sequence )

Definition at line 1445 of file container.h.

template<typename Sequence , typename Compare >

container_algorithm_internal::ContainerIter<Sequence> absl::c_min_element	(	Sequence &	sequence,
		Compare &&	comp
	)

Definition at line 1454 of file container.h.

template<typename C >

container_algorithm_internal::ContainerIterPairType<C, C> absl::c_minmax_element ( C & c )

Definition at line 1491 of file container.h.

template<typename C , typename Compare >

container_algorithm_internal::ContainerIterPairType<C, C> absl::c_minmax_element	(	C &	c,
		Compare &&	comp
	)

Definition at line 1500 of file container.h.

template<typename C1 , typename C2 >

container_algorithm_internal::ContainerIterPairType<C1, C2> absl::c_mismatch	(	C1 &	c1,
		C2 &	c2
	)

Definition at line 332 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >

container_algorithm_internal::ContainerIterPairType<C1, C2> absl::c_mismatch	(	C1 &	c1,
		C2 &	c2,
		BinaryPredicate &&	pred
	)

Definition at line 342 of file container.h.

template<typename C , typename OutputIterator >

OutputIterator absl::c_move	(	C &&	src,
		OutputIterator	dest
	)

Definition at line 508 of file container.h.

template<typename C >

bool absl::c_next_permutation ( C & c )

Definition at line 1545 of file container.h.

template<typename C , typename Compare >

bool absl::c_next_permutation	(	C &	c,
		Compare &&	comp
	)

Definition at line 1553 of file container.h.

template<typename C , typename Pred >

bool absl::c_none_of	(	const C &	c,
		Pred &&	pred
	)

Definition at line 180 of file container.h.

template<typename RandomAccessContainer >

void absl::c_nth_element	(	RandomAccessContainer &	sequence,
		container_algorithm_internal::ContainerIter< RandomAccessContainer >	nth
	)

Definition at line 974 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_nth_element	(	RandomAccessContainer &	sequence,
		container_algorithm_internal::ContainerIter< RandomAccessContainer >	nth,
		Compare &&	comp
	)

Definition at line 984 of file container.h.

template<typename RandomAccessContainer >

void absl::c_partial_sort	(	RandomAccessContainer &	sequence,
		container_algorithm_internal::ContainerIter< RandomAccessContainer >	middle
	)

Definition at line 898 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_partial_sort	(	RandomAccessContainer &	sequence,
		container_algorithm_internal::ContainerIter< RandomAccessContainer >	middle,
		Compare &&	comp
	)

Definition at line 908 of file container.h.

template<typename C , typename RandomAccessContainer >

container_algorithm_internal::ContainerIter<RandomAccessContainer> absl::c_partial_sort_copy	(	const C &	sequence,
		RandomAccessContainer &	result
	)

Definition at line 925 of file container.h.

template<typename C , typename RandomAccessContainer , typename Compare >

container_algorithm_internal::ContainerIter<RandomAccessContainer> absl::c_partial_sort_copy	(	const C &	sequence,
		RandomAccessContainer &	result,
		Compare &&	comp
	)

Definition at line 936 of file container.h.

template<typename InputSequence , typename OutputIt >

OutputIt absl::c_partial_sum	(	const InputSequence &	input,
		OutputIt	output_first
	)

Definition at line 1682 of file container.h.

template<typename InputSequence , typename OutputIt , typename BinaryOp >

OutputIt absl::c_partial_sum	(	const InputSequence &	input,
		OutputIt	output_first,
		BinaryOp &&	op
	)

Definition at line 1691 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerIter<C> absl::c_partition	(	C &	c,
		Pred &&	pred
	)

Definition at line 780 of file container.h.

template<typename C , typename OutputIterator1 , typename OutputIterator2 , typename Pred >

std::pair<OutputIterator1, OutputIterator2> absl::c_partition_copy	(	const C &	c,
		OutputIterator1	out_true,
		OutputIterator2	out_false,
		Pred &&	pred
	)

Definition at line 809 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerIter<C> absl::c_partition_point	(	C &	c,
		Pred &&	pred
	)

Definition at line 823 of file container.h.

template<typename RandomAccessContainer >

void absl::c_pop_heap ( RandomAccessContainer & sequence )

Definition at line 1343 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_pop_heap	(	RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1351 of file container.h.

template<typename C >

bool absl::c_prev_permutation ( C & c )

Definition at line 1565 of file container.h.

template<typename C , typename Compare >

bool absl::c_prev_permutation	(	C &	c,
		Compare &&	comp
	)

Definition at line 1573 of file container.h.

template<typename RandomAccessContainer >

void absl::c_push_heap ( RandomAccessContainer & sequence )

Definition at line 1324 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_push_heap	(	RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1332 of file container.h.

template<typename C , typename OutputIterator , typename T >

OutputIterator absl::c_remove_copy	(	const C &	c,
		OutputIterator	result,
		T &&	value
	)

Definition at line 657 of file container.h.

template<typename C , typename OutputIterator , typename Pred >

OutputIterator absl::c_remove_copy_if	(	const C &	c,
		OutputIterator	result,
		Pred &&	pred
	)

Definition at line 669 of file container.h.

template<typename Sequence , typename T >

void absl::c_replace	(	Sequence &	sequence,
		const T &	old_value,
		const T &	new_value
	)

Definition at line 557 of file container.h.

template<typename C , typename OutputIterator , typename T >

OutputIterator absl::c_replace_copy	(	const C &	c,
		OutputIterator	result,
		T &&	old_value,
		T &&	new_value
	)

Definition at line 581 of file container.h.

template<typename C , typename OutputIterator , typename Pred , typename T >

OutputIterator absl::c_replace_copy_if	(	const C &	c,
		OutputIterator	result,
		Pred &&	pred,
		T &&	new_value
	)

Definition at line 595 of file container.h.

template<typename C , typename Pred , typename T >

void absl::c_replace_if	(	C &	c,
		Pred &&	pred,
		T &&	new_value
	)

Definition at line 569 of file container.h.

template<typename Sequence >

void absl::c_reverse ( Sequence & sequence )

Definition at line 702 of file container.h.

template<typename C , typename OutputIterator >

OutputIterator absl::c_reverse_copy	(	const C &	sequence,
		OutputIterator	result
	)

Definition at line 712 of file container.h.

template<typename C , typename Iterator = container_algorithm_internal::ContainerIter<C>>

Iterator absl::c_rotate	(	C &	sequence,
		Iterator	middle
	)

Definition at line 725 of file container.h.

template<typename C , typename OutputIterator >

OutputIterator absl::c_rotate_copy	(	const C &	sequence,
		container_algorithm_internal::ContainerIter< const C >	middle,
		OutputIterator	result
	)

Definition at line 736 of file container.h.

template<typename Sequence1 , typename Sequence2 >

container_algorithm_internal::ContainerIter<Sequence1> absl::c_search	(	Sequence1 &	sequence,
		Sequence2 &	subsequence
	)

Definition at line 413 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename BinaryPredicate >

container_algorithm_internal::ContainerIter<Sequence1> absl::c_search	(	Sequence1 &	sequence,
		Sequence2 &	subsequence,
		BinaryPredicate &&	pred
	)

Definition at line 424 of file container.h.

template<typename Sequence , typename Size , typename T >

container_algorithm_internal::ContainerIter<Sequence> absl::c_search_n	(	Sequence &	sequence,
		Size	count,
		T &&	value
	)

Definition at line 438 of file container.h.

template<typename Sequence , typename Size , typename T , typename BinaryPredicate >

container_algorithm_internal::ContainerIter<Sequence> absl::c_search_n	(	Sequence &	sequence,
		Size	count,
		T &&	value,
		BinaryPredicate &&	pred
	)

Definition at line 449 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_difference	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output
	)

Definition at line 1248 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_difference	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output,
		Compare &&	comp
	)

Definition at line 1265 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_intersection	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output
	)

Definition at line 1210 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_intersection	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output,
		Compare &&	comp
	)

Definition at line 1227 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_symmetric_difference	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output
	)

Definition at line 1286 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_symmetric_difference	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output,
		Compare &&	comp
	)

Definition at line 1304 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_union	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output
	)

Definition at line 1174 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>

OutputIterator absl::c_set_union	(	const C1 &	c1,
		const C2 &	c2,
		OutputIterator	output,
		Compare &&	comp
	)

Definition at line 1190 of file container.h.

template<typename RandomAccessContainer , typename UniformRandomBitGenerator >

void absl::c_shuffle	(	RandomAccessContainer &	c,
		UniformRandomBitGenerator &&	gen
	)

Definition at line 751 of file container.h.

template<typename C >

void absl::c_sort ( C & c )

Definition at line 839 of file container.h.

template<typename C , typename Compare >

void absl::c_sort	(	C &	c,
		Compare &&	comp
	)

Definition at line 847 of file container.h.

template<typename RandomAccessContainer >

void absl::c_sort_heap ( RandomAccessContainer & sequence )

Definition at line 1381 of file container.h.

template<typename RandomAccessContainer , typename Compare >

void absl::c_sort_heap	(	RandomAccessContainer &	sequence,
		Compare &&	comp
	)

Definition at line 1389 of file container.h.

template<typename C , typename Pred >

container_algorithm_internal::ContainerIter<C> absl::c_stable_partition	(	C &	c,
		Pred &&	pred
	)

Definition at line 794 of file container.h.

template<typename C >

void absl::c_stable_sort ( C & c )

Definition at line 859 of file container.h.

template<typename C , typename Compare >

void absl::c_stable_sort	(	C &	c,
		Compare &&	comp
	)

Definition at line 867 of file container.h.

template<typename C1 , typename C2 >

container_algorithm_internal::ContainerIter<C2> absl::c_swap_ranges	(	C1 &	c1,
		C2 &	c2
	)

Definition at line 518 of file container.h.

template<typename InputSequence , typename OutputIterator , typename UnaryOp >

OutputIterator absl::c_transform	(	const InputSequence &	input,
		OutputIterator	output,
		UnaryOp &&	unary_op
	)

Definition at line 531 of file container.h.

template<typename InputSequence1 , typename InputSequence2 , typename OutputIterator , typename BinaryOp >

OutputIterator absl::c_transform	(	const InputSequence1 &	input1,
		const InputSequence2 &	input2,
		OutputIterator	output,
		BinaryOp &&	binary_op
	)

Definition at line 542 of file container.h.

template<typename C , typename OutputIterator >

OutputIterator absl::c_unique_copy	(	const C &	c,
		OutputIterator	result
	)

Definition at line 682 of file container.h.

template<typename C , typename OutputIterator , typename BinaryPredicate >

OutputIterator absl::c_unique_copy	(	const C &	c,
		OutputIterator	result,
		BinaryPredicate &&	pred
	)

Definition at line 690 of file container.h.

template<typename Sequence , typename T >

container_algorithm_internal::ContainerIter<Sequence> absl::c_upper_bound	(	Sequence &	sequence,
		T &&	value
	)

Definition at line 1026 of file container.h.

template<typename Sequence , typename T , typename Compare >

container_algorithm_internal::ContainerIter<Sequence> absl::c_upper_bound	(	Sequence &	sequence,
		T &&	value,
		Compare &&	comp
	)

Definition at line 1036 of file container.h.

template<typename Callable , typename... Args>

void absl::call_once	(	absl::once_flag &	flag,
		Callable &&	fn,
		Args &&...	args
	)

Definition at line 202 of file call_once.h.

Duration absl::Ceil	(	const Duration	d,
		const Duration	unit
	)

Definition at line 507 of file duration.cc.

std::string absl::CEscape ( absl::string_view src )

Definition at line 1039 of file escaping.cc.

static void absl::CheckForMutexCorruption	(	intptr_t	v,
		const char *	label
	)		`[static]`

Definition at line 1874 of file mutex.cc.

std::string absl::CHexEscape ( absl::string_view src )

Definition at line 1045 of file escaping.cc.

string_view absl::ClippedSubstr	(	string_view	s,
		size_t	pos,
		size_t	n = `string_view::npos`
	)		`[inline]`

Definition at line 548 of file string_view.h.

static void absl::CondVarEnqueue ( SynchWaitParams * waitp ) [static]

Definition at line 2475 of file mutex.cc.

bool absl::ConsumePrefix	(	absl::string_view *	str,
		absl::string_view	expected
	)		`[inline]`

Definition at line 44 of file strip.h.

bool absl::ConsumeSuffix	(	absl::string_view *	str,
		absl::string_view	expected
	)		`[inline]`

Definition at line 59 of file strip.h.

TimeConversion absl::ConvertDateTime	(	int64_t	year,
		int	mon,
		int	day,
		int	hour,
		int	min,
		int	sec,
		TimeZone	tz
	)

Definition at line 396 of file time.cc.

template<typename To , typename Variant >

To absl::ConvertVariantTo ( Variant && variant )

Definition at line 848 of file variant.h.

bool absl::CUnescape	(	absl::string_view	source,
		std::string *	dest
	)		`[inline]`

Definition at line 74 of file escaping.h.

bool absl::CUnescape	(	absl::string_view	source,
		std::string *	dest,
		std::string *	error
	)

Definition at line 1034 of file escaping.cc.

static char* absl::CurrentStackString	(	char *	buf,
		int	maxlen,
		bool	symbolize
	)		`[static]`

Definition at line 1275 of file mutex.cc.

static absl::Time absl::DeadlineFromTimeout ( absl::Duration timeout ) [static]

Definition at line 591 of file mutex.cc.

static GraphId absl::DeadlockCheck ( Mutex * mu ) [static]

Definition at line 1308 of file mutex.cc.

static GraphId absl::DebugOnlyDeadlockCheck ( Mutex * mu ) [inline, static]

Definition at line 1394 of file mutex.cc.

static bool absl::DebugOnlyIsExiting ( ) [static]

Definition at line 709 of file mutex.cc.

static void absl::DebugOnlyLockEnter ( Mutex * mu ) [inline, static]

Definition at line 1225 of file mutex.cc.

static void absl::DebugOnlyLockEnter	(	Mutex *	mu,
		GraphId	id
	)		`[inline, static]`

Definition at line 1235 of file mutex.cc.

static void absl::DebugOnlyLockLeave ( Mutex * mu ) [inline, static]

Definition at line 1245 of file mutex.cc.

int absl::DefaultStackUnwinder	(	void **	pcs,
		int *	sizes,
		int	depth,
		int	skip,
		const void *	uc,
		int *	min_dropped_frames
	)

Definition at line 115 of file stacktrace.cc.

static int absl::Delay	(	int32_t	c,
		DelayMode	mode
	)		`[static]`

Definition at line 146 of file mutex.cc.

static void absl::DeleteSynchEvent ( SynchEvent * e ) [static]

Definition at line 343 of file mutex.cc.

static PerThreadSynch* absl::Dequeue	(	PerThreadSynch *	head,
		PerThreadSynch *	pw
	)		`[static]`

Definition at line 992 of file mutex.cc.

static PerThreadSynch* absl::DequeueAllWakeable	(	PerThreadSynch *	head,
		PerThreadSynch *	pw,
		PerThreadSynch **	wake_tail
	)		`[static]`

Definition at line 1015 of file mutex.cc.

static bool absl::Dereference ( void * arg ) [static]

Definition at line 283 of file mutex_nonprod.cc.

template<typename Formatter >

strings_internal::DereferenceFormatterImpl<Formatter> absl::DereferenceFormatter ( Formatter && f )

Definition at line 140 of file str_join.h.

strings_internal::DereferenceFormatterImpl< strings_internal::AlphaNumFormatterImpl> absl::DereferenceFormatter ( ) [inline]

Definition at line 150 of file str_join.h.

void absl::DoIgnoreLeak ( const void * )

Definition at line 25 of file leak_check.cc.

Duration absl::DurationFromTimespec ( timespec ts )

Definition at line 516 of file duration.cc.

Duration absl::DurationFromTimeval ( timeval tv )

Definition at line 524 of file duration.cc.

void absl::EnableMutexInvariantDebugging ( bool enabled )

Definition at line 730 of file mutex.cc.

bool absl::EndsWith	(	absl::string_view	text,
		absl::string_view	suffix
	)		`[inline]`

Definition at line 61 of file match.h.

bool absl::EndsWithIgnoreCase	(	absl::string_view	text,
		absl::string_view	suffix
	)

Definition at line 33 of file match.cc.

static PerThreadSynch* absl::Enqueue	(	PerThreadSynch *	head,
		SynchWaitParams *	waitp,
		intptr_t	mu,
		int	flags
	)		`[static]`

Definition at line 869 of file mutex.cc.

static SynchEvent* absl::EnsureSynchEvent	(	std::atomic< intptr_t > *	addr,
		const char *	name,
		intptr_t	bits,
		intptr_t	lockbit
	)		`[static]`

Definition at line 308 of file mutex.cc.

template<typename InputIter1 , typename InputIter2 , typename Pred >

bool absl::equal	(	InputIter1	first1,
		InputIter1	last1,
		InputIter2	first2,
		InputIter2	last2,
		Pred &&	pred
	)

Definition at line 99 of file algorithm.h.

template<typename InputIter1 , typename InputIter2 >

bool absl::equal	(	InputIter1	first1,
		InputIter1	last1,
		InputIter2	first2,
		InputIter2	last2
	)

Definition at line 110 of file algorithm.h.

bool absl::EqualsIgnoreCase	(	absl::string_view	piece1,
		absl::string_view	piece2
	)

Definition at line 21 of file match.cc.

static bool absl::EvalConditionAnnotated	(	const Condition *	cond,
		Mutex *	mu,
		bool	locking,
		bool	trylock,
		bool	read_lock
	)		`[inline, static]`

Definition at line 1757 of file mutex.cc.

static bool absl::EvalConditionIgnored	(	Mutex *	mu,
		const Condition *	cond
	)		`[inline, static]`

Definition at line 1807 of file mutex.cc.

static bool absl::ExactlyOneReader ( intptr_t v ) [static]

Definition at line 1702 of file mutex.cc.

static ABSL_CONST_INIT std::atomic<GetTidType> absl::failed_tid ( 0 ) [static]

double absl::FDivDuration	(	Duration	num,
		Duration	den
	)

Definition at line 476 of file duration.cc.

TimeZone absl::FixedTimeZone ( int seconds ) [inline]

Definition at line 1018 of file time.h.

static void absl::FixSkip	(	PerThreadSynch *	ancestor,
		PerThreadSynch *	to_be_removed
	)		`[static]`

Definition at line 836 of file mutex.cc.

Duration absl::Floor	(	const Duration	d,
		const Duration	unit
	)

Definition at line 502 of file duration.cc.

static void absl::ForgetSynchEvent	(	std::atomic< intptr_t > *	addr,
		intptr_t	bits,
		intptr_t	lockbit
	)		`[static]`

Definition at line 362 of file mutex.cc.

template<typename... Args>

bool absl::Format	(	FormatRawSink	raw_sink,
		const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 454 of file str_format.h.

std::string absl::FormatCivilTime ( CivilSecond c )

Definition at line 47 of file civil_time.cc.

std::string absl::FormatCivilTime ( CivilMinute c )

Definition at line 50 of file civil_time.cc.

std::string absl::FormatCivilTime ( CivilHour c )

Definition at line 53 of file civil_time.cc.

std::string absl::FormatCivilTime ( CivilDay c )

Definition at line 56 of file civil_time.cc.

std::string absl::FormatCivilTime ( CivilMonth c )

Definition at line 57 of file civil_time.cc.

std::string absl::FormatCivilTime ( CivilYear c )

Definition at line 58 of file civil_time.cc.

std::string absl::FormatDuration ( Duration d )

Definition at line 758 of file duration.cc.

template<typename T >

str_format_internal::StreamedWrapper<T> absl::FormatStreamed ( const T & v )

Definition at line 122 of file str_format.h.

std::string absl::FormatTime	(	const std::string &	format,
		absl::Time	t,
		absl::TimeZone	tz
	)

Definition at line 70 of file format.cc.

std::string absl::FormatTime	(	absl::Time	t,
		absl::TimeZone	tz
	)

Definition at line 79 of file format.cc.

std::string absl::FormatTime ( absl::Time t )

Definition at line 83 of file format.cc.

ABSL_MUST_USE_RESULT bool absl::FormatUntyped	(	FormatRawSink	raw_sink,
		const UntypedFormatSpec &	format,
		absl::Span< const FormatArg >	args
	)		`[inline]`

Definition at line 512 of file str_format.h.

template<typename T >

constexpr T&& absl::forward ( absl::remove_reference_t< T > & t )

Definition at line 228 of file utility.h.

template<typename... Args>

int absl::FPrintF	(	std::FILE *	output,
		const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 383 of file str_format.h.

absl::from_chars_result absl::from_chars	(	const char *	first,
		const char *	last,
		double &	value,
		chars_format	fmt
	)

Definition at line 679 of file charconv.cc.

absl::from_chars_result absl::from_chars	(	const char *	first,
		const char *	last,
		float &	value,
		chars_format	fmt
	)

Definition at line 684 of file charconv.cc.

Time absl::FromChrono ( const std::chrono::system_clock::time_point & tp )

Definition at line 328 of file time.cc.

constexpr Duration absl::FromChrono ( const std::chrono::nanoseconds & d )

Definition at line 1518 of file time.h.

constexpr Duration absl::FromChrono ( const std::chrono::microseconds & d )

Definition at line 1521 of file time.h.

constexpr Duration absl::FromChrono ( const std::chrono::milliseconds & d )

Definition at line 1524 of file time.h.

constexpr Duration absl::FromChrono ( const std::chrono::seconds & d )

Definition at line 1527 of file time.h.

constexpr Duration absl::FromChrono ( const std::chrono::minutes & d )

Definition at line 1530 of file time.h.

constexpr Duration absl::FromChrono ( const std::chrono::hours & d )

Definition at line 1533 of file time.h.

Time absl::FromCivil	(	CivilSecond	ct,
		TimeZone	tz
	)		`[inline]`

Definition at line 1085 of file time.h.

Time absl::FromDateTime	(	int64_t	year,
		int	mon,
		int	day,
		int	hour,
		int	min,
		int	sec,
		TimeZone	tz
	)		`[inline]`

Definition at line 1152 of file time.h.

constexpr Time absl::FromTimeT ( time_t t )

Definition at line 1553 of file time.h.

Time absl::FromTM	(	const struct tm &	tm,
		absl::TimeZone	tz
	)

Definition at line 428 of file time.cc.

Time absl::FromUDate ( double udate )

Definition at line 229 of file time.cc.

Time absl::FromUniversal ( int64_t universal )

Definition at line 233 of file time.cc.

constexpr Time absl::FromUnixMicros ( int64_t us )

Definition at line 1541 of file time.h.

constexpr Time absl::FromUnixMillis ( int64_t ms )

Definition at line 1545 of file time.h.

constexpr Time absl::FromUnixNanos ( int64_t ns )

Definition at line 1537 of file time.h.

constexpr Time absl::FromUnixSeconds ( int64_t s )

Definition at line 1549 of file time.h.

uint16_t absl::gbswap_16 ( uint16_t host_int ) [inline]

Definition at line 107 of file endian.h.

uint32_t absl::gbswap_32 ( uint32_t host_int ) [inline]

Definition at line 96 of file endian.h.

uint64_t absl::gbswap_64 ( uint64_t host_int ) [inline]

Definition at line 72 of file endian.h.

template<class T , class... Types>

constexpr variant_alternative_t< I, variant< Types...> > & absl::get ( variant< Types...> & v )

Definition at line 297 of file variant.h.

template<class T , class... Types>

constexpr variant_alternative_t< I, variant< Types...> > && absl::get ( variant< Types...> && v )

Definition at line 305 of file variant.h.

template<class T , class... Types>

constexpr const variant_alternative_t< I, variant< Types...> > & absl::get ( const variant< Types...> & v )

Definition at line 312 of file variant.h.

template<class T , class... Types>

constexpr const variant_alternative_t< I, variant< Types...> > && absl::get ( const variant< Types...> && v )

Definition at line 320 of file variant.h.

template<std::size_t I, class... Types>

constexpr absl::add_pointer_t< T > absl::get_if ( variant< Types...> * v )

Definition at line 369 of file variant.h.

template<std::size_t I, class... Types>

constexpr absl::add_pointer_t< const T > absl::get_if ( const variant< Types...> * v )

Definition at line 380 of file variant.h.

int64_t absl::GetCurrentTimeNanos ( )

Definition at line 74 of file clock.cc.

template<typename T >

T absl::GetFlag ( const absl::Flag< T > & flag )

Definition at line 86 of file flag.h.

static GraphId absl::GetGraphId ( Mutex * mu ) [static]

Definition at line 1155 of file mutex.cc.

static GraphId absl::GetGraphIdLocked ( Mutex * mu ) [static]

Definition at line 1145 of file mutex.cc.

static PerThreadSynch* absl::GetPerThreadSynch ( intptr_t v ) [inline, static]

Definition at line 759 of file mutex.cc.

int absl::GetStackFrames	(	void **	result,
		int *	sizes,
		int	max_depth,
		int	skip_count
	)

Definition at line 84 of file stacktrace.cc.

int absl::GetStackFramesWithContext	(	void **	result,
		int *	sizes,
		int	max_depth,
		int	skip_count,
		const void *	uc,
		int *	min_dropped_frames
	)

Definition at line 91 of file stacktrace.cc.

int absl::GetStackTrace	(	void **	result,
		int	max_depth,
		int	skip_count
	)

Definition at line 98 of file stacktrace.cc.

int absl::GetStackTraceWithContext	(	void **	result,
		int	max_depth,
		int	skip_count,
		const void *	uc,
		int *	min_dropped_frames
	)

Definition at line 105 of file stacktrace.cc.

static SynchEvent* absl::GetSynchEvent ( const void * addr ) [static]

Definition at line 387 of file mutex.cc.

Weekday absl::GetWeekday ( CivilDay cd ) [inline]

Definition at line 380 of file civil_time.h.

int absl::GetYearDay ( CivilDay cd ) [inline]

Definition at line 432 of file civil_time.h.

uint32_t absl::gntohl ( uint32_t x ) [inline]

Definition at line 146 of file endian.h.

uint64_t absl::gntohll ( uint64_t x ) [inline]

Definition at line 147 of file endian.h.

uint16_t absl::gntohs ( uint16_t x ) [inline]

Definition at line 145 of file endian.h.

static GraphCycles* deadlock_graph absl::GUARDED_BY ( deadlock_graph_mu ) [static]

static struct absl::SynchEvent absl::GUARDED_BY ( synch_event_mu ) [static]

static bool absl::HasBeenNotifiedInternal ( const std::atomic< bool > * notified_yet ) [inline, static]

Definition at line 47 of file notification.cc.

bool absl::HaveLeakSanitizer ( )

Definition at line 24 of file leak_check.cc.

std::string absl::HexStringToBytes ( absl::string_view from )

Definition at line 1113 of file escaping.cc.

template<class T , class... Types>

constexpr bool absl::holds_alternative ( const variant< Types...> & v )

Definition at line 261 of file variant.h.

constexpr Duration absl::Hours ( int64_t n )

Definition at line 1467 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Hours ( T n )

Definition at line 428 of file time.h.

int64_t absl::IDivDuration	(	Duration	num,
		Duration	den,
		Duration *	rem
	)		`[inline]`

Definition at line 263 of file time.h.

template<typename T >

T* absl::IgnoreLeak ( T * ptr )

Definition at line 65 of file leak_check.h.

template<typename To >

constexpr To absl::implicit_cast ( typename absl::internal::identity_t< To > to )

Definition at line 101 of file casts.h.

template<size_t I>

void absl::in_place_index ( utility_internal::InPlaceIndexTag< I > )

Definition at line 209 of file utility.h.

template<typename T >

void absl::in_place_type ( utility_internal::InPlaceTypeTag< T > )

Definition at line 192 of file utility.h.

constexpr Duration absl::InfiniteDuration ( )

Definition at line 1513 of file time.h.

constexpr Time absl::InfiniteFuture ( )

Definition at line 701 of file time.h.

constexpr Time absl::InfinitePast ( )

Definition at line 709 of file time.h.

void absl::InitializeSymbolizer ( const char * argv0 )

void absl::InstallFailureSignalHandler ( const FailureSignalHandlerOptions & options )

Definition at line 352 of file failure_signal_handler.cc.

static void absl::InstallOneFailureHandler	(	FailureSignalData *	data,
		void()(int, siginfo_t , void *)	handler
	)		`[static]`

Definition at line 179 of file failure_signal_handler.cc.

static bool absl::IsZero ( void * arg ) [static]

Definition at line 23 of file barrier.cc.

template<typename InputIterator , typename EqualityComparable >

bool absl::linear_search	(	InputIterator	first,
		InputIterator	last,
		const EqualityComparable &	value
	)

Definition at line 124 of file algorithm.h.

bool absl::LoadTimeZone	(	const std::string &	name,
		TimeZone *	tz
	)		`[inline]`

Definition at line 1002 of file time.h.

TimeZone absl::LocalTimeZone ( ) [inline]

Definition at line 1036 of file time.h.

static void absl::LockEnter	(	Mutex *	mu,
		GraphId	id,
		SynchLocksHeld *	held_locks
	)		`[static]`

Definition at line 1165 of file mutex.cc.

static void absl::LockLeave	(	Mutex *	mu,
		GraphId	id,
		SynchLocksHeld *	held_locks
	)		`[static]`

Definition at line 1189 of file mutex.cc.

static SynchLocksHeld* absl::LocksHeldAlloc ( ) [static]

Definition at line 511 of file mutex.cc.

constexpr std::array<absl::LogSeverity, 4> absl::LogSeverities ( )

Definition at line 37 of file log_severity.h.

constexpr const char* absl::LogSeverityName ( absl::LogSeverity s )

Definition at line 44 of file log_severity.h.

template<typename T , typename... Args>

any absl::make_any ( Args &&... args )

Definition at line 467 of file any.h.

template<typename T , typename U , typename... Args>

any absl::make_any	(	std::initializer_list< U >	il,
		Args &&...	args
	)

Definition at line 473 of file any.h.

template<typename T >

constexpr optional<typename std::decay<T>::type> absl::make_optional ( T && v )

Definition at line 566 of file optional.h.

template<typename T , typename... Args>

constexpr optional<T> absl::make_optional ( Args &&... args )

Definition at line 571 of file optional.h.

template<typename T , typename U , typename... Args>

constexpr optional<T> absl::make_optional	(	std::initializer_list< U >	il,
		Args &&...	args
	)

Definition at line 576 of file optional.h.

template<typename T , typename... Args>

memory_internal::MakeUniqueResult<T>::scalar absl::make_unique ( Args &&... args )

Definition at line 166 of file memory.h.

template<typename T >

memory_internal::MakeUniqueResult<T>::array absl::make_unique ( size_t n )

Definition at line 176 of file memory.h.

template<typename T , typename... Args>

memory_internal::MakeUniqueResult<T>::invalid absl::make_unique ( Args && ... )

template<int &... ExplicitArgumentBarrier, typename T >

constexpr Span<const T> absl::MakeConstSpan	(	T *	ptr,
		size_t	size
	)

Definition at line 692 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >

Span<const T> absl::MakeConstSpan	(	T *	begin,
		T *	end
	)

Definition at line 697 of file span.h.

template<int &... ExplicitArgumentBarrier, typename C >

constexpr auto absl::MakeConstSpan ( const C & c )

Definition at line 702 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T , size_t N>

constexpr Span<const T> absl::MakeConstSpan ( const T(&) array[N] )

Definition at line 707 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >

constexpr Span<T> absl::MakeSpan	(	T *	ptr,
		size_t	size
	)

Definition at line 647 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >

Span<T> absl::MakeSpan	(	T *	begin,
		T *	end
	)

Definition at line 652 of file span.h.

template<int &... ExplicitArgumentBarrier, typename C >

constexpr auto absl::MakeSpan ( C & c )

Definition at line 657 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T , size_t N>

constexpr Span<T> absl::MakeSpan ( T(&) array[N] )

Definition at line 663 of file span.h.

constexpr uint128 absl::MakeUint128	(	uint64_t	high,
		uint64_t	low
	)

Definition at line 301 of file int128.h.

template<typename Delimiter >

strings_internal::MaxSplitsImpl< typename strings_internal::SelectDelimiter<Delimiter>::type> absl::MaxSplits	(	Delimiter	delimiter,
		int	limit
	)		`[inline]`

Definition at line 292 of file str_split.h.

static int absl::MaybeSetupAlternateStack ( ) [static]

Definition at line 170 of file failure_signal_handler.cc.

constexpr Duration absl::Microseconds ( int64_t n )

Definition at line 1455 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Microseconds ( T n )

Definition at line 404 of file time.h.

constexpr Duration absl::Milliseconds ( int64_t n )

Definition at line 1458 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Milliseconds ( T n )

Definition at line 408 of file time.h.

constexpr Duration absl::Minutes ( int64_t n )

Definition at line 1464 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Minutes ( T n )

Definition at line 424 of file time.h.

template<typename T >

constexpr absl::remove_reference_t<T>&& absl::move ( T && t )

Definition at line 219 of file utility.h.

static std::pair<uint64_t, uint64_t> absl::Mul32	(	std::pair< uint64_t, uint64_t >	num,
		uint32_t	mul
	)		`[static]`

Definition at line 306 of file numbers.cc.

static bool absl::MuSameCondition	(	PerThreadSynch *	x,
		PerThreadSynch *	y
	)		`[static]`

Definition at line 752 of file mutex.cc.

constexpr Duration absl::Nanoseconds ( int64_t n )

Definition at line 1452 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Nanoseconds ( T n )

Definition at line 400 of file time.h.

CivilDay absl::NextWeekday	(	CivilDay	cd,
		Weekday	wd
	)		`[inline]`

Definition at line 414 of file civil_time.h.

constexpr absl::LogSeverity absl::NormalizeLogSeverity ( absl::LogSeverity s )

Definition at line 56 of file log_severity.h.

constexpr absl::LogSeverity absl::NormalizeLogSeverity ( int s )

Definition at line 61 of file log_severity.h.

absl::Time absl::Now ( )

Definition at line 37 of file clock.cc.

string_view absl::NullSafeStringView ( const char * p ) [inline]

Definition at line 559 of file string_view.h.

bool absl::operator! ( uint128 val ) [inline]

Definition at line 580 of file int128.h.

constexpr bool absl::operator!=	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 209 of file time.h.

constexpr bool absl::operator!=	(	monostate	,
		monostate
	)

Definition at line 450 of file variant.h.

template<typename T >

bool absl::operator!=	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 482 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator!=	(	const U &	a,
		Span< T >	b
	)

Definition at line 496 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator!=	(	Span< T >	a,
		const U &	b
	)

Definition at line 502 of file span.h.

bool absl::operator!=	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 515 of file string_view.h.

bool absl::operator!=	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 543 of file int128.h.

template<typename T , typename U >

constexpr auto absl::operator!=	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 608 of file optional.h.

template<typename T >

constexpr bool absl::operator!=	(	const optional< T > &	x,
		nullopt_t
	)

Definition at line 651 of file optional.h.

template<typename T >

constexpr bool absl::operator!=	(	nullopt_t	,
		const optional< T > &	x
	)

Definition at line 655 of file optional.h.

constexpr bool absl::operator!=	(	Time	lhs,
		Time	rhs
	)

Definition at line 675 of file time.h.

template<typename T , typename U >

constexpr auto absl::operator!=	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 707 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator!=	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 712 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveNotEqualT<Types...> absl::operator!=	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 748 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator!=	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1239 of file inlined_vector.h.

uint128 absl::operator%	(	uint128	lhs,
		uint128	rhs
	)

Definition at line 165 of file int128.cc.

Duration absl::operator%	(	Duration	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 233 of file time.h.

constexpr chars_format absl::operator&	(	chars_format	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 85 of file charconv.h.

uint128 absl::operator&	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 595 of file int128.h.

chars_format& absl::operator&=	(	chars_format &	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 100 of file charconv.h.

template<typename T >

Duration absl::operator*	(	Duration	lhs,
		T	rhs
	)

Definition at line 218 of file time.h.

template<typename T >

Duration absl::operator*	(	T	lhs,
		Duration	rhs
	)

Definition at line 222 of file time.h.

uint128 absl::operator*	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 671 of file int128.h.

Duration absl::operator+	(	Duration	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 213 of file time.h.

uint128 absl::operator+	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 653 of file int128.h.

Time absl::operator+	(	Time	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 678 of file time.h.

Time absl::operator+	(	Duration	lhs,
		Time	rhs
	)		`[inline]`

Definition at line 679 of file time.h.

constexpr Duration absl::operator- ( Duration d )

Definition at line 1487 of file time.h.

Duration absl::operator-	(	Duration	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 214 of file time.h.

uint128 absl::operator-	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 662 of file int128.h.

uint128 absl::operator- ( uint128 val ) [inline]

Definition at line 573 of file int128.h.

Time absl::operator-	(	Time	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 680 of file time.h.

Duration absl::operator-	(	Time	lhs,
		Time	rhs
	)		`[inline]`

Definition at line 681 of file time.h.

uint128 absl::operator/	(	uint128	lhs,
		uint128	rhs
	)

Definition at line 154 of file int128.cc.

template<typename T >

Duration absl::operator/	(	Duration	lhs,
		T	rhs
	)

Definition at line 226 of file time.h.

int64_t absl::operator/	(	Duration	lhs,
		Duration	rhs
	)		`[inline]`

Definition at line 229 of file time.h.

constexpr bool absl::operator<	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 1471 of file time.h.

constexpr bool absl::operator<	(	monostate	,
		monostate
	)

Definition at line 445 of file variant.h.

template<typename T >

bool absl::operator<	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 508 of file span.h.

bool absl::operator<	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 519 of file string_view.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator<	(	const U &	a,
		Span< T >	b
	)

Definition at line 522 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator<	(	Span< T >	a,
		const U &	b
	)

Definition at line 528 of file span.h.

bool absl::operator<	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 547 of file int128.h.

template<typename T , typename U >

constexpr auto absl::operator<	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 617 of file optional.h.

template<typename T >

constexpr bool absl::operator<	(	const optional< T > &	,
		nullopt_t
	)

Definition at line 659 of file optional.h.

template<typename T >

constexpr bool absl::operator<	(	nullopt_t	,
		const optional< T > &	x
	)

Definition at line 663 of file optional.h.

constexpr bool absl::operator<	(	Time	lhs,
		Time	rhs
	)

Definition at line 670 of file time.h.

template<typename T , typename U >

constexpr auto absl::operator<	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 717 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator<	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 722 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveLessThanT<Types...> absl::operator<	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 757 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator<	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1249 of file inlined_vector.h.

std::ostream & absl::operator<<	(	std::ostream &	os,
		absl::LogSeverity	s
	)

Definition at line 21 of file log_severity.cc.

std::ostream & absl::operator<<	(	std::ostream &	o,
		string_view	piece
	)

Definition at line 59 of file string_view.cc.

std::ostream & absl::operator<<	(	std::ostream &	os,
		uint128	v
	)

Definition at line 225 of file int128.cc.

uint128 absl::operator<<	(	uint128	lhs,
		int	amount
	)		`[inline]`

Definition at line 625 of file int128.h.

std::ostream& absl::operator<<	(	std::ostream &	os,
		Duration	d
	)		`[inline]`

Definition at line 523 of file time.h.

std::ostream& absl::operator<<	(	std::ostream &	os,
		Time	t
	)		`[inline]`

Definition at line 1239 of file time.h.

constexpr bool absl::operator<=	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 207 of file time.h.

constexpr bool absl::operator<=	(	monostate	,
		monostate
	)

Definition at line 447 of file variant.h.

bool absl::operator<=	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 527 of file string_view.h.

bool absl::operator<=	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 559 of file int128.h.

template<typename T >

bool absl::operator<=	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 560 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator<=	(	const U &	a,
		Span< T >	b
	)

Definition at line 574 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator<=	(	Span< T >	a,
		const U &	b
	)

Definition at line 580 of file span.h.

template<typename T , typename U >

constexpr auto absl::operator<=	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 629 of file optional.h.

template<typename T >

constexpr bool absl::operator<=	(	const optional< T > &	x,
		nullopt_t
	)

Definition at line 667 of file optional.h.

template<typename T >

constexpr bool absl::operator<=	(	nullopt_t	,
		const optional< T > &
	)

Definition at line 671 of file optional.h.

constexpr bool absl::operator<=	(	Time	lhs,
		Time	rhs
	)

Definition at line 673 of file time.h.

template<typename T , typename U >

constexpr auto absl::operator<=	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 727 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator<=	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 732 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> absl::operator<=	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 778 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator<=	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1274 of file inlined_vector.h.

constexpr bool absl::operator==	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 1482 of file time.h.

constexpr bool absl::operator==	(	monostate	,
		monostate
	)

Definition at line 449 of file variant.h.

template<typename T >

bool absl::operator==	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 456 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator==	(	const U &	a,
		Span< T >	b
	)

Definition at line 470 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator==	(	Span< T >	a,
		const U &	b
	)

Definition at line 476 of file span.h.

bool absl::operator==	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 505 of file string_view.h.

bool absl::operator==	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 538 of file int128.h.

template<typename T , typename U >

constexpr auto absl::operator==	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 597 of file optional.h.

template<typename T >

constexpr bool absl::operator==	(	const optional< T > &	x,
		nullopt_t
	)

Definition at line 643 of file optional.h.

template<typename T >

constexpr bool absl::operator==	(	nullopt_t	,
		const optional< T > &	x
	)

Definition at line 647 of file optional.h.

constexpr bool absl::operator==	(	Time	lhs,
		Time	rhs
	)

Definition at line 674 of file time.h.

template<typename T , typename U >

constexpr auto absl::operator==	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 697 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator==	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 702 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveEqualT<Types...> absl::operator==	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 739 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator==	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1226 of file inlined_vector.h.

constexpr bool absl::operator>	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 205 of file time.h.

constexpr bool absl::operator>	(	monostate	,
		monostate
	)

Definition at line 446 of file variant.h.

bool absl::operator>	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 525 of file string_view.h.

template<typename T >

bool absl::operator>	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 534 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator>	(	const U &	a,
		Span< T >	b
	)

Definition at line 548 of file span.h.

bool absl::operator>	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 553 of file int128.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator>	(	Span< T >	a,
		const U &	b
	)

Definition at line 554 of file span.h.

template<typename T , typename U >

constexpr auto absl::operator>	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 623 of file optional.h.

constexpr bool absl::operator>	(	Time	lhs,
		Time	rhs
	)

Definition at line 671 of file time.h.

template<typename T >

constexpr bool absl::operator>	(	const optional< T > &	x,
		nullopt_t
	)

Definition at line 675 of file optional.h.

template<typename T >

constexpr bool absl::operator>	(	nullopt_t	,
		const optional< T > &
	)

Definition at line 679 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator>	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 737 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator>	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 742 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> absl::operator>	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 767 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator>	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1264 of file inlined_vector.h.

constexpr bool absl::operator>=	(	Duration	lhs,
		Duration	rhs
	)

Definition at line 206 of file time.h.

constexpr bool absl::operator>=	(	monostate	,
		monostate
	)

Definition at line 448 of file variant.h.

bool absl::operator>=	(	string_view	x,
		string_view	y
	)		`[inline]`

Definition at line 531 of file string_view.h.

bool absl::operator>=	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 565 of file int128.h.

template<typename T >

bool absl::operator>=	(	Span< T >	a,
		Span< T >	b
	)

Definition at line 586 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator>=	(	const U &	a,
		Span< T >	b
	)

Definition at line 600 of file span.h.

template<typename T , typename U , typename = span_internal::EnableIfConvertibleTo<U, absl::Span<const T>>>

bool absl::operator>=	(	Span< T >	a,
		const U &	b
	)

Definition at line 606 of file span.h.

template<typename T , typename U >

constexpr auto absl::operator>=	(	const optional< T > &	x,
		const optional< U > &	y
	)

Definition at line 635 of file optional.h.

constexpr bool absl::operator>=	(	Time	lhs,
		Time	rhs
	)

Definition at line 672 of file time.h.

template<typename T >

constexpr bool absl::operator>=	(	const optional< T > &	,
		nullopt_t
	)

Definition at line 683 of file optional.h.

template<typename T >

constexpr bool absl::operator>=	(	nullopt_t	,
		const optional< T > &	x
	)

Definition at line 687 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator>=	(	const optional< T > &	x,
		const U &	v
	)

Definition at line 747 of file optional.h.

template<typename T , typename U >

constexpr auto absl::operator>=	(	const U &	v,
		const optional< T > &	x
	)

Definition at line 752 of file optional.h.

template<typename... Types>

constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...> absl::operator>=	(	const variant< Types...> &	a,
		const variant< Types...> &	b
	)

Definition at line 790 of file variant.h.

template<typename T , size_t N, typename A >

bool absl::operator>=	(	const absl::InlinedVector< T, N, A > &	a,
		const absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1284 of file inlined_vector.h.

uint128 absl::operator>>	(	uint128	lhs,
		int	amount
	)		`[inline]`

Definition at line 639 of file int128.h.

constexpr chars_format absl::operator^	(	chars_format	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 93 of file charconv.h.

uint128 absl::operator^	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 600 of file int128.h.

chars_format& absl::operator^=	(	chars_format &	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 108 of file charconv.h.

constexpr chars_format absl::operator\|	(	chars_format	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 89 of file charconv.h.

uint128 absl::operator\|	(	uint128	lhs,
		uint128	rhs
	)		`[inline]`

Definition at line 590 of file int128.h.

chars_format& absl::operator\|=	(	chars_format &	lhs,
		chars_format	rhs
	)		`[inline]`

Definition at line 104 of file charconv.h.

constexpr chars_format absl::operator~ ( chars_format arg ) [inline]

Definition at line 97 of file charconv.h.

uint128 absl::operator~ ( uint128 val ) [inline]

Definition at line 586 of file int128.h.

template<typename FirstFormatter , typename SecondFormatter >

strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter> absl::PairFormatter	(	FirstFormatter	f1,
		absl::string_view	sep,
		SecondFormatter	f2
	)		`[inline]`

Definition at line 119 of file str_join.h.

strings_internal::PairFormatterImpl< strings_internal::AlphaNumFormatterImpl, strings_internal::AlphaNumFormatterImpl> absl::PairFormatter ( absl::string_view sep ) [inline]

Definition at line 129 of file str_join.h.

std::vector< char * > absl::ParseCommandLine	(	int	argc,
		char *	argv[]
	)

Definition at line 755 of file parse.cc.

bool absl::ParseDuration	(	const std::string &	dur_string,
		Duration *	d
	)

Definition at line 863 of file duration.cc.

bool absl::ParseFlag	(	const std::string &	text,
		absl::Time *	t,
		std::string *	error
	)

Definition at line 132 of file format.cc.

template<typename T >

bool absl::ParseFlag	(	absl::string_view	input,
		T *	dst,
		std::string *	error
	)		`[inline]`

Definition at line 240 of file marshalling.h.

bool absl::ParseFlag	(	const std::string &	text,
		Duration *	dst,
		std::string *
	)

Definition at line 905 of file duration.cc.

bool absl::ParseTime	(	const std::string &	format,
		const std::string &	input,
		absl::Time *	time,
		std::string *	err
	)

Definition at line 87 of file format.cc.

bool absl::ParseTime	(	const std::string &	format,
		const std::string &	input,
		absl::TimeZone	tz,
		absl::Time *	time,
		std::string *	err
	)

Definition at line 94 of file format.cc.

static void absl::PortableSleepForSeconds ( int seconds ) [static]

Definition at line 273 of file failure_signal_handler.cc.

static void absl::PostSynchEvent	(	void *	obj,
		int	ev
	)		`[static]`

Definition at line 404 of file mutex.cc.

static std::pair<uint64_t, uint64_t> absl::PowFive	(	uint64_t	num,
		int	expfive
	)		`[static]`

Definition at line 349 of file numbers.cc.

CivilDay absl::PrevWeekday	(	CivilDay	cd,
		Weekday	wd
	)		`[inline]`

Definition at line 417 of file civil_time.h.

template<typename... Args>

int absl::PrintF	(	const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 363 of file str_format.h.

static void absl::RaiseToDefaultHandler ( int signo ) [static]

Definition at line 55 of file failure_signal_handler.cc.

static void absl::RaiseToPreviousHandler ( int signo ) [static]

Definition at line 88 of file failure_signal_handler.cc.

template<typename T >

auto absl::RawPtr ( T && ptr )

Definition at line 195 of file memory.h.

std::nullptr_t absl::RawPtr ( std::nullptr_t ) [inline]

Definition at line 199 of file memory.h.

void absl::RegisterCondVarTracer ( void(*)(const char *msg, const void *cv) fn )

Definition at line 134 of file mutex.cc.

void absl::RegisterLivePointers	(	const void *	,
		size_t
	)

Definition at line 26 of file leak_check.cc.

void absl::RegisterMutexProfiler ( void(*)(int64_t wait_timestamp) fn )

Definition at line 125 of file mutex.cc.

void absl::RegisterMutexTracer ( void(*)(const char *msg, const void *obj, int64_t wait_cycles) fn )

Definition at line 129 of file mutex.cc.

void absl::RegisterSymbolizer ( bool(*)(const void *pc, char *out, int out_size) fn )

Definition at line 138 of file mutex.cc.

void absl::RegisterSymbolizer ( bool(*)(const void *, char *, int) )

Definition at line 316 of file mutex_nonprod.cc.

void absl::RemoveExtraAsciiWhitespace ( std::string * str )

Definition at line 169 of file ascii.cc.

template<typename ForwardIterator >

ForwardIterator absl::rotate	(	ForwardIterator	first,
		ForwardIterator	middle,
		ForwardIterator	last
	)

Definition at line 140 of file algorithm.h.

static void absl::RunWorker	(	int	i,
		ThreadSafeCounter *	ready_counter,
		Notification *	notification,
		ThreadSafeCounter *	done_counter
	)		`[static]`

Definition at line 54 of file notification_test.cc.

constexpr Duration absl::Seconds ( int64_t n )

Definition at line 1461 of file time.h.

template<typename T , time_internal::EnableIfFloat< T > = 0>

Duration absl::Seconds ( T n )

Definition at line 412 of file time.h.

template<typename T >

void absl::SetFlag	(	absl::Flag< T > *	flag,
		const T &	v
	)

Definition at line 134 of file flag.h.

template<typename T , typename V >

void absl::SetFlag	(	absl::Flag< T > *	flag,
		const V &	v
	)

Definition at line 142 of file flag.h.

void absl::SetFlagsUsageConfig ( FlagsUsageConfig usage_config )

Definition at line 126 of file usage_config.cc.

void absl::SetMutexDeadlockDetectionMode ( OnDeadlockCycle mode )

Definition at line 745 of file mutex.cc.

void absl::SetStackUnwinder ( Unwinder w )

Definition at line 111 of file stacktrace.cc.

void absl::SetStackUnwinder ( int(*)(void **pcs, int *sizes, int max_depth, int skip_count, const void *uc, int *min_dropped_frames) unwinder )

static bool absl::SetupAlternateStackOnce ( ) [static]

Definition at line 121 of file failure_signal_handler.cc.

template<typename T , typename D >

std::shared_ptr<T> absl::ShareUniquePtr ( std::unique_ptr< T, D > && ptr )

Definition at line 225 of file memory.h.

ABSL_MUST_USE_RESULT bool absl::SimpleAtob	(	absl::string_view	str,
		bool *	out
	)

Definition at line 132 of file numbers.cc.

ABSL_MUST_USE_RESULT bool absl::SimpleAtod	(	absl::string_view	str,
		double *	out
	)

Definition at line 69 of file numbers.cc.

ABSL_MUST_USE_RESULT bool absl::SimpleAtof	(	absl::string_view	str,
		float *	out
	)

Definition at line 43 of file numbers.cc.

template<typename int_type >

ABSL_MUST_USE_RESULT bool absl::SimpleAtoi	(	absl::string_view	s,
		int_type *	out
	)

Definition at line 183 of file numbers.h.

strings_internal::AlphaNumBuffer< numbers_internal::kSixDigitsToBufferSize> absl::SixDigits ( double d ) [inline]

Definition at line 395 of file str_cat.h.

static PerThreadSynch* absl::Skip ( PerThreadSynch * x ) [static]

Definition at line 817 of file mutex.cc.

void absl::SleepFor ( absl::Duration duration ) [inline]

Definition at line 68 of file clock.h.

template<typename... Args>

int absl::SNPrintF	(	char *	output,
		std::size_t	size,
		const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 406 of file str_format.h.

static ExpDigits absl::SplitToSix ( const double value ) [static]

Definition at line 390 of file numbers.cc.

static char* absl::StackString	(	void **	pcs,
		int	n,
		char *	buf,
		int	maxlen,
		bool	symbolize
	)		`[static]`

Definition at line 1254 of file mutex.cc.

bool absl::StartsWith	(	absl::string_view	text,
		absl::string_view	prefix
	)		`[inline]`

Definition at line 52 of file match.h.

bool absl::StartsWithIgnoreCase	(	absl::string_view	text,
		absl::string_view	prefix
	)

Definition at line 28 of file match.cc.

absl::static_assert	(	PerThreadSynch::kAlignment	,
		kMuLow	,
		"PerThreadSynch::kAlignment must be greater than kMuLow"
	)

absl::static_assert	(	PerThreadSynch::kAlignment	,
		kCvLow	,
		"PerThreadSynch::kAlignment must be greater than kCvLow"
	)

void absl::StrAppend	(	std::string *	dest,
		const AlphaNum &	a
	)

Definition at line 193 of file str_cat.cc.

void absl::StrAppend	(	std::string *	dest,
		const AlphaNum &	a,
		const AlphaNum &	b
	)

Definition at line 198 of file str_cat.cc.

void absl::StrAppend	(	std::string *	dest,
		const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c
	)

Definition at line 211 of file str_cat.cc.

void absl::StrAppend	(	std::string *	dest,
		const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c,
		const AlphaNum &	d
	)

Definition at line 227 of file str_cat.cc.

void absl::StrAppend ( std::string * ) [inline]

Definition at line 373 of file str_cat.h.

template<typename... AV>

void absl::StrAppend	(	std::string *	dest,
		const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c,
		const AlphaNum &	d,
		const AlphaNum &	e,
		const AV &...	args
	)		`[inline]`

Definition at line 383 of file str_cat.h.

template<typename... Args>

std::string& absl::StrAppendFormat	(	std::string *	dst,
		const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 323 of file str_format.h.

ABSL_MUST_USE_RESULT std::string absl::StrCat	(	const AlphaNum &	a,
		const AlphaNum &	b
	)

Definition at line 98 of file str_cat.cc.

ABSL_MUST_USE_RESULT std::string absl::StrCat	(	const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c
	)

Definition at line 110 of file str_cat.cc.

ABSL_MUST_USE_RESULT std::string absl::StrCat	(	const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c,
		const AlphaNum &	d
	)

Definition at line 123 of file str_cat.cc.

ABSL_MUST_USE_RESULT std::string absl::StrCat ( ) [inline]

Definition at line 324 of file str_cat.h.

ABSL_MUST_USE_RESULT std::string absl::StrCat ( const AlphaNum & a ) [inline]

Definition at line 326 of file str_cat.h.

template<typename... AV>

ABSL_MUST_USE_RESULT std::string absl::StrCat	(	const AlphaNum &	a,
		const AlphaNum &	b,
		const AlphaNum &	c,
		const AlphaNum &	d,
		const AlphaNum &	e,
		const AV &...	args
	)		`[inline]`

Definition at line 338 of file str_cat.h.

bool absl::StrContains	(	absl::string_view	haystack,
		absl::string_view	needle
	)		`[inline]`

Definition at line 45 of file match.h.

template<typename... Args>

ABSL_MUST_USE_RESULT str_format_internal::Streamable absl::StreamFormat	(	const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 342 of file str_format.h.

strings_internal::StreamFormatterImpl absl::StreamFormatter ( ) [inline]

Definition at line 108 of file str_join.h.

template<typename... Args>

ABSL_MUST_USE_RESULT std::string absl::StrFormat	(	const FormatSpec< Args...> &	format,
		const Args &...	args
	)

Definition at line 305 of file str_format.h.

ABSL_MUST_USE_RESULT absl::string_view absl::StripAsciiWhitespace ( absl::string_view str ) [inline]

Definition at line 223 of file ascii.h.

void absl::StripAsciiWhitespace ( std::string * str ) [inline]

Definition at line 229 of file ascii.h.

ABSL_MUST_USE_RESULT absl::string_view absl::StripLeadingAsciiWhitespace ( absl::string_view str ) [inline]

Definition at line 195 of file ascii.h.

void absl::StripLeadingAsciiWhitespace ( std::string * str ) [inline]

Definition at line 202 of file ascii.h.

ABSL_MUST_USE_RESULT absl::string_view absl::StripPrefix	(	absl::string_view	str,
		absl::string_view	prefix
	)		`[inline]`

Definition at line 70 of file strip.h.

ABSL_MUST_USE_RESULT absl::string_view absl::StripSuffix	(	absl::string_view	str,
		absl::string_view	suffix
	)		`[inline]`

Definition at line 81 of file strip.h.

ABSL_MUST_USE_RESULT absl::string_view absl::StripTrailingAsciiWhitespace ( absl::string_view str ) [inline]

Definition at line 209 of file ascii.h.

void absl::StripTrailingAsciiWhitespace ( std::string * str ) [inline]

Definition at line 216 of file ascii.h.

template<typename Iterator , typename Formatter >

std::string absl::StrJoin	(	Iterator	start,
		Iterator	end,
		absl::string_view	sep,
		Formatter &&	fmt
	)

Definition at line 244 of file str_join.h.

template<typename Range , typename Formatter >

std::string absl::StrJoin	(	const Range &	range,
		absl::string_view	separator,
		Formatter &&	fmt
	)

Definition at line 250 of file str_join.h.

template<typename T , typename Formatter >

std::string absl::StrJoin	(	std::initializer_list< T >	il,
		absl::string_view	separator,
		Formatter &&	fmt
	)

Definition at line 256 of file str_join.h.

template<typename... T, typename Formatter >

std::string absl::StrJoin	(	const std::tuple< T...> &	value,
		absl::string_view	separator,
		Formatter &&	fmt
	)

Definition at line 262 of file str_join.h.

template<typename Iterator >

std::string absl::StrJoin	(	Iterator	start,
		Iterator	end,
		absl::string_view	separator
	)

Definition at line 268 of file str_join.h.

template<typename Range >

std::string absl::StrJoin	(	const Range &	range,
		absl::string_view	separator
	)

Definition at line 273 of file str_join.h.

template<typename T >

std::string absl::StrJoin	(	std::initializer_list< T >	il,
		absl::string_view	separator
	)

Definition at line 278 of file str_join.h.

template<typename... T>

std::string absl::StrJoin	(	const std::tuple< T...> &	value,
		absl::string_view	separator
	)

Definition at line 283 of file str_join.h.

ABSL_MUST_USE_RESULT std::string absl::StrReplaceAll	(	absl::string_view	s,
		std::initializer_list< std::pair< absl::string_view, absl::string_view >>	replacements
	)

std::string absl::StrReplaceAll	(	absl::string_view	s,
		strings_internal::FixedMapping	replacements
	)

Definition at line 70 of file str_replace.cc.

int absl::StrReplaceAll	(	strings_internal::FixedMapping	replacements,
		std::string *	target
	)

Definition at line 75 of file str_replace.cc.

template<typename StrToStrMapping >

std::string absl::StrReplaceAll	(	absl::string_view	s,
		const StrToStrMapping &	replacements
	)

Definition at line 193 of file str_replace.h.

int absl::StrReplaceAll	(	std::initializer_list< std::pair< absl::string_view, absl::string_view >>	replacements,
		std::string *	target
	)

template<typename StrToStrMapping >

int absl::StrReplaceAll	(	const StrToStrMapping &	replacements,
		std::string *	target
	)

Definition at line 203 of file str_replace.h.

template<typename Delimiter >

strings_internal::Splitter< typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty> absl::StrSplit	(	strings_internal::ConvertibleToStringView	text,
		Delimiter	d
	)

Definition at line 491 of file str_split.h.

template<typename Delimiter , typename Predicate >

strings_internal::Splitter< typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate> absl::StrSplit	(	strings_internal::ConvertibleToStringView	text,
		Delimiter	d,
		Predicate	p
	)

Definition at line 501 of file str_split.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute ( absl::string_view format ) [inline]

Definition at line 473 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0
	)		`[inline]`

Definition at line 479 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1
	)		`[inline]`

Definition at line 486 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2
	)		`[inline]`

Definition at line 494 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3
	)		`[inline]`

Definition at line 502 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4
	)		`[inline]`

Definition at line 511 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5
	)		`[inline]`

Definition at line 520 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6
	)		`[inline]`

Definition at line 530 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7
	)		`[inline]`

Definition at line 540 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7,
		const substitute_internal::Arg &	a8
	)		`[inline]`

Definition at line 551 of file substitute.h.

ABSL_MUST_USE_RESULT std::string absl::Substitute	(	absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7,
		const substitute_internal::Arg &	a8,
		const substitute_internal::Arg &	a9
	)		`[inline]`

Definition at line 562 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format
	)		`[inline]`

Definition at line 228 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0
	)		`[inline]`

Definition at line 232 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1
	)		`[inline]`

Definition at line 239 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2
	)		`[inline]`

Definition at line 247 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3
	)		`[inline]`

Definition at line 256 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4
	)		`[inline]`

Definition at line 267 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5
	)		`[inline]`

Definition at line 279 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6
	)		`[inline]`

Definition at line 292 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7
	)		`[inline]`

Definition at line 307 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7,
		const substitute_internal::Arg &	a8
	)		`[inline]`

Definition at line 320 of file substitute.h.

void absl::SubstituteAndAppend	(	std::string *	output,
		absl::string_view	format,
		const substitute_internal::Arg &	a0,
		const substitute_internal::Arg &	a1,
		const substitute_internal::Arg &	a2,
		const substitute_internal::Arg &	a3,
		const substitute_internal::Arg &	a4,
		const substitute_internal::Arg &	a5,
		const substitute_internal::Arg &	a6,
		const substitute_internal::Arg &	a7,
		const substitute_internal::Arg &	a8,
		const substitute_internal::Arg &	a9
	)		`[inline]`

Definition at line 334 of file substitute.h.

void absl::swap	(	any &	x,
		any &	y
	)		`[inline]`

Definition at line 463 of file any.h.

template<typename... Ts, absl::enable_if_t< absl::conjunction< std::is_move_constructible< Ts >..., type_traits_internal::IsSwappable< Ts >...>::value, int > = 0>

void absl::swap	(	variant< Ts...> &	v,
		variant< Ts...> &	w
	)

Definition at line 138 of file variant.h.

template<typename T , typename std::enable_if< std::is_move_constructible< T >::value &&type_traits_internal::IsSwappable< T >::value, bool >::type = false>

void absl::swap	(	optional< T > &	a,
		optional< T > &	b
	)

Definition at line 546 of file optional.h.

template<typename T , size_t N, typename A >

void absl::swap	(	absl::InlinedVector< T, N, A > &	a,
		absl::InlinedVector< T, N, A > &	b
	)

Definition at line 1217 of file inlined_vector.h.

bool absl::Symbolize	(	const void *	pc,
		char *	out,
		int	out_size
	)

static SynchLocksHeld* absl::Synch_GetAllLocks ( ) [static]

Definition at line 536 of file mutex.cc.

static PerThreadSynch* absl::Synch_GetPerThread ( ) [static]

Definition at line 520 of file mutex.cc.

static PerThreadSynch* absl::Synch_GetPerThreadAnnotated ( Mutex * mu ) [static]

Definition at line 525 of file mutex.cc.

absl::TEST	(	NotificationTest	,
		SanityTest
	)

Definition at line 125 of file notification_test.cc.

Time absl::TimeFromTimespec ( timespec ts )

Definition at line 282 of file time.cc.

Time absl::TimeFromTimeval ( timeval tv )

Definition at line 286 of file time.cc.

std::chrono::hours absl::ToChronoHours ( Duration d )

Definition at line 670 of file duration.cc.

std::chrono::microseconds absl::ToChronoMicroseconds ( Duration d )

Definition at line 658 of file duration.cc.

std::chrono::milliseconds absl::ToChronoMilliseconds ( Duration d )

Definition at line 661 of file duration.cc.

std::chrono::minutes absl::ToChronoMinutes ( Duration d )

Definition at line 667 of file duration.cc.

std::chrono::nanoseconds absl::ToChronoNanoseconds ( Duration d )

Definition at line 655 of file duration.cc.

std::chrono::seconds absl::ToChronoSeconds ( Duration d )

Definition at line 664 of file duration.cc.

std::chrono::system_clock::time_point absl::ToChronoTime ( absl::Time t )

Definition at line 333 of file time.cc.

CivilDay absl::ToCivilDay	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1063 of file time.h.

CivilHour absl::ToCivilHour	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1060 of file time.h.

CivilMinute absl::ToCivilMinute	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1057 of file time.h.

CivilMonth absl::ToCivilMonth	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1066 of file time.h.

CivilSecond absl::ToCivilSecond	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1054 of file time.h.

CivilYear absl::ToCivilYear	(	Time	t,
		TimeZone	tz
	)		`[inline]`

Definition at line 1069 of file time.h.

double absl::ToDoubleHours ( Duration d )

Definition at line 594 of file duration.cc.

double absl::ToDoubleMicroseconds ( Duration d )

Definition at line 582 of file duration.cc.

double absl::ToDoubleMilliseconds ( Duration d )

Definition at line 585 of file duration.cc.

double absl::ToDoubleMinutes ( Duration d )

Definition at line 591 of file duration.cc.

double absl::ToDoubleNanoseconds ( Duration d )

Definition at line 579 of file duration.cc.

double absl::ToDoubleSeconds ( Duration d )

Definition at line 588 of file duration.cc.

int64_t absl::ToInt64Hours ( Duration d )

Definition at line 572 of file duration.cc.

int64_t absl::ToInt64Microseconds ( Duration d )

Definition at line 544 of file duration.cc.

int64_t absl::ToInt64Milliseconds ( Duration d )

Definition at line 552 of file duration.cc.

int64_t absl::ToInt64Minutes ( Duration d )

Definition at line 566 of file duration.cc.

int64_t absl::ToInt64Nanoseconds ( Duration d )

Definition at line 536 of file duration.cc.

int64_t absl::ToInt64Seconds ( Duration d )

Definition at line 560 of file duration.cc.

timespec absl::ToTimespec ( Time t )

Definition at line 290 of file time.cc.

timespec absl::ToTimespec ( Duration d )

Definition at line 598 of file duration.cc.

time_t absl::ToTimeT ( Time t )

Definition at line 271 of file time.cc.

timeval absl::ToTimeval ( Time t )

Definition at line 310 of file time.cc.

timeval absl::ToTimeval ( Duration d )

Definition at line 628 of file duration.cc.

struct tm absl::ToTM	(	absl::Time	t,
		absl::TimeZone	tz
	)		`[read]`

Definition at line 435 of file time.cc.

double absl::ToUDate ( Time t )

Definition at line 273 of file time.cc.

int64_t absl::ToUniversal ( absl::Time t )

Definition at line 278 of file time.cc.

int64_t absl::ToUnixMicros ( Time t )

Definition at line 247 of file time.cc.

int64_t absl::ToUnixMillis ( Time t )

Definition at line 257 of file time.cc.

int64_t absl::ToUnixNanos ( Time t )

Definition at line 237 of file time.cc.

int64_t absl::ToUnixSeconds ( Time t )

Definition at line 267 of file time.cc.

Duration absl::Trunc	(	Duration	d,
		Duration	unit
	)

Definition at line 498 of file duration.cc.

static bool absl::TryAcquireWithSpinning ( std::atomic< intptr_t > * mu ) [static]

Definition at line 1436 of file mutex.cc.

constexpr uint64_t absl::Uint128High64 ( uint128 v )

Definition at line 389 of file int128.h.

constexpr uint64_t absl::Uint128Low64 ( uint128 v )

Definition at line 387 of file int128.h.

constexpr uint128 absl::Uint128Max ( )

Definition at line 242 of file int128.h.

constexpr Time absl::UniversalEpoch ( )

Definition at line 692 of file time.h.

constexpr Time absl::UnixEpoch ( )

Definition at line 686 of file time.h.

std::string absl::UnparseFlag ( absl::Time t )

Definition at line 136 of file format.cc.

template<typename T >

std::string absl::UnparseFlag ( const T & v ) [inline]

Definition at line 254 of file marshalling.h.

std::string absl::UnparseFlag ( Duration d )

Definition at line 909 of file duration.cc.

static void absl::UnrefSynchEvent ( SynchEvent * e ) [static]

Definition at line 348 of file mutex.cc.

void absl::UnRegisterLivePointers	(	const void *	,
		size_t
	)

Definition at line 27 of file leak_check.cc.

TimeZone absl::UTCTimeZone ( ) [inline]

Definition at line 1026 of file time.h.

std::string absl::Utf8SafeCEscape ( absl::string_view src )

Definition at line 1049 of file escaping.cc.

std::string absl::Utf8SafeCHexEscape ( absl::string_view src )

Definition at line 1053 of file escaping.cc.

template<int &... ExplicitBarrier, typename Container >

ABSL_MUST_USE_RESULT testing::AssertionResult absl::VerifyTypeImplementsAbslHashCorrectly ( const Container & values )

Definition at line 344 of file hash_testing.h.

template<int &... ExplicitBarrier, typename Container , typename Eq >

ABSL_MUST_USE_RESULT testing::AssertionResult absl::VerifyTypeImplementsAbslHashCorrectly	(	const Container &	values,
		Eq	equals
	)

Definition at line 352 of file hash_testing.h.

template<int & ..., typename T >

ABSL_MUST_USE_RESULT testing::AssertionResult absl::VerifyTypeImplementsAbslHashCorrectly ( std::initializer_list< T > values )

Definition at line 359 of file hash_testing.h.

template<int & ..., typename T , typename Eq >

ABSL_MUST_USE_RESULT testing::AssertionResult absl::VerifyTypeImplementsAbslHashCorrectly	(	std::initializer_list< T >	values,
		Eq	equals
	)

Definition at line 367 of file hash_testing.h.

template<typename Visitor , typename... Variants>

variant_internal::VisitResult<Visitor, Variants...> absl::visit	(	Visitor &&	vis,
		Variants &&...	vars
	)

Definition at line 427 of file variant.h.

template<typename T >

std::weak_ptr<T> absl::WeakenPtr ( const std::shared_ptr< T > & ptr )

Definition at line 245 of file memory.h.

void absl::WebSafeBase64Escape	(	absl::string_view	src,
		std::string *	dest
	)

Definition at line 1094 of file escaping.cc.

std::string absl::WebSafeBase64Escape ( absl::string_view src )

Definition at line 1106 of file escaping.cc.

bool absl::WebSafeBase64Unescape	(	absl::string_view	src,
		std::string *	dest
	)

Definition at line 1085 of file escaping.cc.

template<typename T >

std::unique_ptr<T> absl::WrapUnique ( T * ptr )

Definition at line 71 of file memory.h.

static void absl::WriteFailureInfo	(	int	signo,
		void *	ucontext,
		void()(const char )	writerfn
	)		`[static]`

Definition at line 262 of file failure_signal_handler.cc.

static void absl::WriterFnWrapper	(	const char *	data,
		void *	arg
	)		`[static]`

Definition at line 236 of file failure_signal_handler.cc.

static void absl::WriteSignalMessage	(	int	signo,
		void()(const char )	writerfn
	)		`[static]`

Definition at line 212 of file failure_signal_handler.cc.

static ABSL_ATTRIBUTE_NOINLINE void absl::WriteStackTrace	(	void *	ucontext,
		bool	symbolize_stacktrace,
		void()(const char , void *)	writerfn,
		void *	writerfn_arg
	)		`[static]`

Definition at line 243 of file failure_signal_handler.cc.

static void absl::WriteToStderr ( const char * data ) [static]

Definition at line 206 of file failure_signal_handler.cc.

constexpr Duration absl::ZeroDuration ( )

Definition at line 286 of file time.h.

Variable Documentation

absl::base_internal::SpinLock absl::deadlock_graph_mu(absl::base_internal::kLinkerInitialized) [static]

struct { ... } absl::event_properties[] [static]

ABSL_CONST_INIT FailureSignalData absl::failure_signal_data[] [static]

Initial value:

 {
    {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT},
    {SIGILL, "SIGILL", FSD_PREVIOUS_INIT},
    {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT},
    {SIGABRT, "SIGABRT", FSD_PREVIOUS_INIT},
    {SIGTERM, "SIGTERM", FSD_PREVIOUS_INIT},

    {SIGBUS, "SIGBUS", FSD_PREVIOUS_INIT},
    {SIGTRAP, "SIGTRAP", FSD_PREVIOUS_INIT},

}

Definition at line 74 of file failure_signal_handler.cc.

int absl::flags

Definition at line 253 of file mutex.cc.

ABSL_CONST_INIT FailureSignalHandlerOptions absl::fsh_options [static]

Definition at line 51 of file failure_signal_handler.cc.

struct absl::SynchWaitParams absl::GUARDED_BY[kNSynchEvent]

const intptr_t absl::ignore_waiting_writers[] [static]

Initial value:

 {
    ~static_cast<intptr_t>(0),  
    ~static_cast<intptr_t>(
        kMuWrWait)  
}

Definition at line 1743 of file mutex.cc.

const intptr_t absl::kCvEvent = 0x0002L [static]

Definition at line 2405 of file mutex.cc.

const intptr_t absl::kCvLow = 0x0003L [static]

Definition at line 2407 of file mutex.cc.

const intptr_t absl::kCvSpin = 0x0001L [static]

Definition at line 2404 of file mutex.cc.

constexpr bool absl::kDebugMode = true [static]

Definition at line 700 of file mutex.cc.

const Mutex::MuHow absl::kExclusive = &kExclusiveS [static]

Definition at line 695 of file mutex.cc.

const MuHowS absl::kExclusiveS [static]

Initial value:

 {
    
    kMuWriter | kMuReader | kMuEvent,  
    kMuWriter,                         
    0,                                 
    kMuWriter | kMuReader,             
    ~static_cast<intptr_t>(0),         
}

Definition at line 686 of file mutex.cc.

constexpr auto absl::kFixedArrayUseDefault = static_cast<size_t>(-1) [static]

Definition at line 55 of file fixed_array.h.

const intptr_t absl::kMuDesig = 0x0002L [static]

Definition at line 612 of file mutex.cc.

const intptr_t absl::kMuEvent = 0x0010L [static]

Definition at line 615 of file mutex.cc.

const int absl::kMuHasBlocked = 0x01 [static]

Definition at line 652 of file mutex.cc.

const intptr_t absl::kMuHigh = ~kMuLow [static]

Definition at line 628 of file mutex.cc.

const int absl::kMuIsCond = 0x02 [static]

Definition at line 653 of file mutex.cc.

const intptr_t absl::kMuLow = 0x00ffL [static]

Definition at line 627 of file mutex.cc.

const intptr_t absl::kMuOne = 0x0100 [static]

Definition at line 649 of file mutex.cc.

const intptr_t absl::kMuReader = 0x0001L [static]

Definition at line 611 of file mutex.cc.

const intptr_t absl::kMuSpin = 0x0040L [static]

Definition at line 626 of file mutex.cc.

const intptr_t absl::kMuWait = 0x0004L [static]

Definition at line 613 of file mutex.cc.

const intptr_t absl::kMuWriter = 0x0008L [static]

Definition at line 614 of file mutex.cc.

const intptr_t absl::kMuWrWait = 0x0020L [static]

Definition at line 624 of file mutex.cc.

const uint32_t absl::kNSynchEvent = 1031 [static]

Definition at line 278 of file mutex.cc.

PerThreadSynch* const absl::kPerThreadSynchNull [static]

Initial value:

  reinterpret_cast<PerThreadSynch *>(1)

Definition at line 508 of file mutex.cc.

const Mutex::MuHow absl::kShared = &kSharedS [static]

Definition at line 694 of file mutex.cc.

const MuHowS absl::kSharedS [static]

Initial value:

 {
    
    kMuWriter | kMuWait | kMuEvent,   
    kMuReader,                        
    kMuOne,                           
    kMuWriter | kMuWait,              
    kMuSpin | kMuWriter | kMuWrWait,  
}

Definition at line 678 of file mutex.cc.

const uint128 absl::kuint128max

Initial value:

 MakeUint128(std::numeric_limits<uint64_t>::max(),
                                        std::numeric_limits<uint64_t>::max())

Definition at line 27 of file int128.cc.

const char* absl::msg

Definition at line 254 of file mutex.cc.

char* absl::out

Definition at line 1013 of file mutex.h.

char int absl::out_size

Definition at line 1013 of file mutex.h.

const char absl::RFC1123_full = "%a, %d %b %E4Y %H:%M:%S %z"

Definition at line 1191 of file time.h.

const char absl::RFC1123_no_wday = "%d %b %E4Y %H:%M:%S %z"

Definition at line 1192 of file time.h.

const char absl::RFC3339_full = "%Y-%m-%dT%H:%M:%E*S%Ez"

Definition at line 1184 of file time.h.

const char absl::RFC3339_sec = "%Y-%m-%dT%H:%M:%S%Ez"

Definition at line 1185 of file time.h.

absl::base_internal::SpinLock absl::synch_event_mu(absl::base_internal::kLinkerInitialized) [static]

const intptr_t absl::zap_desig_waker[] [static]

Initial value:

 {
    ~static_cast<intptr_t>(0),  
    ~static_cast<intptr_t>(
        kMuDesig)  
}

Definition at line 1734 of file mutex.cc.

Namespaces

Classes

Enumerations

Functions

Variables

Enumeration Type Documentation

Function Documentation

Variable Documentation