[#absl]
= absl
:mrdocs:

Abseil&apos;s root namespace&period; Abseil is Google&apos;s open&hyphen;source collection of C&plus;&plus; library code that augments the C&plus;&plus; standard library&period;

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:absl/any_span_adaptor.adoc[`any&lowbar;span&lowbar;adaptor`] 
| Utilities for adapting objects to the interface that `AnySpan` expects&period;
| xref:absl/any_span_transform.adoc[`any&lowbar;span&lowbar;transform`] 
| Accessors returning Transform functors that may be passed to `AnySpan`&period;
| xref:absl/internal_stacktrace.adoc[`internal&lowbar;stacktrace`] 
| Low&hyphen;level stack trace helpers shared by the public `GetStack&ast;()` routines&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:absl/AllowEmpty.adoc[`AllowEmpty`] 
| Always returns `true`, indicating that all strings&hyphen;&hyphen;including empty strings&hyphen;&hyphen;should be included in the split output&period;
| xref:absl/AlphaNum.adoc[`AlphaNum`] 
| The main parameter type for `StrCat()` and `StrAppend()`&period;
| xref:absl/AnyInvocable.adoc[`AnyInvocable`] 
| absl&colon;&colon;AnyInvocable
| xref:absl/AnySpan.adoc[`AnySpan`] 
| A type&hyphen;erased, non&hyphen;owning view over a random&hyphen;access sequence&period;
| xref:absl/BadStatusOrAccess.adoc[`BadStatusOrAccess`] 
| Exception thrown when accessing the value of an invalid `StatusOr`&period;
| xref:absl/Barrier.adoc[`Barrier`] 
| A barrier that blocks threads until a threshold of threads reach it&period;
| xref:absl/BitGen.adoc[`BitGen`] 
| A general&hyphen;purpose random bit generator for the Abseil random library&period;
| xref:absl/BitGenRef.adoc[`BitGenRef`] 
| A type&hyphen;erasing, non&hyphen;owning reference to any uniform random bit generator&period;
| xref:absl/BlockingCounter.adoc[`BlockingCounter`] 
| A counter that lets a thread block until a number of actions complete&period;
| xref:absl/ByAnyChar.adoc[`ByAnyChar`] 
| A delimiter that will match any of the given byte&hyphen;sized characters within its provided string&period;
| xref:absl/ByAsciiWhitespace.adoc[`ByAsciiWhitespace`] 
| A sub&hyphen;string delimiter that splits by ASCII whitespace (space, tab, vertical tab, formfeed, linefeed, or carriage return)&period;
| xref:absl/ByChar.adoc[`ByChar`] 
| A single character delimiter&period;
| xref:absl/ByLength.adoc[`ByLength`] 
| A delimiter for splitting into equal&hyphen;length strings&period;
| xref:absl/ByString.adoc[`ByString`] 
| A sub&hyphen;string delimiter&period;
| xref:absl/CharSet.adoc[`CharSet`] 
| A fast, bit&hyphen;vector set of 8&hyphen;bit unsigned characters&period;
| xref:absl/Cleanup-0a.adoc[`Cleanup`] 
| Scope guard that invokes a callback on scope exit&period;
| xref:absl/Clock.adoc[`Clock`] 
| An abstract interface representing a Clock, which is an object that can tell you the current time, sleep, and wait for a condition variable&period;
| xref:absl/CommandLineFlag.adoc[`CommandLineFlag`] 
| A type&hyphen;erased handle for an instance of an Abseil Flag and holds reflection information pertaining to that flag&period; Use `CommandLineFlag` to access a flag&apos;s name, location, help string etc&period;
| xref:absl/CondVar.adoc[`CondVar`] 
| A condition variable that can be signaled to wake threads waiting on state evaluated outside a `Mutex`&period;
| xref:absl/Condition.adoc[`Condition`] 
| A predicate on state protected by a `Mutex`, used to wait for a condition to become `true`&period;
| xref:absl/Cord.adoc[`Cord`] 
| A sequence of characters stored as a tree of buffers&period;
| xref:absl/CordBuffer.adoc[`CordBuffer`] 
| Manages memory buffers for building cords&period;
| xref:absl/CordBufferTestPeer.adoc[`CordBufferTestPeer`] 
| Test&hyphen;only accessor for `CordBuffer` internals&period;
| xref:absl/CordTestPeer.adoc[`CordTestPeer`] 
| Test&hyphen;only accessor granting access to `Cord` internals&period;
| xref:absl/Dec.adoc[`Dec`] 
| Stores a set of decimal string conversion parameters for use within `AlphaNum` string conversions&period;
| xref:absl/Duration.adoc[`Duration`] 
| The `absl&colon;&colon;Duration` class represents a signed, fixed&hyphen;length amount of time&period; A `Duration` is generated using a unit&hyphen;specific factory function, or is the result of subtracting one `absl&colon;&colon;Time` from another&period; Durations behave like unit&hyphen;safe integers and they support all the natural integer&hyphen;like arithmetic operations&period; Arithmetic overflows and saturates at &plus;&sol;&hyphen; infinity&period; `Duration` is trivially destructible and should be passed by value rather than const reference&period;
| xref:absl/ExtraMessage.adoc[`ExtraMessage`] 
| StatusBuilder policy to append an extra message to the original status&period;
| xref:absl/FailureSignalHandlerOptions.adoc[`FailureSignalHandlerOptions`] 
| Configuration options for `absl&colon;&colon;InstallFailureSignalHandler()`&period;
| xref:absl/FastTypeIdType.adoc[`FastTypeIdType`] 
| The type returned by `absl&colon;&colon;FastTypeId&lt;T&gt;()`&period;
| xref:absl/FixedArray.adoc[`FixedArray`] 
| A run&hyphen;time fixed&hyphen;size array that allocates small arrays inline&period;
| xref:absl/FlagSaver.adoc[`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&period;
| xref:absl/FlagsUsageConfig.adoc[`FlagsUsageConfig`] 
| This structure contains the collection of callbacks for changing the behavior of the usage reporting routines in Abseil Flags&period;
| xref:absl/FormatConversionSpec.adoc[`FormatConversionSpec`] 
| Specifies modifications to the conversion of the format string, through use of one or more format flags in the source format string&period;
| xref:absl/FormatConvertResult.adoc[`FormatConvertResult`] 
| Indicates whether a call to AbslFormatConvert() was successful&period;
| xref:absl/FormatCountCapture.adoc[`FormatCountCapture`] 
| Safely wraps `StrFormat()` captures of `%n` conversions into an integer value&period;
| xref:absl/FormatRawSink.adoc[`FormatRawSink`] 
| A type erased wrapper around arbitrary sink objects specifically used as an argument to `Format()`&period;
| xref:absl/FormatSink.adoc[`FormatSink`] 
| A generic abstraction to which conversions may write their formatted string data&period;
| xref:absl/FunctionRef-0e3.adoc[`FunctionRef`] 
| FunctionRef
| xref:absl/HasAbslStringify-01.adoc[`HasAbslStringify`] 
| Detects if type `T` supports the `AbslStringify()` customization point&period;
| xref:absl/HasOstreamOperator-0f.adoc[`HasOstreamOperator`] 
| Detects if type `T` supports streaming to `std&colon;&colon;ostream`s with `operator&lt;&lt;`&period;
| xref:absl/HashState.adoc[`HashState`] 
| A type&hyphen;erased version of the hash state concept&period;
| xref:absl/Hex.adoc[`Hex`] 
| Stores a set of hexadecimal string conversion parameters for use within `AlphaNum` string conversions&period;
| xref:absl/InlinedVector.adoc[`InlinedVector`] 
| A drop&hyphen;in replacement for `std&colon;&colon;vector` that stores small sequences inline&period;
| xref:absl/InsecureBitGen.adoc[`InsecureBitGen`] 
| An efficient random bit generator for performance&hyphen;sensitive use cases&period;
| xref:absl/LeakCheckDisabler.adoc[`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&period; Leak check disabling will occur within the code block and any nested function calls within the code block&period;
| xref:absl/LogEntry.adoc[`LogEntry`] 
| Represents a single entry in a log, i&period;e&period;, one `LOG` statement or failed `CHECK`&period;
| xref:absl/LogSink.adoc[`LogSink`] 
| `absl&colon;&colon;LogSink` is an interface which can be extended to intercept and process particular messages (with `LOG&period;ToSinkOnly()` or `LOG&period;ToSinkAlso()`) or all messages (if registered with `absl&colon;&colon;AddLogSink`)&period; Implementations must not take any locks that might be held by the `LOG` caller&period;
| xref:absl/LogStreamer.adoc[`LogStreamer`] 
| Although you can stream into `LOG(INFO)`, you can&apos;t pass it into a function that takes a `std&colon;&colon;ostream` parameter&period; `LogStreamer&colon;&colon;stream()` provides a `std&colon;&colon;ostream` that buffers everything that&apos;s streamed in&period; The buffer&apos;s contents are logged as if by `LOG` when the `LogStreamer` is destroyed&period; If nothing is streamed in, an empty message is logged&period; If the specified severity is `absl&colon;&colon;LogSeverity&colon;&colon;kFatal`, the program will be terminated when the `LogStreamer` is destroyed regardless of whether any data were streamed in&period;
| xref:absl/MuHowS.adoc[`MuHowS`] 
| A constant that indicates how a lock should be acquired&period;
| xref:absl/Mutex.adoc[`Mutex`] 
| A non&hyphen;reentrant mutually exclusive lock that also supports reader&hyphen;writer locking and conditional critical regions&period;
| xref:absl/MutexLock.adoc[`MutexLock`] 
| RAII helper that acquires and releases a `Mutex` exclusively&period;
| xref:absl/MutexLockMaybe.adoc[`MutexLockMaybe`] 
| RAII helper like `MutexLock`, but a no&hyphen;op when the mutex pointer is null&period;
| xref:absl/NoDestructor-08.adoc[`NoDestructor`] 
| NoDestructor&lt;T&gt; is a wrapper around an object of type T that behaves as an object of type T but never calls T&apos;s destructor&period; NoDestructor&lt;T&gt; makes it safer and&sol;or more efficient to use such objects in static storage contexts, ideally as function scope static variables&period;
| xref:absl/Notification.adoc[`Notification`] 
| Lets threads wait for a single occurrence of a single event&period;
| xref:absl/Overload-05.adoc[`Overload`] 
| `absl&colon;&colon;Overload` is a functor that provides overloads based on the functors with which it is created&period; This can, for example, be used to locally define an anonymous visitor type for `std&colon;&colon;visit` inside a function using lambdas&period;
| xref:absl/ReaderMutexLock.adoc[`ReaderMutexLock`] 
| RAII helper that acquires and releases a shared (reader) lock on a `Mutex`&period;
| xref:absl/ReleasableMutexLock.adoc[`ReleasableMutexLock`] 
| RAII helper like `MutexLock` that also permits releasing the mutex before destruction&period;
| xref:absl/ScopedStderrThreshold.adoc[`ScopedStderrThreshold`] 
| RAII type used to temporarily update the Stderr Threshold parameter&period;
| xref:absl/SeedGenException.adoc[`SeedGenException`] 
| An exception thrown when suitable seed&hyphen;material cannot be derived&period;
| xref:absl/SimulatedClock.adoc[`SimulatedClock`] 
| A simulated clock is a concrete Clock implementation that does not &quot;tick&quot; on its own&period; Time is advanced by explicit calls to the AdvanceTime() or SetTime() functions&period;
| xref:absl/SkipEmpty.adoc[`SkipEmpty`] 
| Returns `false` if the given `absl&colon;&colon;string&lowbar;view` is empty, indicating that `StrSplit()` should omit the empty string&period;
| xref:absl/SkipWhitespace.adoc[`SkipWhitespace`] 
| Returns `false` if the given `absl&colon;&colon;string&lowbar;view` is empty _or_ contains only whitespace, indicating that `StrSplit()` should omit the string&period;
| xref:absl/Span.adoc[`Span`] 
| A non&hyphen;owning view over a contiguous sequence of objects&period;
| xref:absl/Status.adoc[`Status`] 
| A type used to gracefully handle errors across API boundaries&period;
| xref:absl/StatusBuilder.adoc[`StatusBuilder`] 
| Builds an `absl&colon;&colon;Status` enriched with extra context, logging, and payloads&period;
| xref:absl/StatusBuilderTest.adoc[`StatusBuilderTest`] 
| Test fixture granted access to `Rep`&apos;s implementation&period;
| xref:absl/StatusOr.adoc[`StatusOr`] 
| A union of an object of type `T` and an `absl&colon;&colon;Status`&period;
| xref:absl/SynchWaitParams.adoc[`SynchWaitParams`] 
| Internal parameters describing a pending wait on a `Mutex`&period;
| xref:absl/Time.adoc[`Time`] 
| An `absl&colon;&colon;Time` represents a specific instant in time&period; Arithmetic operators are provided for naturally expressing time calculations&period; Instances are created using `absl&colon;&colon;Now()` and the `absl&colon;&colon;From&ast;()` factory functions that accept the gamut of other time representations&period; Formatting and parsing functions are provided for conversion to and from strings&period; `absl&colon;&colon;Time` is trivially destructible and should be passed by value rather than const reference&period;
| xref:absl/TimeConversion.adoc[`TimeConversion`]  [.small]#[deprecated]#
| An `absl&colon;&colon;TimeConversion` represents the conversion of year, month, day, hour, minute, and second values (i&period;e&period;, a civil time), in a particular `absl&colon;&colon;TimeZone`, to a time instant (an absolute time), as returned by `absl&colon;&colon;ConvertDateTime()`&period; Legacy version of `absl&colon;&colon;TimeZone&colon;&colon;TimeInfo`&period;
| xref:absl/TimeZone.adoc[`TimeZone`] 
| The `absl&colon;&colon;TimeZone` is an opaque, small, value&hyphen;type class representing a geo&hyphen;political region within which particular rules are used for converting between absolute and civil times (see https&colon;&sol;&sol;git&period;io&sol;v59Ly)&period; `absl&colon;&colon;TimeZone` values are named using the TZ identifiers from the IANA Time Zone Database, such as &quot;America&sol;Los&lowbar;Angeles&quot; or &quot;Australia&sol;Sydney&quot;&period; `absl&colon;&colon;TimeZone` values are created from factory functions such as `absl&colon;&colon;LoadTimeZone()`&period; Note&colon; strings like &quot;PST&quot; and &quot;EDT&quot; are not valid TZ identifiers&period; Prefer to pass by value rather than const reference&period;
| xref:absl/UnrecognizedFlag.adoc[`UnrecognizedFlag`] 
| Represents information about an unrecognized flag in the command line&period;
| xref:absl/UntypedFormatSpec.adoc[`UntypedFormatSpec`] 
| A type&hyphen;erased class that can be used directly within untyped API entry points&period;
| xref:absl/WriterMutexLock.adoc[`WriterMutexLock`] 
| RAII helper that acquires and releases a write (exclusive) lock on a `Mutex`&period;
| xref:absl/allocator_is_nothrow.adoc[`allocator&lowbar;is&lowbar;nothrow`] 
| Trait class reporting whether an allocator&apos;s allocation never throws&period;
| xref:absl/bernoulli_distribution.adoc[`bernoulli&lowbar;distribution`] 
| A drop in replacement for `std&colon;&colon;bernoulli&lowbar;distribution`&period;
| xref:absl/beta_distribution.adoc[`beta&lowbar;distribution`] 
| Generates a floating&hyphen;point variate conforming to a Beta distribution&colon; pdf(x) propto x&circ;(alpha&hyphen;1) &ast; (1&hyphen;x)&circ;(beta&hyphen;1), where the params alpha and beta are both strictly positive real values&period;
| xref:absl/btree_map.adoc[`btree&lowbar;map`] 
| An ordered associative container of unique keys and associated values&period;
| xref:absl/btree_multimap.adoc[`btree&lowbar;multimap`] 
| An ordered associative container of keys and associated values that allows equivalent keys&period;
| xref:absl/btree_multiset.adoc[`btree&lowbar;multiset`] 
| An ordered associative container of keys that allows equivalent keys&period;
| xref:absl/btree_set.adoc[`btree&lowbar;set`] 
| An ordered associative container of unique keys&period;
| xref:absl/chunked_queue.adoc[`chunked&lowbar;queue`] 
| A queue implemented as a linked list of fixed or variable sized blocks&period;
| xref:absl/crc32c_t.adoc[`crc32c&lowbar;t`] 
| A strongly&hyphen;typed integer for holding a CRC32C value&period;
| xref:absl/default_allocator_is_nothrow.adoc[`default&lowbar;allocator&lowbar;is&lowbar;nothrow`] 
| Trait reporting whether the default allocator&apos;s allocation never throws&period;
| xref:absl/discrete_distribution.adoc[`discrete&lowbar;distribution`] 
| A distribution over random integers&period;
| xref:absl/exponential_distribution.adoc[`exponential&lowbar;distribution`] 
| Generates a number conforming to an exponential distribution&period;
| xref:absl/flat_hash_map.adoc[`flat&lowbar;hash&lowbar;map`] 
| An unordered associative container of unique keys and associated values, optimized for speed and memory footprint&period;
| xref:absl/flat_hash_set.adoc[`flat&lowbar;hash&lowbar;set`] 
| An unordered associative container of unique keys, optimized for speed and memory footprint&period;
| xref:absl/from_chars_result.adoc[`from&lowbar;chars&lowbar;result`] 
| The return result of a string&hyphen;to&hyphen;number conversion&period;
| xref:absl/gaussian_distribution.adoc[`gaussian&lowbar;distribution`] 
| Generates a number conforming to a Gaussian distribution&period;
| xref:absl/int128.adoc[`int128`] 
| A signed 128&hyphen;bit integer type&period;
| xref:absl/is_trivially_relocatable.adoc[`is&lowbar;trivially&lowbar;relocatable`] 
| https&colon;&sol;&sol;github&period;com&sol;llvm&sol;llvm&hyphen;project&sol;pull&sol;127636&num;pullrequestreview&hyphen;2637005293 In the current implementation, &lowbar;&lowbar;builtin&lowbar;is&lowbar;cpp&lowbar;trivially&lowbar;relocatable will only return true for types that are trivially relocatable according to the standard&period; Notably, this means that marking a type &lsqb;&lsqb;clang&colon;&colon;trivial&lowbar;abi&rsqb;&rsqb; aka ABSL&lowbar;HAVE&lowbar;ATTRIBUTE&lowbar;TRIVIAL&lowbar;ABI will have no effect on this trait&period;
| xref:absl/linked_hash_map.adoc[`linked&lowbar;hash&lowbar;map`] 
| An insertion&hyphen;ordered map&period;
| xref:absl/linked_hash_set.adoc[`linked&lowbar;hash&lowbar;set`] 
| A simple insertion&hyphen;ordered set&period;
| xref:absl/log_uniform_int_distribution.adoc[`log&lowbar;uniform&lowbar;int&lowbar;distribution`] 
| Returns a random variate R in range &lsqb;min, max&rsqb;such that floor(log(R&hyphen;min, base)) is uniformly distributed&period;
| xref:absl/node_hash_map.adoc[`node&lowbar;hash&lowbar;map`] 
| An unordered associative container of unique keys and associated values that provides pointer stability for its elements&period;
| xref:absl/node_hash_set.adoc[`node&lowbar;hash&lowbar;set`] 
| An unordered associative container of unique keys that provides pointer stability for its elements&period;
| xref:absl/nontype_t.adoc[`nontype&lowbar;t`] 
| Backfill for std&colon;&colon;nontype&lowbar;t&period;
| xref:absl/once_flag.adoc[`once&lowbar;flag`] 
| Objects of this type are used to distinguish calls to `call&lowbar;once()` and ensure the provided function is only invoked once across all threads&period; This type is not copyable or movable&period; However, it has a `constexpr` constructor, and is safe to use as a namespace&hyphen;scoped global variable&period;
| xref:absl/optional_ref-0c.adoc[`optional&lowbar;ref`] 
| A `std&colon;&colon;optional`&hyphen;like interface around a `T&ast;`&period;
| xref:absl/poisson_distribution.adoc[`poisson&lowbar;distribution`] 
| A distribution that generates discrete Poisson&hyphen;distributed variates&period;
| xref:absl/uint128.adoc[`uint128`] 
| An unsigned 128&hyphen;bit integer type&period;
| xref:absl/uniform_int_distribution.adoc[`uniform&lowbar;int&lowbar;distribution`] 
| This distribution produces random integer values uniformly distributed in the closed (inclusive) interval &lsqb;a, b&rsqb;&period;
| xref:absl/uniform_real_distribution.adoc[`uniform&lowbar;real&lowbar;distribution`] 
| This distribution produces random floating&hyphen;point values uniformly distributed over the half&hyphen;open interval &lsqb;a, b)&period;&rsqb;
| xref:absl/zipf_distribution.adoc[`zipf&lowbar;distribution`] 
| A distribution over random integer&hyphen;values in the range &lsqb;0, k&rsqb;&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:absl/CivilDay.adoc[`CivilDay`] 
| A civil&hyphen;time value aligned to the day field (YYYY&hyphen;MM&hyphen;DD)&period;
| xref:absl/CivilHour.adoc[`CivilHour`] 
| A civil&hyphen;time value aligned to the hour field (YYYY&hyphen;MM&hyphen;DD hh)&period;
| xref:absl/CivilMinute.adoc[`CivilMinute`] 
| A civil&hyphen;time value aligned to the minute field (YYYY&hyphen;MM&hyphen;DD hh&colon;mm)&period;
| xref:absl/CivilMonth.adoc[`CivilMonth`] 
| A civil&hyphen;time value aligned to the month field (YYYY&hyphen;MM)&period;
| xref:absl/CivilSecond.adoc[`CivilSecond`] 
| A civil&hyphen;time value aligned to the second field (YYYY&hyphen;MM&hyphen;DD hh&colon;mm&colon;ss)&period;
| xref:absl/CivilYear.adoc[`CivilYear`] 
| A civil&hyphen;time value aligned to the year field (YYYY)&period;
| xref:absl/DefaultHashContainerEq.adoc[`DefaultHashContainerEq`] 
| Convenience alias for the default equality functor of Abseil hash&hyphen;based (unordered) containers&period;
| xref:absl/DefaultHashContainerHash.adoc[`DefaultHashContainerHash`] 
| Convenience alias for the default hashing functor of Abseil hash&hyphen;based (unordered) containers&period;
| xref:absl/EnableSplitIfString.adoc[`EnableSplitIfString`] 
| Enables a `StrSplit()` overload only when `T` is `std&colon;&colon;string`&period;
| xref:absl/Flag.adoc[`Flag`] 
| Forward declaration of the `absl&colon;&colon;Flag` type for use in defining the macro&period;
| xref:absl/FormatArg.adoc[`FormatArg`] 
| A type&hyphen;erased handle to a format argument specifically used as an argument to `FormatUntyped()`&period;
| xref:absl/FormatSpec.adoc[`FormatSpec`] 
| Defines the makeup of a format string within the `str&lowbar;format` library&period;
| xref:absl/Hash.adoc[`Hash`] 
| A convenient general&hyphen;purpose hash functor for any hashable type `T`&period;
| xref:absl/ParsedFormat.adoc[`ParsedFormat`] 
| A class template representing a preparsed `FormatSpec`, with template arguments specifying the conversion characters used within the format string&period;
| xref:absl/SeedSeq.adoc[`SeedSeq`] 
| A seed sequence conforming to &lsqb;rand&period;req&period;seedseq&rsqb;for use within bit generators&period;
| xref:absl/SourceLocation.adoc[`SourceLocation`] 
| Provides source&hyphen;code location information for C&plus;&plus;17 and later&period;
| xref:absl/Weekday.adoc[`Weekday`] 
| The Weekday enum class represents the civil&hyphen;time concept of a &quot;weekday&quot; with members for all days of the week&period;
| xref:absl/add_const_t.adoc[`add&lowbar;const&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;const&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/add_cv_t.adoc[`add&lowbar;cv&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;cv&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/add_lvalue_reference_t.adoc[`add&lowbar;lvalue&lowbar;reference&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;lvalue&lowbar;reference&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/add_pointer_t.adoc[`add&lowbar;pointer&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;pointer&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/add_rvalue_reference_t.adoc[`add&lowbar;rvalue&lowbar;reference&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;rvalue&lowbar;reference&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/add_volatile_t.adoc[`add&lowbar;volatile&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;add&lowbar;volatile&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/allocator_traits.adoc[`allocator&lowbar;traits`]  [.small]#[deprecated]#
| Uniform interface to the properties of an allocator type&period;
| xref:absl/any.adoc[`any`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;any` (deprecated&semi; use `std&colon;&colon;any` directly)&period;
| xref:absl/bad_any_cast.adoc[`bad&lowbar;any&lowbar;cast`]  [.small]#[deprecated]#
| Alias for `std&colon;&colon;bad&lowbar;any&lowbar;cast` (deprecated&semi; use `std&colon;&colon;bad&lowbar;any&lowbar;cast`)&period;
| xref:absl/bad_optional_access.adoc[`bad&lowbar;optional&lowbar;access`] 
| Alias for `std&colon;&colon;bad&lowbar;optional&lowbar;access`&period;
| xref:absl/bad_variant_access.adoc[`bad&lowbar;variant&lowbar;access`] 
| Alias for `std&colon;&colon;bad&lowbar;variant&lowbar;access`&period;
| xref:absl/civil_diff_t.adoc[`civil&lowbar;diff&lowbar;t`] 
| Type alias of the difference between two civil&hyphen;time values&period; This type is used to indicate arguments that are not normalized (such as parameters to the civil&hyphen;time constructors), the results of civil&hyphen;time subtraction, or the operand to civil&hyphen;time addition&period;
| xref:absl/civil_year_t.adoc[`civil&lowbar;year&lowbar;t`] 
| Type alias of a civil&hyphen;time year value&period; This type is guaranteed to (at least) support any year value supported by `time&lowbar;t`&period;
| xref:absl/common_type_t.adoc[`common&lowbar;type&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;common&lowbar;type&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/conditional_t.adoc[`conditional&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;conditional&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/conjunction.adoc[`conjunction`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;conjunction`&period; Prefer the std version directly&period;
| xref:absl/decay_t.adoc[`decay&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;decay&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/disjunction.adoc[`disjunction`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;disjunction`&period; Prefer the std version directly&period;
| xref:absl/enable_if_t.adoc[`enable&lowbar;if&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;enable&lowbar;if&lowbar;t`&period; Prefer the std version directly&period; Avoid inlining since the inliner cannot handle default arguments well&period;
| xref:absl/in_place_index_t.adoc[`in&lowbar;place&lowbar;index&lowbar;t`]  [.small]#[deprecated]#
| Tag type for in&hyphen;place construction at a given index&period;
| xref:absl/in_place_t.adoc[`in&lowbar;place&lowbar;t`]  [.small]#[deprecated]#
| Tag type for in&hyphen;place construction&period;
| xref:absl/in_place_type_t.adoc[`in&lowbar;place&lowbar;type&lowbar;t`]  [.small]#[deprecated]#
| Tag type for in&hyphen;place construction of a given type&period;
| xref:absl/index_sequence.adoc[`index&lowbar;sequence`]  [.small]#[deprecated]#
| Compile&hyphen;time sequence of `size&lowbar;t` indices&period;
| xref:absl/index_sequence_for.adoc[`index&lowbar;sequence&lowbar;for`]  [.small]#[deprecated]#
| Index sequence covering the given parameter pack&period;
| xref:absl/integer_sequence.adoc[`integer&lowbar;sequence`]  [.small]#[deprecated]#
| Compile&hyphen;time sequence of integers of a given type&period;
| xref:absl/is_copy_assignable.adoc[`is&lowbar;copy&lowbar;assignable`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;copy&lowbar;assignable`&period; Prefer the std version directly&period;
| xref:absl/is_function.adoc[`is&lowbar;function`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;function`&period; Prefer the std version directly&period;
| xref:absl/is_move_assignable.adoc[`is&lowbar;move&lowbar;assignable`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;move&lowbar;assignable`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_copy_assignable.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;assignable`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;assignable`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_copy_constructible.adoc[`is&lowbar;trivially&lowbar;copy&lowbar;constructible`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;copy&lowbar;constructible`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_default_constructible.adoc[`is&lowbar;trivially&lowbar;default&lowbar;constructible`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;default&lowbar;constructible`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_destructible.adoc[`is&lowbar;trivially&lowbar;destructible`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;destructible`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_move_assignable.adoc[`is&lowbar;trivially&lowbar;move&lowbar;assignable`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;assignable`&period; Prefer the std version directly&period;
| xref:absl/is_trivially_move_constructible.adoc[`is&lowbar;trivially&lowbar;move&lowbar;constructible`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;is&lowbar;trivially&lowbar;move&lowbar;constructible`&period; Prefer the std version directly&period;
| xref:absl/make_index_sequence.adoc[`make&lowbar;index&lowbar;sequence`]  [.small]#[deprecated]#
| Index sequence of the values `0, 1, &period;&period;&period;, N&hyphen;1`&period;
| xref:absl/make_integer_sequence.adoc[`make&lowbar;integer&lowbar;sequence`]  [.small]#[deprecated]#
| Integer sequence of the values `0, 1, &period;&period;&period;, N&hyphen;1` of a given type&period;
| xref:absl/make_signed_t.adoc[`make&lowbar;signed&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;make&lowbar;signed&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/make_unsigned_t.adoc[`make&lowbar;unsigned&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;make&lowbar;unsigned&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/monostate.adoc[`monostate`] 
| Alias for `std&colon;&colon;monostate`, an empty variant alternative&period;
| xref:absl/negation.adoc[`negation`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;negation`&period; Prefer the std version directly&period;
| xref:absl/nullopt_t.adoc[`nullopt&lowbar;t`] 
| Alias for `std&colon;&colon;nullopt&lowbar;t`, the type of `nullopt`&period;
| xref:absl/pointer_traits.adoc[`pointer&lowbar;traits`]  [.small]#[deprecated]#
| Uniform interface to the properties of a pointer&hyphen;like type&period;
| xref:absl/remove_all_extents_t.adoc[`remove&lowbar;all&lowbar;extents&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;all&lowbar;extents&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_const_t.adoc[`remove&lowbar;const&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;const&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_cv_t.adoc[`remove&lowbar;cv&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;cv&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_cvref.adoc[`remove&lowbar;cvref`] 
| C&plus;&plus;17 compatible implementation of `std&colon;&colon;remove&lowbar;cvref`, which was added in C&plus;&plus;20&period; Aliases `std&colon;&colon;remove&lowbar;cvref` when it is available&period;
| xref:absl/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| Convenience alias for `remove&lowbar;cvref&lt;T&gt;&colon;&colon;type`&period;
| xref:absl/remove_extent_t.adoc[`remove&lowbar;extent&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;extent&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_pointer_t.adoc[`remove&lowbar;pointer&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;pointer&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_reference_t.adoc[`remove&lowbar;reference&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;reference&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/remove_volatile_t.adoc[`remove&lowbar;volatile&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;remove&lowbar;volatile&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/result_of_t.adoc[`result&lowbar;of&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;invoke&lowbar;result&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/type_identity.adoc[`type&lowbar;identity`] 
| Back&hyphen;fill of C&plus;&plus;20&apos;s `std&colon;&colon;type&lowbar;identity`&period; Aliases `std&colon;&colon;type&lowbar;identity` when it is available&period;
| xref:absl/type_identity_t.adoc[`type&lowbar;identity&lowbar;t`] 
| Convenience alias for `type&lowbar;identity&lt;T&gt;&colon;&colon;type`&period;
| xref:absl/underlying_type_t.adoc[`underlying&lowbar;type&lowbar;t`]  [.small]#[deprecated]#
| Deprecated alias for `std&colon;&colon;underlying&lowbar;type&lowbar;t`&period; Prefer the std version directly&period;
| xref:absl/variant.adoc[`variant`] 
| Alias for `std&colon;&colon;variant`&period;
| xref:absl/variant_alternative.adoc[`variant&lowbar;alternative`] 
| Alias for `std&colon;&colon;variant&lowbar;alternative`, the type of alternative `I`&period;
| xref:absl/variant_alternative_t.adoc[`variant&lowbar;alternative&lowbar;t`] 
| Alias for `std&colon;&colon;variant&lowbar;alternative&lowbar;t`, the type of alternative `I`&period;
| xref:absl/variant_size.adoc[`variant&lowbar;size`] 
| Alias for `std&colon;&colon;variant&lowbar;size`, the number of alternatives&period;
| xref:absl/void_t.adoc[`void&lowbar;t`]  [.small]#[deprecated]#
| Ignores the type of any its arguments and returns `void`&period; In general, this metafunction allows you to create a general case that maps to `void` while allowing specializations that map to specific types&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:absl/ConstInitType.adoc[`ConstInitType`] 
| Enumerates the constructor tags used to mark an object as safe for use as a global variable&period;
| xref:absl/CordMemoryAccounting.adoc[`CordMemoryAccounting`] 
| Memory accounting modes for `Cord&colon;&colon;EstimatedMemoryUsage()`&period;
| xref:absl/FormatConversionChar.adoc[`FormatConversionChar`] 
| Specifies the formatting character provided in the format string passed to `StrFormat()`&period;
| xref:absl/FormatConversionCharSet.adoc[`FormatConversionCharSet`] 
| Specifies the _accepted_ conversion types as a template parameter to FormatConvertResult for custom implementations of `AbslFormatConvert`&period;
| xref:absl/LogSeverity.adoc[`LogSeverity`] 
| Four severity levels are defined&period; Logging APIs should terminate the program when a message is logged at severity `kFatal`&semi; the other levels have no special semantics&period;
| xref:absl/LogSeverityAtLeast.adoc[`LogSeverityAtLeast`] 
| Enums representing a lower bound for LogSeverity&period; APIs that only operate on messages of at least a certain level (for example, `SetMinLogLevel()`) use this type to specify that level&period; absl&colon;&colon;LogSeverityAtLeast&colon;&colon;kInfinity is a level above all threshold levels and therefore no log message will ever meet this threshold&period;
| xref:absl/LogSeverityAtMost.adoc[`LogSeverityAtMost`] 
| Enums representing an upper bound for LogSeverity&period; 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&period; absl&colon;&colon;LogSeverityAtMost&colon;&colon;kNegativeInfinity is a level below all threshold levels and therefore will exclude all log messages&period;
| xref:absl/MessageJoinStyle.adoc[`MessageJoinStyle`] 
| Specifies how to join the error message in the original status and any additional message that has been streamed into the builder&period;
| xref:absl/OnDeadlockCycle.adoc[`OnDeadlockCycle`] 
| Possible modes of operation for the deadlock detector in debug mode&period;
| xref:absl/PadSpec.adoc[`PadSpec`] 
| Specifies the number of significant digits to return in a `Hex` or `Dec` conversion and the fill character to use&period;
| xref:absl/StatusCode.adoc[`StatusCode`] 
| An enumerated type indicating either no error (&quot;OK&quot;) or an error condition&period;
| xref:absl/StatusToStringMode.adoc[`StatusToStringMode`] 
| An enumerated type indicating how `absl&colon;&colon;Status&colon;&colon;ToString()` should construct the output string for a non&hyphen;ok status&period;
| xref:absl/chars_format.adoc[`chars&lowbar;format`] 
| Workalike compatibility version of std&colon;&colon;chars&lowbar;format from C&plus;&plus;17&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:absl/AbortedError-08.adoc[`AbortedError`] 
| Creates a status with the `kAborted` error code and `message`&period;
| xref:absl/AbsDuration.adoc[`AbsDuration`] 
| Returns the absolute value of a duration&period;
| xref:absl/AbslFormatFlush-0a.adoc[`AbslFormatFlush`] 
| `AbslFormatFlush` overloads
| xref:absl/AbslHashValue-0f7.adoc[`AbslHashValue`] 
| `AbslHashValue` overloads
| xref:absl/AbslInternalSetErrorCode.adoc[`AbslInternalSetErrorCode`] 
| Argument&hyphen;dependent lookup extension point that sets a `StatusBuilder`&apos;s error code&period;
| xref:absl/AbslParseFlag-00.adoc[`AbslParseFlag`] 
| `AbslParseFlag` overloads
| xref:absl/AbslStringify-0f.adoc[`AbslStringify`] 
| `AbslStringify` overloads
| xref:absl/AbslUnparseFlag-07.adoc[`AbslUnparseFlag`] 
| `AbslUnparseFlag` overloads
| xref:absl/AddLogSink.adoc[`AddLogSink`] 
| Adds a `absl&colon;&colon;LogSink` as a consumer of logging data&period;
| xref:absl/AlphaNumFormatter.adoc[`AlphaNumFormatter`] 
| Default formatter used if none is specified&period; Uses `absl&colon;&colon;AlphaNum` to convert numeric arguments to strings&period;
| xref:absl/AlreadyExistsError-0c.adoc[`AlreadyExistsError`] 
| Creates a status with the `kAlreadyExists` error code and `message`&period;
| xref:absl/AppendCordToString.adoc[`AppendCordToString`] 
| Appends the contents of a `src` Cord to a `&ast;dst` string&period;
| xref:absl/AsciiStrToLower-04.adoc[`AsciiStrToLower`] 
| `AsciiStrToLower` overloads
| xref:absl/AsciiStrToUpper-0a.adoc[`AsciiStrToUpper`] 
| `AsciiStrToUpper` overloads
| xref:absl/Base64Escape-05.adoc[`Base64Escape`] 
| `Base64Escape` overloads
| xref:absl/Base64Unescape.adoc[`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&period; If `src` contains invalid characters, `dest` is cleared and returns `false`&period; If padding is included (note that `Base64Escape()` does produce it), it must be correct&period; In the padding, &apos;&equals;&apos; and &apos;&period;&apos; are treated identically&period;
| xref:absl/Bernoulli.adoc[`Bernoulli`] 
| Produces a random boolean value with probability `p` of being `true`&period;
| xref:absl/Beta.adoc[`Beta`] 
| Produces a floating point value from a Beta distribution&period;
| xref:absl/BytesToHexString.adoc[`BytesToHexString`] 
| Converts binary data into an ASCII text string, returning a string of size `2&ast;from&period;size()`&period;
| xref:absl/CEscape.adoc[`CEscape`] 
| Escapes a `src` string using C&hyphen;style escapes sequences (https&colon;&sol;&sol;en&period;cppreference&period;com&sol;w&sol;cpp&sol;language&sol;escape), escaping other non&hyphen;printable&sol;non&hyphen;whitespace bytes as octal sequences (e&period;g&period; &quot;377&quot;)&period;
| xref:absl/CHexEscape.adoc[`CHexEscape`] 
| Escapes a `src` string using C&hyphen;style escape sequences, escaping other non&hyphen;printable&sol;non&hyphen;whitespace bytes as hexadecimal sequences (e&period;g&period; &quot;xFF&quot;)&period;
| xref:absl/CUnescape-01.adoc[`CUnescape`] 
| `CUnescape` overloads
| xref:absl/CancelledError-00e.adoc[`CancelledError`] 
| `CancelledError` overloads
| xref:absl/Ceil.adoc[`Ceil`] 
| Returns the ceiling of a duration using the passed duration unit to its smallest value not less than the duration&period;
| xref:absl/ClearLogBacktraceLocation.adoc[`ClearLogBacktraceLocation`] 
| Clears the set location so that backtraces will no longer be logged at it&period;
| xref:absl/ClippedSubstr.adoc[`ClippedSubstr`] 
| Like `s&period;substr(pos, n)`, but clips `pos` to an upper bound of `s&period;size()`&period;
| xref:absl/ComputeCrc32c.adoc[`ComputeCrc32c`] 
| Compute the CRC32C value of the provided string&period;
| xref:absl/ConcatCrc32c.adoc[`ConcatCrc32c`] 
| Compute the CRC32C value of two concatenated buffers&period;
| xref:absl/ConsumePrefix.adoc[`ConsumePrefix`] 
| Strips the `expected` prefix, if found, from the start of `str`&period; If the operation succeeded, `true` is returned&period; If not, `false` is returned and `str` is not modified&period;
| xref:absl/ConsumeSuffix.adoc[`ConsumeSuffix`] 
| Strips the `expected` suffix, if found, from the end of `str`&period; If the operation succeeded, `true` is returned&period; If not, `false` is returned and `str` is not modified&period;
| xref:absl/ConvertDateTime.adoc[`ConvertDateTime`]  [.small]#[deprecated]#
| Legacy version of `absl&colon;&colon;TimeZone&colon;&colon;At(absl&colon;&colon;CivilSecond)` that takes the civil time as six, separate values (YMDHMS)&period;
| xref:absl/ConvertVariantTo.adoc[`ConvertVariantTo`] 
| Converts a variant to a variant of another set of types&period;
| xref:absl/CopyCordToSpan.adoc[`CopyCordToSpan`] 
| Copies up to `dst&period;size()` bytes starting from the beginning of `src` to `dst`&period;
| xref:absl/CopyCordToString.adoc[`CopyCordToString`] 
| Copies the contents of a `src` Cord into a `&ast;dst` string&period;
| xref:absl/CreateSeedSeqFrom.adoc[`CreateSeedSeqFrom`] 
| Constructs a seed sequence from variates produced by a bit generator&period;
| xref:absl/DataLossError-02.adoc[`DataLossError`] 
| Creates a status with the `kDataLoss` error code and `message`&period;
| xref:absl/DeadlineExceededError-08.adoc[`DeadlineExceededError`] 
| Creates a status with the `kDeadlineExceeded` error code and `message`&period;
| xref:absl/DefaultStackUnwinder.adoc[`DefaultStackUnwinder`] 
| Records program counter values of up to `max&lowbar;depth` frames, skipping the most recent `skip&lowbar;count` stack frames, and stores their corresponding values in `pcs`&period; (Note that the frame generated for this call itself is also skipped&period;) This function acts as a generic stack&hyphen;unwinder&semi; prefer usage of the more specific `GetStack&lcub;Trace,Frames&rcub;&lcub;,WithContext&rcub;()` functions above&period;
| xref:absl/DereferenceFormatter-09.adoc[`DereferenceFormatter`] 
| `DereferenceFormatter` overloads
| xref:absl/DisableFlagfileAndEnvParsing.adoc[`DisableFlagfileAndEnvParsing`] 
| Disables the processing of flags that load values from secondary sources, specifically `&hyphen;&hyphen;flagfile`, `&hyphen;&hyphen;fromenv`, and `&hyphen;&hyphen;tryfromenv`&period; 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&period; Direct command&hyphen;line flags passed via argv are still parsed normally&period;
| xref:absl/DoIgnoreLeak.adoc[`DoIgnoreLeak`] 
| Implements `IgnoreLeak()` below&period; This function should usually not be called directly&semi; calling `IgnoreLeak()` is preferred&period;
| xref:absl/DurationFromTimespec.adoc[`DurationFromTimespec`] 
| Converts a `timespec` to an `absl&colon;&colon;Duration`&period;
| xref:absl/DurationFromTimeval.adoc[`DurationFromTimeval`] 
| Converts a `timeval` to an `absl&colon;&colon;Duration`&period;
| xref:absl/EnableLogPrefix.adoc[`EnableLogPrefix`] 
| Updates the value of the Prepend Log Prefix option&period;
| xref:absl/EnableMutexInvariantDebugging.adoc[`EnableMutexInvariantDebugging`] 
| Enables or disables global support for `Mutex` invariant debugging&period;
| xref:absl/EndsWith.adoc[`EndsWith`] 
| Returns whether a given string `text` ends with `suffix`&period;
| xref:absl/EndsWithIgnoreCase.adoc[`EndsWithIgnoreCase`] 
| Returns whether a given ASCII string `text` ends with `suffix`, ignoring case in the comparison&period;
| xref:absl/EqualsIgnoreCase.adoc[`EqualsIgnoreCase`] 
| Returns whether given ASCII strings `piece1` and `piece2` are equal, ignoring case in the comparison&period;
| xref:absl/ErrnoToStatus.adoc[`ErrnoToStatus`] 
| Convenience function that creates a `absl&colon;&colon;Status` using an `error&lowbar;number`, which should be an `errno` value&period;
| xref:absl/ErrnoToStatusCode.adoc[`ErrnoToStatusCode`] 
| Returns the StatusCode for `error&lowbar;number`, which should be an `errno` value&period;
| xref:absl/Exponential.adoc[`Exponential`] 
| Produces a floating point value from an exponential distribution&period;
| xref:absl/ExtendCrc32c.adoc[`ExtendCrc32c`] 
| Compute a CRC32C value from an existing value and an additional buffer&period;
| xref:absl/ExtendCrc32cByZeroes.adoc[`ExtendCrc32cByZeroes`] 
| Extend a CRC32C value as if trailing zero bytes were appended&period;
| xref:absl/FDivDuration.adoc[`FDivDuration`] 
| Divides a `Duration` numerator into a fractional number of units of a `Duration` denominator&period;
| xref:absl/FPrintF.adoc[`FPrintF`] 
| Writes to a file given a format string and zero or more arguments&period;
| xref:absl/FailedPreconditionError-09.adoc[`FailedPreconditionError`] 
| Creates a status with the `kFailedPrecondition` error code and `message`&period;
| xref:absl/FastTypeId.adoc[`FastTypeId`] 
| `FastTypeId&lt;T&gt;()` is the generator method for FastTypeIdType values&period;
| xref:absl/FindAndReportLeaks.adoc[`FindAndReportLeaks`] 
| If any leaks are detected, prints a leak report and returns true&period; This function may be called repeatedly, and does not affect end&hyphen;of&hyphen;process leak checking&period;
| xref:absl/FindCommandLineFlag.adoc[`FindCommandLineFlag`] 
| Returns the reflection handle of an Abseil flag of the specified name, or `nullptr` if not found&period; This function will emit a warning if the name of a &apos;retired&apos; flag is specified&period;
| xref:absl/FindLongestCommonPrefix.adoc[`FindLongestCommonPrefix`] 
| Yields the longest prefix in common between both input strings&period; Pointer&hyphen;wise, the returned result is a subset of input &quot;a&quot;&period;
| xref:absl/FindLongestCommonSuffix.adoc[`FindLongestCommonSuffix`] 
| Yields the longest suffix in common between both input strings&period; Pointer&hyphen;wise, the returned result is a subset of input &quot;a&quot;&period;
| xref:absl/FixedTimeZone.adoc[`FixedTimeZone`] 
| Returns a TimeZone that is a fixed offset (seconds east) from UTC&period; Note&colon; If the absolute value of the offset is greater than 24 hours you&apos;ll get UTC (i&period;e&period;, no offset) instead&period;
| xref:absl/Floor.adoc[`Floor`] 
| Floors a duration using the passed duration unit to its largest value not greater than the duration&period;
| xref:absl/FlushLogSinks.adoc[`FlushLogSinks`] 
| Calls `absl&colon;&colon;LogSink&colon;&colon;Flush` on all registered sinks&period;
| xref:absl/Format.adoc[`Format`] 
| Writes a formatted string to an arbitrary sink object (implementing the `absl&colon;&colon;FormatRawSink` interface), using a format string and zero or more additional arguments&period;
| xref:absl/FormatCivilTime-0b.adoc[`FormatCivilTime`] 
| Formats the given civil&hyphen;time value into a string value of the following format&colon;
| xref:absl/FormatDuration.adoc[`FormatDuration`] 
| Returns a string representing the duration in the form &quot;72h3m0&period;5s&quot;&period; Returns &quot;inf&quot; or &quot;&hyphen;inf&quot; for &plus;&sol;&hyphen; `InfiniteDuration()`&period;
| xref:absl/FormatStreamed.adoc[`FormatStreamed`] 
| Takes a streamable argument and returns an object that can print it with &apos;%s&apos;&period;
| xref:absl/FormatTime-04.adoc[`FormatTime`] 
| `FormatTime` overloads
| xref:absl/FormatUntyped.adoc[`FormatUntyped`] 
| Writes a formatted string to an arbitrary sink object (implementing the `absl&colon;&colon;FormatRawSink` interface), using an `UntypedFormatSpec` and zero or more additional arguments&period;
| xref:absl/FromChrono-0b.adoc[`FromChrono`] 
| `FromChrono` overloads
| xref:absl/FromCivil.adoc[`FromCivil`] 
| Helper for TimeZone&colon;&colon;At(CivilSecond) that provides &quot;order&hyphen;preserving semantics&period;&quot; If the civil time maps to a unique time, that time is returned&period; If the civil time is repeated in the given time zone, the time using the pre&hyphen;transition offset is returned&period; Otherwise, the civil time is skipped in the given time zone, and the transition time is returned&period; This means that for any two civil times, ct1 and ct2, (ct1 &lt; ct2) &equals;&gt; (FromCivil(ct1) &lt;&equals; FromCivil(ct2)), the equal case being when two non&hyphen;existent civil times map to the same transition time&period;
| xref:absl/FromDateTime.adoc[`FromDateTime`]  [.small]#[deprecated]#
| A convenience wrapper for `absl&colon;&colon;ConvertDateTime()` that simply returns the &quot;pre&quot; `absl&colon;&colon;Time`&period; That is, the unique result, or the instant that is correct using the pre&hyphen;transition offset (as if the transition never happened)&period;
| xref:absl/FromTM.adoc[`FromTM`] 
| Converts the `tm&lowbar;year`, `tm&lowbar;mon`, `tm&lowbar;mday`, `tm&lowbar;hour`, `tm&lowbar;min`, and `tm&lowbar;sec` fields to an `absl&colon;&colon;Time` using the given time zone&period; See ctime(3) for a description of the expected values of the tm fields&period; If the civil time is unique (see `absl&colon;&colon;TimeZone&colon;&colon;At(absl&colon;&colon;CivilSecond)` above), the matching time instant is returned&period; Otherwise, the `tm&lowbar;isdst` field is consulted to choose between the possible results&period; For a repeated civil time, &grave;tm&lowbar;isdst !&equals; 0` returns the matching DST instant, while `tm&lowbar;isdst &equals;&equals; 0&grave; returns the matching non&hyphen;DST instant&period; For a skipped civil time there is no matching instant, so `tm&lowbar;isdst !&equals; 0` returns the DST instant, and `tm&lowbar;isdst &equals;&equals; 0` returns the non&hyphen;DST instant, that would have matched if the transition never happened&period;
| xref:absl/FromTimeT.adoc[`FromTimeT`] 
| Creates an `absl&colon;&colon;Time` from a `time&lowbar;t` value&period;
| xref:absl/FromUDate.adoc[`FromUDate`] 
| Creates an `absl&colon;&colon;Time` from an ICU UDate value&period;
| xref:absl/FromUniversal.adoc[`FromUniversal`] 
| Creates an `absl&colon;&colon;Time` from an ICU Universal Time Scale value&period;
| xref:absl/FromUnixMicros.adoc[`FromUnixMicros`] 
| Creates an `absl&colon;&colon;Time` from a count of microseconds since the Unix epoch&period;
| xref:absl/FromUnixMillis.adoc[`FromUnixMillis`] 
| Creates an `absl&colon;&colon;Time` from a count of milliseconds since the Unix epoch&period;
| xref:absl/FromUnixNanos.adoc[`FromUnixNanos`] 
| Creates an `absl&colon;&colon;Time` from a count of nanoseconds since the Unix epoch&period;
| xref:absl/FromUnixSeconds.adoc[`FromUnixSeconds`] 
| Creates an `absl&colon;&colon;Time` from a count of seconds since the Unix epoch&period;
| xref:absl/Gaussian.adoc[`Gaussian`] 
| Produces a floating point value from a Gaussian (Normal) distribution&period;
| xref:absl/GenericCompare.adoc[`GenericCompare`] 
| Compares `lhs` and `rhs` over the first `size&lowbar;to&lowbar;compare` bytes&period;
| xref:absl/GetAllFlags.adoc[`GetAllFlags`] 
| Returns current state of the Flags registry in a form of mapping from flag name to a flag reflection handle&period;
| xref:absl/GetCordzInfoForTesting.adoc[`GetCordzInfoForTesting`] 
| Returns the internal Cordz sampling info for `cord`, for testing&period;
| xref:absl/GetCurrentTimeNanos.adoc[`GetCurrentTimeNanos`] 
| Returns the current time, expressed as a count of nanoseconds since the Unix Epoch (https&colon;&sol;&sol;en&period;wikipedia&period;org&sol;wiki&sol;Unix&lowbar;time)&period; Prefer `absl&colon;&colon;Now()` instead for all but the most performance&hyphen;sensitive cases (i&period;e&period; when you are calling this function hundreds of thousands of times per second)&period;
| xref:absl/GetFlag.adoc[`GetFlag`] 
| Returns the value (of type `T`) of an `absl&colon;&colon;Flag&lt;T&gt;` instance, by value&period; Do not construct an `absl&colon;&colon;Flag&lt;T&gt;` directly and call `absl&colon;&colon;GetFlag()`&semi; instead, refer to flag&apos;s constructed variable name (e&period;g&period; `FLAGS&lowbar;name`)&period; Because this function returns by value and not by reference, it is thread&hyphen;safe, but note that the operation may be expensive&semi; as a result, avoid `absl&colon;&colon;GetFlag()` within any tight loops&period;
| xref:absl/GetFlagReflectionHandle.adoc[`GetFlagReflectionHandle`] 
| Returns the reflection handle corresponding to specified Abseil Flag instance&period; Use this handle to access flag&apos;s reflection information, like name, location, default value etc&period;
| xref:absl/GetStackFrames.adoc[`GetStackFrames`] 
| Records program counter values for up to `max&lowbar;depth` frames, skipping the most recent `skip&lowbar;count` stack frames, stores their corresponding values and sizes in `results` and `sizes` buffers, and returns the number of frames stored&period; (Note that the frame generated for the `absl&colon;&colon;GetStackFrames()` routine itself is also skipped&period;)
| xref:absl/GetStackFramesWithContext.adoc[`GetStackFramesWithContext`] 
| Records program counter values obtained from a signal handler&period; Records program counter values for up to `max&lowbar;depth` frames, skipping the most recent `skip&lowbar;count` stack frames, stores their corresponding values and sizes in `results` and `sizes` buffers, and returns the number of frames stored&period; (Note that the frame generated for the `absl&colon;&colon;GetStackFramesWithContext()` routine itself is also skipped&period;)
| xref:absl/GetStackTrace.adoc[`GetStackTrace`] 
| Records program counter values for up to `max&lowbar;depth` frames, skipping the most recent `skip&lowbar;count` stack frames, stores their corresponding values in `results`, and returns the number of frames stored&period; Note that this function is similar to `absl&colon;&colon;GetStackFrames()` except that it returns the stack trace only, and not stack frame sizes&period;
| xref:absl/GetStackTraceWithContext.adoc[`GetStackTraceWithContext`] 
| Records program counter values obtained from a signal handler&period; Records program counter values for up to `max&lowbar;depth` frames, skipping the most recent `skip&lowbar;count` stack frames, stores their corresponding values in `results`, and returns the number of frames stored&period; (Note that the frame generated for the `absl&colon;&colon;GetStackFramesWithContext()` routine itself is also skipped&period;)
| xref:absl/GetWeekday.adoc[`GetWeekday`] 
| Returns the absl&colon;&colon;Weekday for the given (realigned) civil&hyphen;time value&period;
| xref:absl/GetYearDay.adoc[`GetYearDay`] 
| Returns the day&hyphen;of&hyphen;year for the given (realigned) civil&hyphen;time value&period;
| xref:absl/HasPayload.adoc[`HasPayload`] 
| Indicates whether the status that `builder` will return has a `MessageSet` payload&period;
| xref:absl/HashOf.adoc[`HashOf`] 
| Generate a hash from the values of its arguments&period;
| xref:absl/HaveLeakSanitizer.adoc[`HaveLeakSanitizer`] 
| Returns true if a leak&hyphen;checking sanitizer (either ASan or standalone LSan) is currently built into this target&period;
| xref:absl/HexStringToBytes-08.adoc[`HexStringToBytes`] 
| `HexStringToBytes` overloads
| xref:absl/HighPrecision-0ba2.adoc[`HighPrecision`] 
| `HighPrecision` overloads
| xref:absl/Hours-02.adoc[`Hours`] 
| `Hours` overloads
| xref:absl/HwasanTagPointer.adoc[`HwasanTagPointer`] 
| No&hyphen;op fallback used when HWASAN is not available&period;
| xref:absl/IDivDuration.adoc[`IDivDuration`] 
| Divides a numerator `Duration` by a denominator `Duration`, returning the quotient and remainder&period; The remainder always has the same sign as the numerator&period; The returned quotient and remainder respect the identity&colon;
| xref:absl/IgnoreLeak.adoc[`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&period; The passed object pointer can point to either the beginning of the object or anywhere within it&period;
| xref:absl/InfiniteDuration.adoc[`InfiniteDuration`] 
| Returns an infinite `Duration`&period; To get a `Duration` representing negative infinity, use `&hyphen;InfiniteDuration()`&period;
| xref:absl/InfiniteFuture.adoc[`InfiniteFuture`] 
| Returns an `absl&colon;&colon;Time` that is infinitely far in the future&period;
| xref:absl/InfinitePast.adoc[`InfinitePast`] 
| Returns an `absl&colon;&colon;Time` that is infinitely far in the past&period;
| xref:absl/InitializeLog.adoc[`InitializeLog`] 
| Initializes the Abseil logging library&period;
| xref:absl/InitializeSymbolizer.adoc[`InitializeSymbolizer`] 
| Initializes the program counter symbolizer, given the path of the program (typically obtained through `main()`s `argv&lsqb;0&rsqb;`)&period; The Abseil symbolizer allows you to read program counters (instruction pointer values) using their human&hyphen;readable names within output such as stack traces&period;
| xref:absl/InstallFailureSignalHandler.adoc[`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)&period; The failure signal handler dumps program failure data useful for debugging in an unspecified format to stderr&period; This data may include the program counter, a stacktrace, and register information on some systems&semi; do not rely on an exact format for the output, as it is subject to change&period;
| xref:absl/Int128High64.adoc[`Int128High64`] 
| Returns the higher 64&hyphen;bit value of an `int128` value&period;
| xref:absl/Int128Low64.adoc[`Int128Low64`] 
| Returns the lower 64&hyphen;bit value of an `int128` value&period;
| xref:absl/Int128Max.adoc[`Int128Max`] 
| Returns the maximum value for a 128&hyphen;bit signed integer&period;
| xref:absl/Int128Min.adoc[`Int128Min`] 
| Returns the minimum value for a 128&hyphen;bit signed integer&period;
| xref:absl/InternalError-06.adoc[`InternalError`] 
| Creates a status with the `kInternal` error code and `message`&period;
| xref:absl/InvalidArgumentError-0b.adoc[`InvalidArgumentError`] 
| Creates a status with the `kInvalidArgument` error code and `message`&period;
| xref:absl/IsAborted.adoc[`IsAborted`] 
| Returns `true` if `status` has the `kAborted` error code&period;
| xref:absl/IsAlreadyExists.adoc[`IsAlreadyExists`] 
| Returns `true` if `status` has the `kAlreadyExists` error code&period;
| xref:absl/IsCancelled.adoc[`IsCancelled`] 
| Returns `true` if `status` has the `kCancelled` error code&period;
| xref:absl/IsDataLoss.adoc[`IsDataLoss`] 
| Returns `true` if `status` has the `kDataLoss` error code&period;
| xref:absl/IsDeadlineExceeded.adoc[`IsDeadlineExceeded`] 
| Returns `true` if `status` has the `kDeadlineExceeded` error code&period;
| xref:absl/IsFailedPrecondition.adoc[`IsFailedPrecondition`] 
| Returns `true` if `status` has the `kFailedPrecondition` error code&period;
| xref:absl/IsInternal.adoc[`IsInternal`] 
| Returns `true` if `status` has the `kInternal` error code&period;
| xref:absl/IsInvalidArgument.adoc[`IsInvalidArgument`] 
| Returns `true` if `status` has the `kInvalidArgument` error code&period;
| xref:absl/IsNotFound.adoc[`IsNotFound`] 
| Returns `true` if `status` has the `kNotFound` error code&period;
| xref:absl/IsOutOfRange.adoc[`IsOutOfRange`] 
| Returns `true` if `status` has the `kOutOfRange` error code&period;
| xref:absl/IsPermissionDenied.adoc[`IsPermissionDenied`] 
| Returns `true` if `status` has the `kPermissionDenied` error code&period;
| xref:absl/IsResourceExhausted.adoc[`IsResourceExhausted`] 
| Returns `true` if `status` has the `kResourceExhausted` error code&period;
| xref:absl/IsUnauthenticated.adoc[`IsUnauthenticated`] 
| Returns `true` if `status` has the `kUnauthenticated` error code&period;
| xref:absl/IsUnavailable.adoc[`IsUnavailable`] 
| Returns `true` if `status` has the `kUnavailable` error code&period;
| xref:absl/IsUnimplemented.adoc[`IsUnimplemented`] 
| Returns `true` if `status` has the `kUnimplemented` error code&period;
| xref:absl/IsUnknown.adoc[`IsUnknown`] 
| Returns `true` if `status` has the `kUnknown` error code&period;
| xref:absl/LeakCheckerIsActive.adoc[`LeakCheckerIsActive`] 
| Returns true if a leak&hyphen;checking sanitizer (either ASan or standalone LSan) is currently built into this target and is turned on&period;
| xref:absl/LoadTimeZone.adoc[`LoadTimeZone`] 
| Loads the named zone&period; May perform I&sol;O on the initial load of the named zone&period; If the name is invalid, or some other kind of error occurs, returns `false` and `&ast;tz` is set to the UTC time zone&period;
| xref:absl/LocalTimeZone.adoc[`LocalTimeZone`] 
| Convenience method returning the local time zone, or UTC if there is no configured local zone&period; Warning&colon; Be wary of using LocalTimeZone(), and particularly so in a server process, as the zone configured for the local machine should be irrelevant&period; Prefer an explicit zone name&period;
| xref:absl/LogAsLiteral.adoc[`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)&period; This does not affect the text representation, only the structure&period;
| xref:absl/LogDebugFatalStreamer-0d.adoc[`LogDebugFatalStreamer`] 
| Returns a LogStreamer that writes at level LogSeverity&colon;&colon;kLogDebugFatal&period;
| xref:absl/LogErrorStreamer-0a.adoc[`LogErrorStreamer`] 
| Returns a LogStreamer that writes at level LogSeverity&colon;&colon;kError&period;
| xref:absl/LogFatalStreamer-0c.adoc[`LogFatalStreamer`] 
| Returns a LogStreamer that writes at level LogSeverity&colon;&colon;kFatal&period;
| xref:absl/LogInfoStreamer-03.adoc[`LogInfoStreamer`] 
| Returns a LogStreamer that writes at level LogSeverity&colon;&colon;kInfo&period;
| xref:absl/LogSeverities.adoc[`LogSeverities`] 
| Returns an iterable of all standard `absl&colon;&colon;LogSeverity` values, ordered from least to most severe&period;
| xref:absl/LogSeverityName.adoc[`LogSeverityName`] 
| Returns the all&hyphen;caps string representation (e&period;g&period; &quot;INFO&quot;) of the specified severity level if it is one of the standard levels and &quot;UNKNOWN&quot; otherwise&period;
| xref:absl/LogUniform.adoc[`LogUniform`] 
| Produces random integral values whose logarithm is uniformly distributed&period;
| xref:absl/LogWarningStreamer-00.adoc[`LogWarningStreamer`] 
| Returns a LogStreamer that writes at level LogSeverity&colon;&colon;kWarning&period;
| xref:absl/MakeAnySpan-01.adoc[`MakeAnySpan`] 
| `MakeAnySpan` overloads
| xref:absl/MakeCleanup.adoc[`MakeCleanup`] 
| Create an `absl&colon;&colon;Cleanup` from a callback&period;
| xref:absl/MakeConstAnySpan-0f.adoc[`MakeConstAnySpan`] 
| `MakeConstAnySpan` overloads
| xref:absl/MakeConstDerefAnySpan-0b.adoc[`MakeConstDerefAnySpan`] 
| `MakeConstDerefAnySpan` overloads
| xref:absl/MakeConstSpan-0ee.adoc[`MakeConstSpan`] 
| `MakeConstSpan` overloads
| xref:absl/MakeCordFromExternal.adoc[`MakeCordFromExternal`] 
| Creates a Cord that takes ownership of external string memory&period;
| xref:absl/MakeDerefAnySpan-0e.adoc[`MakeDerefAnySpan`] 
| `MakeDerefAnySpan` overloads
| xref:absl/MakeInt128.adoc[`MakeInt128`] 
| Constructs an `int128` numeric value from two 64&hyphen;bit integers&period;
| xref:absl/MakeSeedSeq.adoc[`MakeSeedSeq`] 
| Constructs an `absl&colon;&colon;SeedSeq` salted with implementation&hyphen;defined entropy&period;
| xref:absl/MakeSpan-01.adoc[`MakeSpan`] 
| `MakeSpan` overloads
| xref:absl/MakeStatusRepImpl.adoc[`MakeStatusRepImpl`] 
| Builds a status representation from an inlined rep and a message&period;
| xref:absl/MakeUint128.adoc[`MakeUint128`] 
| Constructs a `uint128` numeric value from two 64&hyphen;bit unsigned integers&period;
| xref:absl/MarshalHashtableProfile.adoc[`MarshalHashtableProfile`] 
| Serialize the current hash table profile into a string&period;
| xref:absl/MaxSplits.adoc[`MaxSplits`] 
| A delimiter that limits the number of matches which can occur to the passed `limit`&period;
| xref:absl/MemcpyCrc32c.adoc[`MemcpyCrc32c`] 
| Copy bytes while computing the CRC32C value of the copied data&period;
| xref:absl/Microseconds-0f.adoc[`Microseconds`] 
| `Microseconds` overloads
| xref:absl/Milliseconds-013.adoc[`Milliseconds`] 
| `Milliseconds` overloads
| xref:absl/MinLogLevel.adoc[`MinLogLevel`] 
| Returns the value of the Minimum Log Level parameter&period;
| xref:absl/Minutes-01.adoc[`Minutes`] 
| `Minutes` overloads
| xref:absl/Nanoseconds-06.adoc[`Nanoseconds`] 
| `Nanoseconds` overloads
| xref:absl/NextWeekday.adoc[`NextWeekday`] 
| Returns the absl&colon;&colon;CivilDay that strictly follows a given absl&colon;&colon;CivilDay, and that falls on the given absl&colon;&colon;Weekday&period;
| xref:absl/NormalizeLogSeverity-04.adoc[`NormalizeLogSeverity`] 
| `NormalizeLogSeverity` overloads
| xref:absl/NotFoundError-07.adoc[`NotFoundError`] 
| Creates a status with the `kNotFound` error code and `message`&period;
| xref:absl/Now.adoc[`Now`] 
| Returns the current time, expressed as an `absl&colon;&colon;Time` absolute time value&period;
| xref:absl/NullSafeStringView.adoc[`NullSafeStringView`] 
| Creates an `absl&colon;&colon;string&lowbar;view` from a pointer `p` even if it&apos;s null&hyphen;valued&period;
| xref:absl/OkStatus.adoc[`OkStatus`] 
| Returns an OK status, equivalent to a default constructed instance&period;
| xref:absl/OutOfRangeError-05.adoc[`OutOfRangeError`] 
| Creates a status with the `kOutOfRange` error code and `message`&period;
| xref:absl/PairFormatter-00.adoc[`PairFormatter`] 
| `PairFormatter` overloads
| xref:absl/ParseAbseilFlagsOnly.adoc[`ParseAbseilFlagsOnly`] 
| Parses a list of command&hyphen;line arguments, passed in the `argc` and `argv&lsqb;&rsqb;` parameters, into a set of Abseil Flag values, returning any unparsed arguments in `positional&lowbar;args` and `unrecognized&lowbar;flags` output parameters&period;
| xref:absl/ParseCivilTime-05.adoc[`ParseCivilTime`] 
| Parses a civil&hyphen;time value from the specified `absl&colon;&colon;string&lowbar;view` into the passed output parameter&period; Returns `true` upon successful parsing&period;
| xref:absl/ParseCommandLine.adoc[`ParseCommandLine`] 
| First parses Abseil Flags only from the command line according to the description in `ParseAbseilFlagsOnly`&period; In addition this function handles unrecognized and usage flags&period;
| xref:absl/ParseDuration.adoc[`ParseDuration`] 
| Parses a duration string consisting of a possibly signed sequence of decimal numbers, each with an optional fractional part and a unit suffix&period; The valid suffixes are &quot;ns&quot;, &quot;us&quot; &quot;ms&quot;, &quot;s&quot;, &quot;m&quot;, and &quot;h&quot;&period; Simple examples include &quot;300ms&quot;, &quot;&hyphen;1&period;5h&quot;, and &quot;2h45m&quot;&period; Parses &quot;0&quot; as `ZeroDuration()`&period; Parses &quot;inf&quot; and &quot;&hyphen;inf&quot; as &plus;&sol;&hyphen; `InfiniteDuration()`&period;
| xref:absl/ParseFlag-03.adoc[`ParseFlag`] 
| `ParseFlag` overloads
| xref:absl/ParseLenientCivilTime-0e.adoc[`ParseLenientCivilTime`] 
| Parses any of the formats accepted by `absl&colon;&colon;ParseCivilTime()`&period; Unlike `ParseCivilTime()`, the input string format does not need to match the target civil&hyphen;time type&period; Discrepancies are resolved as follows&colon; &ast; Extra components in the input string are ignored&period; &ast; Missing components are defaulted to their minimum valid values&period; This behavior is consistent with civil&hyphen;time converting constructors&period;
| xref:absl/ParseTime-09.adoc[`ParseTime`] 
| `ParseTime` overloads
| xref:absl/PermissionDeniedError-00.adoc[`PermissionDeniedError`] 
| Creates a status with the `kPermissionDenied` error code and `message`&period;
| xref:absl/Poisson.adoc[`Poisson`] 
| Produces a random integral value from a Poisson distribution&period;
| xref:absl/PrefetchToLocalCache.adoc[`PrefetchToLocalCache`] 
| Moves data into the L1 cache before it is read, or &quot;prefetches&quot; it&period;
| xref:absl/PrefetchToLocalCacheForWrite.adoc[`PrefetchToLocalCacheForWrite`] 
| Moves data into the L1 cache with the intent to modify it&period;
| xref:absl/PrefetchToLocalCacheNta.adoc[`PrefetchToLocalCacheNta`] 
| Moves data into the L1 cache before it is read, or &quot;prefetches&quot; it&period;
| xref:absl/PrevWeekday.adoc[`PrevWeekday`] 
| Returns the absl&colon;&colon;CivilDay that strictly precedes a given absl&colon;&colon;CivilDay, and that falls on the given absl&colon;&colon;Weekday&period;
| xref:absl/PrintF.adoc[`PrintF`] 
| Writes to stdout given a format string and zero or more arguments&period;
| xref:absl/PrintTo.adoc[`PrintTo`] 
| Writes a human&hyphen;readable representation of `entry` to `os`, e&period;g&period; for use by test frameworks such as GoogleTest&period;
| xref:absl/ProgramUsageMessage.adoc[`ProgramUsageMessage`] 
| Returns the usage message set by `SetProgramUsageMessage()`&period;
| xref:absl/RawPtr-0f.adoc[`RawPtr`] 
| `RawPtr` overloads
| xref:absl/RegisterCondVarTracer.adoc[`RegisterCondVarTracer`] 
| Registers a hook for `CondVar` tracing&period;
| xref:absl/RegisterLivePointers.adoc[`RegisterLivePointers`] 
| Registers `ptr&lsqb;0,size&hyphen;1&rsqb;` as pointers to memory that is still actively being referenced and for which leak checking should be ignored&period; 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&period;
| xref:absl/RegisterMutexProfiler.adoc[`RegisterMutexProfiler`] 
| Registers a hook for mutex contention profiling&period;
| xref:absl/RegisterMutexTracer.adoc[`RegisterMutexTracer`] 
| Registers a hook for `Mutex` tracing&period;
| xref:absl/RemoveCrc32cPrefix.adoc[`RemoveCrc32cPrefix`] 
| Compute the CRC32C value of a buffer with a prefix removed&period;
| xref:absl/RemoveCrc32cSuffix.adoc[`RemoveCrc32cSuffix`] 
| Compute the CRC32C value of a buffer with a suffix removed&period;
| xref:absl/RemoveExtraAsciiWhitespace.adoc[`RemoveExtraAsciiWhitespace`] 
| Removes leading, trailing, and consecutive internal whitespace&period;
| xref:absl/RemoveLogSink.adoc[`RemoveLogSink`] 
| Removes a `absl&colon;&colon;LogSink` as a consumer of logging data&period;
| xref:absl/ReportUnrecognizedFlags.adoc[`ReportUnrecognizedFlags`] 
| Reports an error to `stderr` for all non&hyphen;ignored unrecognized flags in the provided `unrecognized&lowbar;flags` list&period;
| xref:absl/ResourceExhaustedError-09a.adoc[`ResourceExhaustedError`] 
| Creates a status with the `kResourceExhausted` error code and `message`&period;
| xref:absl/SNPrintF.adoc[`SNPrintF`] 
| Writes to a sized buffer given a format string and zero or more arguments&period;
| xref:absl/Seconds-06.adoc[`Seconds`] 
| `Seconds` overloads
| xref:absl/SetAndroidNativeTag.adoc[`SetAndroidNativeTag`] 
| Stores a copy of the string pointed to by `tag` and uses it as the Android logging tag thereafter&period; `tag` must not be null&period;
| xref:absl/SetFlag-00.adoc[`SetFlag`] 
| `SetFlag` overloads
| xref:absl/SetFlagsUsageConfig.adoc[`SetFlagsUsageConfig`] 
| Sets the usage reporting configuration callbacks&period; If any of the callbacks are not set in usage&lowbar;config instance, then the default value of the callback is used&period;
| xref:absl/SetGlobalVLogLevel.adoc[`SetGlobalVLogLevel`] 
| Sets the global `VLOG` level to threshold&period;
| xref:absl/SetLogBacktraceLocation.adoc[`SetLogBacktraceLocation`] 
| Sets the location the backtrace should be logged at&period;
| xref:absl/SetMinLogLevel.adoc[`SetMinLogLevel`] 
| Updates the value of Minimum Log Level parameter&period;
| xref:absl/SetMutexDeadlockDetectionMode.adoc[`SetMutexDeadlockDetectionMode`] 
| Enables or disables global detection of potential deadlocks due to `Mutex` lock ordering inversions&period;
| xref:absl/SetProgramUsageMessage.adoc[`SetProgramUsageMessage`] 
| Sets the &quot;usage&quot; message to be used by help reporting routines&period; For example&colon; absl&colon;&colon;SetProgramUsageMessage( absl&colon;&colon;StrCat(&quot;This program does nothing&period; Sample usage&colon;n&quot;, argv&lsqb;0&rsqb;, &quot; &lt;uselessarg1&gt; &lt;uselessarg2&gt;&quot;))&semi; Do not include commandline flags in the usage&colon; we do that for you! Note&colon; Calling SetProgramUsageMessage twice will trigger a call to std&colon;&colon;exit&period;
| xref:absl/SetStackUnwinder.adoc[`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&lcub;Frames,Trace&rcub;&lcub;,WithContext&rcub;() functions above&period;
| xref:absl/SetStderrThreshold-05a4.adoc[`SetStderrThreshold`] 
| Updates the Stderr Threshold parameter&period;
| xref:absl/SetVLogLevel.adoc[`SetVLogLevel`] 
| Sets the `VLOG` threshold for all files that match `module&lowbar;pattern`, overwriting any prior value&period; Files that don&apos;t match aren&apos;t affected&period;
| xref:absl/ShareUniquePtr.adoc[`ShareUniquePtr`] 
| Convert a `std&colon;&colon;unique&lowbar;ptr` into a `std&colon;&colon;shared&lowbar;ptr`&period;
| xref:absl/ShouldPrependLogPrefix.adoc[`ShouldPrependLogPrefix`] 
| Returns the value of the Prepend Log Prefix option&period;
| xref:absl/SimpleAtob.adoc[`SimpleAtob`] 
| Converts the given string into a boolean, returning `true` if successful&period;
| xref:absl/SimpleAtod.adoc[`SimpleAtod`] 
| Converts the given string into a double, returning `true` if successful&period;
| xref:absl/SimpleAtof.adoc[`SimpleAtof`] 
| Converts the given string into a float, returning `true` if successful&period;
| xref:absl/SimpleAtoi-01.adoc[`SimpleAtoi`] 
| `SimpleAtoi` overloads
| xref:absl/SimpleHexAtoi-08.adoc[`SimpleHexAtoi`] 
| `SimpleHexAtoi` overloads
| xref:absl/SixDigits.adoc[`SixDigits`] 
| Helper function for the default `StrCat()` floating&hyphen;point format, `%&period;6g`&period;
| xref:absl/SleepFor.adoc[`SleepFor`] 
| Sleeps for the specified duration, expressed as an `absl&colon;&colon;Duration`&period;
| xref:absl/StartsWith.adoc[`StartsWith`] 
| Returns whether a given string `text` begins with `prefix`&period;
| xref:absl/StartsWithIgnoreCase.adoc[`StartsWithIgnoreCase`] 
| Returns whether a given ASCII string `text` starts with `prefix`, ignoring case in the comparison&period;
| xref:absl/StatusCodeToString.adoc[`StatusCodeToString`] 
| Returns the name for the status code, or &quot;&quot; if it is an unknown value&period;
| xref:absl/StatusCodeToStringView.adoc[`StatusCodeToStringView`] 
| Same as StatusCodeToString(), but returns a string&lowbar;view&period;
| xref:absl/StatusMessageAsCStr.adoc[`StatusMessageAsCStr`] 
| Retrieves a message&apos;s status as a null terminated C string&period;
| xref:absl/StderrThreshold.adoc[`StderrThreshold`] 
| Returns the value of the Stderr Threshold parameter&period;
| xref:absl/StrAppend-0f.adoc[`StrAppend`] 
| `StrAppend` overloads
| xref:absl/StrAppendFormat.adoc[`StrAppendFormat`] 
| Appends to a `dst` string given a format string, and zero or more additional arguments, returning `&ast;dst` as a convenience for chaining purposes&period;
| xref:absl/StrCat-04.adoc[`StrCat`] 
| `StrCat` overloads
| xref:absl/StrContains-0a.adoc[`StrContains`] 
| `StrContains` overloads
| xref:absl/StrContainsIgnoreCase-0d.adoc[`StrContainsIgnoreCase`] 
| `StrContainsIgnoreCase` overloads
| xref:absl/StrFormat.adoc[`StrFormat`] 
| Returns a `string` given a `printf()`&hyphen;style format string and zero or more additional arguments&period;
| xref:absl/StrJoin-0c8.adoc[`StrJoin`] 
| `StrJoin` overloads
| xref:absl/StrReplaceAll-0e8.adoc[`StrReplaceAll`] 
| `StrReplaceAll` overloads
| xref:absl/StrSplit-07.adoc[`StrSplit`] 
| `StrSplit` overloads
| xref:absl/StreamFormat.adoc[`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&colon;&colon;StrFormat()`&period;
| xref:absl/StreamFormatter.adoc[`StreamFormatter`] 
| Formats its argument using the &lt;&lt; operator&period;
| xref:absl/StringResizeAndOverwrite.adoc[`StringResizeAndOverwrite`] 
| Resizes `str` to contain at most `n` characters, using the user&hyphen;provided operation `op` to modify the possibly indeterminate contents&period; `op` must return the finalized length of `str`&period;
| xref:absl/StripAsciiWhitespace-00.adoc[`StripAsciiWhitespace`] 
| `StripAsciiWhitespace` overloads
| xref:absl/StripLeadingAsciiWhitespace-02c.adoc[`StripLeadingAsciiWhitespace`] 
| `StripLeadingAsciiWhitespace` overloads
| xref:absl/StripPrefix.adoc[`StripPrefix`] 
| Returns a view into the input string `str` with the given `prefix` removed, but leaving the original string intact&period; If the prefix does not match at the start of the string, returns the original string instead&period;
| xref:absl/StripSuffix.adoc[`StripSuffix`] 
| Returns a view into the input string `str` with the given `suffix` removed, but leaving the original string intact&period; If the suffix does not match at the end of the string, returns the original string instead&period;
| xref:absl/StripTrailingAsciiWhitespace-06.adoc[`StripTrailingAsciiWhitespace`] 
| `StripTrailingAsciiWhitespace` overloads
| xref:absl/Substitute-03.adoc[`Substitute`] 
| `Substitute` overloads
| xref:absl/SubstituteAndAppend-08.adoc[`SubstituteAndAppend`] 
| `SubstituteAndAppend` overloads
| xref:absl/Symbolize.adoc[`Symbolize`] 
| Symbolizes a program counter (instruction pointer value) `pc` and, on success, writes the name to `out`&period; The symbol name is demangled, if possible&period; Note that the symbolized name may be truncated and will be NUL&hyphen;terminated&period; Demangling is supported for symbols generated by GCC 3&period;x or newer)&period; Returns `false` on failure&period;
| xref:absl/ThrowStdBadAlloc.adoc[`ThrowStdBadAlloc`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;bad&lowbar;alloc`, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdBadArrayNewLength.adoc[`ThrowStdBadArrayNewLength`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;bad&lowbar;array&lowbar;new&lowbar;length`, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdBadFunctionCall.adoc[`ThrowStdBadFunctionCall`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;bad&lowbar;function&lowbar;call`, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdDomainError-02.adoc[`ThrowStdDomainError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;domain&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdInvalidArgument-03.adoc[`ThrowStdInvalidArgument`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;invalid&lowbar;argument` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdLengthError-03.adoc[`ThrowStdLengthError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;length&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdLogicError-0ab.adoc[`ThrowStdLogicError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;logic&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdOutOfRange-07.adoc[`ThrowStdOutOfRange`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;out&lowbar;of&lowbar;range` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdOverflowError-08.adoc[`ThrowStdOverflowError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;overflow&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdRangeError-0a.adoc[`ThrowStdRangeError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;range&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdRuntimeError-05.adoc[`ThrowStdRuntimeError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;runtime&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/ThrowStdUnderflowError-0f.adoc[`ThrowStdUnderflowError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;underflow&lowbar;error` with the given message, or terminates if exceptions are disabled&period;
| xref:absl/TimeFromTimespec.adoc[`TimeFromTimespec`] 
| Converts a `timespec` to an `absl&colon;&colon;Time`&period;
| xref:absl/TimeFromTimeval.adoc[`TimeFromTimeval`] 
| Converts a `timeval` to an `absl&colon;&colon;Time`&period;
| xref:absl/ToChronoHours.adoc[`ToChronoHours`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;hours value&period;
| xref:absl/ToChronoMicroseconds.adoc[`ToChronoMicroseconds`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;microseconds value&period;
| xref:absl/ToChronoMilliseconds.adoc[`ToChronoMilliseconds`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;milliseconds value&period;
| xref:absl/ToChronoMinutes.adoc[`ToChronoMinutes`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;minutes value&period;
| xref:absl/ToChronoNanoseconds.adoc[`ToChronoNanoseconds`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;nanoseconds value&period;
| xref:absl/ToChronoSeconds.adoc[`ToChronoSeconds`] 
| Converts an absl&colon;&colon;Duration to a std&colon;&colon;chrono&colon;&colon;seconds value&period;
| xref:absl/ToChronoTime.adoc[`ToChronoTime`] 
| Converts an absl&colon;&colon;Time to a std&colon;&colon;chrono&colon;&colon;system&lowbar;clock&colon;&colon;time&lowbar;point&period; If overflow would occur, the returned value will saturate at the min&sol;max time point value instead&period;
| xref:absl/ToCivilDay.adoc[`ToCivilDay`] 
| Converts an absolute time to a day&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToCivilHour.adoc[`ToCivilHour`] 
| Converts an absolute time to an hour&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToCivilMinute.adoc[`ToCivilMinute`] 
| Converts an absolute time to a minute&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToCivilMonth.adoc[`ToCivilMonth`] 
| Converts an absolute time to a month&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToCivilSecond.adoc[`ToCivilSecond`] 
| Converts an absolute time to a second&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToCivilYear.adoc[`ToCivilYear`] 
| Converts an absolute time to a year&hyphen;aligned civil time in a time zone&period;
| xref:absl/ToDoubleHours.adoc[`ToDoubleHours`] 
| Converts a Duration to a floating&hyphen;point count of hours&period;
| xref:absl/ToDoubleMicroseconds.adoc[`ToDoubleMicroseconds`] 
| Converts a Duration to a floating&hyphen;point count of microseconds&period;
| xref:absl/ToDoubleMilliseconds.adoc[`ToDoubleMilliseconds`] 
| Converts a Duration to a floating&hyphen;point count of milliseconds&period;
| xref:absl/ToDoubleMinutes.adoc[`ToDoubleMinutes`] 
| Converts a Duration to a floating&hyphen;point count of minutes&period;
| xref:absl/ToDoubleNanoseconds.adoc[`ToDoubleNanoseconds`] 
| Converts a Duration to a floating&hyphen;point count of nanoseconds&period;
| xref:absl/ToDoubleSeconds.adoc[`ToDoubleSeconds`] 
| Converts a Duration to a floating&hyphen;point count of seconds&period;
| xref:absl/ToInt64Hours.adoc[`ToInt64Hours`] 
| Converts a Duration to an integral count of hours&period;
| xref:absl/ToInt64Microseconds.adoc[`ToInt64Microseconds`] 
| Converts a Duration to an integral count of microseconds&period;
| xref:absl/ToInt64Milliseconds.adoc[`ToInt64Milliseconds`] 
| Converts a Duration to an integral count of milliseconds&period;
| xref:absl/ToInt64Minutes.adoc[`ToInt64Minutes`] 
| Converts a Duration to an integral count of minutes&period;
| xref:absl/ToInt64Nanoseconds.adoc[`ToInt64Nanoseconds`] 
| Converts a Duration to an integral count of nanoseconds&period;
| xref:absl/ToInt64Seconds.adoc[`ToInt64Seconds`] 
| Converts a Duration to an integral count of seconds&period;
| xref:absl/ToTM.adoc[`ToTM`] 
| Converts the given `absl&colon;&colon;Time` to a struct tm using the given time zone&period; See ctime(3) for a description of the values of the tm fields&period;
| xref:absl/ToTimeT.adoc[`ToTimeT`] 
| Converts an `absl&colon;&colon;Time` to a `time&lowbar;t` value&period;
| xref:absl/ToTimespec-0b.adoc[`ToTimespec`] 
| `ToTimespec` overloads
| xref:absl/ToTimeval-0c.adoc[`ToTimeval`] 
| `ToTimeval` overloads
| xref:absl/ToUDate.adoc[`ToUDate`] 
| Converts an `absl&colon;&colon;Time` to an ICU UDate value&period;
| xref:absl/ToUniversal.adoc[`ToUniversal`] 
| Converts an `absl&colon;&colon;Time` to an ICU Universal Time Scale value&period;
| xref:absl/ToUnixMicros.adoc[`ToUnixMicros`] 
| Converts an `absl&colon;&colon;Time` to a count of microseconds since the Unix epoch&period;
| xref:absl/ToUnixMillis.adoc[`ToUnixMillis`] 
| Converts an `absl&colon;&colon;Time` to a count of milliseconds since the Unix epoch&period;
| xref:absl/ToUnixNanos.adoc[`ToUnixNanos`] 
| Converts an `absl&colon;&colon;Time` to a count of nanoseconds since the Unix epoch&period;
| xref:absl/ToUnixSeconds.adoc[`ToUnixSeconds`] 
| Converts an `absl&colon;&colon;Time` to a count of seconds since the Unix epoch&period;
| xref:absl/Trunc.adoc[`Trunc`] 
| Truncates a duration (toward zero) to a multiple of a non&hyphen;zero unit&period;
| xref:absl/UTCTimeZone.adoc[`UTCTimeZone`] 
| Convenience method returning the UTC time zone&period;
| xref:absl/Uint128High64.adoc[`Uint128High64`] 
| Returns the higher 64&hyphen;bit value of a `uint128` value&period;
| xref:absl/Uint128Low64.adoc[`Uint128Low64`] 
| Returns the lower 64&hyphen;bit value of a `uint128` value&period;
| xref:absl/Uint128Max.adoc[`Uint128Max`] 
| Returns the highest value for a 128&hyphen;bit unsigned integer&period;
| xref:absl/UnRegisterLivePointers.adoc[`UnRegisterLivePointers`] 
| Deregisters the pointers previously marked as active in `RegisterLivePointers()`, enabling leak checking of those pointers&period;
| xref:absl/UnauthenticatedError-0b.adoc[`UnauthenticatedError`] 
| Creates a status with the `kUnauthenticated` error code and `message`&period;
| xref:absl/UnavailableError-08.adoc[`UnavailableError`] 
| Creates a status with the `kUnavailable` error code and `message`&period;
| xref:absl/Uniform-08.adoc[`Uniform`] 
| `Uniform` overloads
| xref:absl/UnimplementedError-0b.adoc[`UnimplementedError`] 
| Creates a status with the `kUnimplemented` error code and `message`&period;
| xref:absl/UniversalEpoch.adoc[`UniversalEpoch`] 
| Returns the `absl&colon;&colon;Time` representing the ICU Universal Time Scale epoch&period;
| xref:absl/UnixEpoch.adoc[`UnixEpoch`] 
| Returns the `absl&colon;&colon;Time` representing &quot;1970&hyphen;01&hyphen;01 00&colon;00&colon;00&period;0 &plus;0000&quot;&period;
| xref:absl/UnknownError-0e.adoc[`UnknownError`] 
| Creates a status with the `kUnknown` error code and `message`&period;
| xref:absl/UnparseFlag-0e7.adoc[`UnparseFlag`] 
| `UnparseFlag` overloads
| xref:absl/UrlEscape.adoc[`UrlEscape`] 
| Escapes a string so it can be safely used as a value in a URL component by replacing all characters that are not &quot;unreserved characters&quot; with percent&hyphen;escapes&period; See https&colon;&sol;&sol;tools&period;ietf&period;org&sol;html&sol;rfc3986
| xref:absl/UrlEscapePlus.adoc[`UrlEscapePlus`] 
| Escapes a string so it can be safely used as a value for application&sol;x&hyphen;www&hyphen;form&hyphen;urlencoded (HTML form submissions)&period;
| xref:absl/UrlUnescape.adoc[`UrlUnescape`] 
| Performs the inverse transformation of UrlEscape(), converting each percent&hyphen;encoded sequence of the form &quot;%AB&quot; into the character with the hexadecimal value 0xAB&period; It returns `std&colon;&colon;nullopt` if any % is not followed by two hexadecimal digits&period;
| xref:absl/UrlUnescapePlus.adoc[`UrlUnescapePlus`] 
| Performs the inverse transformation of UrlEscapePlus()&period; It returns `std&colon;&colon;nullopt` if any % is not followed by two hexadecimal digits&period;
| xref:absl/Utf8SafeCEscape.adoc[`Utf8SafeCEscape`] 
| Escapes a `src` string using C&hyphen;style escape sequences, escaping bytes as octal sequences, and passing through UTF&hyphen;8 characters without conversion&period;
| xref:absl/Utf8SafeCHexEscape.adoc[`Utf8SafeCHexEscape`] 
| Escapes a `src` string using C&hyphen;style escape sequences, escaping bytes as hexadecimal sequences, and passing through UTF&hyphen;8 characters without conversion&period;
| xref:absl/WeakenPtr.adoc[`WeakenPtr`] 
| Create a weak pointer from a shared pointer&period;
| xref:absl/WebSafeBase64Escape-0c.adoc[`WebSafeBase64Escape`] 
| `WebSafeBase64Escape` overloads
| xref:absl/WebSafeBase64Unescape.adoc[`WebSafeBase64Unescape`] 
| Converts a `src` string encoded in &quot;web safe&quot; Base64 (RFC 4648 section 5) to its binary equivalent, writing it to a `dest` buffer, returning `true` on success&period; If `src` contains invalid characters, `dest` is cleared and returns `false`&period; If padding is included (note that `WebSafeBase64Escape()` does not produce it), it must be correct&period; In the padding, &apos;&equals;&apos; and &apos;&period;&apos; are treated identically&period;
| xref:absl/WrapUnique.adoc[`WrapUnique`] 
| Adopt ownership of a raw pointer into a `std&colon;&colon;unique&lowbar;ptr`&period;
| xref:absl/ZeroDuration.adoc[`ZeroDuration`] 
| Returns a zero&hyphen;length duration&period; This function behaves just like the default constructor, but the name helps make the semantics clear at call sites&period;
| xref:absl/Zipf.adoc[`Zipf`] 
| Produces a random integral value from a Zipf distribution&period;
| xref:absl/any_cast.adoc[`any&lowbar;cast`]  [.small]#[deprecated]#
| Casts the value stored in an `any` object to type `T` (deprecated)&period;
| xref:absl/apply.adoc[`apply`]  [.small]#[deprecated]#
| Invoke a callable with the elements of a tuple as arguments&period;
| xref:absl/ascii_isalnum.adoc[`ascii&lowbar;isalnum`] 
| Determines whether the given character is an alphanumeric character&period;
| xref:absl/ascii_isalpha.adoc[`ascii&lowbar;isalpha`] 
| Determines whether the given character is an alphabetic character&period;
| xref:absl/ascii_isascii.adoc[`ascii&lowbar;isascii`] 
| Determines whether the given character is ASCII&period;
| xref:absl/ascii_isblank.adoc[`ascii&lowbar;isblank`] 
| Determines whether the given character is a blank character (tab or space)&period;
| xref:absl/ascii_iscntrl.adoc[`ascii&lowbar;iscntrl`] 
| Determines whether the given character is a control character&period;
| xref:absl/ascii_isdigit.adoc[`ascii&lowbar;isdigit`] 
| Determines whether the given character can be represented as a decimal digit character (i&period;e&period; &lcub;0&hyphen;9&rcub;)&period;
| xref:absl/ascii_isgraph.adoc[`ascii&lowbar;isgraph`] 
| Determines whether the given character has a graphical representation&period;
| xref:absl/ascii_islower.adoc[`ascii&lowbar;islower`] 
| Determines whether the given character is lowercase&period;
| xref:absl/ascii_isprint.adoc[`ascii&lowbar;isprint`] 
| Determines whether the given character is printable, including spaces&period;
| xref:absl/ascii_ispunct.adoc[`ascii&lowbar;ispunct`] 
| Determines whether the given character is a punctuation character&period;
| xref:absl/ascii_isspace.adoc[`ascii&lowbar;isspace`] 
| Determines whether the given character is a whitespace character (space, tab, vertical tab, formfeed, linefeed, or carriage return)&period;
| xref:absl/ascii_isupper.adoc[`ascii&lowbar;isupper`] 
| Determines whether the given character is uppercase&period;
| xref:absl/ascii_isxdigit.adoc[`ascii&lowbar;isxdigit`] 
| Determines whether the given character can be represented as a hexadecimal digit character (i&period;e&period; &lcub;0&hyphen;9&rcub; or &lcub;A&hyphen;F&rcub; or &lcub;a&hyphen;f&rcub;)&period;
| xref:absl/ascii_tolower.adoc[`ascii&lowbar;tolower`] 
| Returns an ASCII character, converting to lowercase if uppercase is passed&period; Note that character values &gt; 127 are simply returned&period;
| xref:absl/ascii_toupper.adoc[`ascii&lowbar;toupper`] 
| Returns the ASCII character, converting to upper&hyphen;case if lower&hyphen;case is passed&period; Note that characters values &gt; 127 are simply returned&period;
| xref:absl/c_accumulate-01.adoc[`c&lowbar;accumulate`] 
| `c&lowbar;accumulate` overloads
| xref:absl/c_adjacent_difference-0b.adoc[`c&lowbar;adjacent&lowbar;difference`] 
| `c&lowbar;adjacent&lowbar;difference` overloads
| xref:absl/c_adjacent_find-01.adoc[`c&lowbar;adjacent&lowbar;find`] 
| `c&lowbar;adjacent&lowbar;find` overloads
| xref:absl/c_all_of.adoc[`c&lowbar;all&lowbar;of`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;all&lowbar;of()` function to test if all elements within a container satisfy a condition&period;
| xref:absl/c_any_of.adoc[`c&lowbar;any&lowbar;of`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;any&lowbar;of()` function to test if any element in a container fulfills a condition&period;
| xref:absl/c_binary_search-0e.adoc[`c&lowbar;binary&lowbar;search`] 
| `c&lowbar;binary&lowbar;search` overloads
| xref:absl/c_contains.adoc[`c&lowbar;contains`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;ranges&colon;&colon;contains()` C&plus;&plus;23 function to search a container for a value&period;
| xref:absl/c_contains_subrange-07.adoc[`c&lowbar;contains&lowbar;subrange`] 
| `c&lowbar;contains&lowbar;subrange` overloads
| xref:absl/c_copy-07.adoc[`c&lowbar;copy`] 
| `c&lowbar;copy` overloads
| xref:absl/c_copy_backward.adoc[`c&lowbar;copy&lowbar;backward`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;copy&lowbar;backward()` function to copy a container&apos;s elements in reverse order into an iterator&period;
| xref:absl/c_copy_if.adoc[`c&lowbar;copy&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;copy&lowbar;if()` function to copy a container&apos;s elements satisfying some condition into an iterator&period;
| xref:absl/c_copy_n-03.adoc[`c&lowbar;copy&lowbar;n`] 
| `c&lowbar;copy&lowbar;n` overloads
| xref:absl/c_count.adoc[`c&lowbar;count`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;count()` function to count values that match within a container&period;
| xref:absl/c_count_if.adoc[`c&lowbar;count&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;count&lowbar;if()` function to count values matching a condition within a container&period;
| xref:absl/c_distance.adoc[`c&lowbar;distance`] 
| Container&hyphen;based version of the &lt;iterator&gt; `std&colon;&colon;distance()` function to return the number of elements within a container&period;
| xref:absl/c_equal-09.adoc[`c&lowbar;equal`] 
| `c&lowbar;equal` overloads
| xref:absl/c_equal_range-0d.adoc[`c&lowbar;equal&lowbar;range`] 
| `c&lowbar;equal&lowbar;range` overloads
| xref:absl/c_fill.adoc[`c&lowbar;fill`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;fill()` function to fill a container with some value&period;
| xref:absl/c_fill_n.adoc[`c&lowbar;fill&lowbar;n`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;fill&lowbar;n()` function to fill the first N elements in a container with some value&period;
| xref:absl/c_find.adoc[`c&lowbar;find`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;find()` function to find the first element containing the passed value within a container value&period;
| xref:absl/c_find_end-07.adoc[`c&lowbar;find&lowbar;end`] 
| `c&lowbar;find&lowbar;end` overloads
| xref:absl/c_find_first_of-027.adoc[`c&lowbar;find&lowbar;first&lowbar;of`] 
| `c&lowbar;find&lowbar;first&lowbar;of` overloads
| xref:absl/c_find_if.adoc[`c&lowbar;find&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;find&lowbar;if()` function to find the first element in a container matching the given condition&period;
| xref:absl/c_find_if_not.adoc[`c&lowbar;find&lowbar;if&lowbar;not`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;find&lowbar;if&lowbar;not()` function to find the first element in a container not matching the given condition&period;
| xref:absl/c_for_each.adoc[`c&lowbar;for&lowbar;each`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;for&lowbar;each()` function to apply a function to a container&apos;s elements&period;
| xref:absl/c_generate.adoc[`c&lowbar;generate`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;generate()` function to assign a container&apos;s elements to the values provided by the given generator&period;
| xref:absl/c_generate_n.adoc[`c&lowbar;generate&lowbar;n`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;generate&lowbar;n()` function to assign a container&apos;s first N elements to the values provided by the given generator&period;
| xref:absl/c_includes-07.adoc[`c&lowbar;includes`] 
| `c&lowbar;includes` overloads
| xref:absl/c_inner_product-09.adoc[`c&lowbar;inner&lowbar;product`] 
| `c&lowbar;inner&lowbar;product` overloads
| xref:absl/c_inplace_merge-0f.adoc[`c&lowbar;inplace&lowbar;merge`] 
| `c&lowbar;inplace&lowbar;merge` overloads
| xref:absl/c_iota.adoc[`c&lowbar;iota`] 
| Container&hyphen;based version of the &lt;numeric&gt; `std&colon;&colon;iota()` function to compute successive values of `value`, as if incremented with `&plus;&plus;value` after each element is written, and write them to the container&period;
| xref:absl/c_is_heap-02.adoc[`c&lowbar;is&lowbar;heap`] 
| `c&lowbar;is&lowbar;heap` overloads
| xref:absl/c_is_heap_until-04b.adoc[`c&lowbar;is&lowbar;heap&lowbar;until`] 
| `c&lowbar;is&lowbar;heap&lowbar;until` overloads
| xref:absl/c_is_partitioned.adoc[`c&lowbar;is&lowbar;partitioned`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;is&lowbar;partitioned()` function to test whether all elements in the container for which `pred` returns `true` precede those for which `pred` is `false`&period;
| xref:absl/c_is_permutation-06.adoc[`c&lowbar;is&lowbar;permutation`] 
| `c&lowbar;is&lowbar;permutation` overloads
| xref:absl/c_is_sorted-0b.adoc[`c&lowbar;is&lowbar;sorted`] 
| `c&lowbar;is&lowbar;sorted` overloads
| xref:absl/c_is_sorted_until-04.adoc[`c&lowbar;is&lowbar;sorted&lowbar;until`] 
| `c&lowbar;is&lowbar;sorted&lowbar;until` overloads
| xref:absl/c_lexicographical_compare-08.adoc[`c&lowbar;lexicographical&lowbar;compare`] 
| `c&lowbar;lexicographical&lowbar;compare` overloads
| xref:absl/c_linear_search.adoc[`c&lowbar;linear&lowbar;search`] 
| Container&hyphen;based version of `absl&colon;&colon;linear&lowbar;search()` for performing a linear search within a container&period;
| xref:absl/c_lower_bound-03.adoc[`c&lowbar;lower&lowbar;bound`] 
| `c&lowbar;lower&lowbar;bound` overloads
| xref:absl/c_make_heap-06.adoc[`c&lowbar;make&lowbar;heap`] 
| `c&lowbar;make&lowbar;heap` overloads
| xref:absl/c_max_element-0c.adoc[`c&lowbar;max&lowbar;element`] 
| `c&lowbar;max&lowbar;element` overloads
| xref:absl/c_merge-0e.adoc[`c&lowbar;merge`] 
| `c&lowbar;merge` overloads
| xref:absl/c_min_element-0b.adoc[`c&lowbar;min&lowbar;element`] 
| `c&lowbar;min&lowbar;element` overloads
| xref:absl/c_minmax_element-02.adoc[`c&lowbar;minmax&lowbar;element`] 
| `c&lowbar;minmax&lowbar;element` overloads
| xref:absl/c_mismatch-0f.adoc[`c&lowbar;mismatch`] 
| `c&lowbar;mismatch` overloads
| xref:absl/c_move-0c.adoc[`c&lowbar;move`] 
| `c&lowbar;move` overloads
| xref:absl/c_move_backward.adoc[`c&lowbar;move&lowbar;backward`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;move&lowbar;backward()` function to move a container&apos;s elements into an iterator in reverse order&period;
| xref:absl/c_next_permutation-03.adoc[`c&lowbar;next&lowbar;permutation`] 
| `c&lowbar;next&lowbar;permutation` overloads
| xref:absl/c_none_of.adoc[`c&lowbar;none&lowbar;of`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;none&lowbar;of()` function to test if no elements in a container fulfill a condition&period;
| xref:absl/c_nth_element-09.adoc[`c&lowbar;nth&lowbar;element`] 
| `c&lowbar;nth&lowbar;element` overloads
| xref:absl/c_partial_sort-0e.adoc[`c&lowbar;partial&lowbar;sort`] 
| `c&lowbar;partial&lowbar;sort` overloads
| xref:absl/c_partial_sort_copy-022.adoc[`c&lowbar;partial&lowbar;sort&lowbar;copy`] 
| `c&lowbar;partial&lowbar;sort&lowbar;copy` overloads
| xref:absl/c_partial_sum-0c0.adoc[`c&lowbar;partial&lowbar;sum`] 
| `c&lowbar;partial&lowbar;sum` overloads
| xref:absl/c_partition.adoc[`c&lowbar;partition`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;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&period;
| xref:absl/c_partition_copy.adoc[`c&lowbar;partition&lowbar;copy`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;partition&lowbar;copy()` function to partition a container&apos;s elements and return them into two iterators&colon; one for which `pred` returns `true`, and one for which `pred` returns `false&period;`
| xref:absl/c_partition_point.adoc[`c&lowbar;partition&lowbar;point`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;partition&lowbar;point()` function to return the first element of an already partitioned container for which the given `pred` is not `true`&period;
| xref:absl/c_pop_heap-08.adoc[`c&lowbar;pop&lowbar;heap`] 
| `c&lowbar;pop&lowbar;heap` overloads
| xref:absl/c_prev_permutation-08.adoc[`c&lowbar;prev&lowbar;permutation`] 
| `c&lowbar;prev&lowbar;permutation` overloads
| xref:absl/c_push_heap-0e.adoc[`c&lowbar;push&lowbar;heap`] 
| `c&lowbar;push&lowbar;heap` overloads
| xref:absl/c_remove_copy.adoc[`c&lowbar;remove&lowbar;copy`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;remove&lowbar;copy()` function to copy a container&apos;s elements while removing any elements matching the given `value`&period;
| xref:absl/c_remove_copy_if.adoc[`c&lowbar;remove&lowbar;copy&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;remove&lowbar;copy&lowbar;if()` function to copy a container&apos;s elements while removing any elements matching the given condition&period;
| xref:absl/c_replace.adoc[`c&lowbar;replace`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;replace()` function to replace a container&apos;s elements of some value with a new value&period; The container is modified in place&period;
| xref:absl/c_replace_copy.adoc[`c&lowbar;replace&lowbar;copy`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;replace&lowbar;copy()` function to replace a container&apos;s elements of some value with a new value and return the results within an iterator&period;
| xref:absl/c_replace_copy_if.adoc[`c&lowbar;replace&lowbar;copy&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;replace&lowbar;copy&lowbar;if()` function to replace a container&apos;s elements of some value with a new value based on some condition, and return the results within an iterator&period;
| xref:absl/c_replace_if.adoc[`c&lowbar;replace&lowbar;if`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;replace&lowbar;if()` function to replace a container&apos;s elements of some value with a new value based on some condition&period; The container is modified in place&period;
| xref:absl/c_reverse.adoc[`c&lowbar;reverse`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;reverse()` function to reverse a container&apos;s elements&period;
| xref:absl/c_reverse_copy.adoc[`c&lowbar;reverse&lowbar;copy`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;reverse()` function to reverse a container&apos;s elements and write them to an iterator range&period;
| xref:absl/c_rotate.adoc[`c&lowbar;rotate`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;rotate()` function to shift a container&apos;s elements leftward such that the `middle` element becomes the first element in the container&period;
| xref:absl/c_rotate_copy.adoc[`c&lowbar;rotate&lowbar;copy`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;rotate&lowbar;copy()` function to shift a container&apos;s elements leftward such that the `middle` element becomes the first element in a new iterator range&period;
| xref:absl/c_sample.adoc[`c&lowbar;sample`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;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&period;
| xref:absl/c_search-0d.adoc[`c&lowbar;search`] 
| `c&lowbar;search` overloads
| xref:absl/c_search_n-033.adoc[`c&lowbar;search&lowbar;n`] 
| `c&lowbar;search&lowbar;n` overloads
| xref:absl/c_set_difference-07.adoc[`c&lowbar;set&lowbar;difference`] 
| `c&lowbar;set&lowbar;difference` overloads
| xref:absl/c_set_intersection-0f.adoc[`c&lowbar;set&lowbar;intersection`] 
| `c&lowbar;set&lowbar;intersection` overloads
| xref:absl/c_set_symmetric_difference-09.adoc[`c&lowbar;set&lowbar;symmetric&lowbar;difference`] 
| `c&lowbar;set&lowbar;symmetric&lowbar;difference` overloads
| xref:absl/c_set_union-0c.adoc[`c&lowbar;set&lowbar;union`] 
| `c&lowbar;set&lowbar;union` overloads
| xref:absl/c_shuffle.adoc[`c&lowbar;shuffle`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;shuffle()` function to randomly shuffle elements within the container using a `gen()` uniform random number generator&period;
| xref:absl/c_sort-00.adoc[`c&lowbar;sort`] 
| `c&lowbar;sort` overloads
| xref:absl/c_sort_heap-09.adoc[`c&lowbar;sort&lowbar;heap`] 
| `c&lowbar;sort&lowbar;heap` overloads
| xref:absl/c_stable_partition.adoc[`c&lowbar;stable&lowbar;partition`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;stable&lowbar;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&period; The function returns an iterator to the first element of the second group&period;
| xref:absl/c_stable_sort-0b.adoc[`c&lowbar;stable&lowbar;sort`] 
| `c&lowbar;stable&lowbar;sort` overloads
| xref:absl/c_swap_ranges.adoc[`c&lowbar;swap&lowbar;ranges`] 
| Container&hyphen;based version of the &lt;algorithm&gt; `std&colon;&colon;swap&lowbar;ranges()` function to swap a container&apos;s elements with another container&apos;s elements&period; Swaps the first N elements of `c1` and `c2`, where N &equals; min(size(c1), size(c2))&period;
| xref:absl/c_transform-06.adoc[`c&lowbar;transform`] 
| `c&lowbar;transform` overloads
| xref:absl/c_unique_copy-0f.adoc[`c&lowbar;unique&lowbar;copy`] 
| `c&lowbar;unique&lowbar;copy` overloads
| xref:absl/c_upper_bound-02a.adoc[`c&lowbar;upper&lowbar;bound`] 
| `c&lowbar;upper&lowbar;bound` overloads
| xref:absl/call_once.adoc[`call&lowbar;once`] 
| For all invocations using a given `once&lowbar;flag`, invokes a given `fn` exactly once across all threads&period; The first call to `call&lowbar;once()` with a particular `once&lowbar;flag` argument (that does not throw an exception) will run the specified function with the provided `args`&semi; other calls with the same `once&lowbar;flag` argument will not run the function, but will wait for the provided function to finish running (if it is still running)&period;
| xref:absl/down_cast-04a.adoc[`down&lowbar;cast`] 
| `down&lowbar;cast` overloads
| xref:absl/equal-0b.adoc[`equal`]  [.small]#[deprecated]#
| `equal` overloads
| xref:absl/erase_if-02.adoc[`erase&lowbar;if`] 
| `erase&lowbar;if` overloads
| xref:absl/exchange.adoc[`exchange`]  [.small]#[deprecated]#
| Replace the value of an object and return its old value&period;
| xref:absl/forward-07.adoc[`forward`]  [.small]#[deprecated]#
| `forward` overloads
| xref:absl/from_chars-06.adoc[`from&lowbar;chars`] 
| `from&lowbar;chars` overloads
| xref:absl/get-066.adoc[`get`]  [.small]#[deprecated]#
| `get` overloads
| xref:absl/get_if-07.adoc[`get&lowbar;if`]  [.small]#[deprecated]#
| `get&lowbar;if` overloads
| xref:absl/holds_alternative.adoc[`holds&lowbar;alternative`]  [.small]#[deprecated]#
| Tests whether a variant currently holds the alternative `T` (deprecated)&period;
| xref:absl/implicit_cast-00.adoc[`implicit&lowbar;cast`] 
| `implicit&lowbar;cast` overloads
| xref:absl/is_constant_evaluated.adoc[`is&lowbar;constant&lowbar;evaluated`] 
| Detects whether the function call occurs within a constant&hyphen;evaluated context&period; Returns true if the evaluation of the call occurs within the evaluation of an expression or conversion that is manifestly constant&hyphen;evaluated&semi; otherwise returns false&period;
| xref:absl/linear_search.adoc[`linear&lowbar;search`] 
| Performs a linear search for a value in a range&period;
| xref:absl/make_any-05.adoc[`make&lowbar;any`]  [.small]#[deprecated]#
| `make&lowbar;any` overloads
| xref:absl/make_from_tuple.adoc[`make&lowbar;from&lowbar;tuple`]  [.small]#[deprecated]#
| Construct an object of a type from the elements of a tuple&period;
| xref:absl/make_optional-0b.adoc[`make&lowbar;optional`] 
| `make&lowbar;optional` overloads
| xref:absl/move-07.adoc[`move`]  [.small]#[deprecated]#
| `move` overloads
| xref:absl/operator_mod-05.adoc[`operator%`] 
| Modulus operators
| xref:absl/operator_bitand-0d.adoc[`operator&amp;`] 
| Bitwise conjunction operators
| xref:absl/operator_and_eq-0d.adoc[`operator&amp;&equals;`] 
| Assigns to `lhs` the bitwise AND of `lhs` and `rhs`&period;
| xref:absl/operator_star-0b60.adoc[`operator&ast;`] 
| Multiplication operators
| xref:absl/operator_plus-0a.adoc[`operator&plus;`] 
| Unary plus operators
| xref:absl/operator_minus-01d.adoc[`operator&hyphen;`] 
| Unary minus operators
| xref:absl/operator_slash-04.adoc[`operator&sol;`] 
| Division operators
| xref:absl/operator_rshift-05.adoc[`operator&gt;&gt;`] 
| Right shift operators
| xref:absl/operator_xor-0a.adoc[`operator&circ;`] 
| Bitwise exclusive&hyphen;or operators
| xref:absl/operator_xor_eq-07.adoc[`operator&circ;&equals;`] 
| Assigns to `lhs` the bitwise XOR of `lhs` and `rhs`&period;
| xref:absl/operator_bitor-0c.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:absl/operator_or_eq-02.adoc[`operator&verbar;&equals;`] 
| Assigns to `lhs` the bitwise OR of `lhs` and `rhs`&period;
| xref:absl/operator_bitnot-01b.adoc[`operator&#126;`] 
| Bitwise negation operators
| xref:absl/rotate.adoc[`rotate`]  [.small]#[deprecated]#
| Rotates the elements in a range so that `n&lowbar;first` becomes the new first&period;
| xref:absl/swap-00e.adoc[`swap`] 
| `swap` overloads
| xref:absl/visit.adoc[`visit`]  [.small]#[deprecated]#
| Applies a visitor to the alternatives of one or more variants (deprecated)&period;
| xref:absl/operator_lshift-03b.adoc[`operator&lt;&lt;`] 
| Left shift operators
| xref:absl/operator_not.adoc[`operator!`] 
| Returns the logical negation of `val`&period;
| xref:absl/operator_eq-03e9.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:absl/operator_not_eq-0486.adoc[`operator!&equals;`] 
| Inequality operators
| xref:absl/operator_lt-02.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:absl/operator_le-06.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:absl/operator_gt-024.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:absl/operator_ge-0fb.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
| xref:absl/operator_3way-04.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:absl/IntervalClosed.adoc[`IntervalClosed`] 
| Tag selecting a closed interval &lsqb;lo, hi&rsqb;for `absl&colon;&colon;Uniform`&period;
| xref:absl/IntervalClosedClosed.adoc[`IntervalClosedClosed`] 
| Tag selecting a closed&hyphen;closed interval &lsqb;lo, hi&rsqb;for `absl&colon;&colon;Uniform`&period;
| xref:absl/IntervalClosedOpen.adoc[`IntervalClosedOpen`] 
| Tag selecting a closed&hyphen;open interval &lsqb;lo, hi) for `absl&colon;&colon;Uniform`&period;&rsqb;
| xref:absl/IntervalOpen.adoc[`IntervalOpen`] 
| Tag selecting an open interval (lo, hi) for `absl&colon;&colon;Uniform`&period;
| xref:absl/IntervalOpenClosed.adoc[`IntervalOpenClosed`] 
| Tag selecting an open&hyphen;closed interval (lo, hi&rsqb; for `absl&colon;&colon;Uniform`&period;
| xref:absl/IntervalOpenOpen.adoc[`IntervalOpenOpen`] 
| Tag selecting an open&hyphen;open interval (lo, hi) for `absl&colon;&colon;Uniform`&period;
| xref:absl/RFC1123_full.adoc[`RFC1123&lowbar;full`] 
| FormatTime()&sol;ParseTime() format specifier for RFC1123 date&sol;time strings&period;
| xref:absl/RFC1123_no_wday.adoc[`RFC1123&lowbar;no&lowbar;wday`] 
| FormatTime()&sol;ParseTime() format specifier for RFC1123 date&sol;time strings without the weekday name&period;
| xref:absl/RFC3339_full.adoc[`RFC3339&lowbar;full`] 
| FormatTime()&sol;ParseTime() format specifier for RFC3339 date&sol;time strings, with trailing zeros trimmed&period;
| xref:absl/RFC3339_sec.adoc[`RFC3339&lowbar;sec`] 
| FormatTime()&sol;ParseTime() format specifier for RFC3339 date&sol;time strings, with fractional seconds omitted altogether&period;
| xref:absl/in_place.adoc[`in&lowbar;place`]  [.small]#[deprecated]#
| Disambiguation tag for in&hyphen;place construction&period;
| xref:absl/in_place_index.adoc[`in&lowbar;place&lowbar;index`]  [.small]#[deprecated]#
| Disambiguation tag for in&hyphen;place construction at a given index&period;
| xref:absl/in_place_type.adoc[`in&lowbar;place&lowbar;type`]  [.small]#[deprecated]#
| Disambiguation tag for in&hyphen;place construction of a given type&period;
| xref:absl/nontype.adoc[`nontype`] 
| Disambiguation tag value of type `nontype&lowbar;t`&period;
| xref:absl/variant_npos.adoc[`variant&lowbar;npos`] 
| Alias for `std&colon;&colon;variant&lowbar;npos`, the index of a valueless variant&period;
| xref:absl/variant_size_v.adoc[`variant&lowbar;size&lowbar;v`] 
| Alias for `std&colon;&colon;variant&lowbar;size&lowbar;v`, the number of alternatives&period;
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:absl/bind_back.adoc[`bind&lowbar;back`] 
| Binds the last N arguments of an invocable object and stores them by value&period;
| xref:absl/bind_front.adoc[`bind&lowbar;front`] 
| Binds the first N arguments of an invocable object and stores them by value&period;
| xref:absl/bit_cast.adoc[`bit&lowbar;cast`] 
| Alias for `std&colon;&colon;bit&lowbar;cast`, used when the standard library provides it&period;
| xref:absl/bit_ceil.adoc[`bit&lowbar;ceil`] 
| Returns the smallest power of two not less than `x`&period;
| xref:absl/bit_floor.adoc[`bit&lowbar;floor`] 
| Returns the largest power of two not greater than `x`&period;
| xref:absl/bit_width.adoc[`bit&lowbar;width`] 
| Returns the number of bits needed to represent the value of `x`&period;
| xref:absl/byteswap.adoc[`byteswap`] 
| Reverses the bytes in the given integer value `x`&period;
| xref:absl/countl_one.adoc[`countl&lowbar;one`] 
| Counts the number of consecutive one bits starting from the most significant bit of `x`&period;
| xref:absl/countl_zero.adoc[`countl&lowbar;zero`] 
| Counts the number of consecutive zero bits starting from the most significant bit of `x`&period;
| xref:absl/countr_one.adoc[`countr&lowbar;one`] 
| Counts the number of consecutive one bits starting from the least significant bit of `x`&period;
| xref:absl/countr_zero.adoc[`countr&lowbar;zero`] 
| Counts the number of consecutive zero bits starting from the least significant bit of `x`&period;
| xref:absl/endian.adoc[`endian`] 
| Indicates the endianness of all scalar types&period;
| xref:absl/has_single_bit.adoc[`has&lowbar;single&lowbar;bit`] 
| Determines whether `x` is an integral power of two&period;
| xref:absl/make_unique.adoc[`make&lowbar;unique`] 
| Create a `std&colon;&colon;unique&lowbar;ptr` owning a newly constructed object&period;
| xref:absl/make_unique_for_overwrite.adoc[`make&lowbar;unique&lowbar;for&lowbar;overwrite`] 
| Create a `std&colon;&colon;unique&lowbar;ptr` whose object is default&hyphen;initialized&period;
| xref:absl/nullopt.adoc[`nullopt`] 
| Alias for `std&colon;&colon;nullopt`, the disengaged&hyphen;optional constant&period;
| xref:absl/optional.adoc[`optional`] 
| Alias for `std&colon;&colon;optional`&period;
| xref:absl/partial_ordering.adoc[`partial&lowbar;ordering`] 
| Result of a three&hyphen;way comparison that may be unordered&period;
| xref:absl/popcount.adoc[`popcount`] 
| Counts the number of one bits in the value of `x`&period;
| xref:absl/rotl.adoc[`rotl`] 
| Rotates the bits of `x` to the left by `s` positions&period;
| xref:absl/rotr.adoc[`rotr`] 
| Rotates the bits of `x` to the right by `s` positions&period;
| xref:absl/string_view.adoc[`string&lowbar;view`] 
| An alias for `std&colon;&colon;string&lowbar;view`&period;
| xref:absl/strong_ordering.adoc[`strong&lowbar;ordering`] 
| Result of a three&hyphen;way comparison that is strongly ordered&period;
| xref:absl/weak_ordering.adoc[`weak&lowbar;ordering`] 
| Result of a three&hyphen;way comparison that is weakly ordered&period;
|===



[.small]#Created with https://www.mrdocs.com[MrDocs]#
