Namespaces | Classes | Enumerations | Functions | Variables
absl Namespace Reference

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 >
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 PerThreadSynchDequeue (PerThreadSynch *head, PerThreadSynch *pw)
static PerThreadSynchDequeueAllWakeable (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 PerThreadSynchEnqueue (PerThreadSynch *head, SynchWaitParams *waitp, intptr_t mu, int flags)
static SynchEventEnsureSynchEvent (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 >
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 PerThreadSynchGetPerThreadSynch (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 SynchEventGetSynchEvent (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 SynchLocksHeldLocksHeldAlloc ()
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_formatoperator&= (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_formatoperator^= (chars_format &lhs, chars_format rhs)
constexpr chars_format operator| (chars_format lhs, chars_format rhs)
uint128 operator| (uint128 lhs, uint128 rhs)
chars_formatoperator|= (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 PerThreadSynchSkip (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 SynchLocksHeldSynch_GetAllLocks ()
static PerThreadSynchSynch_GetPerThread ()
static PerThreadSynchSynch_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.

Enumerator:
scientific 
fixed 
hex 
general 

Definition at line 26 of file charconv.h.

Enumerator:
kConstInit 

Definition at line 66 of file const_init.h.

Enumerator:
kInfo 
kWarning 
kError 
kFatal 

Definition at line 28 of file log_severity.h.

Enumerator:
kIgnore 
kReport 
kAbort 

Definition at line 1027 of file mutex.h.

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   
)

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,
const absl::InlinedVector< TheT, TheN, TheA > &  a 
)

Definition at line 1294 of file inlined_vector.h.

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.

Definition at line 169 of file ascii.h.

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

Definition at line 163 of file ascii.cc.

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.

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.

Definition at line 150 of file str_join.h.

void absl::DoIgnoreLeak ( const void *  )

Definition at line 25 of file leak_check.cc.

Definition at line 516 of file duration.cc.

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.

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.

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 ( ) [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.

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.

Definition at line 24 of file leak_check.cc.

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 ( 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.

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.

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 ( 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 ( 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 ( 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 ( 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.

Definition at line 56 of file log_severity.h.

Definition at line 61 of file log_severity.h.

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,
rhs 
)

Definition at line 218 of file time.h.

template<typename T >
Duration absl::operator* ( 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,
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.

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 ( 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.

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.

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.

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.

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.

Definition at line 223 of file ascii.h.

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

Definition at line 229 of file ascii.h.

Definition at line 195 of file ascii.h.

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

Definition at line 202 of file ascii.h.

Definition at line 70 of file strip.h.

Definition at line 81 of file strip.h.

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