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

Namespaces

 algorithm_internal
 
 any_internal
 
 ascii_internal
 
 base_internal
 
 big_endian
 
 compare_internal
 
 container_algorithm_internal
 
 container_internal
 
 debugging_internal
 
 flags_internal
 
 hash_internal
 
 inline_variable_testing_internal
 
 inlined_vector_internal
 
 internal
 
 internal_casts
 
 little_endian
 
 macros_internal
 
 memory_internal
 
 numbers_internal
 
 optional_internal
 
 raw_logging_internal
 
 span_internal
 
 str_format_internal
 
 streamed_test
 
 strings_internal
 
 substitute_internal
 
 swap_internal
 
 synchronization_internal
 
 test_internal
 
 time_internal
 
 type_traits_internal
 
 utility_internal
 
 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
 
struct  conjunction< T >
 
struct  conjunction< T, Ts... >
 
struct  conjunction<>
 
struct  Dec
 
struct  default_allocator_is_nothrow
 
struct  disjunction
 
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
 
class  variant< T0, Tn... >
 
struct  variant_alternative
 
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
 
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
 

Typedefs

template<typename T >
using add_const_t = typename std::add_const< T >::type
 
template<typename T >
using add_cv_t = typename std::add_cv< T >::type
 
template<typename T >
using add_lvalue_reference_t = typename std::add_lvalue_reference< T >::type
 
template<typename T >
using add_pointer_t = typename std::add_pointer< T >::type
 
template<typename T >
using add_rvalue_reference_t = typename std::add_rvalue_reference< T >::type
 
template<typename T >
using add_volatile_t = typename std::add_volatile< T >::type
 
template<size_t Len, size_t Align = type_traits_internal:: default_alignment_of_aligned_storage<Len>::value>
using aligned_storage_t = typename std::aligned_storage< Len, Align >::type
 
using civil_diff_t = time_internal::cctz::diff_t
 
using civil_year_t = time_internal::cctz::year_t
 
using CivilDay = time_internal::cctz::detail::civil_time< time_internal::day_tag >
 
using CivilHour = time_internal::cctz::detail::civil_time< time_internal::hour_tag >
 
using CivilMinute = time_internal::cctz::detail::civil_time< time_internal::minute_tag >
 
using CivilMonth = time_internal::cctz::detail::civil_time< time_internal::month_tag >
 
using CivilSecond = time_internal::cctz::detail::civil_time< time_internal::second_tag >
 
using CivilYear = time_internal::cctz::detail::civil_time< time_internal::year_tag >
 
template<typename... T>
using common_type_t = typename std::common_type< T... >::type
 
template<bool B, typename T , typename F >
using conditional_t = typename std::conditional< B, T, F >::type
 
template<typename T >
using decay_t = typename std::decay< T >::type
 
template<bool B, typename T = void>
using enable_if_t = typename std::enable_if< B, T >::type
 
template<typename T >
using Flag = flags_internal::Flag< T >
 
using FormatArg = str_format_internal::FormatArgImpl
 
template<typename... Args>
using FormatSpec = typename str_format_internal::FormatSpecDeductionBarrier< Args... >::type
 
using GetTidType = decltype(absl::base_internal::GetTID())
 
template<typename T >
using Hash = absl::hash_internal::Hash< T >
 
template<size_t I>
using in_place_index_t = void(*)(utility_internal::InPlaceIndexTag< I >)
 
template<typename T >
using in_place_type_t = void(*)(utility_internal::InPlaceTypeTag< T >)
 
template<size_t... Ints>
using index_sequence = integer_sequence< size_t, Ints... >
 
template<typename... Ts>
using index_sequence_for = make_index_sequence< sizeof...(Ts)>
 
template<size_t N>
using make_index_sequence = make_integer_sequence< size_t, N >
 
template<typename T , T N>
using make_integer_sequence = typename utility_internal::Gen< T, N >::type
 
template<typename T >
using make_signed_t = typename std::make_signed< T >::type
 
template<typename T >
using make_unsigned_t = typename std::make_unsigned< T >::type
 
template<char... Conv>
using ParsedFormat = str_format_internal::ExtendedParsedFormat< str_format_internal::ConversionCharToConv(Conv)... >
 
template<typename T >
using remove_all_extents_t = typename std::remove_all_extents< T >::type
 
template<typename T >
using remove_const_t = typename std::remove_const< T >::type
 
template<typename T >
using remove_cv_t = typename std::remove_cv< T >::type
 
template<typename T >
using remove_extent_t = typename std::remove_extent< T >::type
 
template<typename T >
using remove_pointer_t = typename std::remove_pointer< T >::type
 
template<typename T >
using remove_reference_t = typename std::remove_reference< T >::type
 
template<typename T >
using remove_volatile_t = typename std::remove_volatile< T >::type
 
template<typename T >
using result_of_t = typename std::result_of< T >::type
 
template<typename T >
using underlying_type_t = typename std::underlying_type< T >::type
 
template<std::size_t I, class T >
using variant_alternative_t = typename variant_alternative< I, T >::type
 
template<typename... Ts>
using void_t = typename type_traits_internal::VoidTImpl< Ts... >::type
 
using Weekday = time_internal::cctz::weekday
 

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 { chars_format::scientific = 1, chars_format::fixed = 2, chars_format::hex = 4, chars_format::general = fixed | scientific }
 
enum  ConstInitType { kConstInit }
 
enum  LogSeverity : int { LogSeverity::kInfo = 0, LogSeverity::kWarning = 1, LogSeverity::kError = 2, LogSeverity::kFatal = 3 }
 
enum  OnDeadlockCycle { OnDeadlockCycle::kIgnore, OnDeadlockCycle::kReport, OnDeadlockCycle::kAbort }
 
enum  PadSpec : uint8_t {
  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
 
template<typename T >
const T * any_cast (const any *operand) noexcept
 
template<typename T >
T * 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::apply_helper(absl::forward< Functor >(functor), absl::forward< Tuple >(t), absl::make_index_sequence< std::tuple_size< typename std::remove_reference< Tuple >::type >::value >
 
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)
 
static bool Dereference (void *arg)
 
template<typename Formatter >
strings_internal::DereferenceFormatterImpl< Formatter > DereferenceFormatter (Formatter &&f)
 
strings_internal::DereferenceFormatterImpl< strings_internal::AlphaNumFormatterImplDereferenceFormatter ()
 
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)
 
template<typename T , typename U = T>
exchange (T &obj, U &&new_value)
 
static ABSL_CONST_INIT std::atomic< GetTidTypefailed_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 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 variant_alternative_t< I, variant< Types... > > & get (variant< Types... > &v)
 
template<std::size_t I, class... Types>
constexpr variant_alternative_t< I, variant< Types... > > && get (variant< Types... > &&v)
 
template<std::size_t I, class... Types>
constexpr const variant_alternative_t< I, variant< Types... > > & get (const variant< Types... > &v)
 
template<std::size_t I, class... Types>
constexpr const variant_alternative_t< I, variant< Types... > > && 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
 
template<class T , class... Types>
constexpr absl::add_pointer_t< T > get_if (variant< Types... > *v) noexcept
 
template<class T , class... Types>
constexpr absl::add_pointer_t< const T > 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)
 
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 &&...)=delete
 
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::MakeSpan(span_internal::GetData(c), c.size()))
 
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::convertible_to_bool(*x!=*y))
 
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::convertible_to_bool(*x!=v))
 
template<typename T , typename U >
constexpr auto operator!= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v!=*x))
 
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::convertible_to_bool(*x< *y))
 
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::convertible_to_bool(*x< v))
 
template<typename T , typename U >
constexpr auto operator< (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v< *x))
 
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::convertible_to_bool(*x<=*y))
 
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::convertible_to_bool(*x<=v))
 
template<typename T , typename U >
constexpr auto operator<= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v<=*x))
 
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::convertible_to_bool(*x==*y))
 
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::convertible_to_bool(*x==v))
 
template<typename T , typename U >
constexpr auto operator== (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v==*x))
 
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::convertible_to_bool(*x > *y))
 
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::convertible_to_bool(*x > v))
 
template<typename T , typename U >
constexpr auto operator> (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v > *x))
 
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::convertible_to_bool(*x >=*y))
 
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::convertible_to_bool(*x >=v))
 
template<typename T , typename U >
constexpr auto operator>= (const U &v, const optional< T > &x) -> decltype(optional_internal::convertible_to_bool(v >=*x))
 
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::AlphaNumFormatterImplPairFormatter (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::addressof(*ptr))
 
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::kSixDigitsToBufferSizeSixDigits (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)
 
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, AllowEmptyStrSplit (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 []
 

Typedef Documentation

template<typename T >
using absl::add_const_t = typedef typename std::add_const<T>::type

Definition at line 507 of file type_traits.h.

template<typename T >
using absl::add_cv_t = typedef typename std::add_cv<T>::type

Definition at line 504 of file type_traits.h.

template<typename T >
using absl::add_lvalue_reference_t = typedef typename std::add_lvalue_reference<T>::type

Definition at line 516 of file type_traits.h.

template<typename T >
using absl::add_pointer_t = typedef typename std::add_pointer<T>::type

Definition at line 525 of file type_traits.h.

template<typename T >
using absl::add_rvalue_reference_t = typedef typename std::add_rvalue_reference<T>::type

Definition at line 519 of file type_traits.h.

template<typename T >
using absl::add_volatile_t = typedef typename std::add_volatile<T>::type

Definition at line 510 of file type_traits.h.

template<size_t Len, size_t Align = type_traits_internal:: default_alignment_of_aligned_storage<Len>::value>
using absl::aligned_storage_t = typedef typename std::aligned_storage<Len, Align>::type

Definition at line 541 of file type_traits.h.

Definition at line 359 of file civil_time.h.

Definition at line 346 of file civil_time.h.

Definition at line 329 of file civil_time.h.

Definition at line 327 of file civil_time.h.

Definition at line 325 of file civil_time.h.

Definition at line 331 of file civil_time.h.

Definition at line 323 of file civil_time.h.

Definition at line 333 of file civil_time.h.

template<typename... T>
using absl::common_type_t = typedef typename std::common_type<T...>::type

Definition at line 553 of file type_traits.h.

template<bool B, typename T , typename F >
using absl::conditional_t = typedef typename std::conditional<B, T, F>::type

Definition at line 550 of file type_traits.h.

template<typename T >
using absl::decay_t = typedef typename std::decay<T>::type

Definition at line 544 of file type_traits.h.

template<bool B, typename T = void>
using absl::enable_if_t = typedef typename std::enable_if<B, T>::type

Definition at line 547 of file type_traits.h.

template<typename T >
using absl::Flag = typedef flags_internal::Flag<T>

Definition at line 43 of file declare.h.

Definition at line 470 of file str_format.h.

template<typename... Args>
using absl::FormatSpec = typedef typename str_format_internal::FormatSpecDeductionBarrier<Args...>::type

Definition at line 251 of file str_format.h.

using absl::GetTidType = typedef decltype(absl::base_internal::GetTID())

Definition at line 297 of file failure_signal_handler.cc.

template<typename T >
using absl::Hash = typedef absl::hash_internal::Hash<T>

Definition at line 213 of file hash.h.

template<size_t I>
using absl::in_place_index_t = typedef void (*)(utility_internal::InPlaceIndexTag<I>)

Definition at line 206 of file utility.h.

template<typename T >
using absl::in_place_type_t = typedef void (*)(utility_internal::InPlaceTypeTag<T>)

Definition at line 189 of file utility.h.

template<size_t... Ints>
using absl::index_sequence = typedef integer_sequence<size_t, Ints...>

Definition at line 85 of file utility.h.

template<typename... Ts>
using absl::index_sequence_for = typedef make_index_sequence<sizeof...(Ts)>

Definition at line 156 of file utility.h.

template<size_t N>
using absl::make_index_sequence = typedef make_integer_sequence<size_t, N>

Definition at line 148 of file utility.h.

template<typename T , T N>
using absl::make_integer_sequence = typedef typename utility_internal::Gen<T, N>::type

Definition at line 140 of file utility.h.

template<typename T >
using absl::make_signed_t = typedef typename std::make_signed<T>::type

Definition at line 528 of file type_traits.h.

template<typename T >
using absl::make_unsigned_t = typedef typename std::make_unsigned<T>::type

Definition at line 531 of file type_traits.h.

Definition at line 280 of file str_format.h.

template<typename T >
using absl::remove_all_extents_t = typedef typename std::remove_all_extents<T>::type

Definition at line 537 of file type_traits.h.

template<typename T >
using absl::remove_const_t = typedef typename std::remove_const<T>::type

Definition at line 498 of file type_traits.h.

template<typename T >
using absl::remove_cv_t = typedef typename std::remove_cv<T>::type

Definition at line 495 of file type_traits.h.

template<typename T >
using absl::remove_extent_t = typedef typename std::remove_extent<T>::type

Definition at line 534 of file type_traits.h.

template<typename T >
using absl::remove_pointer_t = typedef typename std::remove_pointer<T>::type

Definition at line 522 of file type_traits.h.

template<typename T >
using absl::remove_reference_t = typedef typename std::remove_reference<T>::type

Definition at line 513 of file type_traits.h.

template<typename T >
using absl::remove_volatile_t = typedef typename std::remove_volatile<T>::type

Definition at line 501 of file type_traits.h.

template<typename T >
using absl::result_of_t = typedef typename std::result_of<T>::type

Definition at line 559 of file type_traits.h.

template<typename T >
using absl::underlying_type_t = typedef typename std::underlying_type<T>::type

Definition at line 556 of file type_traits.h.

template<std::size_t I, class T >
using absl::variant_alternative_t = typedef typename variant_alternative<I, T>::type

Definition at line 247 of file variant.h.

template<typename... Ts>
using absl::void_t = typedef typename type_traits_internal::VoidTImpl<Ts...>::type

Definition at line 171 of file type_traits.h.

using absl::Weekday = typedef time_internal::cctz::weekday

Definition at line 369 of file civil_time.h.

Enumeration Type Documentation

anonymous enum
Enumerator
kGdbMuSpin 
kGdbMuEvent 
kGdbMuWait 
kGdbMuWriter 
kGdbMuDesig 
kGdbMuWrWait 
kGdbMuReader 
kGdbMuLow 

Definition at line 631 of file mutex.cc.

anonymous enum
Enumerator
kGdbCvSpin 
kGdbCvEvent 
kGdbCvLow 

Definition at line 2410 of file mutex.cc.

enum absl::chars_format
strong
Enumerator
scientific 
fixed 
hex 
general 

Definition at line 26 of file charconv.h.

Enumerator
kConstInit 

Definition at line 66 of file const_init.h.

enum absl::LogSeverity : int
strong
Enumerator
kInfo 
kWarning 
kError 
kFatal 

Definition at line 28 of file log_severity.h.

enum absl::OnDeadlockCycle
strong
Enumerator
kIgnore 
kReport 
kAbort 

Definition at line 1027 of file mutex.h.

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

Definition at line 83 of file str_cat.h.

Function Documentation

Duration absl::AbsDuration ( Duration  d)
inline

Definition at line 291 of file time.h.

template<typename Dest , typename Source , typename std::enable_if< !internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>
absl::ABSL_DEPRECATED ( "absl::bit_cast type requirements were violated. Update the types being ""used such that they are the same size and are both TriviallyCopyable."  ) const

Definition at line 168 of file casts.h.

absl::ABSL_DEPRECATED ( "absl::RegisterSymbolizer() is deprecated and will be removed ""on or after 2023-05-01"  ) const
absl::ABSL_INTERNAL_INLINE_CONSTEXPR ( size_t  ,
variant_npos  ,
1 
)
absl::ABSL_INTERNAL_INLINE_CONSTEXPR ( nullopt_t  ,
nullopt  ,
nullopt_t(optional_internal::init_t())   
)
absl::ABSL_INTERNAL_INLINE_CONSTEXPR ( in_place_t  ,
in_place  ,
{}   
)
absl::ABSL_XRAY_LOG_ARGS ( )

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.

strings_internal::AlphaNumFormatterImpl absl::AlphaNumFormatter ( )
inline

Definition at line 101 of file str_join.h.

template<typename ValueType >
ValueType absl::any_cast ( const any operand)

Definition at line 479 of file any.h.

template<typename ValueType >
ValueType absl::any_cast ( any operand)

Definition at line 493 of file any.h.

template<typename ValueType >
ValueType absl::any_cast ( any &&  operand)

Definition at line 507 of file any.h.

template<typename ValueType >
const ValueType* absl::any_cast ( const any operand)
noexcept

Definition at line 517 of file any.h.

template<typename ValueType >
ValueType* absl::any_cast ( any operand)
noexcept

Definition at line 526 of file any.h.

template<typename T >
const T* absl::any_cast ( const any operand)
noexcept

Definition at line 517 of file any.h.

template<typename T >
T* absl::any_cast ( any operand)
noexcept

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 
) -> decltype(utility_internal::apply_helper( absl::forward<Functor>(functor), absl::forward<Tuple>(t), absl::make_index_sequence<std::tuple_size< typename std::remove_reference<Tuple>::type>::value>

Definition at line 287 of file utility.h.

bool absl::ascii_isalnum ( unsigned char  c)
inline

Definition at line 85 of file ascii.h.

bool absl::ascii_isalpha ( unsigned char  c)
inline

Definition at line 78 of file ascii.h.

bool absl::ascii_isascii ( unsigned char  c)
inline

Definition at line 155 of file ascii.h.

bool absl::ascii_isblank ( unsigned char  c)
inline

Definition at line 107 of file ascii.h.

bool absl::ascii_iscntrl ( unsigned char  c)
inline

Definition at line 114 of file ascii.h.

bool absl::ascii_isdigit ( unsigned char  c)
inline

Definition at line 130 of file ascii.h.

bool absl::ascii_isgraph ( unsigned char  c)
inline

Definition at line 140 of file ascii.h.

bool absl::ascii_islower ( unsigned char  c)
inline

Definition at line 150 of file ascii.h.

bool absl::ascii_isprint ( unsigned char  c)
inline

Definition at line 135 of file ascii.h.

bool absl::ascii_ispunct ( unsigned char  c)
inline

Definition at line 100 of file ascii.h.

bool absl::ascii_isspace ( unsigned char  c)
inline

Definition at line 93 of file ascii.h.

bool absl::ascii_isupper ( unsigned char  c)
inline

Definition at line 145 of file ascii.h.

bool absl::ascii_isxdigit ( unsigned char  c)
inline

Definition at line 122 of file ascii.h.

char absl::ascii_tolower ( unsigned char  c)
inline

Definition at line 161 of file ascii.h.

char absl::ascii_toupper ( unsigned char  c)
inline

Definition at line 179 of file ascii.h.

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

Definition at line 157 of file ascii.cc.

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

Definition at line 169 of file ascii.h.

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

Definition at line 163 of file ascii.cc.

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

Definition at line 187 of file ascii.h.

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

Definition at line 191 of file mutex.cc.

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

Definition at line 175 of file mutex.cc.

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

Definition at line 1089 of file escaping.cc.

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

Definition at line 1099 of file escaping.cc.

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

Definition at line 1081 of file escaping.cc.

static void absl::BasicTests ( bool  notify_before_waiting,
Notification notification 
)
static

Definition at line 68 of file notification_test.cc.

template<typename Dest , typename Source , typename std::enable_if< internal_casts::is_bitcastable< Dest, Source >::value, int >::type = 0>
Dest absl::bit_cast ( const Source &  source)
inline

Definition at line 154 of file casts.h.

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

Definition at line 1121 of file escaping.cc.

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

Definition at line 1604 of file container.h.

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

Definition at line 1613 of file container.h.

template<typename InputSequence , typename OutputIt >
OutputIt absl::c_adjacent_difference ( const InputSequence &  input,
OutputIt  output_first 
)

Definition at line 1658 of file container.h.

template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt absl::c_adjacent_difference ( const InputSequence &  input,
OutputIt  output_first,
BinaryOp &&  op 
)

Definition at line 1668 of file container.h.

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

Definition at line 286 of file container.h.

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

Definition at line 295 of file container.h.

template<typename C , typename Pred >
bool absl::c_all_of ( const C &  c,
Pred &&  pred 
)

Definition at line 158 of file container.h.

template<typename C , typename Pred >
bool absl::c_any_of ( const C &  c,
Pred &&  pred 
)

Definition at line 169 of file container.h.

template<typename Sequence , typename T >
bool absl::c_binary_search ( Sequence &&  sequence,
T &&  value 
)

Definition at line 1072 of file container.h.

template<typename Sequence , typename T , typename Compare >
bool absl::c_binary_search ( Sequence &&  sequence,
T &&  value,
Compare &&  comp 
)

Definition at line 1081 of file container.h.

template<typename InputSequence , typename OutputIterator >
OutputIterator absl::c_copy ( const InputSequence &  input,
OutputIterator  output 
)

Definition at line 466 of file container.h.

template<typename C , typename BidirectionalIterator >
BidirectionalIterator absl::c_copy_backward ( const C &  src,
BidirectionalIterator  dest 
)

Definition at line 497 of file container.h.

template<typename InputSequence , typename OutputIterator , typename Pred >
OutputIterator absl::c_copy_if ( const InputSequence &  input,
OutputIterator  output,
Pred &&  pred 
)

Definition at line 485 of file container.h.

template<typename C , typename Size , typename OutputIterator >
OutputIterator absl::c_copy_n ( const C &  input,
Size  n,
OutputIterator  output 
)

Definition at line 476 of file container.h.

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

Definition at line 307 of file container.h.

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

Definition at line 319 of file container.h.

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

Definition at line 143 of file container.h.

template<typename C1 , typename C2 >
bool absl::c_equal ( const C1 &  c1,
const C2 &  c2 
)

Definition at line 367 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >
bool absl::c_equal ( const C1 &  c1,
const C2 &  c2,
BinaryPredicate &&  pred 
)

Definition at line 377 of file container.h.

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

Definition at line 1050 of file container.h.

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

Definition at line 1060 of file container.h.

template<typename C , typename T >
void absl::c_fill ( C &  c,
T &&  value 
)

Definition at line 608 of file container.h.

template<typename C , typename Size , typename T >
void absl::c_fill_n ( C &  c,
Size  n,
T &&  value 
)

Definition at line 618 of file container.h.

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

Definition at line 202 of file container.h.

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

Definition at line 236 of file container.h.

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

Definition at line 247 of file container.h.

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

Definition at line 261 of file container.h.

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

Definition at line 272 of file container.h.

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

Definition at line 213 of file container.h.

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

Definition at line 224 of file container.h.

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

Definition at line 191 of file container.h.

template<typename C , typename Generator >
void absl::c_generate ( C &  c,
Generator &&  gen 
)

Definition at line 628 of file container.h.

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

Definition at line 640 of file container.h.

template<typename C1 , typename C2 >
bool absl::c_includes ( const C1 &  c1,
const C2 &  c2 
)

Definition at line 1144 of file container.h.

template<typename C1 , typename C2 , typename Compare >
bool absl::c_includes ( const C1 &  c1,
const C2 &  c2,
Compare &&  comp 
)

Definition at line 1154 of file container.h.

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

Definition at line 1630 of file container.h.

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

Definition at line 1643 of file container.h.

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

Definition at line 1121 of file container.h.

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

Definition at line 1130 of file container.h.

template<typename Sequence , typename T >
void absl::c_iota ( Sequence &  sequence,
T &&  value 
)

Definition at line 1589 of file container.h.

template<typename RandomAccessContainer >
bool absl::c_is_heap ( const RandomAccessContainer &  sequence)

Definition at line 1400 of file container.h.

template<typename RandomAccessContainer , typename Compare >
bool absl::c_is_heap ( const RandomAccessContainer &  sequence,
Compare &&  comp 
)

Definition at line 1408 of file container.h.

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

Definition at line 1420 of file container.h.

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

Definition at line 1429 of file container.h.

template<typename C , typename Pred >
bool absl::c_is_partitioned ( const C &  c,
Pred &&  pred 
)

Definition at line 767 of file container.h.

template<typename C1 , typename C2 >
bool absl::c_is_permutation ( const C1 &  c1,
const C2 &  c2 
)

Definition at line 390 of file container.h.

template<typename C1 , typename C2 , typename BinaryPredicate >
bool absl::c_is_permutation ( const C1 &  c1,
const C2 &  c2,
BinaryPredicate &&  pred 
)

Definition at line 400 of file container.h.

template<typename C >
bool absl::c_is_sorted ( const C &  c)

Definition at line 878 of file container.h.

template<typename C , typename Compare >
bool absl::c_is_sorted ( const C &  c,
Compare &&  comp 
)

Definition at line 886 of file container.h.

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

Definition at line 951 of file container.h.

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

Definition at line 959 of file container.h.

template<typename Sequence1 , typename Sequence2 >
bool absl::c_lexicographical_compare ( Sequence1 &&  sequence1,
Sequence2 &&  sequence2 
)

Definition at line 1518 of file container.h.

template<typename Sequence1 , typename Sequence2 , typename Compare >
bool absl::c_lexicographical_compare ( Sequence1 &&  sequence1,
Sequence2 &&  sequence2,
Compare &&  comp 
)

Definition at line 1529 of file container.h.

template<typename C , typename EqualityComparable >
bool absl::c_linear_search ( const C &  c,
EqualityComparable &&  value 
)

Definition at line 128 of file container.h.

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

Definition at line 1003 of file container.h.

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

Definition at line 1013 of file container.h.

template<typename RandomAccessContainer >
void absl::c_make_heap ( RandomAccessContainer &  sequence)

Definition at line 1362 of file container.h.

template<typename RandomAccessContainer , typename Compare >
void absl::c_make_heap ( RandomAccessContainer &  sequence,
Compare &&  comp 
)

Definition at line 1370 of file container.h.

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

Definition at line 1467 of file container.h.

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

Definition at line 1476 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator >
OutputIterator absl::c_merge ( const C1 &  c1,
const C2 &  c2,
OutputIterator  result 
)

Definition at line 1097 of file container.h.

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

Definition at line 1107 of file container.h.

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

Definition at line 1445 of file container.h.

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

Definition at line 1454 of file container.h.

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

Definition at line 1491 of file container.h.

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

Definition at line 1500 of file container.h.

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

Definition at line 332 of file container.h.

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

Definition at line 342 of file container.h.

template<typename C , typename OutputIterator >
OutputIterator absl::c_move ( C &&  src,
OutputIterator  dest 
)

Definition at line 508 of file container.h.

template<typename C >
bool absl::c_next_permutation ( C &  c)

Definition at line 1545 of file container.h.

template<typename C , typename Compare >
bool absl::c_next_permutation ( C &  c,
Compare &&  comp 
)

Definition at line 1553 of file container.h.

template<typename C , typename Pred >
bool absl::c_none_of ( const C &  c,
Pred &&  pred 
)

Definition at line 180 of file container.h.

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

Definition at line 974 of file container.h.

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

Definition at line 984 of file container.h.

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

Definition at line 898 of file container.h.

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

Definition at line 908 of file container.h.

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

Definition at line 925 of file container.h.

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

Definition at line 936 of file container.h.

template<typename InputSequence , typename OutputIt >
OutputIt absl::c_partial_sum ( const InputSequence &  input,
OutputIt  output_first 
)

Definition at line 1682 of file container.h.

template<typename InputSequence , typename OutputIt , typename BinaryOp >
OutputIt absl::c_partial_sum ( const InputSequence &  input,
OutputIt  output_first,
BinaryOp &&  op 
)

Definition at line 1691 of file container.h.

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

Definition at line 780 of file container.h.

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

Definition at line 809 of file container.h.

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

Definition at line 823 of file container.h.

template<typename RandomAccessContainer >
void absl::c_pop_heap ( RandomAccessContainer &  sequence)

Definition at line 1343 of file container.h.

template<typename RandomAccessContainer , typename Compare >
void absl::c_pop_heap ( RandomAccessContainer &  sequence,
Compare &&  comp 
)

Definition at line 1351 of file container.h.

template<typename C >
bool absl::c_prev_permutation ( C &  c)

Definition at line 1565 of file container.h.

template<typename C , typename Compare >
bool absl::c_prev_permutation ( C &  c,
Compare &&  comp 
)

Definition at line 1573 of file container.h.

template<typename RandomAccessContainer >
void absl::c_push_heap ( RandomAccessContainer &  sequence)

Definition at line 1324 of file container.h.

template<typename RandomAccessContainer , typename Compare >
void absl::c_push_heap ( RandomAccessContainer &  sequence,
Compare &&  comp 
)

Definition at line 1332 of file container.h.

template<typename C , typename OutputIterator , typename T >
OutputIterator absl::c_remove_copy ( const C &  c,
OutputIterator  result,
T &&  value 
)

Definition at line 657 of file container.h.

template<typename C , typename OutputIterator , typename Pred >
OutputIterator absl::c_remove_copy_if ( const C &  c,
OutputIterator  result,
Pred &&  pred 
)

Definition at line 669 of file container.h.

template<typename Sequence , typename T >
void absl::c_replace ( Sequence &  sequence,
const T &  old_value,
const T &  new_value 
)

Definition at line 557 of file container.h.

template<typename C , typename OutputIterator , typename T >
OutputIterator absl::c_replace_copy ( const C &  c,
OutputIterator  result,
T &&  old_value,
T &&  new_value 
)

Definition at line 581 of file container.h.

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

Definition at line 595 of file container.h.

template<typename C , typename Pred , typename T >
void absl::c_replace_if ( C &  c,
Pred &&  pred,
T &&  new_value 
)

Definition at line 569 of file container.h.

template<typename Sequence >
void absl::c_reverse ( Sequence &  sequence)

Definition at line 702 of file container.h.

template<typename C , typename OutputIterator >
OutputIterator absl::c_reverse_copy ( const C &  sequence,
OutputIterator  result 
)

Definition at line 712 of file container.h.

template<typename C , typename Iterator = container_algorithm_internal::ContainerIter<C>>
Iterator absl::c_rotate ( C &  sequence,
Iterator  middle 
)

Definition at line 725 of file container.h.

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

Definition at line 736 of file container.h.

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

Definition at line 413 of file container.h.

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

Definition at line 424 of file container.h.

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

Definition at line 438 of file container.h.

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

Definition at line 449 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_difference ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output 
)

Definition at line 1248 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_difference ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output,
Compare &&  comp 
)

Definition at line 1265 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_intersection ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output 
)

Definition at line 1210 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_intersection ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output,
Compare &&  comp 
)

Definition at line 1227 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_symmetric_difference ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output 
)

Definition at line 1286 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_symmetric_difference ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output,
Compare &&  comp 
)

Definition at line 1304 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_union ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output 
)

Definition at line 1174 of file container.h.

template<typename C1 , typename C2 , typename OutputIterator , typename Compare , typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C1>::value, void>::type, typename = typename std::enable_if< !container_algorithm_internal::IsUnorderedContainer<C2>::value, void>::type>
OutputIterator absl::c_set_union ( const C1 &  c1,
const C2 &  c2,
OutputIterator  output,
Compare &&  comp 
)

Definition at line 1190 of file container.h.

template<typename RandomAccessContainer , typename UniformRandomBitGenerator >
void absl::c_shuffle ( RandomAccessContainer &  c,
UniformRandomBitGenerator &&  gen 
)

Definition at line 751 of file container.h.

template<typename C >
void absl::c_sort ( C &  c)

Definition at line 839 of file container.h.

template<typename C , typename Compare >
void absl::c_sort ( C &  c,
Compare &&  comp 
)

Definition at line 847 of file container.h.

template<typename RandomAccessContainer >
void absl::c_sort_heap ( RandomAccessContainer &  sequence)

Definition at line 1381 of file container.h.

template<typename RandomAccessContainer , typename Compare >
void absl::c_sort_heap ( RandomAccessContainer &  sequence,
Compare &&  comp 
)

Definition at line 1389 of file container.h.

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

Definition at line 794 of file container.h.

template<typename C >
void absl::c_stable_sort ( C &  c)

Definition at line 859 of file container.h.

template<typename C , typename Compare >
void absl::c_stable_sort ( C &  c,
Compare &&  comp 
)

Definition at line 867 of file container.h.

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

Definition at line 518 of file container.h.

template<typename InputSequence , typename OutputIterator , typename UnaryOp >
OutputIterator absl::c_transform ( const InputSequence &  input,
OutputIterator  output,
UnaryOp &&  unary_op 
)

Definition at line 531 of file container.h.

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

Definition at line 542 of file container.h.

template<typename C , typename OutputIterator >
OutputIterator absl::c_unique_copy ( const C &  c,
OutputIterator  result 
)

Definition at line 682 of file container.h.

template<typename C , typename OutputIterator , typename BinaryPredicate >
OutputIterator absl::c_unique_copy ( const C &  c,
OutputIterator  result,
BinaryPredicate &&  pred 
)

Definition at line 690 of file container.h.

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

Definition at line 1026 of file container.h.

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

Definition at line 1036 of file container.h.

template<typename Callable , typename... Args>
void absl::call_once ( absl::once_flag flag,
Callable &&  fn,
Args &&...  args 
)

Definition at line 202 of file call_once.h.

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

Definition at line 507 of file duration.cc.

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

Definition at line 1039 of file escaping.cc.

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

Definition at line 1874 of file mutex.cc.

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

Definition at line 1045 of file escaping.cc.

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

Definition at line 548 of file string_view.h.

static void absl::CondVarEnqueue ( SynchWaitParams waitp)
static

Definition at line 2475 of file mutex.cc.

bool absl::ConsumePrefix ( absl::string_view str,
absl::string_view  expected 
)
inline

Definition at line 44 of file strip.h.

bool absl::ConsumeSuffix ( absl::string_view str,
absl::string_view  expected 
)
inline

Definition at line 59 of file strip.h.

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

Definition at line 396 of file time.cc.

template<typename To , typename Variant >
To absl::ConvertVariantTo ( Variant &&  variant)

Definition at line 848 of file variant.h.

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

Definition at line 74 of file escaping.h.

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

Definition at line 1034 of file escaping.cc.

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

Definition at line 1275 of file mutex.cc.

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

Definition at line 591 of file mutex.cc.

static GraphId absl::DeadlockCheck ( Mutex mu)
static

Definition at line 1308 of file mutex.cc.

static GraphId absl::DebugOnlyDeadlockCheck ( Mutex mu)
inlinestatic

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)
inlinestatic

Definition at line 1225 of file mutex.cc.

static void absl::DebugOnlyLockEnter ( Mutex mu,
GraphId  id 
)
inlinestatic

Definition at line 1235 of file mutex.cc.

static void absl::DebugOnlyLockLeave ( Mutex mu)
inlinestatic

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.

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

Definition at line 2679 of file mutex.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.

Duration absl::DurationFromTimespec ( timespec  ts)

Definition at line 516 of file duration.cc.

Duration absl::DurationFromTimeval ( timeval  tv)

Definition at line 524 of file duration.cc.

void absl::EnableMutexInvariantDebugging ( bool  enabled)

Definition at line 730 of file mutex.cc.

bool absl::EndsWith ( absl::string_view  text,
absl::string_view  suffix 
)
inline

Definition at line 61 of file match.h.

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

Definition at line 33 of file match.cc.

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

Definition at line 869 of file mutex.cc.

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

Definition at line 308 of file mutex.cc.

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

Definition at line 99 of file algorithm.h.

template<typename InputIter1 , typename InputIter2 >
bool absl::equal ( InputIter1  first1,
InputIter1  last1,
InputIter2  first2,
InputIter2  last2 
)

Definition at line 110 of file algorithm.h.

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

Definition at line 21 of file match.cc.

static bool absl::EvalConditionAnnotated ( const Condition cond,
Mutex mu,
bool  locking,
bool  trylock,
bool  read_lock 
)
inlinestatic

Definition at line 1757 of file mutex.cc.

static bool absl::EvalConditionIgnored ( Mutex mu,
const Condition cond 
)
inlinestatic

Definition at line 1807 of file mutex.cc.

static bool absl::ExactlyOneReader ( intptr_t  v)
static

Definition at line 1702 of file mutex.cc.

template<typename T , typename U = T>
T absl::exchange ( T &  obj,
U &&  new_value 
)

Definition at line 312 of file utility.h.

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::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)
noexcept

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 T& absl::get ( variant< Types... > &  v)

Definition at line 297 of file variant.h.

template<class T , class... Types>
constexpr T&& absl::get ( variant< Types... > &&  v)

Definition at line 305 of file variant.h.

template<class T , class... Types>
constexpr const T& absl::get ( const variant< Types... > &  v)

Definition at line 312 of file variant.h.

template<class T , class... Types>
constexpr const T&& absl::get ( const variant< Types... > &&  v)

Definition at line 320 of file variant.h.

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

Definition at line 327 of file variant.h.

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

Definition at line 335 of file variant.h.

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

Definition at line 342 of file variant.h.

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

Definition at line 350 of file variant.h.

template<std::size_t I, class... Types>
constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...> > > absl::get_if ( variant< Types... > *  v)
noexcept

Definition at line 369 of file variant.h.

template<std::size_t I, class... Types>
constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...> > > absl::get_if ( const variant< Types... > *  v)
noexcept

Definition at line 380 of file variant.h.

template<class T , class... Types>
constexpr absl::add_pointer_t<T> absl::get_if ( variant< Types... > *  v)
noexcept

Definition at line 390 of file variant.h.

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

Definition at line 397 of file variant.h.

int64_t absl::GetCurrentTimeNanos ( )

Definition at line 74 of file clock.cc.

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

Definition at line 86 of file flag.h.

static GraphId absl::GetGraphId ( Mutex mu)
static

Definition at line 1155 of file mutex.cc.

static GraphId absl::GetGraphIdLocked ( Mutex mu)
static

Definition at line 1145 of file mutex.cc.

static PerThreadSynch* absl::GetPerThreadSynch ( intptr_t  v)
inlinestatic

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)
inlinestatic

Definition at line 47 of file notification.cc.

bool absl::HaveLeakSanitizer ( )

Definition at line 24 of file leak_check.cc.

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

Definition at line 1113 of file escaping.cc.

template<class T , class... Types>
constexpr bool absl::holds_alternative ( const variant< Types... > &  v)
noexcept

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.

constexpr Duration absl::InfiniteDuration ( )

Definition at line 1513 of file time.h.

constexpr Time absl::InfiniteFuture ( )

Definition at line 701 of file time.h.

constexpr Time absl::InfinitePast ( )

Definition at line 709 of file time.h.

void absl::InitializeSymbolizer ( const char *  argv0)
void absl::InstallFailureSignalHandler ( const FailureSignalHandlerOptions options)

Definition at line 352 of file failure_signal_handler.cc.

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

Definition at line 179 of file failure_signal_handler.cc.

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

Definition at line 22 of file blocking_counter.cc.

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

Definition at line 23 of file barrier.cc.

template<typename InputIterator , typename EqualityComparable >
bool absl::linear_search ( InputIterator  first,
InputIterator  last,
const EqualityComparable &  value 
)

Definition at line 124 of file algorithm.h.

bool absl::LoadTimeZone ( const std::string &  name,
TimeZone tz 
)
inline

Definition at line 1002 of file time.h.

TimeZone absl::LocalTimeZone ( )
inline

Definition at line 1036 of file time.h.

static void absl::LockEnter ( Mutex mu,
GraphId  id,
SynchLocksHeld held_locks 
)
static

Definition at line 1165 of file mutex.cc.

static void absl::LockLeave ( Mutex mu,
GraphId  id,
SynchLocksHeld held_locks 
)
static

Definition at line 1189 of file mutex.cc.

static SynchLocksHeld* absl::LocksHeldAlloc ( )
static

Definition at line 511 of file mutex.cc.

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

Definition at line 37 of file log_severity.h.

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

Definition at line 44 of file log_severity.h.

template<typename T , typename... Args>
any absl::make_any ( Args &&...  args)

Definition at line 467 of file any.h.

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

Definition at line 473 of file any.h.

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

Definition at line 566 of file optional.h.

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

Definition at line 571 of file optional.h.

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

Definition at line 576 of file optional.h.

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

Definition at line 166 of file memory.h.

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

Definition at line 176 of file memory.h.

template<typename T , typename... Args>
memory_internal::MakeUniqueResult<T>::invalid absl::make_unique ( Args &&  ...)
delete
template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span<const T> absl::MakeConstSpan ( T *  ptr,
size_t  size 
)
noexcept

Definition at line 692 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >
Span<const T> absl::MakeConstSpan ( T *  begin,
T *  end 
)
noexcept

Definition at line 697 of file span.h.

template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto absl::MakeConstSpan ( const C &  c) -> decltype(MakeSpan(c))
noexcept

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])
noexcept

Definition at line 707 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >
constexpr Span<T> absl::MakeSpan ( T *  ptr,
size_t  size 
)
noexcept

Definition at line 647 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T >
Span<T> absl::MakeSpan ( T *  begin,
T *  end 
)
noexcept

Definition at line 652 of file span.h.

template<int &... ExplicitArgumentBarrier, typename C >
constexpr auto absl::MakeSpan ( C &  c) -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size()))
noexcept

Definition at line 657 of file span.h.

template<int &... ExplicitArgumentBarrier, typename T , size_t N>
constexpr Span<T> absl::MakeSpan ( T(&)  array[N])
noexcept

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)
noexcept

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.

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

Definition at line 56 of file log_severity.h.

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

Definition at line 61 of file log_severity.h.

absl::Time absl::Now ( )

Definition at line 37 of file clock.cc.

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

Definition at line 559 of file string_view.h.

bool absl::operator! ( uint128  val)
inline

Definition at line 580 of file int128.h.

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

Definition at line 209 of file time.h.

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

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 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x != *y))

Definition at line 608 of file optional.h.

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

Definition at line 651 of file optional.h.

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

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 
) -> decltype(optional_internal::convertible_to_bool(*x != 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 
) -> decltype(optional_internal::convertible_to_bool(v != *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   
)
noexcept

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 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x < *y))

Definition at line 617 of file optional.h.

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

Definition at line 659 of file optional.h.

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

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 
) -> decltype(optional_internal::convertible_to_bool(*x < 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 
) -> decltype(optional_internal::convertible_to_bool(v < *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   
)
noexcept

Definition at line 447 of file variant.h.

bool absl::operator<= ( string_view  x,
string_view  y 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x <= *y))

Definition at line 629 of file optional.h.

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

Definition at line 667 of file optional.h.

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

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 
) -> decltype(optional_internal::convertible_to_bool(*x <= 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 
) -> decltype(optional_internal::convertible_to_bool(v <= *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   
)
noexcept

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 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x == *y))

Definition at line 597 of file optional.h.

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

Definition at line 643 of file optional.h.

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

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 
) -> decltype(optional_internal::convertible_to_bool(*x == 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 
) -> decltype(optional_internal::convertible_to_bool(v == *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   
)
noexcept

Definition at line 446 of file variant.h.

bool absl::operator> ( string_view  x,
string_view  y 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x > *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   
)
noexcept

Definition at line 675 of file optional.h.

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

Definition at line 679 of file optional.h.

template<typename T , typename U >
constexpr auto absl::operator> ( const optional< T > &  x,
const U &  v 
) -> decltype(optional_internal::convertible_to_bool(*x > 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 
) -> decltype(optional_internal::convertible_to_bool(v > *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   
)
noexcept

Definition at line 448 of file variant.h.

bool absl::operator>= ( string_view  x,
string_view  y 
)
inlinenoexcept

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 
) -> decltype(optional_internal::convertible_to_bool(*x >= *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   
)
noexcept

Definition at line 683 of file optional.h.

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

Definition at line 687 of file optional.h.

template<typename T , typename U >
constexpr auto absl::operator>= ( const optional< T > &  x,
const U &  v 
) -> decltype(optional_internal::convertible_to_bool(*x >= 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 
) -> decltype(optional_internal::convertible_to_bool(v >= *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.