Global namespace

A type‐erased handle for an instance of an Abseil Flag and holds reflection information pertaining to that flag. Use CommandLineFlag to access a flag's name, location, help string etc.

CondVar

A condition variable that can be signaled to wake threads waiting on state evaluated outside a Mutex.

Condition

A predicate on state protected by a Mutex, used to wait for a condition to become true.

Cord

A sequence of characters stored as a tree of buffers.

CordBuffer

Manages memory buffers for building cords.

CordBufferTestPeer

Test‐only accessor for CordBuffer internals.

CordTestPeer

Test‐only accessor granting access to Cord internals.

Dec

Stores a set of decimal string conversion parameters for use within AlphaNum string conversions.

Duration

The absl::Duration class represents a signed, fixed‐length amount of time. A Duration is generated using a unit‐specific factory function, or is the result of subtracting one absl::Time from another. Durations behave like unit‐safe integers and they support all the natural integer‐like arithmetic operations. Arithmetic overflows and saturates at +/‐ infinity. Duration is trivially destructible and should be passed by value rather than const reference.

ExtraMessage

StatusBuilder policy to append an extra message to the original status.

FailureSignalHandlerOptions

Configuration options for absl::InstallFailureSignalHandler().

FastTypeIdType

The type returned by absl::FastTypeId<T>().

FixedArray

A run‐time fixed‐size array that allocates small arrays inline.

FlagSaver

A FlagSaver object stores the state of flags in the scope where the FlagSaver is defined, allowing modification of those flags within that scope and automatic restoration of the flags to their previous state upon leaving the scope.

FlagsUsageConfig

This structure contains the collection of callbacks for changing the behavior of the usage reporting routines in Abseil Flags.

FormatConversionSpec

Specifies modifications to the conversion of the format string, through use of one or more format flags in the source format string.

FormatConvertResult

Indicates whether a call to AbslFormatConvert() was successful.

FormatCountCapture

Safely wraps StrFormat() captures of %n conversions into an integer value.

FormatRawSink

A type erased wrapper around arbitrary sink objects specifically used as an argument to Format().

FormatSink

A generic abstraction to which conversions may write their formatted string data.

FunctionRef

FunctionRef

HasAbslStringify

Detects if type T supports the AbslStringify() customization point.

HasOstreamOperator

Detects if type T supports streaming to std::ostream`s with `operator<<.

HashState

A type‐erased version of the hash state concept.

Hex

Stores a set of hexadecimal string conversion parameters for use within AlphaNum string conversions.

InlinedVector

A drop‐in replacement for std::vector that stores small sequences inline.

InsecureBitGen

An efficient random bit generator for performance‐sensitive use cases.

LeakCheckDisabler

This helper class indicates that any heap allocations done in the code block covered by the scoped object, which should be allocated on the stack, will not be reported as leaks. Leak check disabling will occur within the code block and any nested function calls within the code block.

LogEntry

Represents a single entry in a log, i.e., one LOG statement or failed CHECK.

LogSink

absl::LogSink is an interface which can be extended to intercept and process particular messages (with LOG.ToSinkOnly() or LOG.ToSinkAlso()) or all messages (if registered with absl::AddLogSink). Implementations must not take any locks that might be held by the LOG caller.

LogStreamer

Although you can stream into LOG(INFO), you can't pass it into a function that takes a std::ostream parameter. LogStreamer::stream() provides a std::ostream that buffers everything that's streamed in. The buffer's contents are logged as if by LOG when the LogStreamer is destroyed. If nothing is streamed in, an empty message is logged. If the specified severity is absl::LogSeverity::kFatal, the program will be terminated when the LogStreamer is destroyed regardless of whether any data were streamed in.

MuHowS

A constant that indicates how a lock should be acquired.

Mutex

A non‐reentrant mutually exclusive lock that also supports reader‐writer locking and conditional critical regions.

MutexLock

RAII helper that acquires and releases a Mutex exclusively.

MutexLockMaybe

RAII helper like MutexLock, but a no‐op when the mutex pointer is null.

NoDestructor

NoDestructor<T> is a wrapper around an object of type T that behaves as an object of type T but never calls T's destructor. NoDestructor<T> makes it safer and/or more efficient to use such objects in static storage contexts, ideally as function scope static variables.

Notification

Lets threads wait for a single occurrence of a single event.

Overload

absl::Overload is a functor that provides overloads based on the functors with which it is created. This can, for example, be used to locally define an anonymous visitor type for std::visit inside a function using lambdas.

ReaderMutexLock

RAII helper that acquires and releases a shared (reader) lock on a Mutex.

ReleasableMutexLock

RAII helper like MutexLock that also permits releasing the mutex before destruction.

ScopedStderrThreshold

RAII type used to temporarily update the Stderr Threshold parameter.

SeedGenException

An exception thrown when suitable seed‐material cannot be derived.

SimulatedClock

A simulated clock is a concrete Clock implementation that does not "tick" on its own. Time is advanced by explicit calls to the AdvanceTime() or SetTime() functions.

SkipEmpty

Returns false if the given absl::string_view is empty, indicating that StrSplit() should omit the empty string.

SkipWhitespace

Returns false if the given absl::string_view is empty or contains only whitespace, indicating that StrSplit() should omit the string.

Span

A non‐owning view over a contiguous sequence of objects.

Status

A type used to gracefully handle errors across API boundaries.

StatusBuilder

Builds an absl::Status enriched with extra context, logging, and payloads.

StatusBuilderTest

Test fixture granted access to Rep's implementation.

StatusOr

A union of an object of type T and an absl::Status.

SynchWaitParams

Internal parameters describing a pending wait on a Mutex.

Time

An absl::Time represents a specific instant in time. Arithmetic operators are provided for naturally expressing time calculations. Instances are created using absl::Now() and the absl::From*() factory functions that accept the gamut of other time representations. Formatting and parsing functions are provided for conversion to and from strings. absl::Time is trivially destructible and should be passed by value rather than const reference.

TimeConversion [deprecated]

An absl::TimeConversion represents the conversion of year, month, day, hour, minute, and second values (i.e., a civil time), in a particular absl::TimeZone, to a time instant (an absolute time), as returned by absl::ConvertDateTime(). Legacy version of absl::TimeZone::TimeInfo.

TimeZone

The absl::TimeZone is an opaque, small, value‐type class representing a geo‐political region within which particular rules are used for converting between absolute and civil times (see https://git.io/v59Ly). absl::TimeZone values are named using the TZ identifiers from the IANA Time Zone Database, such as "America/Los_Angeles" or "Australia/Sydney". absl::TimeZone values are created from factory functions such as absl::LoadTimeZone(). Note: strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by value rather than const reference.

UnrecognizedFlag

Represents information about an unrecognized flag in the command line.

UntypedFormatSpec

A type‐erased class that can be used directly within untyped API entry points.

WriterMutexLock

RAII helper that acquires and releases a write (exclusive) lock on a Mutex.

allocator_is_nothrow

Trait class reporting whether an allocator's allocation never throws.

bernoulli_distribution

A drop in replacement for std::bernoulli_distribution.

beta_distribution

Generates a floating‐point variate conforming to a Beta distribution: pdf(x) propto xˆ(alpha‐1) * (1‐x)ˆ(beta‐1), where the params alpha and beta are both strictly positive real values.

btree_map

An ordered associative container of unique keys and associated values.

btree_multimap

An ordered associative container of keys and associated values that allows equivalent keys.

btree_multiset

An ordered associative container of keys that allows equivalent keys.

btree_set

An ordered associative container of unique keys.

chunked_queue

A queue implemented as a linked list of fixed or variable sized blocks.

crc32c_t

A strongly‐typed integer for holding a CRC32C value.

default_allocator_is_nothrow

Trait reporting whether the default allocator's allocation never throws.

discrete_distribution

A distribution over random integers.

exponential_distribution

Generates a number conforming to an exponential distribution.

flat_hash_map

An unordered associative container of unique keys and associated values, optimized for speed and memory footprint.

flat_hash_set

An unordered associative container of unique keys, optimized for speed and memory footprint.

from_chars_result

The return result of a string‐to‐number conversion.

gaussian_distribution

Generates a number conforming to a Gaussian distribution.

int128

A signed 128‐bit integer type.

is_trivially_relocatable

https://github.com/llvm/llvm‐project/pull/127636#pullrequestreview‐2637005293 In the current implementation, __builtin_is_cpp_trivially_relocatable will only return true for types that are trivially relocatable according to the standard. Notably, this means that marking a type [[clang::trivial_abi]] aka ABSL_HAVE_ATTRIBUTE_TRIVIAL_ABI will have no effect on this trait.

linked_hash_map

An insertion‐ordered map.

linked_hash_set

A simple insertion‐ordered set.

log_uniform_int_distribution

Returns a random variate R in range [min, max]such that floor(log(R‐min, base)) is uniformly distributed.

node_hash_map

An unordered associative container of unique keys and associated values that provides pointer stability for its elements.

node_hash_set

An unordered associative container of unique keys that provides pointer stability for its elements.

nontype_t

Backfill for std::nontype_t.

once_flag

Objects of this type are used to distinguish calls to call_once() and ensure the provided function is only invoked once across all threads. This type is not copyable or movable. However, it has a constexpr constructor, and is safe to use as a namespace‐scoped global variable.

optional_ref

A std::optional‐like interface around a T*.

poisson_distribution

A distribution that generates discrete Poisson‐distributed variates.

uint128

An unsigned 128‐bit integer type.

uniform_int_distribution

This distribution produces random integer values uniformly distributed in the closed (inclusive) interval [a, b].

uniform_real_distribution

This distribution produces random floating‐point values uniformly distributed over the half‐open interval [a, b).]

zipf_distribution

A distribution over random integer‐values in the range [0, k].

Type Aliases

Name

Description

CivilDay

A civil‐time value aligned to the day field (YYYY‐MM‐DD).

CivilHour

A civil‐time value aligned to the hour field (YYYY‐MM‐DD hh).

CivilMinute

A civil‐time value aligned to the minute field (YYYY‐MM‐DD hh:mm).

CivilMonth

A civil‐time value aligned to the month field (YYYY‐MM).

CivilSecond

A civil‐time value aligned to the second field (YYYY‐MM‐DD hh:mm:ss).

CivilYear

A civil‐time value aligned to the year field (YYYY).

DefaultHashContainerEq

Convenience alias for the default equality functor of Abseil hash‐based (unordered) containers.

DefaultHashContainerHash

Convenience alias for the default hashing functor of Abseil hash‐based (unordered) containers.

EnableSplitIfString

Enables a StrSplit() overload only when T is std::string.

Flag

Forward declaration of the absl::Flag type for use in defining the macro.

FormatArg

A type‐erased handle to a format argument specifically used as an argument to FormatUntyped().

FormatSpec

Defines the makeup of a format string within the str_format library.

Hash

A convenient general‐purpose hash functor for any hashable type T.

ParsedFormat

A class template representing a preparsed FormatSpec, with template arguments specifying the conversion characters used within the format string.

SeedSeq

A seed sequence conforming to [rand.req.seedseq]for use within bit generators.

SourceLocation

Provides source‐code location information for C++17 and later.

Weekday

The Weekday enum class represents the civil‐time concept of a "weekday" with members for all days of the week.

add_const_t [deprecated]

Deprecated alias for std::add_const_t. Prefer the std version directly.

add_cv_t [deprecated]

Deprecated alias for std::add_cv_t. Prefer the std version directly.

add_lvalue_reference_t [deprecated]

Deprecated alias for std::add_lvalue_reference_t. Prefer the std version directly.

add_pointer_t [deprecated]

Deprecated alias for std::add_pointer_t. Prefer the std version directly.

add_rvalue_reference_t [deprecated]

Deprecated alias for std::add_rvalue_reference_t. Prefer the std version directly.

add_volatile_t [deprecated]

Deprecated alias for std::add_volatile_t. Prefer the std version directly.

allocator_traits [deprecated]

Uniform interface to the properties of an allocator type.

any [deprecated]

Alias for std::any (deprecated; use std::any directly).

bad_any_cast [deprecated]

Alias for std::bad_any_cast (deprecated; use std::bad_any_cast).

bad_optional_access

Alias for std::bad_optional_access.

bad_variant_access

Alias for std::bad_variant_access.

civil_diff_t

Type alias of the difference between two civil‐time values. This type is used to indicate arguments that are not normalized (such as parameters to the civil‐time constructors), the results of civil‐time subtraction, or the operand to civil‐time addition.

civil_year_t

Type alias of a civil‐time year value. This type is guaranteed to (at least) support any year value supported by time_t.

common_type_t [deprecated]

Deprecated alias for std::common_type_t. Prefer the std version directly.

conditional_t [deprecated]

Deprecated alias for std::conditional_t. Prefer the std version directly.

conjunction [deprecated]

Deprecated alias for std::conjunction. Prefer the std version directly.

decay_t [deprecated]

Deprecated alias for std::decay_t. Prefer the std version directly.

disjunction [deprecated]

Deprecated alias for std::disjunction. Prefer the std version directly.

enable_if_t [deprecated]

Deprecated alias for std::enable_if_t. Prefer the std version directly. Avoid inlining since the inliner cannot handle default arguments well.

in_place_index_t [deprecated]

Tag type for in‐place construction at a given index.

in_place_t [deprecated]

Tag type for in‐place construction.

in_place_type_t [deprecated]

Tag type for in‐place construction of a given type.

index_sequence [deprecated]

Compile‐time sequence of size_t indices.

index_sequence_for [deprecated]

Index sequence covering the given parameter pack.

integer_sequence [deprecated]

Compile‐time sequence of integers of a given type.

is_copy_assignable [deprecated]

Deprecated alias for std::is_copy_assignable. Prefer the std version directly.

is_function [deprecated]

Deprecated alias for std::is_function. Prefer the std version directly.

is_move_assignable [deprecated]

Deprecated alias for std::is_move_assignable. Prefer the std version directly.

is_trivially_copy_assignable [deprecated]

Deprecated alias for std::is_trivially_copy_assignable. Prefer the std version directly.

is_trivially_copy_constructible [deprecated]

Deprecated alias for std::is_trivially_copy_constructible. Prefer the std version directly.

is_trivially_default_constructible [deprecated]

Deprecated alias for std::is_trivially_default_constructible. Prefer the std version directly.

is_trivially_destructible [deprecated]

Deprecated alias for std::is_trivially_destructible. Prefer the std version directly.

is_trivially_move_assignable [deprecated]

Deprecated alias for std::is_trivially_move_assignable. Prefer the std version directly.

is_trivially_move_constructible [deprecated]

Deprecated alias for std::is_trivially_move_constructible. Prefer the std version directly.

make_index_sequence [deprecated]

Index sequence of the values 0, 1, ..., N‐1.

make_integer_sequence [deprecated]

Integer sequence of the values 0, 1, ..., N‐1 of a given type.

make_signed_t [deprecated]

Deprecated alias for std::make_signed_t. Prefer the std version directly.

make_unsigned_t [deprecated]

Deprecated alias for std::make_unsigned_t. Prefer the std version directly.

monostate

Alias for std::monostate, an empty variant alternative.

negation [deprecated]

Deprecated alias for std::negation. Prefer the std version directly.

nullopt_t

Alias for std::nullopt_t, the type of nullopt.

pointer_traits [deprecated]

Uniform interface to the properties of a pointer‐like type.

remove_all_extents_t [deprecated]

Deprecated alias for std::remove_all_extents_t. Prefer the std version directly.

remove_const_t [deprecated]

Deprecated alias for std::remove_const_t. Prefer the std version directly.

remove_cv_t [deprecated]

Deprecated alias for std::remove_cv_t. Prefer the std version directly.

remove_cvref

C++17 compatible implementation of std::remove_cvref, which was added in C++20. Aliases std::remove_cvref when it is available.

remove_cvref_t

Convenience alias for remove_cvref<T>::type.

remove_extent_t [deprecated]

Deprecated alias for std::remove_extent_t. Prefer the std version directly.

remove_pointer_t [deprecated]

Deprecated alias for std::remove_pointer_t. Prefer the std version directly.

remove_reference_t [deprecated]

Deprecated alias for std::remove_reference_t. Prefer the std version directly.

remove_volatile_t [deprecated]

Deprecated alias for std::remove_volatile_t. Prefer the std version directly.

result_of_t [deprecated]

Deprecated alias for std::invoke_result_t. Prefer the std version directly.

type_identity

Back‐fill of C++20's std::type_identity. Aliases std::type_identity when it is available.

type_identity_t

Convenience alias for type_identity<T>::type.

underlying_type_t [deprecated]

Deprecated alias for std::underlying_type_t. Prefer the std version directly.

variant

Alias for std::variant.

variant_alternative

Alias for std::variant_alternative, the type of alternative I.

variant_alternative_t

Alias for std::variant_alternative_t, the type of alternative I.

variant_size

Alias for std::variant_size, the number of alternatives.

void_t [deprecated]

Ignores the type of any its arguments and returns void. In general, this metafunction allows you to create a general case that maps to void while allowing specializations that map to specific types.

Enums

Name

Description

ConstInitType

Enumerates the constructor tags used to mark an object as safe for use as a global variable.

CordMemoryAccounting

Memory accounting modes for Cord::EstimatedMemoryUsage().

FormatConversionChar

Specifies the formatting character provided in the format string passed to StrFormat().

FormatConversionCharSet

Specifies the accepted conversion types as a template parameter to FormatConvertResult for custom implementations of AbslFormatConvert.

LogSeverity

Four severity levels are defined. Logging APIs should terminate the program when a message is logged at severity kFatal; the other levels have no special semantics.

LogSeverityAtLeast

Enums representing a lower bound for LogSeverity. APIs that only operate on messages of at least a certain level (for example, SetMinLogLevel()) use this type to specify that level. absl::LogSeverityAtLeast::kInfinity is a level above all threshold levels and therefore no log message will ever meet this threshold.

LogSeverityAtMost

Enums representing an upper bound for LogSeverity. APIs that only operate on messages of at most a certain level (for example, buffer all messages at or below a certain level) use this type to specify that level. absl::LogSeverityAtMost::kNegativeInfinity is a level below all threshold levels and therefore will exclude all log messages.

MessageJoinStyle

Specifies how to join the error message in the original status and any additional message that has been streamed into the builder.

OnDeadlockCycle

Possible modes of operation for the deadlock detector in debug mode.

PadSpec

Specifies the number of significant digits to return in a Hex or Dec conversion and the fill character to use.

StatusCode

An enumerated type indicating either no error ("OK") or an error condition.

StatusToStringMode

An enumerated type indicating how absl::Status::ToString() should construct the output string for a non‐ok status.

chars_format

Workalike compatibility version of std::chars_format from C++17.

Functions

Name

Description

AbortedError

Creates a status with the kAborted error code and message.

AbsDuration

Returns the absolute value of a duration.

AbslFormatFlush

AbslFormatFlush overloads

AbslHashValue

AbslHashValue overloads

AbslInternalSetErrorCode

Argument‐dependent lookup extension point that sets a StatusBuilder's error code.

AbslParseFlag

AbslParseFlag overloads

AbslStringify

AbslStringify overloads

AbslUnparseFlag

AbslUnparseFlag overloads

AddLogSink

Adds a absl::LogSink as a consumer of logging data.

AlphaNumFormatter

Default formatter used if none is specified. Uses absl::AlphaNum to convert numeric arguments to strings.

AlreadyExistsError

Creates a status with the kAlreadyExists error code and message.

AppendCordToString

Appends the contents of a src Cord to a *dst string.

AsciiStrToLower

AsciiStrToLower overloads

AsciiStrToUpper

AsciiStrToUpper overloads

Base64Escape

Base64Escape overloads

Base64Unescape

Converts a src string encoded in Base64 (RFC 4648 section 4) to its binary equivalent, writing it to a dest buffer, returning true on success. If src contains invalid characters, dest is cleared and returns false. If padding is included (note that Base64Escape() does produce it), it must be correct. In the padding, '=' and '.' are treated identically.

Bernoulli

Produces a random boolean value with probability p of being true.

Beta

Produces a floating point value from a Beta distribution.

BytesToHexString

Converts binary data into an ASCII text string, returning a string of size 2*from.size().

CEscape

Escapes a src string using C‐style escapes sequences (https://en.cppreference.com/w/cpp/language/escape), escaping other non‐printable/non‐whitespace bytes as octal sequences (e.g. "377").

CHexEscape

Escapes a src string using C‐style escape sequences, escaping other non‐printable/non‐whitespace bytes as hexadecimal sequences (e.g. "xFF").

CUnescape

CUnescape overloads

CancelledError

CancelledError overloads

Ceil

Returns the ceiling of a duration using the passed duration unit to its smallest value not less than the duration.

ClearLogBacktraceLocation

Clears the set location so that backtraces will no longer be logged at it.

ClippedSubstr

Like s.substr(pos, n), but clips pos to an upper bound of s.size().

ComputeCrc32c

Compute the CRC32C value of the provided string.

ConcatCrc32c

Compute the CRC32C value of two concatenated buffers.

ConsumePrefix

Strips the expected prefix, if found, from the start of str. If the operation succeeded, true is returned. If not, false is returned and str is not modified.

ConsumeSuffix

Strips the expected suffix, if found, from the end of str. If the operation succeeded, true is returned. If not, false is returned and str is not modified.

ConvertDateTime [deprecated]

Legacy version of absl::TimeZone::At(absl::CivilSecond) that takes the civil time as six, separate values (YMDHMS).

ConvertVariantTo

Converts a variant to a variant of another set of types.

CopyCordToSpan

Copies up to dst.size() bytes starting from the beginning of src to dst.

CopyCordToString

Copies the contents of a src Cord into a *dst string.

CreateSeedSeqFrom

Constructs a seed sequence from variates produced by a bit generator.

DataLossError

Creates a status with the kDataLoss error code and message.

DeadlineExceededError

Creates a status with the kDeadlineExceeded error code and message.

DefaultStackUnwinder

Records program counter values of up to max_depth frames, skipping the most recent skip_count stack frames, and stores their corresponding values in pcs. (Note that the frame generated for this call itself is also skipped.) This function acts as a generic stack‐unwinder; prefer usage of the more specific GetStack{Trace,Frames}{,WithContext}() functions above.

DereferenceFormatter

DereferenceFormatter overloads

DisableFlagfileAndEnvParsing

Disables the processing of flags that load values from secondary sources, specifically ‐‐flagfile, ‐‐fromenv, and ‐‐tryfromenv. When disabled, occurrences of these flags on the command line are skipped without opening files or inspecting environment variables, and a warning is printed to stderr. Direct command‐line flags passed via argv are still parsed normally.

DoIgnoreLeak

Implements IgnoreLeak() below. This function should usually not be called directly; calling IgnoreLeak() is preferred.

DurationFromTimespec

Converts a timespec to an absl::Duration.

DurationFromTimeval

Converts a timeval to an absl::Duration.

EnableLogPrefix

Updates the value of the Prepend Log Prefix option.

EnableMutexInvariantDebugging

Enables or disables global support for Mutex invariant debugging.

EndsWith

Returns whether a given string text ends with suffix.

EndsWithIgnoreCase

Returns whether a given ASCII string text ends with suffix, ignoring case in the comparison.

EqualsIgnoreCase

Returns whether given ASCII strings piece1 and piece2 are equal, ignoring case in the comparison.

ErrnoToStatus

Convenience function that creates a absl::Status using an error_number, which should be an errno value.

ErrnoToStatusCode

Returns the StatusCode for error_number, which should be an errno value.

Exponential

Produces a floating point value from an exponential distribution.

ExtendCrc32c

Compute a CRC32C value from an existing value and an additional buffer.

ExtendCrc32cByZeroes

Extend a CRC32C value as if trailing zero bytes were appended.

FDivDuration

Divides a Duration numerator into a fractional number of units of a Duration denominator.

FPrintF

Writes to a file given a format string and zero or more arguments.

FailedPreconditionError

Creates a status with the kFailedPrecondition error code and message.

FastTypeId

FastTypeId<T>() is the generator method for FastTypeIdType values.

FindAndReportLeaks

If any leaks are detected, prints a leak report and returns true. This function may be called repeatedly, and does not affect end‐of‐process leak checking.

FindCommandLineFlag

Returns the reflection handle of an Abseil flag of the specified name, or nullptr if not found. This function will emit a warning if the name of a 'retired' flag is specified.

FindLongestCommonPrefix

Yields the longest prefix in common between both input strings. Pointer‐wise, the returned result is a subset of input "a".

FindLongestCommonSuffix

Yields the longest suffix in common between both input strings. Pointer‐wise, the returned result is a subset of input "a".

FixedTimeZone

Returns a TimeZone that is a fixed offset (seconds east) from UTC. Note: If the absolute value of the offset is greater than 24 hours you'll get UTC (i.e., no offset) instead.

Floor

Floors a duration using the passed duration unit to its largest value not greater than the duration.

FlushLogSinks

Calls absl::LogSink::Flush on all registered sinks.

Format

Writes a formatted string to an arbitrary sink object (implementing the absl::FormatRawSink interface), using a format string and zero or more additional arguments.

FormatCivilTime

Formats the given civil‐time value into a string value of the following format:

FormatDuration

Returns a string representing the duration in the form "72h3m0.5s". Returns "inf" or "‐inf" for +/‐ InfiniteDuration().

FormatStreamed

Takes a streamable argument and returns an object that can print it with '%s'.

FormatTime

FormatTime overloads

FormatUntyped

Writes a formatted string to an arbitrary sink object (implementing the absl::FormatRawSink interface), using an UntypedFormatSpec and zero or more additional arguments.

FromChrono

FromChrono overloads

FromCivil

Helper for TimeZone::At(CivilSecond) that provides "order‐preserving semantics." If the civil time maps to a unique time, that time is returned. If the civil time is repeated in the given time zone, the time using the pre‐transition offset is returned. Otherwise, the civil time is skipped in the given time zone, and the transition time is returned. This means that for any two civil times, ct1 and ct2, (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case being when two non‐existent civil times map to the same transition time.

FromDateTime [deprecated]

A convenience wrapper for absl::ConvertDateTime() that simply returns the "pre" absl::Time. That is, the unique result, or the instant that is correct using the pre‐transition offset (as if the transition never happened).

FromTM

Converts the tm_year, tm_mon, tm_mday, tm_hour, tm_min, and tm_sec fields to an absl::Time using the given time zone. See ctime(3) for a description of the expected values of the tm fields. If the civil time is unique (see absl::TimeZone::At(absl::CivilSecond) above), the matching time instant is returned. Otherwise, the tm_isdst field is consulted to choose between the possible results. For a repeated civil time, `tm_isdst != 0` returns the matching DST instant, while tm_isdst == 0` returns the matching non‐DST instant. For a skipped civil time there is no matching instant, so `tm_isdst != 0 returns the DST instant, and tm_isdst == 0 returns the non‐DST instant, that would have matched if the transition never happened.

FromTimeT

Creates an absl::Time from a time_t value.

FromUDate

Creates an absl::Time from an ICU UDate value.

FromUniversal

Creates an absl::Time from an ICU Universal Time Scale value.

FromUnixMicros

Creates an absl::Time from a count of microseconds since the Unix epoch.

FromUnixMillis

Creates an absl::Time from a count of milliseconds since the Unix epoch.

FromUnixNanos

Creates an absl::Time from a count of nanoseconds since the Unix epoch.

FromUnixSeconds

Creates an absl::Time from a count of seconds since the Unix epoch.

Gaussian

Produces a floating point value from a Gaussian (Normal) distribution.

GenericCompare

Compares lhs and rhs over the first size_to_compare bytes.

GetAllFlags

Returns current state of the Flags registry in a form of mapping from flag name to a flag reflection handle.

GetCordzInfoForTesting

Returns the internal Cordz sampling info for cord, for testing.

GetCurrentTimeNanos

Returns the current time, expressed as a count of nanoseconds since the Unix Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer absl::Now() instead for all but the most performance‐sensitive cases (i.e. when you are calling this function hundreds of thousands of times per second).

GetFlag

Returns the value (of type T) of an absl::Flag<T> instance, by value. Do not construct an absl::Flag<T> directly and call absl::GetFlag(); instead, refer to flag's constructed variable name (e.g. FLAGS_name). Because this function returns by value and not by reference, it is thread‐safe, but note that the operation may be expensive; as a result, avoid absl::GetFlag() within any tight loops.

GetFlagReflectionHandle

Returns the reflection handle corresponding to specified Abseil Flag instance. Use this handle to access flag's reflection information, like name, location, default value etc.

GetStackFrames

Records program counter values for up to max_depth frames, skipping the most recent skip_count stack frames, stores their corresponding values and sizes in results and sizes buffers, and returns the number of frames stored. (Note that the frame generated for the absl::GetStackFrames() routine itself is also skipped.)

GetStackFramesWithContext

Records program counter values obtained from a signal handler. Records program counter values for up to max_depth frames, skipping the most recent skip_count stack frames, stores their corresponding values and sizes in results and sizes buffers, and returns the number of frames stored. (Note that the frame generated for the absl::GetStackFramesWithContext() routine itself is also skipped.)

GetStackTrace

Records program counter values for up to max_depth frames, skipping the most recent skip_count stack frames, stores their corresponding values in results, and returns the number of frames stored. Note that this function is similar to absl::GetStackFrames() except that it returns the stack trace only, and not stack frame sizes.

GetStackTraceWithContext

Records program counter values obtained from a signal handler. Records program counter values for up to max_depth frames, skipping the most recent skip_count stack frames, stores their corresponding values in results, and returns the number of frames stored. (Note that the frame generated for the absl::GetStackFramesWithContext() routine itself is also skipped.)

GetWeekday

Returns the absl::Weekday for the given (realigned) civil‐time value.

GetYearDay

Returns the day‐of‐year for the given (realigned) civil‐time value.

HasPayload

Indicates whether the status that builder will return has a MessageSet payload.

HashOf

Generate a hash from the values of its arguments.

HaveLeakSanitizer

Returns true if a leak‐checking sanitizer (either ASan or standalone LSan) is currently built into this target.

HexStringToBytes

HexStringToBytes overloads

HighPrecision

HighPrecision overloads

Hours

Hours overloads

HwasanTagPointer

No‐op fallback used when HWASAN is not available.

IDivDuration

Divides a numerator Duration by a denominator Duration, returning the quotient and remainder. The remainder always has the same sign as the numerator. The returned quotient and remainder respect the identity:

IgnoreLeak

Instruct the leak sanitizer to ignore leak warnings on the object referenced by the passed pointer, as well as all heap objects transitively referenced by it. The passed object pointer can point to either the beginning of the object or anywhere within it.

InfiniteDuration

Returns an infinite Duration. To get a Duration representing negative infinity, use ‐InfiniteDuration().

InfiniteFuture

Returns an absl::Time that is infinitely far in the future.

InfinitePast

Returns an absl::Time that is infinitely far in the past.

InitializeLog

Initializes the Abseil logging library.

InitializeSymbolizer

Initializes the program counter symbolizer, given the path of the program (typically obtained through main()`s `argv[0]). The Abseil symbolizer allows you to read program counters (instruction pointer values) using their human‐readable names within output such as stack traces.

InstallFailureSignalHandler

Installs a signal handler for the common failure signals SIGSEGV, SIGILL, SIGFPE, SIGABRT, SIGTERM, SIGBUG, and SIGTRAP (provided they exist on the given platform). The failure signal handler dumps program failure data useful for debugging in an unspecified format to stderr. This data may include the program counter, a stacktrace, and register information on some systems; do not rely on an exact format for the output, as it is subject to change.

Int128High64

Returns the higher 64‐bit value of an int128 value.

Int128Low64

Returns the lower 64‐bit value of an int128 value.

Int128Max

Returns the maximum value for a 128‐bit signed integer.

Int128Min

Returns the minimum value for a 128‐bit signed integer.

InternalError

Creates a status with the kInternal error code and message.

InvalidArgumentError

Creates a status with the kInvalidArgument error code and message.

IsAborted

Returns true if status has the kAborted error code.

IsAlreadyExists

Returns true if status has the kAlreadyExists error code.

IsCancelled

Returns true if status has the kCancelled error code.

IsDataLoss

Returns true if status has the kDataLoss error code.

IsDeadlineExceeded

Returns true if status has the kDeadlineExceeded error code.

IsFailedPrecondition

Returns true if status has the kFailedPrecondition error code.

IsInternal

Returns true if status has the kInternal error code.

IsInvalidArgument

Returns true if status has the kInvalidArgument error code.

IsNotFound

Returns true if status has the kNotFound error code.

IsOutOfRange

Returns true if status has the kOutOfRange error code.

IsPermissionDenied

Returns true if status has the kPermissionDenied error code.

IsResourceExhausted

Returns true if status has the kResourceExhausted error code.

IsUnauthenticated

Returns true if status has the kUnauthenticated error code.

IsUnavailable

Returns true if status has the kUnavailable error code.

IsUnimplemented

Returns true if status has the kUnimplemented error code.

IsUnknown

Returns true if status has the kUnknown error code.

LeakCheckerIsActive

Returns true if a leak‐checking sanitizer (either ASan or standalone LSan) is currently built into this target and is turned on.

LoadTimeZone

Loads the named zone. May perform I/O on the initial load of the named zone. If the name is invalid, or some other kind of error occurs, returns false and *tz is set to the UTC time zone.

LocalTimeZone

Convenience method returning the local time zone, or UTC if there is no configured local zone. Warning: Be wary of using LocalTimeZone(), and particularly so in a server process, as the zone configured for the local machine should be irrelevant. Prefer an explicit zone name.

LogAsLiteral

Annotates its argument as a string literal so that structured logging captures it as a literal field instead of a str field (the default). This does not affect the text representation, only the structure.

LogDebugFatalStreamer

Returns a LogStreamer that writes at level LogSeverity::kLogDebugFatal.

LogErrorStreamer

Returns a LogStreamer that writes at level LogSeverity::kError.

LogFatalStreamer

Returns a LogStreamer that writes at level LogSeverity::kFatal.

LogInfoStreamer

Returns a LogStreamer that writes at level LogSeverity::kInfo.

LogSeverities

Returns an iterable of all standard absl::LogSeverity values, ordered from least to most severe.

LogSeverityName

Returns the all‐caps string representation (e.g. "INFO") of the specified severity level if it is one of the standard levels and "UNKNOWN" otherwise.

LogUniform

Produces random integral values whose logarithm is uniformly distributed.

LogWarningStreamer

Returns a LogStreamer that writes at level LogSeverity::kWarning.

MakeAnySpan

MakeAnySpan overloads

MakeCleanup

Create an absl::Cleanup from a callback.

MakeConstAnySpan

MakeConstAnySpan overloads

MakeConstDerefAnySpan

MakeConstDerefAnySpan overloads

MakeConstSpan

MakeConstSpan overloads

MakeCordFromExternal

Creates a Cord that takes ownership of external string memory.

MakeDerefAnySpan

MakeDerefAnySpan overloads

MakeInt128

Constructs an int128 numeric value from two 64‐bit integers.

MakeSeedSeq

Constructs an absl::SeedSeq salted with implementation‐defined entropy.

MakeSpan

MakeSpan overloads

MakeStatusRepImpl

Builds a status representation from an inlined rep and a message.

MakeUint128

Constructs a uint128 numeric value from two 64‐bit unsigned integers.

MarshalHashtableProfile

Serialize the current hash table profile into a string.

MaxSplits

A delimiter that limits the number of matches which can occur to the passed limit.

MemcpyCrc32c

Copy bytes while computing the CRC32C value of the copied data.

Microseconds

Microseconds overloads

Milliseconds

Milliseconds overloads

MinLogLevel

Returns the value of the Minimum Log Level parameter.

Minutes

Minutes overloads

Nanoseconds

Nanoseconds overloads

NextWeekday

Returns the absl::CivilDay that strictly follows a given absl::CivilDay, and that falls on the given absl::Weekday.

NormalizeLogSeverity

NormalizeLogSeverity overloads

NotFoundError

Creates a status with the kNotFound error code and message.

Now

Returns the current time, expressed as an absl::Time absolute time value.

NullSafeStringView

Creates an absl::string_view from a pointer p even if it's null‐valued.

OkStatus

Returns an OK status, equivalent to a default constructed instance.

OutOfRangeError

Creates a status with the kOutOfRange error code and message.

PairFormatter

PairFormatter overloads

ParseAbseilFlagsOnly

Parses a list of command‐line arguments, passed in the argc and argv[] parameters, into a set of Abseil Flag values, returning any unparsed arguments in positional_args and unrecognized_flags output parameters.

ParseCivilTime

Parses a civil‐time value from the specified absl::string_view into the passed output parameter. Returns true upon successful parsing.

ParseCommandLine

First parses Abseil Flags only from the command line according to the description in ParseAbseilFlagsOnly. In addition this function handles unrecognized and usage flags.

ParseDuration

Parses a duration string consisting of a possibly signed sequence of decimal numbers, each with an optional fractional part and a unit suffix. The valid suffixes are "ns", "us" "ms", "s", "m", and "h". Simple examples include "300ms", "‐1.5h", and "2h45m". Parses "0" as ZeroDuration(). Parses "inf" and "‐inf" as +/‐ InfiniteDuration().

ParseFlag

ParseFlag overloads

ParseLenientCivilTime

Parses any of the formats accepted by absl::ParseCivilTime(). Unlike ParseCivilTime(), the input string format does not need to match the target civil‐time type. Discrepancies are resolved as follows: * Extra components in the input string are ignored. * Missing components are defaulted to their minimum valid values. This behavior is consistent with civil‐time converting constructors.

ParseTime

ParseTime overloads

PermissionDeniedError

Creates a status with the kPermissionDenied error code and message.

Poisson

Produces a random integral value from a Poisson distribution.

PrefetchToLocalCache

Moves data into the L1 cache before it is read, or "prefetches" it.

PrefetchToLocalCacheForWrite

Moves data into the L1 cache with the intent to modify it.

PrefetchToLocalCacheNta

Moves data into the L1 cache before it is read, or "prefetches" it.

PrevWeekday

Returns the absl::CivilDay that strictly precedes a given absl::CivilDay, and that falls on the given absl::Weekday.

PrintF

Writes to stdout given a format string and zero or more arguments.

PrintTo

Writes a human‐readable representation of entry to os, e.g. for use by test frameworks such as GoogleTest.

ProgramUsageMessage

Returns the usage message set by SetProgramUsageMessage().

RawPtr

RawPtr overloads

RegisterCondVarTracer

Registers a hook for CondVar tracing.

RegisterLivePointers

Registers ptr[0,size‐1] as pointers to memory that is still actively being referenced and for which leak checking should be ignored. This function is useful if you store pointers in mapped memory, for memory ranges that we know are correct but for which normal analysis would flag as leaked code.

RegisterMutexProfiler

Registers a hook for mutex contention profiling.

RegisterMutexTracer

Registers a hook for Mutex tracing.

RemoveCrc32cPrefix

Compute the CRC32C value of a buffer with a prefix removed.

RemoveCrc32cSuffix

Compute the CRC32C value of a buffer with a suffix removed.

RemoveExtraAsciiWhitespace

Removes leading, trailing, and consecutive internal whitespace.

RemoveLogSink

Removes a absl::LogSink as a consumer of logging data.

ReportUnrecognizedFlags

Reports an error to stderr for all non‐ignored unrecognized flags in the provided unrecognized_flags list.

ResourceExhaustedError

Creates a status with the kResourceExhausted error code and message.

SNPrintF

Writes to a sized buffer given a format string and zero or more arguments.

Seconds

Seconds overloads

SetAndroidNativeTag

Stores a copy of the string pointed to by tag and uses it as the Android logging tag thereafter. tag must not be null.

SetFlag

SetFlag overloads

SetFlagsUsageConfig

Sets the usage reporting configuration callbacks. If any of the callbacks are not set in usage_config instance, then the default value of the callback is used.

SetGlobalVLogLevel

Sets the global VLOG level to threshold.

SetLogBacktraceLocation

Sets the location the backtrace should be logged at.

SetMinLogLevel

Updates the value of Minimum Log Level parameter.

SetMutexDeadlockDetectionMode

Enables or disables global detection of potential deadlocks due to Mutex lock ordering inversions.

SetProgramUsageMessage

Sets the "usage" message to be used by help reporting routines. For example: absl::SetProgramUsageMessage( absl::StrCat("This program does nothing. Sample usage:n", argv[0], " <uselessarg1> <uselessarg2>")); Do not include commandline flags in the usage: we do that for you! Note: Calling SetProgramUsageMessage twice will trigger a call to std::exit.

SetStackUnwinder

Provides a custom function for unwinding stack frames that will be used in place of the default stack unwinder when invoking the static GetStack{Frames,Trace}{,WithContext}() functions above.

SetStderrThreshold

Updates the Stderr Threshold parameter.

SetVLogLevel

Sets the VLOG threshold for all files that match module_pattern, overwriting any prior value. Files that don't match aren't affected.

ShareUniquePtr

Convert a std::unique_ptr into a std::shared_ptr.

ShouldPrependLogPrefix

Returns the value of the Prepend Log Prefix option.

SimpleAtob

Converts the given string into a boolean, returning true if successful.

SimpleAtod

Converts the given string into a double, returning true if successful.

SimpleAtof

Converts the given string into a float, returning true if successful.

SimpleAtoi

SimpleAtoi overloads

SimpleHexAtoi

SimpleHexAtoi overloads

SixDigits

Helper function for the default StrCat() floating‐point format, %.6g.

SleepFor

Sleeps for the specified duration, expressed as an absl::Duration.

StartsWith

Returns whether a given string text begins with prefix.

StartsWithIgnoreCase

Returns whether a given ASCII string text starts with prefix, ignoring case in the comparison.

StatusCodeToString

Returns the name for the status code, or "" if it is an unknown value.

StatusCodeToStringView

Same as StatusCodeToString(), but returns a string_view.

StatusMessageAsCStr

Retrieves a message's status as a null terminated C string.

StderrThreshold

Returns the value of the Stderr Threshold parameter.

StrAppend

StrAppend overloads

StrAppendFormat

Appends to a dst string given a format string, and zero or more additional arguments, returning *dst as a convenience for chaining purposes.

StrCat

StrCat overloads

StrContains

StrContains overloads

StrContainsIgnoreCase

StrContainsIgnoreCase overloads

StrFormat

Returns a string given a printf()‐style format string and zero or more additional arguments.

StrJoin

StrJoin overloads

StrReplaceAll

StrReplaceAll overloads

StrSplit

StrSplit overloads

StreamFormat

Writes to an output stream given a format string and zero or more arguments, generally in a manner that is more efficient than streaming the result of absl::StrFormat().

StreamFormatter

Formats its argument using the << operator.

StringResizeAndOverwrite

Resizes str to contain at most n characters, using the user‐provided operation op to modify the possibly indeterminate contents. op must return the finalized length of str.

StripAsciiWhitespace

StripAsciiWhitespace overloads

StripLeadingAsciiWhitespace

StripLeadingAsciiWhitespace overloads

StripPrefix

Returns a view into the input string str with the given prefix removed, but leaving the original string intact. If the prefix does not match at the start of the string, returns the original string instead.

StripSuffix

Returns a view into the input string str with the given suffix removed, but leaving the original string intact. If the suffix does not match at the end of the string, returns the original string instead.

StripTrailingAsciiWhitespace

StripTrailingAsciiWhitespace overloads

Substitute

Substitute overloads

SubstituteAndAppend

SubstituteAndAppend overloads

Symbolize

Symbolizes a program counter (instruction pointer value) pc and, on success, writes the name to out. The symbol name is demangled, if possible. Note that the symbolized name may be truncated and will be NUL‐terminated. Demangling is supported for symbols generated by GCC 3.x or newer). Returns false on failure.

ThrowStdBadAlloc [noreturn]

Throws a std::bad_alloc, or terminates if exceptions are disabled.

ThrowStdBadArrayNewLength [noreturn]

Throws a std::bad_array_new_length, or terminates if exceptions are disabled.

ThrowStdBadFunctionCall [noreturn]

Throws a std::bad_function_call, or terminates if exceptions are disabled.

ThrowStdDomainError [noreturn]

Throws a std::domain_error with the given message, or terminates if exceptions are disabled.

ThrowStdInvalidArgument [noreturn]

Throws a std::invalid_argument with the given message, or terminates if exceptions are disabled.

ThrowStdLengthError [noreturn]

Throws a std::length_error with the given message, or terminates if exceptions are disabled.

ThrowStdLogicError [noreturn]

Throws a std::logic_error with the given message, or terminates if exceptions are disabled.

ThrowStdOutOfRange [noreturn]

Throws a std::out_of_range with the given message, or terminates if exceptions are disabled.

ThrowStdOverflowError [noreturn]

Throws a std::overflow_error with the given message, or terminates if exceptions are disabled.

ThrowStdRangeError [noreturn]

Throws a std::range_error with the given message, or terminates if exceptions are disabled.

ThrowStdRuntimeError [noreturn]

Throws a std::runtime_error with the given message, or terminates if exceptions are disabled.

ThrowStdUnderflowError [noreturn]

Throws a std::underflow_error with the given message, or terminates if exceptions are disabled.

TimeFromTimespec

Converts a timespec to an absl::Time.

TimeFromTimeval

Converts a timeval to an absl::Time.

ToChronoHours

Converts an absl::Duration to a std::chrono::hours value.

ToChronoMicroseconds

Converts an absl::Duration to a std::chrono::microseconds value.

ToChronoMilliseconds

Converts an absl::Duration to a std::chrono::milliseconds value.

ToChronoMinutes

Converts an absl::Duration to a std::chrono::minutes value.

ToChronoNanoseconds

Converts an absl::Duration to a std::chrono::nanoseconds value.

ToChronoSeconds

Converts an absl::Duration to a std::chrono::seconds value.

ToChronoTime

Converts an absl::Time to a std::chrono::system_clock::time_point. If overflow would occur, the returned value will saturate at the min/max time point value instead.

ToCivilDay

Converts an absolute time to a day‐aligned civil time in a time zone.

ToCivilHour

Converts an absolute time to an hour‐aligned civil time in a time zone.

ToCivilMinute

Converts an absolute time to a minute‐aligned civil time in a time zone.

ToCivilMonth

Converts an absolute time to a month‐aligned civil time in a time zone.

ToCivilSecond

Converts an absolute time to a second‐aligned civil time in a time zone.

ToCivilYear

Converts an absolute time to a year‐aligned civil time in a time zone.

ToDoubleHours

Converts a Duration to a floating‐point count of hours.

ToDoubleMicroseconds

Converts a Duration to a floating‐point count of microseconds.

ToDoubleMilliseconds

Converts a Duration to a floating‐point count of milliseconds.

ToDoubleMinutes

Converts a Duration to a floating‐point count of minutes.

ToDoubleNanoseconds

Converts a Duration to a floating‐point count of nanoseconds.

ToDoubleSeconds

Converts a Duration to a floating‐point count of seconds.

ToInt64Hours

Converts a Duration to an integral count of hours.

ToInt64Microseconds

Converts a Duration to an integral count of microseconds.

ToInt64Milliseconds

Converts a Duration to an integral count of milliseconds.

ToInt64Minutes

Converts a Duration to an integral count of minutes.

ToInt64Nanoseconds

Converts a Duration to an integral count of nanoseconds.

ToInt64Seconds

Converts a Duration to an integral count of seconds.

ToTM

Converts the given absl::Time to a struct tm using the given time zone. See ctime(3) for a description of the values of the tm fields.

ToTimeT

Converts an absl::Time to a time_t value.

ToTimespec

ToTimespec overloads

ToTimeval

ToTimeval overloads

ToUDate

Converts an absl::Time to an ICU UDate value.

ToUniversal

Converts an absl::Time to an ICU Universal Time Scale value.

ToUnixMicros

Converts an absl::Time to a count of microseconds since the Unix epoch.

ToUnixMillis

Converts an absl::Time to a count of milliseconds since the Unix epoch.

ToUnixNanos

Converts an absl::Time to a count of nanoseconds since the Unix epoch.

ToUnixSeconds

Converts an absl::Time to a count of seconds since the Unix epoch.

Trunc

Truncates a duration (toward zero) to a multiple of a non‐zero unit.

UTCTimeZone

Convenience method returning the UTC time zone.

Uint128High64

Returns the higher 64‐bit value of a uint128 value.

Uint128Low64

Returns the lower 64‐bit value of a uint128 value.

Uint128Max

Returns the highest value for a 128‐bit unsigned integer.

UnRegisterLivePointers

Deregisters the pointers previously marked as active in RegisterLivePointers(), enabling leak checking of those pointers.

UnauthenticatedError

Creates a status with the kUnauthenticated error code and message.

UnavailableError

Creates a status with the kUnavailable error code and message.

Uniform

Uniform overloads

UnimplementedError

Creates a status with the kUnimplemented error code and message.

UniversalEpoch

Returns the absl::Time representing the ICU Universal Time Scale epoch.

UnixEpoch

Returns the absl::Time representing "1970‐01‐01 00:00:00.0 +0000".

UnknownError

Creates a status with the kUnknown error code and message.

UnparseFlag

UnparseFlag overloads

UrlEscape

Escapes a string so it can be safely used as a value in a URL component by replacing all characters that are not "unreserved characters" with percent‐escapes. See https://tools.ietf.org/html/rfc3986

UrlEscapePlus

Escapes a string so it can be safely used as a value for application/x‐www‐form‐urlencoded (HTML form submissions).

UrlUnescape

Performs the inverse transformation of UrlEscape(), converting each percent‐encoded sequence of the form "%AB" into the character with the hexadecimal value 0xAB. It returns std::nullopt if any % is not followed by two hexadecimal digits.

UrlUnescapePlus

Performs the inverse transformation of UrlEscapePlus(). It returns std::nullopt if any % is not followed by two hexadecimal digits.

Utf8SafeCEscape

Escapes a src string using C‐style escape sequences, escaping bytes as octal sequences, and passing through UTF‐8 characters without conversion.

Utf8SafeCHexEscape

Escapes a src string using C‐style escape sequences, escaping bytes as hexadecimal sequences, and passing through UTF‐8 characters without conversion.

WeakenPtr

Create a weak pointer from a shared pointer.

WebSafeBase64Escape

WebSafeBase64Escape overloads

WebSafeBase64Unescape

Converts a src string encoded in "web safe" Base64 (RFC 4648 section 5) to its binary equivalent, writing it to a dest buffer, returning true on success. If src contains invalid characters, dest is cleared and returns false. If padding is included (note that WebSafeBase64Escape() does not produce it), it must be correct. In the padding, '=' and '.' are treated identically.

WrapUnique

Adopt ownership of a raw pointer into a std::unique_ptr.

ZeroDuration

Returns a zero‐length duration. This function behaves just like the default constructor, but the name helps make the semantics clear at call sites.

Zipf

Produces a random integral value from a Zipf distribution.

any_cast [deprecated]

Casts the value stored in an any object to type T (deprecated).

apply [deprecated]

Invoke a callable with the elements of a tuple as arguments.

ascii_isalnum

Determines whether the given character is an alphanumeric character.

ascii_isalpha

Determines whether the given character is an alphabetic character.

ascii_isascii

Determines whether the given character is ASCII.

ascii_isblank

Determines whether the given character is a blank character (tab or space).

ascii_iscntrl

Determines whether the given character is a control character.

ascii_isdigit

Determines whether the given character can be represented as a decimal digit character (i.e. {0‐9}).

ascii_isgraph

Determines whether the given character has a graphical representation.

ascii_islower

Determines whether the given character is lowercase.

ascii_isprint

Determines whether the given character is printable, including spaces.

ascii_ispunct

Determines whether the given character is a punctuation character.

ascii_isspace

Determines whether the given character is a whitespace character (space, tab, vertical tab, formfeed, linefeed, or carriage return).

ascii_isupper

Determines whether the given character is uppercase.

ascii_isxdigit

Determines whether the given character can be represented as a hexadecimal digit character (i.e. {0‐9} or {A‐F} or {a‐f}).

ascii_tolower

Returns an ASCII character, converting to lowercase if uppercase is passed. Note that character values > 127 are simply returned.

ascii_toupper

Returns the ASCII character, converting to upper‐case if lower‐case is passed. Note that characters values > 127 are simply returned.

c_accumulate

c_accumulate overloads

c_adjacent_difference

c_adjacent_difference overloads

c_adjacent_find

c_adjacent_find overloads

c_all_of

Container‐based version of the <algorithm> std::all_of() function to test if all elements within a container satisfy a condition.

c_any_of

Container‐based version of the <algorithm> std::any_of() function to test if any element in a container fulfills a condition.

c_binary_search

c_binary_search overloads

c_contains

Container‐based version of the <algorithm> std::ranges::contains() C++23 function to search a container for a value.

c_contains_subrange

c_contains_subrange overloads

c_copy

c_copy overloads

c_copy_backward

Container‐based version of the <algorithm> std::copy_backward() function to copy a container's elements in reverse order into an iterator.

c_copy_if

Container‐based version of the <algorithm> std::copy_if() function to copy a container's elements satisfying some condition into an iterator.

c_copy_n

c_copy_n overloads

c_count

Container‐based version of the <algorithm> std::count() function to count values that match within a container.

c_count_if

Container‐based version of the <algorithm> std::count_if() function to count values matching a condition within a container.

c_distance

Container‐based version of the <iterator> std::distance() function to return the number of elements within a container.

c_equal

c_equal overloads

c_equal_range

c_equal_range overloads

c_fill

Container‐based version of the <algorithm> std::fill() function to fill a container with some value.

c_fill_n

Container‐based version of the <algorithm> std::fill_n() function to fill the first N elements in a container with some value.

c_find

Container‐based version of the <algorithm> std::find() function to find the first element containing the passed value within a container value.

c_find_end

c_find_end overloads

c_find_first_of

c_find_first_of overloads

c_find_if

Container‐based version of the <algorithm> std::find_if() function to find the first element in a container matching the given condition.

c_find_if_not

Container‐based version of the <algorithm> std::find_if_not() function to find the first element in a container not matching the given condition.

c_for_each

Container‐based version of the <algorithm> std::for_each() function to apply a function to a container's elements.

c_generate

Container‐based version of the <algorithm> std::generate() function to assign a container's elements to the values provided by the given generator.

c_generate_n

Container‐based version of the <algorithm> std::generate_n() function to assign a container's first N elements to the values provided by the given generator.

c_includes

c_includes overloads

c_inner_product

c_inner_product overloads

c_inplace_merge

c_inplace_merge overloads

c_iota

Container‐based version of the <numeric> std::iota() function to compute successive values of value, as if incremented with ++value after each element is written, and write them to the container.

c_is_heap

c_is_heap overloads

c_is_heap_until

c_is_heap_until overloads

c_is_partitioned

Container‐based version of the <algorithm> std::is_partitioned() function to test whether all elements in the container for which pred returns true precede those for which pred is false.

c_is_permutation

c_is_permutation overloads

c_is_sorted

c_is_sorted overloads

c_is_sorted_until

c_is_sorted_until overloads

c_lexicographical_compare

c_lexicographical_compare overloads

c_linear_search

Container‐based version of absl::linear_search() for performing a linear search within a container.

c_lower_bound

c_lower_bound overloads

c_make_heap

c_make_heap overloads

c_max_element

c_max_element overloads

c_merge

c_merge overloads

c_min_element

c_min_element overloads

c_minmax_element

c_minmax_element overloads

c_mismatch

c_mismatch overloads

c_move

c_move overloads

c_move_backward

Container‐based version of the <algorithm> std::move_backward() function to move a container's elements into an iterator in reverse order.

c_next_permutation

c_next_permutation overloads

c_none_of

Container‐based version of the <algorithm> std::none_of() function to test if no elements in a container fulfill a condition.

c_nth_element

c_nth_element overloads

c_partial_sort

c_partial_sort overloads

c_partial_sort_copy

c_partial_sort_copy overloads

c_partial_sum

c_partial_sum overloads

c_partition

Container‐based version of the <algorithm> std::partition() function to rearrange all elements in a container in such a way that all elements for which pred returns true precede all those for which it returns false, returning an iterator to the first element of the second group.

c_partition_copy

Container‐based version of the <algorithm> std::partition_copy() function to partition a container's elements and return them into two iterators: one for which pred returns true, and one for which pred returns false.

c_partition_point

Container‐based version of the <algorithm> std::partition_point() function to return the first element of an already partitioned container for which the given pred is not true.

c_pop_heap

c_pop_heap overloads

c_prev_permutation

c_prev_permutation overloads

c_push_heap

c_push_heap overloads

c_remove_copy

Container‐based version of the <algorithm> std::remove_copy() function to copy a container's elements while removing any elements matching the given value.

c_remove_copy_if

Container‐based version of the <algorithm> std::remove_copy_if() function to copy a container's elements while removing any elements matching the given condition.

c_replace

Container‐based version of the <algorithm> std::replace() function to replace a container's elements of some value with a new value. The container is modified in place.

c_replace_copy

Container‐based version of the <algorithm> std::replace_copy() function to replace a container's elements of some value with a new value and return the results within an iterator.

c_replace_copy_if

Container‐based version of the <algorithm> std::replace_copy_if() function to replace a container's elements of some value with a new value based on some condition, and return the results within an iterator.

c_replace_if

Container‐based version of the <algorithm> std::replace_if() function to replace a container's elements of some value with a new value based on some condition. The container is modified in place.

c_reverse

Container‐based version of the <algorithm> std::reverse() function to reverse a container's elements.

c_reverse_copy

Container‐based version of the <algorithm> std::reverse() function to reverse a container's elements and write them to an iterator range.

c_rotate

Container‐based version of the <algorithm> std::rotate() function to shift a container's elements leftward such that the middle element becomes the first element in the container.

c_rotate_copy

Container‐based version of the <algorithm> std::rotate_copy() function to shift a container's elements leftward such that the middle element becomes the first element in a new iterator range.

c_sample

Container‐based version of the <algorithm> std::sample() function to randomly sample elements from the container without replacement using a gen() uniform random number generator and write them to an iterator range.

c_search

c_search overloads

c_search_n

c_search_n overloads

c_set_difference

c_set_difference overloads

c_set_intersection

c_set_intersection overloads

c_set_symmetric_difference

c_set_symmetric_difference overloads

c_set_union

c_set_union overloads

c_shuffle

Container‐based version of the <algorithm> std::shuffle() function to randomly shuffle elements within the container using a gen() uniform random number generator.

c_sort

c_sort overloads

c_sort_heap

c_sort_heap overloads

c_stable_partition

Container‐based version of the <algorithm> std::stable_partition() function to rearrange all elements in a container in such a way that all elements for which pred returns true precede all those for which it returns false, preserving the relative ordering between the two groups. The function returns an iterator to the first element of the second group.

c_stable_sort

c_stable_sort overloads

c_swap_ranges

Container‐based version of the <algorithm> std::swap_ranges() function to swap a container's elements with another container's elements. Swaps the first N elements of c1 and c2, where N = min(size(c1), size(c2)).

c_transform

c_transform overloads

c_unique_copy

c_unique_copy overloads

c_upper_bound

c_upper_bound overloads

call_once

For all invocations using a given once_flag, invokes a given fn exactly once across all threads. The first call to call_once() with a particular once_flag argument (that does not throw an exception) will run the specified function with the provided args; other calls with the same once_flag argument will not run the function, but will wait for the provided function to finish running (if it is still running).

down_cast

down_cast overloads

equal [deprecated]

equal overloads

erase_if

erase_if overloads

exchange [deprecated]

Replace the value of an object and return its old value.

forward [deprecated]

forward overloads

from_chars

from_chars overloads

get [deprecated]

get overloads

get_if [deprecated]

get_if overloads

holds_alternative [deprecated]

Tests whether a variant currently holds the alternative T (deprecated).

implicit_cast

implicit_cast overloads

is_constant_evaluated

Detects whether the function call occurs within a constant‐evaluated context. Returns true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant‐evaluated; otherwise returns false.

linear_search

Performs a linear search for a value in a range.

make_any [deprecated]

make_any overloads

make_from_tuple [deprecated]

Construct an object of a type from the elements of a tuple.

make_optional

make_optional overloads

move [deprecated]

move overloads

operator%

Modulus operators

operator&

Bitwise conjunction operators

operator&=

Assigns to lhs the bitwise AND of lhs and rhs.

operator*

Multiplication operators

operator+

Unary plus operators

operator‐

Unary minus operators

operator/

Division operators

operator>>

Right shift operators

operatorˆ

Bitwise exclusive‐or operators

operatorˆ=

Assigns to lhs the bitwise XOR of lhs and rhs.

operator|

Bitwise disjunction operators

operator|=

Assigns to lhs the bitwise OR of lhs and rhs.

operator~

Bitwise negation operators

rotate [deprecated]

Rotates the elements in a range so that n_first becomes the new first.

swap

swap overloads

visit [deprecated]

Applies a visitor to the alternatives of one or more variants (deprecated).

operator<<

Left shift operators

operator!

Returns the logical negation of val.

Equality operators

Inequality operators

Less‐than operators

Less‐than‐or‐equal operators

operator>

Greater‐than operators

operator>=

Greater‐than‐or‐equal operators

operator<=>

Three‐way comparison operators

Variables

Name

Description

IntervalClosed

Tag selecting a closed interval [lo, hi]for absl::Uniform.

IntervalClosedClosed

Tag selecting a closed‐closed interval [lo, hi]for absl::Uniform.

IntervalClosedOpen

Tag selecting a closed‐open interval [lo, hi) for absl::Uniform.]

IntervalOpen

Tag selecting an open interval (lo, hi) for absl::Uniform.

IntervalOpenClosed

Tag selecting an open‐closed interval (lo, hi] for absl::Uniform.

IntervalOpenOpen

Tag selecting an open‐open interval (lo, hi) for absl::Uniform.

RFC1123_full

FormatTime()/ParseTime() format specifier for RFC1123 date/time strings.

RFC1123_no_wday

FormatTime()/ParseTime() format specifier for RFC1123 date/time strings without the weekday name.

RFC3339_full

FormatTime()/ParseTime() format specifier for RFC3339 date/time strings, with trailing zeros trimmed.

RFC3339_sec

FormatTime()/ParseTime() format specifier for RFC3339 date/time strings, with fractional seconds omitted altogether.

in_place [deprecated]

Disambiguation tag for in‐place construction.

in_place_index [deprecated]

Disambiguation tag for in‐place construction at a given index.

in_place_type [deprecated]

Disambiguation tag for in‐place construction of a given type.

nontype

Disambiguation tag value of type nontype_t.

variant_npos

Alias for std::variant_npos, the index of a valueless variant.

variant_size_v

Alias for std::variant_size_v, the number of alternatives.

Using Declarations

Name

Description

bind_back

Binds the last N arguments of an invocable object and stores them by value.

bind_front

Binds the first N arguments of an invocable object and stores them by value.

bit_cast

Alias for std::bit_cast, used when the standard library provides it.

bit_ceil

Returns the smallest power of two not less than x.

bit_floor

Returns the largest power of two not greater than x.

bit_width

Returns the number of bits needed to represent the value of x.

byteswap

Reverses the bytes in the given integer value x.

countl_one

Counts the number of consecutive one bits starting from the most significant bit of x.

countl_zero

Counts the number of consecutive zero bits starting from the most significant bit of x.

countr_one

Counts the number of consecutive one bits starting from the least significant bit of x.

countr_zero

Counts the number of consecutive zero bits starting from the least significant bit of x.

endian

Indicates the endianness of all scalar types.

has_single_bit

Determines whether x is an integral power of two.

make_unique

Create a std::unique_ptr owning a newly constructed object.

make_unique_for_overwrite

Create a std::unique_ptr whose object is default‐initialized.

nullopt

Alias for std::nullopt, the disengaged‐optional constant.

optional

Alias for std::optional.

partial_ordering

Result of a three‐way comparison that may be unordered.

popcount

Counts the number of one bits in the value of x.

rotl

Rotates the bits of x to the left by s positions.

rotr

Rotates the bits of x to the right by s positions.

string_view

An alias for std::string_view.

Low‐level stack trace helpers shared by the public GetStack*() routines.

Functions

Name

Description

FixUpStack

Fixes up the stack trace of the current thread, in the first depth frames of each buffer. The buffers need to be larger than depth, to accommodate any newly inserted elements. depth is updated to reflect the new number of elements valid across all the buffers. (It is therefore recommended that all buffer sizes be equal.)

GetStackTraceNoFixup

Same as GetStackTrace(), but skips fix‐ups for efficiency.

ShouldFixUpStack

Returns true if the platform's stack unwinder is expected to need fix‐ups applied via FixUpStack().

Created with MrDocs