[#folly]
= folly
:mrdocs:

include or backport&colon; &ast; std&colon;&colon;invoke &ast; std&colon;&colon;invoke&lowbar;result &ast; std&colon;&colon;invoke&lowbar;result&lowbar;t &ast; std&colon;&colon;is&lowbar;invocable &ast; std&colon;&colon;is&lowbar;invocable&lowbar;v &ast; std&colon;&colon;is&lowbar;invocable&lowbar;r &ast; std&colon;&colon;is&lowbar;invocable&lowbar;r&lowbar;v &ast; std&colon;&colon;is&lowbar;nothrow&lowbar;invocable &ast; std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;v &ast; std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r &ast; std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/array_detail.adoc[`array&lowbar;detail`] 
| Implementation helpers for make&lowbar;array and make&lowbar;array&lowbar;with&period;
| xref:folly/async_tracing.adoc[`async&lowbar;tracing`] 
| Implementation details&period;
| xref:folly/bind.adoc[`bind`] 
| READ ME&colon; The docs for this library are in `Bind&period;md`&period;
| xref:folly/bititerator_detail.adoc[`bititerator&lowbar;detail`] 
| Implementation details for BitIterator&period;
| xref:folly/bser.adoc[`bser`] 
| BSER binary serialization for dynamic values&period;
| xref:folly/bskip_detail.adoc[`bskip&lowbar;detail`] 
| Internal implementation details for ConcurrentBSkipList&period;
| xref:folly/channels.adoc[`channels`] 
| Sender&sol;receiver channel primitives for asynchronous value streams&period;
| xref:folly/chrono.adoc[`chrono`] 
| Time&hyphen;related wrappers and clock utilities&period;
| xref:folly/compression.adoc[`compression`] 
| Compression and decompression codecs over IOBufs&period;
| xref:folly/coro.adoc[`coro`] 
| Coroutine primitives and combinators&period;
| xref:folly/crypto.adoc[`crypto`] 
| Cryptographic hashing primitives&period;
| xref:folly/detail_tag_invoke_fn.adoc[`detail&lowbar;tag&lowbar;invoke&lowbar;fn`] 
| Implementation details of the `tag&lowbar;invoke` customization&hyphen;point machinery&period;
| xref:folly/dptr_detail.adoc[`dptr&lowbar;detail`] 
| Implementation details&period;
| xref:folly/dynamic_detail.adoc[`dynamic&lowbar;detail`] 
| Implementation details for dynamic&period;
| xref:folly/dynamicconverter_detail.adoc[`dynamicconverter&lowbar;detail`] 
| Implementation details for DynamicConverter and DynamicConstructor&period;
| xref:folly/exception_tracer.adoc[`exception&lowbar;tracer`] 
| Facilities for capturing and stacking exception stack traces&period;
| xref:folly/expected_detail.adoc[`expected&lowbar;detail`] 
| Implementation details for folly&colon;&colon;Expected&period;
| xref:folly/experimental.adoc[`experimental`] 
| Namespace for experimental Folly components&period;
| xref:folly/ext.adoc[`ext`] 
| Extension namespace for library authors, a public analog of `folly&colon;&colon;detail`&period;
| xref:folly/external.adoc[`external`] 
| Vendored third&hyphen;party code adapted for use in Folly&period;
| xref:folly/f14.adoc[`f14`] 
| Implementation details for the F14 hash table family&period;
| xref:folly/fallback.adoc[`fallback`] 
| A fallback implementation used when the standard trait is unavailable&period;
| xref:folly/fbstring_detail.adoc[`fbstring&lowbar;detail`] 
| Implementation details for fbstring&period;
| xref:folly/fibers.adoc[`fibers`] 
| Lightweight cooperative userspace threads (fibers) and related primitives&period;
| xref:folly/fileops.adoc[`fileops`] 
| Portable wrappers and imports for file&hyphen;descriptor operations&period;
| xref:folly/fileutil_detail.adoc[`fileutil&lowbar;detail`] 
| Implementation details&period;
| xref:folly/find_fixed_detail.adoc[`find&lowbar;fixed&lowbar;detail`] 
| Implementation details for folly&colon;&colon;findFixed&period;
| xref:folly/for_each_detail.adoc[`for&lowbar;each&lowbar;detail`] 
| The user should return loop&lowbar;break and loop&lowbar;continue if they want to iterate in such a way that they can preemptively stop the loop and break out when certain conditions are met&period;
| xref:folly/format_value.adoc[`format&lowbar;value`] 
| Utilities for all format value specializations&period;
| xref:folly/fs.adoc[`fs`] 
| Portable filesystem imports selecting the available `&lt;filesystem&gt;` backend&period;
| xref:folly/futures.adoc[`futures`] 
| Futures&hyphen;based asynchronous programming primitives&period;
| xref:folly/gen.adoc[`gen`] 
| Lazy sequence generators and pipeline operators&period;
| xref:folly/gflags.adoc[`gflags`] 
| Minimal stand&hyphen;in for the gflags namespace when gflags is unavailable&period;
| xref:folly/hash-04.adoc[`hash`] 
| Hashing algorithms and helpers&period;
| xref:folly/invoke_detail.adoc[`invoke&lowbar;detail`] 
| Implementation details of the folly invocation traits&period;
| xref:folly/io.adoc[`io`] 
| Cursor and queue utilities for reading and writing IOBuf chains&period;
| xref:folly/json.adoc[`json`] 
| JSON parsing and serialization utilities&period;
| xref:folly/jsonschema.adoc[`jsonschema`] 
| JSON Schema (draft v4) validation utilities&period;
| xref:folly/libcpp_detail.adoc[`libcpp&lowbar;detail`] 
| Implementation details for libc&plus;&plus; bitset support&period;
| xref:folly/logging.adoc[`logging`] 
| Folly&apos;s logging library&period;
| xref:folly/memory.adoc[`memory`] 
| Memory management utilities&period;
| xref:folly/moveonly_.adoc[`moveonly&lowbar;`] 
| Internal namespace hosting the copy&sol;move control base types&period;
| xref:folly/netops.adoc[`netops`] 
| Cross&hyphen;platform socket operation wrappers&period;
| xref:folly/numbers.adoc[`numbers`] 
| numbers
| xref:folly/observer.adoc[`observer`] 
| Folly&apos;s observer library&period;
| xref:folly/observer_detail.adoc[`observer&lowbar;detail`] 
| Implementation details&period;
| xref:folly/padded.adoc[`padded`] 
| Utilities for storing data aligned on block (possibly cache&hyphen;line) boundaries, with optional padding&period;
| xref:folly/pmr.adoc[`pmr`] 
| Aliases that use a polymorphic allocator&period;
| xref:folly/poly-07.adoc[`poly`] 
| Interfaces and helpers for the `Poly` type&hyphen;erasure utility&period;
| xref:folly/portability.adoc[`portability`] 
| Portability shims for platform&hyphen;specific system interfaces&period;
| xref:folly/recordio_helpers.adoc[`recordio&lowbar;helpers`] 
| Low&hyphen;level helpers exposing the RecordIO record format&period;
| xref:folly/replaceable_detail.adoc[`replaceable&lowbar;detail`] 
| Implementation details for `Replaceable`&semi; not part of the public API&period;
| xref:folly/settings.adoc[`settings`] 
| Runtime configuration settings framework&period;
| xref:folly/shared_mutex_detail.adoc[`shared&lowbar;mutex&lowbar;detail`] 
| Implementation details for SharedMutex&semi; not part of the public API&period;
| xref:folly/simd.adoc[`simd`] 
| SIMD algorithms and utilities&period;
| xref:folly/small_vector_policy.adoc[`small&lowbar;vector&lowbar;policy`] 
| Policies that customize the behavior of folly&colon;&colon;small&lowbar;vector&period;
| xref:folly/ssl.adoc[`ssl`] 
| SSL and TLS helpers built on OpenSSL&period;
| xref:folly/stable_radix_sort_detail.adoc[`stable&lowbar;radix&lowbar;sort&lowbar;detail`] 
| Implementation details for the stable radix sort&period;
| xref:folly/stable_radix_sort_keys.adoc[`stable&lowbar;radix&lowbar;sort&lowbar;keys`] 
| Stable LSD (Least Significant Digit) Radix Sort
| xref:folly/symbolizer.adoc[`symbolizer`] 
| Stack trace capture and symbolization utilities&period;
| xref:folly/test.adoc[`test`] 
| Testing utilities&period;
| xref:folly/threadlocal_detail.adoc[`threadlocal&lowbar;detail`] 
| Implementation details&period;
| xref:folly/traits_detail.adoc[`traits&lowbar;detail`] 
| There is a bug in libstdc&plus;&plus;, libc&plus;&plus;, and MSVC&apos;s STL that causes it to ignore unused template parameter arguments in template aliases and does not cause substitution failures&period; This defect has been recorded here&colon; http&colon;&sol;&sol;open&hyphen;std&period;org&sol;JTC1&sol;SC22&sol;WG21&sol;docs&sol;cwg&lowbar;defects&period;html&num;1558&period;
| xref:folly/traits_detail_IsEqualityComparable.adoc[`traits&lowbar;detail&lowbar;IsEqualityComparable`] 
| Implementation namespace for the IsEqualityComparable trait&period;
| xref:folly/traits_detail_IsLessThanComparable.adoc[`traits&lowbar;detail&lowbar;IsLessThanComparable`] 
| Implementation namespace for the IsLessThanComparable trait&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/AccessModeStrict.adoc[`AccessModeStrict`] 
| Tag selecting strict access mode for thread&hyphen;local storage&period;
| xref:folly/AccessSpreader.adoc[`AccessSpreader`] 
| AccessSpreader arranges access to a striped data structure in such a way that concurrently executing threads are likely to be accessing different stripes&period; It does NOT guarantee uncontended access&period; Your underlying algorithm must be thread&hyphen;safe without spreading, this is merely an optimization&period; AccessSpreader&colon;&colon;current(n) is typically much faster than a cache miss (12 nanos on my dev box, tested fast in both 2&period;6 and 3&period;2 kernels)&period;
| xref:folly/AlignedSysAllocator.adoc[`AlignedSysAllocator`] 
| AlignedSysAllocator
| xref:folly/AllocatorHasDefaultObjectConstruct-0f.adoc[`AllocatorHasDefaultObjectConstruct`] 
| AllocatorHasDefaultObjectConstruct
| xref:folly/AllocatorHasDefaultObjectDestroy-0f.adoc[`AllocatorHasDefaultObjectDestroy`] 
| AllocatorHasDefaultObjectDestroy
| xref:folly/AllocatorHasTrivialDeallocate-01e.adoc[`AllocatorHasTrivialDeallocate`] 
| AllocatorHasTrivialDeallocate
| xref:folly/AnnotatedLockGuard.adoc[`AnnotatedLockGuard`] 
| A scoped lock for any capability&hyphen;annotated mutex&period;
| xref:folly/AnnotatedMutex.adoc[`AnnotatedMutex`] 
| A `std&colon;&colon;mutex` wrapper carrying the `capability(&quot;mutex&quot;)` attribute&period;
| xref:folly/ApplyInvoke.adoc[`ApplyInvoke`] 
| Callable that invokes a function with the elements of a tuple as arguments&period;
| xref:folly/Arena-03.adoc[`Arena`] 
| Arena that allocates memory in blocks and frees it all at destruction&period;
| xref:folly/ArenaAllocatorTraits-03.adoc[`ArenaAllocatorTraits`] 
| Simple arena&colon; allocate memory which gets freed when the arena gets destroyed&period;
| xref:folly/AsciiCaseInsensitive.adoc[`AsciiCaseInsensitive`] 
| Check if two ascii characters are case insensitive equal&period; The difference between the lower&sol;upper case characters are the 6&hyphen;th bit&period; We also check they are alpha chars, in case of xor &equals; 32&period;
| xref:folly/AsciiCaseSensitive.adoc[`AsciiCaseSensitive`] 
| Case&hyphen;sensitive equality comparator for ASCII characters&period;
| xref:folly/AsyncBase.adoc[`AsyncBase`] 
| Generic C&plus;&plus; interface around Linux IO(io&lowbar;submit, io&lowbar;uring)
| xref:folly/AsyncBaseOp.adoc[`AsyncBaseOp`] 
| An AsyncBaseOp represents a pending operation&period; You may set a notification callback or you may use this class&apos;s methods directly&period;
| xref:folly/AsyncBaseQueue.adoc[`AsyncBaseQueue`] 
| Wrapper around AsyncBase that allows you to schedule more requests than the AsyncBase&apos;s object capacity&period; Other requests are queued and processed in a FIFO order&period;
| xref:folly/AsyncDetachFdCallback.adoc[`AsyncDetachFdCallback`] 
| Receives the result of detaching a file descriptor from a socket&period;
| xref:folly/AsyncFdSocket.adoc[`AsyncFdSocket`] 
| Intended for use with Unix sockets&period; Unlike regular `AsyncSocket`&colon; &hyphen; Can send FDs via `writeChainWithFds` using socket ancillary data (see `man cmsg`)&period; &hyphen; Whenever handling regular reads, concurrently attempts to receive FDs included in incoming ancillary data&period; Groups of received FDs are enqueued to be retrieved via `popNextReceivedFds`&period; &hyphen; The &quot;read ancillary data&quot; and &quot;sendmsg params&quot; callbacks are built&hyphen;in are NOT customizable&period;
| xref:folly/AsyncFdSocketSequenceRoundtripTest_WithDataSize_Test.adoc[`AsyncFdSocketSequenceRoundtripTest&lowbar;WithDataSize&lowbar;Test`] 
| Test fixture friendship declaration generated by the GTest macro&period;
| xref:folly/AsyncFileWriter.adoc[`AsyncFileWriter`] 
| An implementation of `folly&colon;&colon;AsyncLogWriter` that writes log messages into a file&period;
| xref:folly/AsyncIO.adoc[`AsyncIO`] 
| C&plus;&plus; interface around Linux Async IO&period;
| xref:folly/AsyncIOOp.adoc[`AsyncIOOp`] 
| A pending operation backed by the Linux io&lowbar;submit interface&period;
| xref:folly/AsyncIoUringSocket.adoc[`AsyncIoUringSocket`] 
| 
| xref:folly/AsyncIoUringSocketFactory.adoc[`AsyncIoUringSocketFactory`] 
| Creates AsyncIoUringSocket instances and reports io&lowbar;uring support&period;
| xref:folly/AsyncLogWriter.adoc[`AsyncLogWriter`] 
| An abstract LogWriter implementation that provides functionality for asynchronous IO operations&period; Users can subclass this class and provide their own IO operation implementation by overriding `performIO` method&period; This class will automatically manage incoming log messages and call the method in appropriate time&period;
| xref:folly/AsyncPipeReader.adoc[`AsyncPipeReader`] 
| Read from a pipe in an async manner&period;
| xref:folly/AsyncPipeWriter.adoc[`AsyncPipeWriter`] 
| Write to a pipe in an async manner&period;
| xref:folly/AsyncReader.adoc[`AsyncReader`] 
| Interface for the read side of an asynchronous transport&period;
| xref:folly/AsyncSSLSocket.adoc[`AsyncSSLSocket`] 
| A class for performing asynchronous I&sol;O on an SSL connection&period;
| xref:folly/AsyncSSLSocketConnector.adoc[`AsyncSSLSocketConnector`] 
| Connector that drives the SSL handshake for an AsyncSSLSocket&period;
| xref:folly/AsyncServerSocket.adoc[`AsyncServerSocket`] 
| AsyncServerSocket is a listening socket that asynchronously informs a callback whenever a new connection has been accepted&period;
| xref:folly/AsyncSignalHandler.adoc[`AsyncSignalHandler`] 
| A handler to receive notification about POSIX signals&period;
| xref:folly/AsyncSocket.adoc[`AsyncSocket`] 
| An asynchronous socket&period;
| xref:folly/AsyncSocketBase.adoc[`AsyncSocketBase`] 
| Base interface for asynchronous sockets bound to an event base&period;
| xref:folly/AsyncSocketException.adoc[`AsyncSocketException`] 
| Exception thrown by folly asynchronous socket operations&period;
| xref:folly/AsyncSocketObserverContainer.adoc[`AsyncSocketObserverContainer`] 
| Container of observers attached to an AsyncSocket&period;
| xref:folly/AsyncSocketObserverInterface.adoc[`AsyncSocketObserverInterface`] 
| Observer of socket events&period;
| xref:folly/AsyncSocketTransport.adoc[`AsyncSocketTransport`] 
| Abstract asynchronous transport backed by a socket&period;
| xref:folly/AsyncStackFrame.adoc[`AsyncStackFrame`] 
| Represents a frame in an async stack trace&period;
| xref:folly/AsyncStackRoot.adoc[`AsyncStackRoot`] 
| A stack&hyphen;root represents the context of an event loop that is running some asynchronous work&period; The current async operation that is being executed by the event loop (if any) is pointed to by the &apos;topFrame&apos;&period;
| xref:folly/AsyncTimeout.adoc[`AsyncTimeout`] 
| AsyncTimeout is used to asynchronously wait for a timeout to occur&period;
| xref:folly/AsyncTransport.adoc[`AsyncTransport`] 
| AsyncTransport defines an asynchronous API for bidirectional streaming I&sol;O&period;
| xref:folly/AsyncTransportCertificate.adoc[`AsyncTransportCertificate`] 
| Generic interface applications may implement to convey self or peer certificate related information&period;
| xref:folly/AsyncUDPServerSocket.adoc[`AsyncUDPServerSocket`] 
| UDP server socket
| xref:folly/AsyncUDPSocket.adoc[`AsyncUDPSocket`] 
| UDP socket
| xref:folly/AsyncWriter.adoc[`AsyncWriter`] 
| Interface for the write side of an asynchronous transport&period;
| xref:folly/AtFork.adoc[`AtFork`] 
| AtFork
| xref:folly/AtForkList.adoc[`AtForkList`] 
| AtForkList
| xref:folly/AtomicCoreCachedSharedPtr.adoc[`AtomicCoreCachedSharedPtr`] 
| This class creates core&hyphen;local caches for a given shared&lowbar;ptr, to mitigate contention when acquiring&sol;releasing it&period;
| xref:folly/AtomicHashArray.adoc[`AtomicHashArray`] 
| Fixed&hyphen;size, lock&hyphen;free hash array and building block for `AtomicHashMap`&period;
| xref:folly/AtomicHashArrayLinearProbeFcn.adoc[`AtomicHashArrayLinearProbeFcn`] 
| Linear probing strategy for `AtomicHashArray`&period;
| xref:folly/AtomicHashArrayQuadraticProbeFcn.adoc[`AtomicHashArrayQuadraticProbeFcn`] 
| Quadratic probing strategy for `AtomicHashArray`&period;
| xref:folly/AtomicHashMap.adoc[`AtomicHashMap`] 
| Lock&hyphen;free, growable hash map built on top of `AtomicHashArray`&period;
| xref:folly/AtomicHashMapFullError.adoc[`AtomicHashMapFullError`] 
| Thrown when insertion fails due to running out of space for submaps&period;
| xref:folly/AtomicIntrusiveLinkedList.adoc[`AtomicIntrusiveLinkedList`] 
| A lock&hyphen;free intrusive single&hyphen;linked list&period;
| xref:folly/AtomicIntrusiveLinkedListHook.adoc[`AtomicIntrusiveLinkedListHook`] 
| A very simple atomic single&hyphen;linked list primitive&period;
| xref:folly/AtomicLinkedList.adoc[`AtomicLinkedList`] 
| A very simple atomic single&hyphen;linked list primitive&period;
| xref:folly/AtomicNotificationQueue.adoc[`AtomicNotificationQueue`] 
| A producer&hyphen;consumer queue for passing tasks to consumer thread&period;
| xref:folly/AtomicReadMostlyMainPtr.adoc[`AtomicReadMostlyMainPtr`] 
| An atomically&hyphen;swappable owner of a `ReadMostlyMainPtr`&period;
| xref:folly/AtomicStruct.adoc[`AtomicStruct`] 
| AtomicStruct&lt;T&gt; work like C&plus;&plus; atomics, but can be used on any POD type &lt;&equals; 8 bytes&period;
| xref:folly/AtomicUnorderedInsertMap.adoc[`AtomicUnorderedInsertMap`] 
| You&apos;re probably reading this because you are looking for an AtomicUnorderedMap&lt;K,V&gt; that is fully general, highly concurrent (for reads, writes, and iteration), and makes no performance compromises&period; We haven&apos;t figured that one out yet&period; What you will find here is a hash table implementation that sacrifices generality so that it can give you all of the other things&period;
| xref:folly/AutoTimer.adoc[`AutoTimer`] 
| Automatically times a block of code, printing a specified log message on destruction or whenever the log() method is called&period; For example&colon;
| xref:folly/BadExpectedAccess-0c.adoc[`BadExpectedAccess`] 
| An exception type thrown by Expected on catastrophic logic errors, i&period;e&period;, when the caller tries to access the value within an Expected but when the Expected instead contains an error&period;
| xref:folly/BadFormatArg.adoc[`BadFormatArg`] 
| Exception thrown when a format argument string is invalid&period;
| xref:folly/BadPolyAccess.adoc[`BadPolyAccess`] 
| Exception type that is thrown on invalid access of an empty `Poly` object&period;
| xref:folly/BadPolyCast.adoc[`BadPolyCast`] 
| Exception type that is thrown when attempting to extract from a `Poly` a value of the wrong type&period;
| xref:folly/BaseFormatterImpl-064.adoc[`BaseFormatterImpl`] 
| Formatter class&period;
| xref:folly/BasicDynamicTokenBucket.adoc[`BasicDynamicTokenBucket`] 
| Thread&hyphen;safe (atomic) token bucket implementation&period;
| xref:folly/BasicFixedString.adoc[`BasicFixedString`] 
| A class for holding up to `N` characters of type `Char` that is amenable to `constexpr` string manipulation&period; It is guaranteed to not perform any dynamic allocation&period;
| xref:folly/BasicTokenBucket.adoc[`BasicTokenBucket`] 
| Specialization of BasicDynamicTokenBucket with a fixed token generation rate and a fixed maximum burst size&period;
| xref:folly/Baton.adoc[`Baton`] 
| A Baton allows a thread to block once and be awoken&period; Captures a single handoff, and during its lifecycle (from construction&sol;reset to destruction&sol;reset) a baton must either be post()ed and wait()ed exactly once each, or not at all&period;
| xref:folly/BenchmarkSuspender.adoc[`BenchmarkSuspender`] 
| Supporting type for BENCHMARK&lowbar;SUSPEND defined below&period;
| xref:folly/BitIterator.adoc[`BitIterator`] 
| Fast bit iteration facility&period;
| xref:folly/Bits.adoc[`Bits`] 
| Wrapper class with static methods for various bit&hyphen;level operations, treating an array of T as an array of bits (in little&hyphen;endian order)&period; (T is either an unsigned integral type or Unaligned&lt;X&gt;, where X is an unsigned integral type)
| xref:folly/BlockingQueue-0f8.adoc[`BlockingQueue`] 
| Abstract interface for a queue that can block callers until items are available&period;
| xref:folly/BlockingQueueAddResult.adoc[`BlockingQueueAddResult`] 
| Result of adding an item to a BlockingQueue&period;
| xref:folly/BucketedTimeSeries.adoc[`BucketedTimeSeries`] 
| This class represents a bucketed time series which keeps track of values added in the recent past, and merges these values together into a fixed number of buckets to keep a lid on memory use if the number of values added is very large&period;
| xref:folly/CPUThreadPoolExecutor.adoc[`CPUThreadPoolExecutor`] 
| A Thread pool for CPU bound tasks&period;
| xref:folly/CacheLocality.adoc[`CacheLocality`] 
| Holds cache sharing topology for the current system&period;
| xref:folly/CallbackAsyncSignalHandler.adoc[`CallbackAsyncSignalHandler`] 
| Derived template class that allows forwarding of a callback to be invoked in the overridden signalReceived()&period;
| xref:folly/CalledProcessError.adoc[`CalledProcessError`] 
| Exception thrown by &ast;Checked methods of Subprocess&period;
| xref:folly/CancellationCallback.adoc[`CancellationCallback`] 
| A CancellationCallback object registers the callback with the specified CancellationToken such that the callback will be executed if the corresponding CancellationSource object has the requestCancellation() method called on it&period;
| xref:folly/CancellationSource.adoc[`CancellationSource`] 
| A CancellationSource object provides the ability to request cancellation of operations that an associated CancellationToken was passed to&period;
| xref:folly/CancellationToken.adoc[`CancellationToken`] 
| A CancellationToken is an object that can be passed into an function or operation that allows the caller to later request that the operation be cancelled&period;
| xref:folly/CertificateIdentityVerifier.adoc[`CertificateIdentityVerifier`] 
| CertificateIdentityVerifier implementations are used during TLS handshakes to extract and verify end&hyphen;entity certificate identities&period;
| xref:folly/CertificateIdentityVerifierException.adoc[`CertificateIdentityVerifierException`] 
| Base of exception hierarchy for CertificateIdentityVerifier failure reasons&period;
| xref:folly/Cleanup.adoc[`Cleanup`] 
| Base class for structured async cleanup&period;
| xref:folly/Codel.adoc[`Codel`] 
| CoDel (controlled delay) is an active queue management algorithm from networking for battling bufferbloat&period;
| xref:folly/ConcurrentBSkipDefaultPolicy.adoc[`ConcurrentBSkipDefaultPolicy`] 
| The default configuration policy for ConcurrentBSkipList&period;
| xref:folly/ConcurrentBSkipList.adoc[`ConcurrentBSkipList`] 
| Concurrent B&hyphen;skip&hyphen;list container&semi; declared here for friend declarations&period;
| xref:folly/ConcurrentBitSet.adoc[`ConcurrentBitSet`] 
| An atomic bitset of fixed size (specified at compile time)&period;
| xref:folly/ConcurrentHashMap.adoc[`ConcurrentHashMap`] 
| Implementations of high&hyphen;performance Concurrent Hashmaps that support erase and update&period;
| xref:folly/ConcurrentLazy.adoc[`ConcurrentLazy`] 
| Thread&hyphen;safe, delayed initialization of a value computed once at first access&period;
| xref:folly/ConcurrentSkipList.adoc[`ConcurrentSkipList`] 
| A concurrent, sorted, unique&hyphen;key associative container&period;
| xref:folly/ConstructorCallbackList-0e.adoc[`ConstructorCallbackList`] 
| A mixin that fires registered callbacks each time a class constructor runs&period;
| xref:folly/ConversionError.adoc[`ConversionError`] 
| Exception thrown when a conversion fails, carrying a ConversionCode&period;
| xref:folly/ConversionErrorBase.adoc[`ConversionErrorBase`] 
| Base class for exceptions thrown by folly conversion routines&period;
| xref:folly/CoreAllocator.adoc[`CoreAllocator`] 
| An C&plus;&plus; allocator adapter for coreMalloc&sol;Free&period; The allocator is stateless, to avoid increasing the footprint of the container that uses it, so the stripe needs to be passed out of band&colon; allocate() can only be called while there is an active CoreAllocatorGuard&period; deallocate() can instead be called at any point&period;
| xref:folly/CoreAllocatorGuard.adoc[`CoreAllocatorGuard`] 
| Scope guard that binds CoreAllocator allocations to a stripe&period;
| xref:folly/CoreCachedSharedPtr.adoc[`CoreCachedSharedPtr`] 
| This class creates core&hyphen;local caches for a given shared&lowbar;ptr, to mitigate contention when acquiring&sol;releasing it&period;
| xref:folly/CoreCachedWeakPtr.adoc[`CoreCachedWeakPtr`] 
| Core&hyphen;local cache of weak pointers to a shared object&period;
| xref:folly/CpuId.adoc[`CpuId`] 
| Identification of an Intel CPU&period; Supports CPUID feature flags (EAX&equals;1) and extended features (EAX&equals;7, ECX&equals;0)&period; Values from http&colon;&sol;&sol;www&period;intel&period;com&sol;content&sol;www&sol;us&sol;en&sol;processors&sol;processor&hyphen;identification&hyphen;cpuid&hyphen;instruction&hyphen;note&period;html
| xref:folly/CustomLogFormatter.adoc[`CustomLogFormatter`] 
| A LogFormatter implementation that produces messages in a format specified using a config&period;
| xref:folly/CxxAllocatorAdaptor.adoc[`CxxAllocatorAdaptor`] 
| CxxAllocatorAdaptor
| xref:folly/CxxHugePageAllocator.adoc[`CxxHugePageAllocator`] 
| STL compatible huge page allocator, for use with STL&hyphen;style containers&period;
| xref:folly/CxxIoUringAllocator.adoc[`CxxIoUringAllocator`] 
| An STL&hyphen;compatible allocator backed by the io&lowbar;uring arena&period;
| xref:folly/DCheckRequestContextRestoredGuard.adoc[`DCheckRequestContextRestoredGuard`] 
| Debug&hyphen;only guard that checks the context is unchanged across a scope&period;
| xref:folly/DeadlockDetector.adoc[`DeadlockDetector`] 
| Interface for an object that watches an executor for deadlocks&period;
| xref:folly/DeadlockDetectorFactory.adoc[`DeadlockDetectorFactory`] 
| Factory that creates DeadlockDetector instances for executors&period;
| xref:folly/DecoratedAsyncTransportWrapper.adoc[`DecoratedAsyncTransportWrapper`] 
| Convenience class so that AsyncTransport can be decorated without having to redefine every single method&period;
| xref:folly/DefaultAlign.adoc[`DefaultAlign`] 
| An alignment policy that carries a runtime alignment value&period;
| xref:folly/DefaultKeepAliveExecutor.adoc[`DefaultKeepAliveExecutor`] 
| An Executor accepts units of work with add(), which should be threadsafe&period;
| xref:folly/DefaultWeightFn.adoc[`DefaultWeightFn`] 
| DynamicBoundedQueue supports&colon; &hyphen; Dynamic memory usage that grows and shrink in proportion to the number of elements in the queue&period; &hyphen; Adjustable capacity that helps throttle pathological cases of producer&hyphen;consumer imbalance that may lead to excessive memory usage&period; &hyphen; The adjustable capacity can also help prevent deadlock by allowing users to temporarily increase capacity substantially to guarantee accommodating producer requests that cannot wait&period; &hyphen; SPSC, SPMC, MPSC, MPMC variants&period; &hyphen; Blocking and spinning&hyphen;only variants&period; &hyphen; Inter&hyphen;operable non&hyphen;waiting, timed until, timed for, and waiting variants of producer and consumer operations&period; &hyphen; Optional variable element weights&period;
| xref:folly/DelayedDestruction.adoc[`DelayedDestruction`] 
| DelayedDestruction is a helper class to ensure objects are not deleted while they still have functions executing in a higher stack frame&period;
| xref:folly/DelayedDestructionBase.adoc[`DelayedDestructionBase`] 
| DelayedDestructionBase is a helper class to ensure objects are not deleted while they still have functions executing in a higher stack frame&period;
| xref:folly/DelayedInit.adoc[`DelayedInit`] 
| DelayedInit &hyphen;&hyphen; thread&hyphen;safe delayed initialization of a value&period; There are two important differences between Lazy and DelayedInit&colon; 1&period; DelayedInit does not store the factory function inline&period; 2&period; DelayedInit is thread&hyphen;safe&period;
| xref:folly/DerivedNodeTraits.adoc[`DerivedNodeTraits`] 
| Node traits for types that derive from IntrusiveHeapNode&period;
| xref:folly/DestructorCheck.adoc[`DestructorCheck`] 
| DestructorCheck is a helper class that helps to detect if a tracked object was deleted&period; This is useful for objects that request callbacks from other components&period;
| xref:folly/DetachFdState.adoc[`DetachFdState`] 
| 
| xref:folly/DigestBuilder.adoc[`DigestBuilder`] 
| Stat digests, such as TDigest, can be expensive to merge&period; It is faster to buffer writes and merge them in larger chunks&period; DigestBuilder buffers writes to improve performance&period;
| xref:folly/DiscriminatedPtr.adoc[`DiscriminatedPtr`] 
| Discriminated pointer&period;
| xref:folly/DrivableExecutor.adoc[`DrivableExecutor`] 
| An executor that can be driven forward via its `drive()` method&period;
| xref:folly/DynamicBoundedQueue.adoc[`DynamicBoundedQueue`] 
| A bounded, FIFO, multi&hyphen;producer multi&hyphen;consumer queue with adjustable capacity and dynamic memory usage&period;
| xref:folly/DynamicConstructor-00.adoc[`DynamicConstructor`] 
| Each specialization of DynamicConstructor has the function &apos;static dynamic construct(const C&amp;)&semi;&apos;
| xref:folly/DynamicConverter-05.adoc[`DynamicConverter`] 
| Each specialization of DynamicConverter has the function &apos;static T convert(const dynamic&amp;)&semi;&apos;
| xref:folly/DynamicParser.adoc[`DynamicParser`] 
| A small DSL for losslessly parsing a folly&colon;&colon;dynamic into another representation while recording any parts that cause errors&period;
| xref:folly/DynamicParserLogicError.adoc[`DynamicParserLogicError`] 
| When DynamicParser is used incorrectly, it will throw this exception instead of reporting an error via releaseErrors()&period; It is unsafe to call any parser methods after catching a LogicError&period;
| xref:folly/DynamicParserParseError.adoc[`DynamicParserParseError`] 
| With DynamicParser&colon;&colon;OnError&colon;&colon;THROW, reports the first error&period; It is forbidden to call releaseErrors() if you catch this&period;
| xref:folly/DynamicRingQueue.adoc[`DynamicRingQueue`] 
| A ring buffer queue backed by a power&hyphen;of&hyphen;two sized array that grows on overflow&period; Not thread&hyphen;safe&period;
| xref:folly/EDFThreadPoolExecutor.adoc[`EDFThreadPoolExecutor`] 
| DEPRECATED&colon; use `folly&colon;&colon;StripedEDFThreadPoolExecutor` directly&period; This wrapper exists only for legacy callers&period;
| xref:folly/ElfHwCaps.adoc[`ElfHwCaps`] 
| Identification of hardware capabilities via the ELF auxiliary vector&period;
| xref:folly/EnablePrimaryFromThis.adoc[`EnablePrimaryFromThis`] 
| EnablePrimaryFromThis provides an object with appropriate access to the functionality of the PrimaryPtr holding this&period;
| xref:folly/Endian.adoc[`Endian`] 
| Converts integral and floating point values between native, big&hyphen;endian, and little&hyphen;endian byte orders&period;
| xref:folly/EpollBackend.adoc[`EpollBackend`] 
| 
| xref:folly/EventBase.adoc[`EventBase`] 
| An event loop that drives asynchronous I&sol;O and timers&period;
| xref:folly/EventBaseAtomicNotificationQueue.adoc[`EventBaseAtomicNotificationQueue`] 
| Lock&hyphen;free notification queue of tasks consumed by a single consumer&period;
| xref:folly/EventBaseBackendBase.adoc[`EventBaseBackendBase`] 
| Abstract base for the backend that drives an EventBase loop&period;
| xref:folly/EventBaseEvent.adoc[`EventBaseEvent`] 
| Wrapper around a libevent event owned by an EventBase backend&period;
| xref:folly/EventBaseLocal.adoc[`EventBaseLocal`] 
| Storage for data tied to the lifetime of an EventBase&period;
| xref:folly/EventBaseManager.adoc[`EventBaseManager`] 
| Manager for per&hyphen;thread EventBase objects&period; This class will find or create a EventBase for the current thread, associated with thread&hyphen;specific storage for that thread&period; Although a typical application will generally only have one EventBaseManager, there is no restriction on multiple instances&semi; the EventBases belong to one instance are isolated from those of another&period;
| xref:folly/EventBaseObserver.adoc[`EventBaseObserver`] 
| Observer interface that samples EventBase loop activity&period;
| xref:folly/EventBaseThread.adoc[`EventBaseThread`] 
| Owns an EventBase running on its own thread&period;
| xref:folly/EventBaseThreadTimekeeper.adoc[`EventBaseThreadTimekeeper`] 
| A Timekeeper that schedules timeouts on an externally supplied EventBase&period;
| xref:folly/EventCount.adoc[`EventCount`] 
| Event count&colon; a condition variable for lock free algorithms&period;
| xref:folly/EventHandler.adoc[`EventHandler`] 
| The EventHandler class is used to asynchronously wait for events on a file descriptor&period;
| xref:folly/EventUtil.adoc[`EventUtil`] 
| low&hyphen;level libevent utility functions
| xref:folly/EvictingCacheMap.adoc[`EvictingCacheMap`] 
| A general purpose LRU evicting cache designed to support constant time set&sol;get&sol;insert&sol;erase ops&period; The only required configuration parameter is the `maxSize`, which is the maximum number of entries held by the cache, which is also dynamically changeable&period; Insertion will evict (and destroy with &#126;TKey and &#126;TValue) existing entries in LRU order as needed to keep number of entries less than maxSize&period; When automatic eviction is triggered, the minimum number of evictions is `clearSize`, which is configurable with a default of 1&period; If a callback is specified with setPruneHook, it is invoked for each eviction&period; However, the prune hook cannot manage object lifetimes because it is not invoked on erase nor cache destruction&period;
| xref:folly/ExecutionObserver.adoc[`ExecutionObserver`] 
| Observes the execution of a task&period; Multiple execution observers can be chained together&period; As a caveat, execution observers should not remove themselves from the list of observers during execution
| xref:folly/ExecutionObserverScopeGuard.adoc[`ExecutionObserverScopeGuard`] 
| Notifies a list of execution observers around a scoped task execution&period;
| xref:folly/Executor.adoc[`Executor`] 
| Schedules and runs asynchronous work&period;
| xref:folly/ExecutorBlockingContext.adoc[`ExecutorBlockingContext`] 
| Records whether blocking is forbidden while an executor is running work&period;
| xref:folly/ExecutorBlockingGuard.adoc[`ExecutorBlockingGuard`] 
| Scoped guard that pushes an executor blocking context for its lifetime&period;
| xref:folly/ExecutorBlockingList.adoc[`ExecutorBlockingList`] 
| A node in the thread&hyphen;local stack of executor blocking contexts&period;
| xref:folly/ExecutorKeepAlive.adoc[`ExecutorKeepAlive`] 
| `ExecutorKeepAlive` is a safe pointer to an `Executor`&period;
| xref:folly/ExecutorWithPriority.adoc[`ExecutorWithPriority`] 
| Wraps an executor so that submitted tasks run at a chosen priority&period;
| xref:folly/Expected.adoc[`Expected`] 
| Forward declarations
| xref:folly/F14FastMap-07.adoc[`F14FastMap`] 
| F14 hash map that selects a value or vector layout based on entry size&period;
| xref:folly/F14FastSet-08.adoc[`F14FastSet`] 
| F14 hash set that selects a value or vector layout based on element size&period;
| xref:folly/F14HashToken.adoc[`F14HashToken`] 
| An opaque token holding the precomputed hash of a key&period;
| xref:folly/F14HashedKey.adoc[`F14HashedKey`] 
| A key paired with its precomputed F14 hash token for faster lookups&period;
| xref:folly/F14NodeMap-058.adoc[`F14NodeMap`] 
| F14 hash map that stores each entry in a separately allocated node&period;
| xref:folly/F14NodeSet-02.adoc[`F14NodeSet`] 
| F14 hash set that stores each element in a separately allocated node&period;
| xref:folly/F14TableStats.adoc[`F14TableStats`] 
| Diagnostic statistics describing the internal state of an F14 table&period;
| xref:folly/F14ValueMap-091.adoc[`F14ValueMap`] 
| F14 hash map that stores entries inline in the main array&period;
| xref:folly/F14ValueSet-0a.adoc[`F14ValueSet`] 
| F14 hash set that stores elements inline in the main array&period;
| xref:folly/F14ValueSetTester.adoc[`F14ValueSetTester`] 
| Test&hyphen;only accessor granting inspection of F14ValueSet internals&period;
| xref:folly/F14VectorMap-0a.adoc[`F14VectorMap`] 
| F14 hash map that keeps entries in a dense, index&hyphen;addressable vector&period;
| xref:folly/F14VectorSet-0f9.adoc[`F14VectorSet`] 
| F14 hash set that keeps elements in a dense, index&hyphen;addressable vector&period;
| xref:folly/FallbackGetcpu.adoc[`FallbackGetcpu`] 
| A class that lazily binds a unique (for each implementation of Atom) identifier to a thread&period; This is a fallback mechanism for the access spreader if &lowbar;&lowbar;vdso&lowbar;getcpu can&apos;t be loaded
| xref:folly/FiberIOExecutor.adoc[`FiberIOExecutor`] 
| An IOExecutor that executes funcs under mapped fiber context
| xref:folly/File.adoc[`File`] 
| A File represents an open file&period;
| xref:folly/FileHandlerFactory.adoc[`FileHandlerFactory`] 
| FileHandlerFactory is a LogHandlerFactory that constructs log handlers that write to a file&period;
| xref:folly/FileWriterFactory.adoc[`FileWriterFactory`] 
| A helper class for creating an AsyncFileWriter or ImmediateFileWriter based on log handler options settings&period;
| xref:folly/Fingerprint.adoc[`Fingerprint`] 
| Compute the Rabin fingerprint&period;
| xref:folly/FixedAlign.adoc[`FixedAlign`] 
| An alignment policy that carries a compile&hyphen;time alignment value&period;
| xref:folly/FixedCapacityRingQueue.adoc[`FixedCapacityRingQueue`] 
| A simple fixed&hyphen;capacity ring buffer queue backed by a power&hyphen;of&hyphen;two sized array&period; Not thread&hyphen;safe&period;
| xref:folly/FlatCombining.adoc[`FlatCombining`] 
| &hyphen; A simple interface that requires minimal extra code by the user&period; To use this interface efficiently the user&hyphen;provided functions must be copyable to folly&colon;&colon;Function without dynamic allocation&period; If this is impossible or inconvenient, the user is encouraged to use the custom interface described below&period; &hyphen; A custom interface that supports custom combining and custom request structure, either for the sake of smart combining or for efficiently supporting operations that are not be copyable to folly&colon;&colon;Function without dynamic allocation&period; &hyphen; Both synchronous and asynchronous operations&period; &hyphen; Request records with and without thread&hyphen;caching&period; &hyphen; Combining with and without a dedicated combiner thread&period;
| xref:folly/FlatCombiningPriorityQueue.adoc[`FlatCombiningPriorityQueue`] 
| Thread&hyphen;safe priority queue based on flat combining&period; If the constructor parameter maxSize is greater than 0 (default &equals; 0), then the queue is bounded&period; This template provides blocking, non&hyphen;blocking, and timed variants of each of push(), pop(), and peek() operations&period; The empty() and size() functions are inherently non&hyphen;blocking&period;
| xref:folly/FormatArg.adoc[`FormatArg`] 
| Parsed format argument&period;
| xref:folly/FormatKeyNotFoundException.adoc[`FormatKeyNotFoundException`] 
| Exception class thrown when a format key is not found in the given associative container keyed by strings&period; We inherit std&colon;&colon;out&lowbar;of&lowbar;range for compatibility with callers that expect exception to be thrown directly by std&colon;&colon;map or std&colon;&colon;unordered&lowbar;map&period;
| xref:folly/FormatValue.adoc[`FormatValue`] 
| Customization point for formatting a value of type `T`&period;
| xref:folly/Formatter.adoc[`Formatter`] 
| Binds a format string to its arguments for deferred formatting&period;
| xref:folly/Function-0c.adoc[`Function`] 
| A polymorphic, move&hyphen;only wrapper for any callable of a given signature&period;
| xref:folly/FunctionRef-0d.adoc[`FunctionRef`] 
| A reference wrapper for callable objects
| xref:folly/FunctionScheduler.adoc[`FunctionScheduler`] 
| Schedules any number of functions to run at various intervals&period; E&period;g&period;,
| xref:folly/FutureExecutor.adoc[`FutureExecutor`] 
| Executor wrapper that adds future&hyphen;returning task submission&period;
| xref:folly/FutureSplitter.adoc[`FutureSplitter`] 
| FutureSplitter provides a &grave;getFuture()&apos; method which can be called multiple times, returning a new Future each time&period; These futures are completed when the original Future passed to the FutureSplitter constructor is completed, and are completed on the same executor (if any) and at the same priority as the original Future&period; Calls to &grave;getFuture()&apos; after that time return a completed Future&period;
| xref:folly/FutureSplitterInvalid.adoc[`FutureSplitterInvalid`] 
| Exception thrown when a FutureSplitter holds no Future&period;
| xref:folly/GenerationalCacheMap.adoc[`GenerationalCacheMap`] 
| A concurrent, bounded, approximately&hyphen;LRU cache with lock&hyphen;free lookups&period;
| xref:folly/GetThreadIdCollector.adoc[`GetThreadIdCollector`] 
| Interface for executors that provide a WorkerProvider to collect thread ids&period;
| xref:folly/Getcpu.adoc[`Getcpu`] 
| Knows how to derive a function pointer to the VDSO implementation of getcpu(2), if available
| xref:folly/GlobalCPUExecutorCounters.adoc[`GlobalCPUExecutorCounters`] 
| Load counters for the global immutable CPU executor&period;
| xref:folly/GlogStyleFormatter.adoc[`GlogStyleFormatter`] 
| A LogFormatter implementation that produces messages in a format similar to that produced by the Google logging library&period;
| xref:folly/GoogleLogger.adoc[`GoogleLogger`] 
| The default `AutoTimer` logger, which writes timing messages via glog&period;
| xref:folly/GroupVarint-09.adoc[`GroupVarint`] 
| Group varint encoder&sol;decoder for 32&hyphen; or 64&hyphen;bit integers&period;
| xref:folly/GroupVarintDecoder.adoc[`GroupVarintDecoder`] 
| Simplify use of GroupVarint&ast; for the case where the last group in the input may be incomplete (but the exact size of the input is known)&period; Allows for extracting values one at a time&period;
| xref:folly/GroupVarintEncoder.adoc[`GroupVarintEncoder`] 
| Simplify use of GroupVarint&ast; for the case where data is available one entry at a time (instead of one group at a time)&period; Handles buffering and an incomplete last chunk&period;
| xref:folly/HHWheelTimerBase-01.adoc[`HHWheelTimerBase`] 
| Hashed Hierarchical Wheel Timer
| xref:folly/Hash-06.adoc[`Hash`] 
| Generic variadic hasher that dispatches to folly&colon;&colon;hasher for each argument&period;
| xref:folly/HashingThreadId.adoc[`HashingThreadId`] 
| Assigns thread ids by hashing the platform thread identifier&period;
| xref:folly/HazptrLockFreeLIFO.adoc[`HazptrLockFreeLIFO`] 
| A lock&hyphen;free LIFO stack that reclaims popped nodes with hazard pointers&period;
| xref:folly/HazptrSWMRSet.adoc[`HazptrSWMRSet`] 
| Set implemented as an ordered singly&hyphen;linked list&period;
| xref:folly/HazptrWideCAS.adoc[`HazptrWideCAS`] 
| Wide CAS&period;
| xref:folly/HeapTimekeeper.adoc[`HeapTimekeeper`] 
| A Timekeeper with a dedicated thread that manages the timeouts using a heap&period; Timeouts can be scheduled with microsecond resolution, though in practice the accuracy depends on the OS scheduler&apos;s ability to wake up the worker thread in a timely fashion&period;
| xref:folly/HeterogeneousAccessEqualTo-0f.adoc[`HeterogeneousAccessEqualTo`] 
| Equality comparator that enables heterogeneous lookup for key type `T`&period;
| xref:folly/HeterogeneousAccessHash-04.adoc[`HeterogeneousAccessHash`] 
| Hasher that enables heterogeneous lookup for key type `T`&period;
| xref:folly/HeterogeneousPreHashCompatible-04.adoc[`HeterogeneousPreHashCompatible`] 
| Trait that is true when two hashers agree on prehash values&period;
| xref:folly/Histogram.adoc[`Histogram`] 
| A basic histogram class&period;
| xref:folly/HugePageSize.adoc[`HugePageSize`] 
| A supported huge page size and its mount point&period;
| xref:folly/IOBuf.adoc[`IOBuf`] 
| IOBuf manages heap&hyphen;allocated byte buffers&period;
| xref:folly/IOBufCompare.adoc[`IOBufCompare`] 
| Ordering for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufEqualTo.adoc[`IOBufEqualTo`] 
| Equality predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufGreater.adoc[`IOBufGreater`] 
| Greater predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufGreaterEqual.adoc[`IOBufGreaterEqual`] 
| At&hyphen;least predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufHash.adoc[`IOBufHash`] 
| Hasher for IOBuf objects&period; Hashes the entire chain using SpookyHashV2&period;
| xref:folly/IOBufIovecBuilder.adoc[`IOBufIovecBuilder`] 
| IOBufIovecBuilder exists to help allocate and fill IOBuf chains using iovec&hyphen;based scatter&sol;gather APIs&period;
| xref:folly/IOBufLess.adoc[`IOBufLess`] 
| Less predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufLessEqual.adoc[`IOBufLessEqual`] 
| At&hyphen;most predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufNotEqualTo.adoc[`IOBufNotEqualTo`] 
| Inequality predicate for IOBuf objects&period; Compares data in the entire chain&period;
| xref:folly/IOBufQueue.adoc[`IOBufQueue`] 
| An IOBufQueue encapsulates a chain of IOBufs and provides convenience functions to append data to the back of the chain and remove data from the front&period;
| xref:folly/IOExecutor.adoc[`IOExecutor`] 
| An executor backed by an I&sol;O event loop&period;
| xref:folly/IOObjectCache.adoc[`IOObjectCache`] 
| Caches objects of type T that are bound to an EventBase from the global IOExecutor&period;
| xref:folly/IOThreadPoolDeadlockDetectorObserver.adoc[`IOThreadPoolDeadlockDetectorObserver`] 
| Observer that attaches a deadlock detector to each event base of an IO thread pool&period;
| xref:folly/IOThreadPoolExecutor.adoc[`IOThreadPoolExecutor`] 
| A Thread Pool for IO bound tasks
| xref:folly/IOThreadPoolExecutorBase.adoc[`IOThreadPoolExecutorBase`] 
| Base interface for executors that run tasks on IO threads with EventBases&period;
| xref:folly/IPAddress.adoc[`IPAddress`] 
| A representation of an IP address (IPv4 or IPv6)&period;
| xref:folly/IPAddressFormatException.adoc[`IPAddressFormatException`] 
| Exception that is thrown when dealing with invalid IP addresses&period; A subclass of `std&colon;&colon;runtime&lowbar;error`
| xref:folly/IPAddressV4.adoc[`IPAddressV4`] 
| A representation of an IPv4 address&period;
| xref:folly/IPAddressV6.adoc[`IPAddressV6`] 
| A representation of an IPv6 address&period;
| xref:folly/Ignore.adoc[`Ignore`] 
| A type that is implicitly constructible from and assignable by anything&period;
| xref:folly/ImmediateFileWriter.adoc[`ImmediateFileWriter`] 
| A LogWriter implementation that immediately writes to a file descriptor when it is invoked&period;
| xref:folly/ImmutableRequestData.adoc[`ImmutableRequestData`] 
| ImmutableRequestData is a folly&colon;&colon;RequestData that holds an immutable value&period; It is thread&hyphen;safe (a requirement of RequestData) because it is immutable&period;
| xref:folly/ImplicitSynchronized.adoc[`ImplicitSynchronized`]  [.small]#[deprecated]#
| Deprecated subclass of Synchronized that provides implicit locking via operator&hyphen;&gt;&period; This is intended to ease migration while preventing accidental use of operator&hyphen;&gt; in new code&period;
| xref:folly/ImplicitlyWeightedEvictingCacheMap.adoc[`ImplicitlyWeightedEvictingCacheMap`] 
| A variant of EvictingCacheMap that assigns weights to entries and evicts entries in LRU order to ensure the total weight of all entries stays below some set maximum&period; ImplicitlyWeighted means this variant derives the weights from the key&hyphen;values using a chosen function&period; TWeightFn must be a type implementing `size&lowbar;t operator()(const TKey&amp;, const Tvalue&amp;)`
| xref:folly/Indestructible.adoc[`Indestructible`] 
| Wraps an inline object that is never destructed, for Meyers singletons&period;
| xref:folly/IndexedMemPool.adoc[`IndexedMemPool`] 
| Instances of IndexedMemPool dynamically allocate and then pool their element type (T), returning 4&hyphen;byte integer indices that can be passed to the pool&apos;s operator&lsqb;&rsqb;method to access or obtain pointers to the actual elements&period; The memory backing items returned from the pool will always be readable, even if items have been returned to the pool&period; These two features are useful for lock&hyphen;free algorithms&period; The indexing behavior makes it easy to build tagged pointer&hyphen;like&hyphen;things, since a large number of elements can be managed using fewer bits than a full pointer&period; The access&hyphen;after&hyphen;free behavior makes it safe to read from T&hyphen;s even after they have been recycled, since it is guaranteed that the memory won&apos;t have been returned to the OS and unmapped (the algorithm must still use a mechanism to validate that the read was correct, but it doesn&apos;t have to worry about page faults), and if the elements use internal sequence numbers it can be guaranteed that there won&apos;t be an ABA match due to the element being overwritten with a different type that has the same bit pattern&period;
| xref:folly/IndexedMemPoolTraits.adoc[`IndexedMemPoolTraits`] 
| A Traits type that controls the object lifecycle strategy of an IndexedMemPool&period;
| xref:folly/Init-0d.adoc[`Init`] 
| RAII object constructed at the beginning of main() and destructed implicitly at the end of main()&period;
| xref:folly/InitOptions.adoc[`InitOptions`] 
| Options controlling folly initialization&period;
| xref:folly/InitThreadFactory.adoc[`InitThreadFactory`] 
| A thread factory that runs setup and teardown callbacks around each thread&period;
| xref:folly/InlineExecutor.adoc[`InlineExecutor`] 
| When work is &quot;queued&quot;, execute it immediately inline&period; Usually when you think you want this, you actually want a QueuedImmediateExecutor&period;
| xref:folly/InlineLikeExecutor.adoc[`InlineLikeExecutor`] 
| Base class for executors that run queued work inline&period;
| xref:folly/IntrusiveHeap.adoc[`IntrusiveHeap`] 
| IntrusiveHeap implements a skew heap with intrusive pointers to provide O(log(n)) operations on any node in the heap with no separately allocated node type&period;
| xref:folly/IntrusiveHeapNode.adoc[`IntrusiveHeapNode`] 
| Base class for items to be inserted into IntrusiveHeap&lt;&period;&period;&period;, Tag&gt; storing pointers for internal use&period;
| xref:folly/IntrusiveHeapTest.adoc[`IntrusiveHeapTest`] 
| Test fixture granted access to node internals&period;
| xref:folly/InvalidAddressFamilyException.adoc[`InvalidAddressFamilyException`] 
| Exception that is thrown when an IP Address is not of the family expected (ie, expected a V4 but is a V6)&period; A subclass of IPAddressFormatException&period;
| xref:folly/IoSqeBase.adoc[`IoSqeBase`] 
| Base class for an io&lowbar;uring submission queue entry managed by Folly&period;
| xref:folly/IoUringArena.adoc[`IoUringArena`] 
| A memory arena registered with the kernel for io&lowbar;uring operations&period;
| xref:folly/IoUringBackend.adoc[`IoUringBackend`] 
| The io&lowbar;uring&hyphen;based EventBase backend&period;
| xref:folly/IoUringBufferProvider.adoc[`IoUringBufferProvider`] 
| 
| xref:folly/IoUringConnectCallback.adoc[`IoUringConnectCallback`] 
| Receives notifications about the outcome of an io&lowbar;uring connect operation&period;
| xref:folly/IoUringConnectHandle.adoc[`IoUringConnectHandle`] 
| Performs an asynchronous connect over an io&lowbar;uring&hyphen;backed socket&period;
| xref:folly/IoUringDynamicProvidedBufferRing.adoc[`IoUringDynamicProvidedBufferRing`] 
| 
| xref:folly/IoUringDynamicProvidedBufferRingTestHelper.adoc[`IoUringDynamicProvidedBufferRingTestHelper`] 
| 
| xref:folly/IoUringFdRegistrationRecord.adoc[`IoUringFdRegistrationRecord`] 
| Tracks a file descriptor registered with an io&lowbar;uring ring&period;
| xref:folly/IoUringOp.adoc[`IoUringOp`] 
| A pending operation backed by the Linux io&lowbar;uring interface&period;
| xref:folly/IoUringOptions.adoc[`IoUringOptions`] 
| 
| xref:folly/IoUringProvidedBufferRing.adoc[`IoUringProvidedBufferRing`] 
| 
| xref:folly/IoUringProvidedBufferRingTestHelper.adoc[`IoUringProvidedBufferRingTestHelper`] 
| 
| xref:folly/IoUringRecvCallback.adoc[`IoUringRecvCallback`] 
| Receives notifications about the progress of an io&lowbar;uring receive operation&period;
| xref:folly/IoUringRecvHandle.adoc[`IoUringRecvHandle`] 
| Manages inbound receives over an io&lowbar;uring&hyphen;backed socket&period;
| xref:folly/IoUringSendCallback.adoc[`IoUringSendCallback`] 
| Receives notifications about the progress of an io&lowbar;uring send operation&period;
| xref:folly/IoUringSendHandle.adoc[`IoUringSendHandle`] 
| Manages a single outbound send over an io&lowbar;uring&hyphen;backed socket&period;
| xref:folly/IoUringZeroCopyBufferPool.adoc[`IoUringZeroCopyBufferPool`] 
| 
| xref:folly/IoUringZeroCopyBufferPoolImpl.adoc[`IoUringZeroCopyBufferPoolImpl`] 
| 
| xref:folly/IoUringZeroCopyBufferPoolTestHelper.adoc[`IoUringZeroCopyBufferPoolTestHelper`] 
| 
| xref:folly/IsAvalanchingHasher-01.adoc[`IsAvalanchingHasher`] 
| Trait&colon; true when hasher Hasher avalanches input entropy across every bit of the hash of key Key&period;
| xref:folly/IsConvertible.adoc[`IsConvertible`] 
| Trait detecting whether a type can be a split() output field&period;
| xref:folly/IsRelocatable-0b.adoc[`IsRelocatable`] 
| A trait describing whether a value of type T can be relocated with memcpy&period;
| xref:folly/IsSomeString-04.adoc[`IsSomeString`] 
| Trait that identifies string&hyphen;like types such as `std&colon;&colon;string` and fbstring&period;
| xref:folly/IsZeroInitializable.adoc[`IsZeroInitializable`] 
| A trait describing whether value&hyphen;initialization equals zero&hyphen;filling memory&period;
| xref:folly/JemallocHugePageAllocator.adoc[`JemallocHugePageAllocator`] 
| An allocator which uses Jemalloc to create a dedicated huge page arena, backed by 2MB huge pages (on linux x86&hyphen;64)&period;
| xref:folly/JemallocNodumpAllocator.adoc[`JemallocNodumpAllocator`] 
| An allocator which uses Jemalloc to create an dedicated arena to allocate memory from&period; The only special property set on the allocated memory is that the memory is not dump&hyphen;able&period;
| xref:folly/LLCAccessSpreader.adoc[`LLCAccessSpreader`] 
| Similar to AccessSpreader, but it has exactly one stripe for each last&hyphen;level cache that is accessible by the current process&period;
| xref:folly/Latch.adoc[`Latch`] 
| Example&colon;
| xref:folly/LeakySingleton.adoc[`LeakySingleton`] 
| A singleton whose instance is intentionally never destroyed&period;
| xref:folly/LegacyStatsClock.adoc[`LegacyStatsClock`] 
| A helper clock type to helper older code using BucketedTimeSeries with std&colon;&colon;chrono&colon;&colon;seconds transition to properly using clock types and time&lowbar;point objects&period;
| xref:folly/LifoSemImpl.adoc[`LifoSemImpl`] 
| Concrete LIFO semaphore parameterized by its baton and atomic types&period;
| xref:folly/LifoSemMPMCQueue.adoc[`LifoSemMPMCQueue`] 
| A blocking multi&hyphen;producer, multi&hyphen;consumer queue backed by a LIFO semaphore&period;
| xref:folly/LockFreeRingBuffer.adoc[`LockFreeRingBuffer`] 
| LockFreeRingBuffer&lt;T&gt; is a fixed&hyphen;size, concurrent ring buffer with the following semantics&colon;
| xref:folly/LockedPtr.adoc[`LockedPtr`] 
| A LockedPtr keeps a Synchronized&lt;T&gt; object locked for the duration of LockedPtr&apos;s existence&period;
| xref:folly/LockedPtrBase.adoc[`LockedPtrBase`] 
| Base class that owns the lock held by a `LockedPtr`&period;
| xref:folly/LogCategory.adoc[`LogCategory`] 
| LogCategory stores all of the logging configuration for a specific log category&period;
| xref:folly/LogCategoryConfig.adoc[`LogCategoryConfig`] 
| Configuration for a LogCategory
| xref:folly/LogConfig.adoc[`LogConfig`] 
| Configuration describing log categories and handlers&period;
| xref:folly/LogConfigParseError.adoc[`LogConfigParseError`] 
| Exception thrown when a log configuration string cannot be parsed&period;
| xref:folly/LogFormatter.adoc[`LogFormatter`] 
| LogFormatter defines the interface for serializing a LogMessage object into a buffer to be given to a LogWriter&period;
| xref:folly/LogHandler.adoc[`LogHandler`] 
| Consumes and processes log messages&period;
| xref:folly/LogHandlerConfig.adoc[`LogHandlerConfig`] 
| Configuration for a LogHandler
| xref:folly/LogHandlerFactory.adoc[`LogHandlerFactory`] 
| Interface for factories that construct log handlers from config options&period;
| xref:folly/LogMessage.adoc[`LogMessage`] 
| LogMessage represents a single message to be logged&period;
| xref:folly/LogName.adoc[`LogName`] 
| The LogName class contains utility functions for processing log category names&period; It primarily handles canonicalization of names&period;
| xref:folly/LogStream.adoc[`LogStream`] 
| A std&colon;&colon;ostream implementation for use by the logging macros&period;
| xref:folly/LogStreamBuffer.adoc[`LogStreamBuffer`] 
| A std&colon;&colon;streambuf implementation for use by LogStream
| xref:folly/LogStreamProcessor.adoc[`LogStreamProcessor`] 
| LogStreamProcessor receives a LogStream and logs it&period;
| xref:folly/LogStreamVoidify-01.adoc[`LogStreamVoidify`] 
| LogStreamVoidify() is a helper class used in the FB&lowbar;LOG() and XLOG() macros&period;
| xref:folly/LogWriter.adoc[`LogWriter`] 
| Writes serialized log messages to an output&period;
| xref:folly/Logger.adoc[`Logger`] 
| Logger is the class you will use to specify the log category when logging messages with FB&lowbar;LOG()&period;
| xref:folly/LoggerDB.adoc[`LoggerDB`] 
| LoggerDB stores the set of LogCategory objects&period;
| xref:folly/MPMCPipeline.adoc[`MPMCPipeline`] 
| A multi&hyphen;producer, multi&hyphen;consumer pipeline of processing stages&period;
| xref:folly/MPMCPipelineStage.adoc[`MPMCPipelineStage`] 
| Describes a pipeline stage carrying element type T with amplification Amp&period;
| xref:folly/MPMCQueue-0a1.adoc[`MPMCQueue`] 
| MPMCQueue&lt;T&gt; is a high&hyphen;performance bounded concurrent queue that supports multiple producers, multiple consumers, and optional blocking&period; The queue has a fixed capacity, for which all memory will be allocated up front&period; The bulk of the work of enqueuing and dequeuing can be performed in parallel&period;
| xref:folly/MacAddress.adoc[`MacAddress`] 
| A 48&hyphen;bit ethernet MAC address&period;
| xref:folly/MallctlMibCallCache.adoc[`MallctlMibCallCache`] 
| Caches the resolved MIB for a `mallctl` command that neither reads nor writes a value, for repeated fast invocation&period;
| xref:folly/MallctlMibReadCache.adoc[`MallctlMibReadCache`] 
| Caches the resolved MIB for a `mallctl` command that reads a value, for repeated fast invocation&period;
| xref:folly/MallctlMibReadWriteCache.adoc[`MallctlMibReadWriteCache`] 
| Caches the resolved MIB for a `mallctl` command that writes a value and reads the previous one, for repeated fast invocation&period;
| xref:folly/MallctlMibWriteCache.adoc[`MallctlMibWriteCache`] 
| Caches the resolved MIB for a `mallctl` command that writes a value, for repeated fast invocation&period;
| xref:folly/ManualExecutor.adoc[`ManualExecutor`] 
| A ManualExecutor only does work when you turn the crank, by calling run() or indirectly with makeProgress() or waitFor()&period;
| xref:folly/ManualTimekeeper.adoc[`ManualTimekeeper`] 
| Manually controlled Timekeeper for unit testing&period;
| xref:folly/MaybeManagedPtr.adoc[`MaybeManagedPtr`] 
| MaybeManagedPtr stores either a raw pointer or a shared&lowbar;ptr&period; It provides normal pointer operations on the underlying raw pointer&sol;shared&lowbar;ptr&period;
| xref:folly/MemberNodeTraits.adoc[`MemberNodeTraits`] 
| Node traits for types that hold an IntrusiveHeapNode member&period;
| xref:folly/MemoryMapping.adoc[`MemoryMapping`] 
| Maps files in memory (read&hyphen;only)&period;
| xref:folly/MicroLockBase.adoc[`MicroLockBase`] 
| A tiny one&hyphen;byte spinlock with a configurable spin and yield budget&period;
| xref:folly/MicroLockCore.adoc[`MicroLockCore`] 
| Base class holding the lock byte and the bit&hyphen;packing helpers shared by every MicroLock specialization&period;
| xref:folly/MicroSpinLock.adoc[`MicroSpinLock`] 
| A really, _really_ small spinlock for fine&hyphen;grained locking of lots of teeny&hyphen;tiny data&period;
| xref:folly/MoveWrapper.adoc[`MoveWrapper`] 
| C&plus;&plus;11 closures don&apos;t support move&hyphen;in capture&period; Nor does std&colon;&colon;bind&period; facepalm&period;
| xref:folly/MultiLevelTimeSeries.adoc[`MultiLevelTimeSeries`] 
| This class represents a timeseries which keeps several levels of data granularity (similar in principle to the loads reported by the UNIX &apos;uptime&apos; command)&period; It uses several instances (one per level) of BucketedTimeSeries as the underlying storage&period;
| xref:folly/MultiSlidingWindowQuantileEstimator.adoc[`MultiSlidingWindowQuantileEstimator`] 
| Equivalent to (but more efficient than) a SimpleQuantileEstimator plus one SlidingWindowQuantileEstimator for each requested window&period;
| xref:folly/MutableAtom.adoc[`MutableAtom`] 
| MutableAtom is a tiny wrapper that gives you the option of atomically updating values inserted into an AtomicUnorderedInsertMap&lt;K, MutableAtom&lt;V&gt;&gt;&period; This relies on AtomicUnorderedInsertMap&apos;s guarantee that it doesn&apos;t move values&period;
| xref:folly/MutableData.adoc[`MutableData`] 
| MutableData is a tiny wrapper that gives you the option of using an external concurrency control mechanism to updating values inserted into an AtomicUnorderedInsertMap&period;
| xref:folly/MuxIOThreadPoolExecutor.adoc[`MuxIOThreadPoolExecutor`] 
| NOTE&colon; This is highly experimental&period; Do not use&period;
| xref:folly/NamedThreadFactory.adoc[`NamedThreadFactory`] 
| A ThreadFactory that names each thread it creates&period;
| xref:folly/NativeSemaphore.adoc[`NativeSemaphore`] 
| A thin wrapper over the platform&apos;s native counting semaphore&period;
| xref:folly/NestedCommandLineApp.adoc[`NestedCommandLineApp`] 
| App that uses a nested command line, of the form&colon;
| xref:folly/NestedCommandLineParseResult.adoc[`NestedCommandLineParseResult`] 
| Result of parsing a nested command line&period;
| xref:folly/NetworkSocket.adoc[`NetworkSocket`] 
| NetworkSocket is just a very thin wrapper around either a file descriptor or a SOCKET depending on platform, along with a couple of helper methods for explicitly converting to&sol;from file descriptors, even on Windows&period;
| xref:folly/None-03.adoc[`None`] 
| Tag type used to construct an empty Optional, akin to std&colon;&colon;nullopt&lowbar;t&period;
| xref:folly/NotificationQueue.adoc[`NotificationQueue`] 
| Queue used to deliver messages to an EventBase thread&period;
| xref:folly/ObserverContainer-0c.adoc[`ObserverContainer`] 
| Policy&hyphen;based implementation of ObserverContainerBase&period;
| xref:folly/ObserverContainerBase-00.adoc[`ObserverContainerBase`] 
| Base ObserverContainer and definition of Observers&period;
| xref:folly/ObserverContainerBasePolicyDefault-0c.adoc[`ObserverContainerBasePolicyDefault`] 
| Policy for ObserverContainerBase&period;
| xref:folly/ObserverContainerStore.adoc[`ObserverContainerStore`] 
| Policy&hyphen;based implementation of ObserverContainerStoreBase&period;
| xref:folly/ObserverContainerStoreBase.adoc[`ObserverContainerStoreBase`] 
| Interface for store of pointers to observers&period;
| xref:folly/ObserverContainerStorePolicyDefault.adoc[`ObserverContainerStorePolicyDefault`] 
| Policy for ObserverContainerStore&period;
| xref:folly/OpenSSLTicketHandler.adoc[`OpenSSLTicketHandler`] 
| Handler for OpenSSL session tickets&period;
| xref:folly/OpenSSLTransportCertificate.adoc[`OpenSSLTransportCertificate`] 
| Generic interface applications may implement to convey self or peer certificate related information&period;
| xref:folly/OperationCancelled.adoc[`OperationCancelled`] 
| IMPORTANT&colon; `folly`&hyphen;internal, do NOT use this in new user code&period; Instead&colon;
| xref:folly/Optional.adoc[`Optional`] 
| Optional is superseded by std&colon;&colon;optional&period; Now that the C&plus;&plus; has a standardized implementation, Optional exists primarily for backward compatibility&period;
| xref:folly/OptionalEmptyException.adoc[`OptionalEmptyException`] 
| Exception thrown when unwrapping the value of an empty Optional&period;
| xref:folly/PackedSyncPtr.adoc[`PackedSyncPtr`] 
| An 8&hyphen;byte pointer with an integrated spin lock and 15&hyphen;bit integer&period;
| xref:folly/ParkingLot.adoc[`ParkingLot`] 
| A portable, futex&hyphen;like waiter registry keyed by address&period;
| xref:folly/PasswordInFile.adoc[`PasswordInFile`] 
| Password collector that reads a passphrase from a file on construction&period;
| xref:folly/PicoSpinLock.adoc[`PicoSpinLock`] 
| Spin lock on a single bit in an integral type&period; You can use this with 16, 32, or 64&hyphen;bit integral types&period;
| xref:folly/Poly-00.adoc[`Poly`] 
| `Poly` is a class template that makes it relatively easy to define a type&hyphen;erasing polymorphic object wrapper&period;
| xref:folly/PolyExtends-07.adoc[`PolyExtends`] 
| Used in the definition of a `Poly` interface to say that the current interface is an extension of a set of zero or more interfaces&period;
| xref:folly/PolyMembers.adoc[`PolyMembers`] 
| A list of member pointers describing a `Poly` interface&period;
| xref:folly/PolySelf_.adoc[`PolySelf&lowbar;`] 
| Helper that computes the self type of a `Poly` interface node&period;
| xref:folly/PredefinedQuantiles.adoc[`PredefinedQuantiles`] 
| Predefined sets of quantiles for use with QuantileHistogram&period;
| xref:folly/PrimaryPtr.adoc[`PrimaryPtr`] 
| PrimaryPtr should be used to achieve deterministic destruction of objects with shared ownership&period; Once an object is managed by a PrimaryPtr, shared&lowbar;ptrs can be obtained pointing to that object&period; However destroying those shared&lowbar;ptrs will never call the object destructor inline&period; To destroy the object, join() method must be called on PrimaryPtr or the task returned from cleanup() must be completed, which will wait for all shared&lowbar;ptrs to be released and then call the object destructor on the caller supplied execution context&period;
| xref:folly/PrimaryPtrRef.adoc[`PrimaryPtrRef`] 
| PrimaryPtrRef is a non&hyphen;owning reference to the pointer&period; PrimaryPtr&colon;&colon;join() and the PrimaryPtr&colon;&colon;cleanup() work do _NOT_ wait for outstanding PrimaryPtrRef objects to be released&period;
| xref:folly/PriorityLifoSemMPMCQueue.adoc[`PriorityLifoSemMPMCQueue`] 
| A blocking queue with priority levels backed by per&hyphen;priority MPMC queues and a LIFO semaphore&period;
| xref:folly/PriorityThreadFactory.adoc[`PriorityThreadFactory`] 
| A ThreadFactory that sets nice values for each thread&period; The main use case for this class is if there are multiple CPUThreadPoolExecutors in a single process, or between multiple processes, where some should have a higher priority than the others&period;
| xref:folly/PriorityUnboundedBlockingQueue.adoc[`PriorityUnboundedBlockingQueue`] 
| A blocking queue with a fixed number of priority levels&period;
| xref:folly/PriorityUnboundedQueueSet.adoc[`PriorityUnboundedQueueSet`] 
| PriorityUnboundedQueueSet
| xref:folly/ProcessReturnCode.adoc[`ProcessReturnCode`] 
| Class to wrap a process return code&period;
| xref:folly/ProducerConsumerQueue.adoc[`ProducerConsumerQueue`] 
| A single&hyphen;producer, single&hyphen;consumer, lock&hyphen;free bounded queue&period;
| xref:folly/ProgramExit.adoc[`ProgramExit`] 
| Exception that commands may throw to force the program to exit cleanly with a given exit code&period; NestedCommandLineApp&colon;&colon;run() catches this and makes run() print the given message on stderr (followed by a newline, unless empty&semi; the message is only allowed when exiting with a non&hyphen;zero status), and return the exit code&period; (Other exceptions will propagate out of run())
| xref:folly/QuantileEstimates.adoc[`QuantileEstimates`] 
| Summary statistics and quantile estimates produced by a QuantileEstimator&period;
| xref:folly/QuantileHistogram.adoc[`QuantileHistogram`]  [.small]#[deprecated]#
| A histogram that tracks the locations of a fixed set of quantiles&period;
| xref:folly/QueueFullException.adoc[`QueueFullException`] 
| Exception thrown when adding to a full queue that uses THROW behavior&period;
| xref:folly/QueueInfo.adoc[`QueueInfo`] 
| Aggregates the worker thread ids per queue name along with their keep&hyphen;alives&period;
| xref:folly/QueueObserver.adoc[`QueueObserver`] 
| Observes enqueue and dequeue events on a queue&period;
| xref:folly/QueueObserverFactory.adoc[`QueueObserverFactory`] 
| Factory that creates QueueObserver instances for a queue&period;
| xref:folly/QueuedImmediateExecutor.adoc[`QueuedImmediateExecutor`] 
| Runs inline like InlineExecutor, but with a queue so that any tasks added to this executor by one of its own callbacks will be queued instead of executed inline (nested)&period; This is usually better behavior than Inline&period;
| xref:folly/RWSpinLock.adoc[`RWSpinLock`] 
| A simple, small (4&hyphen;bytes), but unfair rwlock&period; Use it when you want a nice writer and don&apos;t expect a lot of write&sol;read contention, or when you need small rwlocks since you are creating a large number of them&period;
| xref:folly/Random.adoc[`Random`] 
| Provides static random number generation utilities&period;
| xref:folly/Range-05.adoc[`Range`] 
| A lightweight, non&hyphen;owning view over a range of elements&period;
| xref:folly/ReadMostlyMainPtr.adoc[`ReadMostlyMainPtr`] 
| Owning pointer that gives cheap, lock&hyphen;free reads to shared objects&period;
| xref:folly/ReadMostlyMainPtrDeleter.adoc[`ReadMostlyMainPtrDeleter`] 
| This can be used to destroy multiple ReadMostlyMainPtrs at once&period;
| xref:folly/ReadMostlySharedPtr.adoc[`ReadMostlySharedPtr`] 
| Shared reader handle to a read&hyphen;mostly managed object&period;
| xref:folly/ReadMostlyWeakPtr.adoc[`ReadMostlyWeakPtr`] 
| Non&hyphen;owning weak reference to a read&hyphen;mostly managed object&period;
| xref:folly/ReadSqe.adoc[`ReadSqe`] 
| 
| xref:folly/RecordIOReader.adoc[`RecordIOReader`] 
| Class to read from a RecordIO file&period; Will skip invalid records&period;
| xref:folly/RecordIOWriter.adoc[`RecordIOWriter`] 
| Class to write a stream of RecordIO records to a file&period;
| xref:folly/RegexMatchCache.adoc[`RegexMatchCache`] 
| RegexMatchCache
| xref:folly/RegexMatchCacheDynamicBitset.adoc[`RegexMatchCacheDynamicBitset`] 
| RegexMatchCacheDynamicBitset
| xref:folly/RegexMatchCacheIndexedVector.adoc[`RegexMatchCacheIndexedVector`] 
| RegexMatchCacheIndexedVector
| xref:folly/RegexMatchCacheKey.adoc[`RegexMatchCacheKey`] 
| RegexMatchCacheKey
| xref:folly/RegexMatchCacheKeyAndView.adoc[`RegexMatchCacheKeyAndView`] 
| RegexMatchCacheKeyAndView
| xref:folly/RelaxedConcurrentPriorityQueue.adoc[`RelaxedConcurrentPriorityQueue`] 
| A fast, scalable, relaxed concurrent priority queue&period;
| xref:folly/Replaceable-08.adoc[`Replaceable`] 
| Wraps a `T` that can be replaced in place without allocation or indirection&period;
| xref:folly/RequestContext.adoc[`RequestContext`] 
| Holds data that follows an async request across queues and threads&period;
| xref:folly/RequestContextSaverScopeGuard.adoc[`RequestContextSaverScopeGuard`] 
| RequestContextSaverScopeGuard allows to replace the current context without switching back to original context, while ensuring that the original context is restored on guard destruction&period;
| xref:folly/RequestContextScopeGuard.adoc[`RequestContextScopeGuard`] 
| Note&colon; you probably want to use ShallowCopyRequestContextScopeGuard This resets all other RequestData for the duration of the scope!
| xref:folly/RequestData.adoc[`RequestData`] 
| Base class for data that follows an async request through a process&period;
| xref:folly/RequestEventBase.adoc[`RequestEventBase`] 
| Sets and retrieves the EventBase associated with a request via RequestContext&period;
| xref:folly/RequestToken.adoc[`RequestToken`] 
| A token used to fetch data from a RequestContext&period;
| xref:folly/SSLAcceptRunner.adoc[`SSLAcceptRunner`] 
| Run SSL&lowbar;accept via a runner
| xref:folly/SSLContext.adoc[`SSLContext`] 
| Wrap OpenSSL SSL&lowbar;CTX into a class&period;
| xref:folly/SSLException.adoc[`SSLException`] 
| Exception describing an SSL error and its underlying OpenSSL code&period;
| xref:folly/STTimerFDTimeoutManager.adoc[`STTimerFDTimeoutManager`] 
| A TimeoutManager backed by a TimerFD that tracks a single timeout&period;
| xref:folly/SaturatingSemaphore.adoc[`SaturatingSemaphore`] 
| SaturatingSemaphore is a flag that allows concurrent posting by multiple posters and concurrent non&hyphen;destructive waiting by multiple waiters&period;
| xref:folly/ScheduledExecutor.adoc[`ScheduledExecutor`] 
| An executor that supports timed scheduling&period; Like RxScheduler&period;
| xref:folly/ScopedEventBaseThread.adoc[`ScopedEventBaseThread`] 
| Helper that runs an EventBase loop on a dedicated std&colon;&colon;thread&period;
| xref:folly/ScopedUnlocker.adoc[`ScopedUnlocker`] 
| This class temporarily unlocks a LockedPtr in a scoped manner&period;
| xref:folly/SequencedExecutor.adoc[`SequencedExecutor`] 
| An executor that sequences tasks whose submissions were sequenced&period;
| xref:folly/SequentialThreadId.adoc[`SequentialThreadId`] 
| Assigns thread ids from a monotonically increasing counter&period;
| xref:folly/SerializedExecutor.adoc[`SerializedExecutor`] 
| A sequenced executor that never runs its tasks concurrently&period;
| xref:folly/ShallowCopyRequestContextScopeGuard.adoc[`ShallowCopyRequestContextScopeGuard`] 
| This guard maintains all the RequestData pointers of the parent&period; This allows to overwrite a specific RequestData pointer for the scope&apos;s duration, without breaking others&period;
| xref:folly/SharedMutexImpl.adoc[`SharedMutexImpl`] 
| A small, fast, scalable reader&hyphen;writer lock&period;
| xref:folly/SharedMutexPolicyDefault.adoc[`SharedMutexPolicyDefault`] 
| Default tuning and feature policy for SharedMutexImpl&period;
| xref:folly/SharedMutexToken.adoc[`SharedMutexToken`] 
| Records where a shared lock was recorded so it can be released quickly&period;
| xref:folly/SharedPromise.adoc[`SharedPromise`] 
| SharedPromise provides the same interface as Promise, but you can extract multiple Futures from it, i&period;e&period; you can call getFuture() as many times as you&apos;d like&period; When the SharedPromise is fulfilled, all of the Futures are completed&period; Calls to getFuture() after the SharedPromise is fulfilled return a completed Future&period; If you find yourself constructing collections of Promises and fulfilling them simultaneously with the same value, consider this utility instead&period; Likewise, if you find yourself in need of setting multiple callbacks on the same Future (which is indefinitely unsupported), consider refactoring to use SharedPromise to &quot;split&quot; the Future&period;
| xref:folly/ShutdownSemError.adoc[`ShutdownSemError`] 
| The exception thrown when wait()ing on an isShutdown() LifoSem
| xref:folly/ShutdownSocketSet.adoc[`ShutdownSocketSet`] 
| Set of sockets that allows immediate, take&hyphen;no&hyphen;prisoners abort&period;
| xref:folly/SimpleAsyncIO.adoc[`SimpleAsyncIO`] 
| SimpleAsyncIO is a wrapper around AsyncIO intended to hide all the details&period;
| xref:folly/SimpleQuantileEstimator.adoc[`SimpleQuantileEstimator`] 
| A QuantileEstimator that buffers writes for 1 second&period;
| xref:folly/SingleWriterFixedHashMap.adoc[`SingleWriterFixedHashMap`] 
| SingleWriterFixedHashMap&colon;
| xref:folly/Singleton.adoc[`Singleton`] 
| Singleton allows for simple access to registering and instantiating singletons&period; Create instances of this class in the global scope of type Singleton&lt;T&gt; to register your singleton for later access via Singleton&lt;T&gt;&colon;&colon;try&lowbar;get()&period;
| xref:folly/SingletonRelaxedCountable.adoc[`SingletonRelaxedCountable`] 
| A CRTP base class that keeps a global count of instances of a type&period;
| xref:folly/SingletonRelaxedCountableAccess.adoc[`SingletonRelaxedCountableAccess`] 
| Provides access to the running instance count of a countable type&period;
| xref:folly/SingletonRelaxedCounter.adoc[`SingletonRelaxedCounter`] 
| A singleton&hyphen;per&hyphen;tag relaxed counter&period;
| xref:folly/SingletonThreadLocal-09.adoc[`SingletonThreadLocal`] 
| SingletonThreadLocal
| xref:folly/SingletonVault.adoc[`SingletonVault`] 
| SingletonVault &hyphen; a library to manage the creation and destruction of interdependent singletons&period;
| xref:folly/SlidingWindowQuantileEstimator.adoc[`SlidingWindowQuantileEstimator`] 
| A QuantileEstimator that keeps values for nWindows &ast; windowDuration (see constructor)&period; Values are buffered for windowDuration&period;
| xref:folly/SocketAddress.adoc[`SocketAddress`] 
| Provides a unified interface for socket addresses&period;
| xref:folly/SocketFds.adoc[`SocketFds`] 
| Represents an ordered collection of file descriptors&period; This union type either contains&colon; &hyphen; FDs to be sent on a socket &hyphen;&hyphen; with shared ownership, since the sender may still need them, OR &hyphen; FDs just received, with sole ownership&period;
| xref:folly/SocketOptionKey.adoc[`SocketOptionKey`] 
| Uniquely identifies a handle to a socket option value&period; Each combination of level and option name corresponds to one socket option value&period;
| xref:folly/SocketOptionValue.adoc[`SocketOptionValue`] 
| Variant container for socket option values&colon; integer or string&period; Implicit ctor&sol;compares with int for backward compatibility&period;
| xref:folly/SoftRealTimeExecutor.adoc[`SoftRealTimeExecutor`] 
| Executor that performs priority&hyphen;based scheduling with a deadline assigned to each task&period;
| xref:folly/SparseByteSet.adoc[`SparseByteSet`] 
| &ast; SparseByteSet
| xref:folly/SpinLock.adoc[`SpinLock`] 
| A small, non&hyphen;recursive spin lock with a standard lock interface&period;
| xref:folly/SpinLockArray.adoc[`SpinLockArray`] 
| Array of spinlocks where each one is padded to prevent false sharing&period; Useful for shard&hyphen;based locking implementations in environments where contention is unlikely&period;
| xref:folly/SplitOptions.adoc[`SplitOptions`] 
| SplitOptions
| xref:folly/StandardLogHandler.adoc[`StandardLogHandler`] 
| StandardLogHandler is a LogHandler implementation that uses a LogFormatter class to serialize the LogMessage into a string, and then gives it to a LogWriter object&period;
| xref:folly/StandardLogHandlerFactory.adoc[`StandardLogHandlerFactory`] 
| StandardLogHandlerFactory contains helper methods for LogHandlerFactory implementations that create StandardLogHandler objects&period;
| xref:folly/StaticConst.adoc[`StaticConst`] 
| A template for defining ODR&hyphen;usable constexpr instances, free of ODR and init&hyphen;order problems&period;
| xref:folly/StrandContext.adoc[`StrandContext`] 
| Shared serialising queue used by StrandExecutors to run at most one task at a time&period;
| xref:folly/StrandExecutor.adoc[`StrandExecutor`] 
| Executor that serialises work while delegating execution to a parent executor, sharing a StrandContext to serialise across executors&period;
| xref:folly/StreamHandlerFactory.adoc[`StreamHandlerFactory`] 
| StreamHandlerFactory is a LogHandlerFactory that constructs log handlers that write to stdout or stderr&period;
| xref:folly/StreamingStats.adoc[`StreamingStats`] 
| Robust and efficient online computation of statistics, using Welford&apos;s method for variance&period; https&colon;&sol;&sol;en&period;wikipedia&period;org&sol;wiki&sol;Algorithms&lowbar;for&lowbar;calculating&lowbar;variance&num;Welford&apos;s&lowbar;online&lowbar;algorithm
| xref:folly/StrictConjunction.adoc[`StrictConjunction`] 
| A logical conjunction of traits that evaluates all sub&hyphen;conditions eagerly&period;
| xref:folly/StrictDisjunction.adoc[`StrictDisjunction`] 
| A logical disjunction of traits that evaluates all sub&hyphen;conditions eagerly&period;
| xref:folly/StripedEDFThreadPoolExecutor.adoc[`StripedEDFThreadPoolExecutor`] 
| An approximate implementation of an Earliest Deadline First executor&period;
| xref:folly/StripedPriorityUnboundedBlockingQueue.adoc[`StripedPriorityUnboundedBlockingQueue`] 
| A BlockingQueue sharded by LLC cache&period; Compared to the default PriorityUnboundedBlockingQueue, this can reduce contention on systems with a large number of LLC caches, at the cost of unfairness and work conservation&semi; see the StripedThrottledLifoSem documentation for a detailed explanation&period;
| xref:folly/StripedThrottledLifoSem.adoc[`StripedThrottledLifoSem`] 
| A striped version of ThrottledLifoSem&period;
| xref:folly/StripedThrottledLifoSemBalancer.adoc[`StripedThrottledLifoSemBalancer`] 
| Background balancer that periodically corrects stripe imbalances&period;
| xref:folly/Subprocess.adoc[`Subprocess`] 
| Subprocess&period;
| xref:folly/SubprocessError.adoc[`SubprocessError`] 
| Base exception thrown by the Subprocess methods&period;
| xref:folly/SubprocessSpawnError.adoc[`SubprocessSpawnError`] 
| Exception thrown if the subprocess cannot be started&period;
| xref:folly/SubstringConversionCode.adoc[`SubstringConversionCode`] 
| Error type for trySplitTo(), below&period;
| xref:folly/Synchronized-04.adoc[`Synchronized`] 
| `folly&colon;&colon;Synchronized` pairs a datum with a mutex&period; The datum can only be reached through a `LockedPtr`, typically acquired via `&period;rlock()` or `&period;wlock()`&semi; the mutex is held for the lifetime of the `LockedPtr`&period;
| xref:folly/SynchronizedBase-02.adoc[`SynchronizedBase`] 
| SynchronizedBase is a helper parent class for Synchronized&lt;T&gt;&period;
| xref:folly/SynchronizedPtr.adoc[`SynchronizedPtr`] 
| A `Synchronized` variant that protects a pointed&hyphen;to object&period;
| xref:folly/SynchronizedPtrLockedElement.adoc[`SynchronizedPtrLockedElement`] 
| Holds a lock together with access to the element it protects&period;
| xref:folly/SysAllocator-04.adoc[`SysAllocator`] 
| SysAllocator
| xref:folly/SysArena.adoc[`SysArena`] 
| Arena that uses the system allocator (malloc &sol; free)
| xref:folly/SysBufferDeleter.adoc[`SysBufferDeleter`] 
| Deleter that releases memory with `std&colon;&colon;free`&period;
| xref:folly/TDigest.adoc[`TDigest`] 
| TDigests are a biased quantile estimator designed to estimate the values of the quantiles of streaming data with high accuracy and low memory, particularly for quantiles at the tails (p0&period;1, p1, p99, p99&period;9)&period; See https&colon;&sol;&sol;github&period;com&sol;tdunning&sol;t&hyphen;digest&sol;blob&sol;master&sol;docs&sol;t&hyphen;digest&hyphen;paper&sol;histo&period;pdf for an explanation of what the purpose of TDigests is, and how they work&period;
| xref:folly/TLRefCount.adoc[`TLRefCount`] 
| A reference counter that keeps per&hyphen;thread counts to avoid contention&period;
| xref:folly/TcpInfo.adoc[`TcpInfo`] 
| Abstraction layer for capturing current TCP and congestion control state&period;
| xref:folly/TcpInfoDispatcher.adoc[`TcpInfoDispatcher`] 
| Dispatcher that enables calls to TcpInfo to be intercepted for tests&period;
| xref:folly/TcpInfoDispatcherContainer.adoc[`TcpInfoDispatcherContainer`] 
| Container for folly&colon;&colon;TcpInfoDispatcher&period;
| xref:folly/ThreadCachedArena.adoc[`ThreadCachedArena`] 
| Thread&hyphen;caching arena&colon; allocate memory which gets freed when the arena gets destroyed&period;
| xref:folly/ThreadCachedInt.adoc[`ThreadCachedInt`] 
| A thread&hyphen;safe counter that caches increments in thread&hyphen;local storage&period;
| xref:folly/ThreadFactory.adoc[`ThreadFactory`] 
| Interface for creating threads used by executors&period;
| xref:folly/ThreadIdWorkerProvider.adoc[`ThreadIdWorkerProvider`] 
| WorkerProvider backed by an explicitly maintained set of thread ids&period;
| xref:folly/ThreadLocal-02.adoc[`ThreadLocal`] 
| Thread&hyphen;local storage for a value of type `T`&period;
| xref:folly/ThreadLocalPRNG.adoc[`ThreadLocalPRNG`] 
| A PRNG with one instance per thread&period; This PRNG uses a mersenne twister random number generator and is seeded from &sol;dev&sol;urandom&period; It should not be used for anything which requires security, only for statistical randomness&period;
| xref:folly/ThreadLocalPtr-0c.adoc[`ThreadLocalPtr`] 
| Thread&hyphen;local owning pointer to a value of type `T`&period;
| xref:folly/ThreadPoolExecutor.adoc[`ThreadPoolExecutor`] 
| Base class for implementing threadpool based executors&period;
| xref:folly/ThreadPoolListHook.adoc[`ThreadPoolListHook`] 
| A hook for tracking which threads belong to which thread pools&period; This is used only by a gdb extension to aid in debugging&period; You won&apos;t be able to see any useful information from within C&plus;&plus; code&period;
| xref:folly/ThreadWheelTimekeeper.adoc[`ThreadWheelTimekeeper`] 
| The default Timekeeper implementation which uses a HHWheelTimer on an EventBase in a dedicated thread&period; Users needn&apos;t deal with this directly, it is used by default by Future methods that work with timeouts&period;
| xref:folly/ThreadedExecutor.adoc[`ThreadedExecutor`] 
| &ast; ThreadedExecutor
| xref:folly/ThreadedRepeatingFunctionRunner.adoc[`ThreadedRepeatingFunctionRunner`] 
| For each function `fn` you add to this object, `fn` will be run in a loop in its own thread, with the thread sleeping between invocations of `fn` for the duration returned by `fn`&apos;s previous run&period;
| xref:folly/ThrottledLifoSem.adoc[`ThrottledLifoSem`] 
| ThrottledLifoSem is a semaphore that can wait up to a configurable wakeUpInterval before waking up a sleeping waiter&period; This gives an opportunity to new waiters to consume the posted values, avoiding the overhead of waking up a thread when the already active threads can consume values fast enough, effectively allowing to batch the work&period; The semaphore is &quot;throttled&quot; because sleeping waiters can be awoken at most once every wakeUpInterval&period;
| xref:folly/TimedDrivableExecutor.adoc[`TimedDrivableExecutor`] 
| A DrivableExecutor can be driven via its drive() method or its driveUntil() that drives until some time point&period;
| xref:folly/TimekeeperScheduledExecutor.adoc[`TimekeeperScheduledExecutor`] 
| This class turns a Executor into a ScheduledExecutor&period;
| xref:folly/TimekeeperScheduledExecutorNoTimekeeper.adoc[`TimekeeperScheduledExecutorNoTimekeeper`] 
| Exception thrown when no timekeeper is available for scheduling&period;
| xref:folly/TimeoutManager.adoc[`TimeoutManager`] 
| Base interface to be implemented by all classes expecting to manage timeouts&period; AsyncTimeout will use implementations of this interface to schedule&sol;cancel timeouts&period;
| xref:folly/TimeoutQueue.adoc[`TimeoutQueue`] 
| A queue of scheduled timeout events keyed by expiration time&period;
| xref:folly/TimerFD.adoc[`TimerFD`] 
| 
| xref:folly/TimerFDTimeoutManager.adoc[`TimerFDTimeoutManager`] 
| Manages many timeouts on a single TimerFD&period;
| xref:folly/TimeseriesHistogram.adoc[`TimeseriesHistogram`] 
| TimeseriesHistogram tracks data distributions as they change over time&period;
| xref:folly/TokenBucketPolicyDefault.adoc[`TokenBucketPolicyDefault`] 
| Default policy for the token bucket templates, selecting the alignment, atomic type, clock, and concurrency behavior&period;
| xref:folly/TokenBucketStorage.adoc[`TokenBucketStorage`] 
| Thread&hyphen;safe (atomic) token bucket primitive&period;
| xref:folly/TransparentStringEqualTo.adoc[`TransparentStringEqualTo`] 
| Equality comparator for strings of `CharT` supporting transparent lookup&period;
| xref:folly/TransparentStringHash.adoc[`TransparentStringHash`] 
| Hasher for strings of `CharT` supporting transparent lookup&period;
| xref:folly/Try-06.adoc[`Try`] 
| A wrapper that contains either an instance of `T`, an exception, or nothing&period;
| xref:folly/TryException.adoc[`TryException`] 
| Exception type thrown by `Try` when it is used incorrectly&period;
| xref:folly/TupleHasher-06.adoc[`TupleHasher`] 
| Recursively hashes tuple elements, combining them into a single hash&period;
| xref:folly/TypeError.adoc[`TypeError`] 
| Exception thrown when a dynamic is accessed as the wrong type&period;
| xref:folly/TypedIOBuf.adoc[`TypedIOBuf`] 
| Wrapper class to handle a IOBuf as a typed buffer (to a standard layout class)&period;
| xref:folly/UTF8StringPiece.adoc[`UTF8StringPiece`] 
| A view over a UTF&hyphen;8 string that iterates it as UTF&hyphen;32 code points&period;
| xref:folly/Unaligned.adoc[`Unaligned`] 
| Representation of an unaligned value of a POD type&period;
| xref:folly/UnalignedNoASan.adoc[`UnalignedNoASan`] 
| An Unaligned&lt;T&gt; variant whose loads and stores can have address sanitizer disabled on demand&period;
| xref:folly/UnboundedBlockingQueue.adoc[`UnboundedBlockingQueue`] 
| A blocking queue with unbounded capacity&period;
| xref:folly/UnboundedQueue.adoc[`UnboundedQueue`] 
| UnboundedQueue supports a variety of options for unbounded dynamically expanding an shrinking queues, including variations of&colon; &hyphen; Single vs&period; multiple producers &hyphen; Single vs&period; multiple consumers &hyphen; Blocking vs&period; spin&hyphen;waiting &hyphen; Non&hyphen;waiting, timed, and waiting consumer operations&period; Producer operations never wait or fail (unless out&hyphen;of&hyphen;memory)&period;
| xref:folly/Unexpected-09.adoc[`Unexpected`] 
| Unexpected &hyphen; a helper type used to disambiguate the construction of Expected objects in the error state&period;
| xref:folly/Unit-0d.adoc[`Unit`] 
| In functional programming, the degenerate case is often called &quot;unit&quot;&period; In C&plus;&plus;, &quot;void&quot; is often the best analogue&period; However, because of the syntactic special&hyphen;casing required for void, it is frequently a liability for template metaprogramming&period; So, instead of writing specializations to handle cases like SomeContainer&lt;void&gt;, a library author may instead rule that out and simply have library users use SomeContainer&lt;Unit&gt;&period; Contained values may be ignored&period; Much easier&period;
| xref:folly/Uri.adoc[`Uri`] 
| Class representing a URI&period;
| xref:folly/UserMetric.adoc[`UserMetric`] 
| A single user&hyphen;defined benchmark metric holding a value and its kind&period;
| xref:folly/UsingUninitializedTry.adoc[`UsingUninitializedTry`] 
| Exception thrown when an uninitialized `Try` is accessed&period;
| xref:folly/VirtualEventBase.adoc[`VirtualEventBase`] 
| Light&hyphen;weight view onto an existing EventBase&period;
| xref:folly/VirtualExecutor.adoc[`VirtualExecutor`] 
| VirtualExecutor implements a light&hyphen;weight view onto existing Executor&period;
| xref:folly/WTCallback.adoc[`WTCallback`] 
| Callback object for `HHWheelTimer` that fulfills a future on timeout&period;
| xref:folly/WaitOptions.adoc[`WaitOptions`] 
| WaitOptions
| xref:folly/WeightedEvictingCacheMap.adoc[`WeightedEvictingCacheMap`] 
| A variant of EvictingCacheMap that tracks weights for entries and evicts entries in LRU order to ensure the total weight of all entries stays below some set maximum&period; Weights are stored as a size&lowbar;t with each entry&period;
| xref:folly/WorkerProvider.adoc[`WorkerProvider`] 
| WorkerProvider is a simple interface that can be used to collect information about worker threads that are pulling work from a given queue&period;
| xref:folly/WriteCallbackWithState.adoc[`WriteCallbackWithState`] 
| Wrapper class for WriteCallback that includes a boolean variable to track whether the write has already started or not
| xref:folly/WriteChainAsyncTransportWrapper.adoc[`WriteChainAsyncTransportWrapper`] 
| Helper class that redirects write() and writev() calls to writeChain()&period;
| xref:folly/WriteFileAtomicOptions.adoc[`WriteFileAtomicOptions`] 
| Options controlling the behavior of writeFileAtomic()&period;
| xref:folly/WriteSqe.adoc[`WriteSqe`] 
| 
| xref:folly/XlogCategoryInfo-0e.adoc[`XlogCategoryInfo`] 
| Per&hyphen;XLOG()&hyphen;statement storage for the resolved log category&period;
| xref:folly/XlogFileScopeInfo.adoc[`XlogFileScopeInfo`] 
| File&hyphen;scope cache of the log level and category shared by a `&period;cpp` file&period;
| xref:folly/XlogLevelInfo-0d.adoc[`XlogLevelInfo`] 
| A file&hyphen;static XlogLevelInfo and XlogCategoryInfo object is declared for each XLOG() statement&period;
| xref:folly/adopt_lock_state_t.adoc[`adopt&lowbar;lock&lowbar;state&lowbar;t`] 
| Tag type indicating that a lock transition should adopt existing lock state&period;
| xref:folly/aligned.adoc[`aligned`] 
| A wrapper that stores a value of type T with at least the given alignment&period;
| xref:folly/allocator_delete.adoc[`allocator&lowbar;delete`] 
| allocator&lowbar;delete
| xref:folly/annotate_ignore_thread_sanitizer_guard.adoc[`annotate&lowbar;ignore&lowbar;thread&lowbar;sanitizer&lowbar;guard`] 
| Scoped guard that suppresses ThreadSanitizer reports within its lifetime&period;
| xref:folly/any_badge.adoc[`any&lowbar;badge`] 
| For cases when multiple badge holders need to call a function we can use folly&colon;&colon;any&lowbar;badge over each individual holder allowed&period; We allow subsets of badges to lift into supersets&colon; folly&colon;&colon;any&lowbar;badge[ lifts into folly&colon;&colon;any&lowbar;badge[&period;]]
| xref:folly/asymmetric_thread_fence_traits-08.adoc[`asymmetric&lowbar;thread&lowbar;fence&lowbar;traits`] 
| Traits providing the asymmetric fence callables for an atomic template&period;
| xref:folly/atomic_grow_array.adoc[`atomic&lowbar;grow&lowbar;array`] 
| atomic&lowbar;grow&lowbar;array
| xref:folly/atomic_grow_array_policy_default.adoc[`atomic&lowbar;grow&lowbar;array&lowbar;policy&lowbar;default`] 
| atomic&lowbar;grow&lowbar;array&lowbar;policy&lowbar;default
| xref:folly/atomic_ref-09.adoc[`atomic&lowbar;ref`] 
| A reference wrapper offering atomic operations on a non&hyphen;atomic object&period;
| xref:folly/atomic_shared_ptr-07.adoc[`atomic&lowbar;shared&lowbar;ptr`] 
| Atomic wrapper around std&colon;&colon;shared&lowbar;ptr providing lock&hyphen;free style operations&period;
| xref:folly/atomic_thread_fence_traits-0a.adoc[`atomic&lowbar;thread&lowbar;fence&lowbar;traits`] 
| Trait giving the thread&hyphen;fence function for an atomic template&period;
| xref:folly/atomic_value_type.adoc[`atomic&lowbar;value&lowbar;type`] 
| Trait giving the effective value type of an atomic&hyphen;like type&period;
| xref:folly/badge.adoc[`badge`] 
| Badge pattern allows us to abstract over friend classes and make friend feature more scoped&period; Using this simple technique we can specify a badge tag on specific functions we want to gate for particular caller contexts (badge holders)&period; Badge can only be constructed by the specified badge holder binding the tagged functions to that call site&period;
| xref:folly/base64_decode_error.adoc[`base64&lowbar;decode&lowbar;error`] 
| Exception thrown when base64 decoding fails&period;
| xref:folly/base64_decode_result.adoc[`base64&lowbar;decode&lowbar;result`] 
| Result of a low&hyphen;level base64 decode operation&period;
| xref:folly/basic_cstring_view.adoc[`basic&lowbar;cstring&lowbar;view`] 
| cstring&lowbar;view
| xref:folly/basic_fbstring.adoc[`basic&lowbar;fbstring`] 
| This is the basic&lowbar;string replacement&period; For conformity, basic&lowbar;fbstring takes the same template parameters, plus the last one which is the core&period;
| xref:folly/basic_once_flag.adoc[`basic&lowbar;once&lowbar;flag`] 
| The flag template to be used with call&lowbar;once&period; Parameterizable by the mutex type and atomic template&period; The mutex type is required to mimic std&colon;&colon;mutex and the atomic type is required to mimic std&colon;&colon;atomic&period;
| xref:folly/c_array.adoc[`c&lowbar;array`] 
| A container for C arrays, for returning non&hyphen;zero&hyphen;sized C arrays from constexpr functions&period;
| xref:folly/cacheline_align_t.adoc[`cacheline&lowbar;align&lowbar;t`] 
| An empty type aligned to cacheline&lowbar;align&lowbar;v&period;
| xref:folly/cli_apply_args_files_error.adoc[`cli&lowbar;apply&lowbar;args&lowbar;files&lowbar;error`] 
| Exception thrown by the simple cli&lowbar;apply&lowbar;args&lowbar;files overload&period;
| xref:folly/cli_apply_args_files_options.adoc[`cli&lowbar;apply&lowbar;args&lowbar;files&lowbar;options`] 
| Options controlling args&hyphen;file expansion&period;
| xref:folly/cli_apply_args_files_receiver.adoc[`cli&lowbar;apply&lowbar;args&lowbar;files&lowbar;receiver`] 
| Callback interface receiving events while expanding args&hyphen;files&period;
| xref:folly/coded_rich_error.adoc[`coded&lowbar;rich&lowbar;error`] 
| Start with the user docs in `docs&sol;rich&lowbar;error&lowbar;code&period;md`&period;
| xref:folly/compact_once_flag.adoc[`compact&lowbar;once&lowbar;flag`] 
| An alternative flag that can be used with call&lowbar;once that uses only 1 byte&period; Uses a 3&hyphen;state std&colon;&colon;atomic&lt;uint8&lowbar;t&gt; with wait&sol;notify for synchronization&period;
| xref:folly/compare_equal_to-0a.adoc[`compare&lowbar;equal&lowbar;to`] 
| Comparison predicate that is true when the underlying comparator `C` reports the two operands as equal&period;
| xref:folly/compare_greater-0a.adoc[`compare&lowbar;greater`] 
| Comparison predicate that is true when the underlying comparator `C` reports the left operand as greater than the right operand&period;
| xref:folly/compare_greater_equal-07.adoc[`compare&lowbar;greater&lowbar;equal`] 
| Comparison predicate that is true when the underlying comparator `C` reports the left operand as greater than or equal to the right operand&period;
| xref:folly/compare_less-0e.adoc[`compare&lowbar;less`] 
| Comparison predicate that is true when the underlying comparator `C` reports the left operand as less than the right operand&period;
| xref:folly/compare_less_equal-06.adoc[`compare&lowbar;less&lowbar;equal`] 
| Comparison predicate that is true when the underlying comparator `C` reports the left operand as less than or equal to the right operand&period;
| xref:folly/compare_not_equal_to-01.adoc[`compare&lowbar;not&lowbar;equal&lowbar;to`] 
| Comparison predicate that is true when the underlying comparator `C` reports the two operands as not equal&period;
| xref:folly/const_dynamic_view.adoc[`const&lowbar;dynamic&lowbar;view`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/constexpr_iterated_squares_desc.adoc[`constexpr&lowbar;iterated&lowbar;squares&lowbar;desc`] 
| constexpr&lowbar;iterated&lowbar;squares&lowbar;desc
| xref:folly/custom_stop_watch.adoc[`custom&lowbar;stop&lowbar;watch`] 
| Calculates the duration of time intervals&period; Prefer this over directly using monotonic clocks&period; It is very lightweight and provides convenient facilities to avoid common pitfalls&period;
| xref:folly/default_null_handler.adoc[`default&lowbar;null&lowbar;handler`] 
| Default policy handling null&hyphen;pointer violations for not&lowbar;null&period;
| xref:folly/drop_unit-03.adoc[`drop&lowbar;unit`] 
| Maps a type to itself, and maps Unit back to `void`&period;
| xref:folly/dummy_fbstring_core.adoc[`dummy&lowbar;fbstring&lowbar;core`] 
| Dummy fbstring core that uses an actual std&colon;&colon;string&period; This doesn&apos;t make any sense &hyphen; it&apos;s just for testing purposes&period;
| xref:folly/dynamic.adoc[`dynamic`] 
| Forward declaration of folly&colon;&colon;dynamic used for serializing results&period;
| xref:folly/dynamic_view.adoc[`dynamic&lowbar;view`] 
| A mutable view of a dynamic that can extract values without copying&period;
| xref:folly/emplace_args.adoc[`emplace&lowbar;args`] 
| Argument tuple for variadic emplace&sol;constructor calls&period; Stores arguments by (decayed) value&period; Restores original argument types with reference qualifiers and adornments at unpack time to emulate perfect forwarding&period;
| xref:folly/empty_try_as_error_t.adoc[`empty&lowbar;try&lowbar;as&lowbar;error&lowbar;t`] 
| Empty&hyphen;`Try` policy type that maps the empty state to an error `result`&period;
| xref:folly/empty_try_with.adoc[`empty&lowbar;try&lowbar;with`] 
| Empty&hyphen;`Try` policy that produces a `result` by invoking a callable&period;
| xref:folly/epoll_event.adoc[`epoll&lowbar;event`] 
| 
| xref:folly/error_or_stopped.adoc[`error&lowbar;or&lowbar;stopped`] 
| Holds an error (`std&colon;&colon;exception&lowbar;ptr`) or a &quot;stopped&quot;&sol;cancellation state&period;
| xref:folly/exception_shared_string.adoc[`exception&lowbar;shared&lowbar;string`] 
| An immutable refcounted string suitable for use in an exception&period;
| xref:folly/exception_wrapper.adoc[`exception&lowbar;wrapper`] 
| Throwing exceptions can be a convenient way to handle errors&period; Storing exceptions in an `exception&lowbar;ptr` makes it easy to handle exceptions in a different thread or at a later time&period; `exception&lowbar;ptr` can also be used in a very generic result&sol;exception wrapper&period;
| xref:folly/factory_constructor_t.adoc[`factory&lowbar;constructor&lowbar;t`] 
| Tag type selecting the factory constructor of `Indestructible`&period;
| xref:folly/fbstring_core.adoc[`fbstring&lowbar;core`] 
| This is the core of the string&period; The code should work on 32&hyphen; and 64&hyphen;bit and both big&hyphen; and little&hyphen;endian architectures with any Char size&period;
| xref:folly/fbvector-04.adoc[`fbvector`] 
| Forward declaration of the fbvector container&period;
| xref:folly/floating_point_integral_constant.adoc[`floating&lowbar;point&lowbar;integral&lowbar;constant`] 
| floating&lowbar;point&lowbar;integral&lowbar;constant
| xref:folly/fmt_vformat_mangle_format_string_fn.adoc[`fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string&lowbar;fn`] 
| fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string&lowbar;fn fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string
| xref:folly/format_string_for_each_named_arg_fn.adoc[`format&lowbar;string&lowbar;for&lowbar;each&lowbar;named&lowbar;arg&lowbar;fn`] 
| Callable that invokes a function for each named argument in a format string&period;
| xref:folly/function_like_value.adoc[`function&lowbar;like&lowbar;value`] 
| Transports the cvref&hyphen;qualifications of `Src` onto the function type `Dst`&period;
| xref:folly/function_remove_cvref.adoc[`function&lowbar;remove&lowbar;cvref`] 
| Yields the function type `F` stripped of its cvref&hyphen;qualifications&period;
| xref:folly/function_traits-05.adoc[`function&lowbar;traits`] 
| Discovers every fact of a function type `S` as types or constexpr values&period;
| xref:folly/get_exception_tag_t.adoc[`get&lowbar;exception&lowbar;tag&lowbar;t`] 
| get&lowbar;exception&lowbar;tag&lowbar;t
| xref:folly/get_rich_error_code_fn.adoc[`get&lowbar;rich&lowbar;error&lowbar;code&lowbar;fn`] 
| Retrieves the rich error code associated with an error&period;
| xref:folly/guaranteed_not_null_provider.adoc[`guaranteed&lowbar;not&lowbar;null&lowbar;provider`] 
| Base that grants trusted subclasses a token to bypass null checks&period;
| xref:folly/hash_counter_engine.adoc[`hash&lowbar;counter&lowbar;engine`] 
| hash&lowbar;counter&lowbar;engine
| xref:folly/hasher-010.adoc[`hasher`] 
| Primary template for folly&apos;s per&hyphen;type hasher&semi; specialized for supported key types&period;
| xref:folly/hazptr_array.adoc[`hazptr&lowbar;array`] 
| hazptr&lowbar;array
| xref:folly/hazptr_deleter-01.adoc[`hazptr&lowbar;deleter`] 
| hazptr&lowbar;deleter
| xref:folly/hazptr_domain.adoc[`hazptr&lowbar;domain`] 
| hazptr&lowbar;domain
| xref:folly/hazptr_holder.adoc[`hazptr&lowbar;holder`] 
| hazptr&lowbar;holder
| xref:folly/hazptr_local.adoc[`hazptr&lowbar;local`] 
| Grants hazptr&lowbar;local access to the thread cache internals&period;
| xref:folly/hazptr_obj.adoc[`hazptr&lowbar;obj`] 
| hazptr&lowbar;obj
| xref:folly/hazptr_obj_base.adoc[`hazptr&lowbar;obj&lowbar;base`] 
| hazptr&lowbar;obj&lowbar;base
| xref:folly/hazptr_obj_base_linked.adoc[`hazptr&lowbar;obj&lowbar;base&lowbar;linked`] 
| hazptr&lowbar;obj&lowbar;base&lowbar;linked
| xref:folly/hazptr_obj_cohort.adoc[`hazptr&lowbar;obj&lowbar;cohort`] 
| hazptr&lowbar;obj&lowbar;cohort
| xref:folly/hazptr_obj_linked.adoc[`hazptr&lowbar;obj&lowbar;linked`] 
| hazptr&lowbar;obj&lowbar;linked
| xref:folly/hazptr_obj_list.adoc[`hazptr&lowbar;obj&lowbar;list`] 
| hazptr&lowbar;obj&lowbar;list
| xref:folly/hazptr_obj_retired_list.adoc[`hazptr&lowbar;obj&lowbar;retired&lowbar;list`] 
| hazptr&lowbar;obj&lowbar;retired&lowbar;list
| xref:folly/hazptr_rec.adoc[`hazptr&lowbar;rec`] 
| hazptr&lowbar;rec&colon;
| xref:folly/hazptr_root.adoc[`hazptr&lowbar;root`] 
| hazptr&lowbar;root
| xref:folly/hazptr_tc.adoc[`hazptr&lowbar;tc`] 
| hazptr&lowbar;tc&colon;
| xref:folly/hazptr_tc_entry.adoc[`hazptr&lowbar;tc&lowbar;entry`] 
| hazptr&lowbar;tc&lowbar;entry
| xref:folly/hazptr_tc_tls_tag.adoc[`hazptr&lowbar;tc&lowbar;tls&lowbar;tag`] 
| Tag type identifying the hazard pointer thread cache&apos;s thread&hyphen;local singleton&period;
| xref:folly/heap_vector_map.adoc[`heap&lowbar;vector&lowbar;map`] 
| A heap&lowbar;vector&lowbar;map based on heap layout&period;
| xref:folly/heap_vector_set.adoc[`heap&lowbar;vector&lowbar;set`] 
| heap&lowbar;vector&lowbar;set is a specialization of heap&lowbar;vector&lowbar;container
| xref:folly/hybrid_lock-05.adoc[`hybrid&lowbar;lock`] 
| A lock&hyphen;holder type which holds shared locks for shared mutex types or exclusive locks otherwise&period;
| xref:folly/hybrid_lock_base.adoc[`hybrid&lowbar;lock&lowbar;base`] 
| A lock&hyphen;holder base which holds shared locks for shared mutex types or exclusive locks otherwise&period;
| xref:folly/hybrid_lock_guard-02.adoc[`hybrid&lowbar;lock&lowbar;guard`] 
| For shared mutex types, effectively `shared&lowbar;lock&lowbar;guard`&semi; otherwise, effectively `unique&lowbar;lock&lowbar;guard`&period;
| xref:folly/immortal_rich_error_t.adoc[`immortal&lowbar;rich&lowbar;error&lowbar;t`] 
| A rich error whose storage has static (immortal) lifetime&period;
| xref:folly/index_iterator.adoc[`index&lowbar;iterator`] 
| index&lowbar;iterator
| xref:folly/indirect-09.adoc[`indirect`] 
| indirect
| xref:folly/inheriting_coded_rich_error.adoc[`inheriting&lowbar;coded&lowbar;rich&lowbar;error`] 
| inheriting&lowbar;coded&lowbar;rich&lowbar;error
| xref:folly/initlist_construct_t.adoc[`initlist&lowbar;construct&lowbar;t`] 
| Initializer lists are a powerful compile time syntax introduced in C&plus;&plus;11 but due to their often conflicting syntax they are not used by APIs for construction&period;
| xref:folly/invoke_first_match.adoc[`invoke&lowbar;first&lowbar;match`] 
| Composite invoker delegating to the first invoker matching the call&period;
| xref:folly/invoke_member_wrapper_fn-0b.adoc[`invoke&lowbar;member&lowbar;wrapper&lowbar;fn`] 
| Wraps a callable made via `FOLLY&lowbar;INVOKE&lowbar;MEMBER` so it is recognizable&period;
| xref:folly/invoke_traits.adoc[`invoke&lowbar;traits`] 
| Traits container mimicking the C&plus;&plus;17 invocation traits for invoker `I`&period;
| xref:folly/io_uring.adoc[`io&lowbar;uring`] 
| 
| xref:folly/io_uring_buf.adoc[`io&lowbar;uring&lowbar;buf`] 
| 
| xref:folly/io_uring_buf_ring.adoc[`io&lowbar;uring&lowbar;buf&lowbar;ring`] 
| 
| xref:folly/io_uring_cqe.adoc[`io&lowbar;uring&lowbar;cqe`] 
| 
| xref:folly/io_uring_zcrx_cqe.adoc[`io&lowbar;uring&lowbar;zcrx&lowbar;cqe`] 
| 
| xref:folly/isTry-03.adoc[`isTry`] 
| Trait that detects whether a type is a `Try`&period;
| xref:folly/is_allocator.adoc[`is&lowbar;allocator`] 
| A trait type to test whether a type is an allocator&period;
| xref:folly/is_arithmetic-02.adoc[`is&lowbar;arithmetic`] 
| A trait type that is true when T is an arithmetic type&period;
| xref:folly/is_bounded_array.adoc[`is&lowbar;bounded&lowbar;array`] 
| A type to check if a given type is a bounded array&period;
| xref:folly/is_complete.adoc[`is&lowbar;complete`] 
| is&lowbar;complete is&lowbar;complete&lowbar;v
| xref:folly/is_constexpr_default_constructible.adoc[`is&lowbar;constexpr&lowbar;default&lowbar;constructible`] 
| A type which determines whether the type parameter is constexpr default&hyphen;constructible&period;
| xref:folly/is_detected.adoc[`is&lowbar;detected`] 
| A trait type to test whether a metafunction succeeds in substitution&period;
| xref:folly/is_heap_vector_map.adoc[`is&lowbar;heap&lowbar;vector&lowbar;map`] 
| Trait that reports whether T is an instantiation of heap&lowbar;vector&lowbar;map&period;
| xref:folly/is_heap_vector_set.adoc[`is&lowbar;heap&lowbar;vector&lowbar;set`] 
| Trait that reports whether T is an instantiation of heap&lowbar;vector&lowbar;set&period;
| xref:folly/is_instantiation_of.adoc[`is&lowbar;instantiation&lowbar;of`] 
| A type to check if a given type is an instantiation of a class template&period;
| xref:folly/is_integral-02.adoc[`is&lowbar;integral`] 
| A trait type that is true when T is an integral type&period;
| xref:folly/is_invocable.adoc[`is&lowbar;invocable`] 
| Trait testing whether `F` is invocable with `A&period;&period;&period;`&semi; mimics std&colon;&colon;is&lowbar;invocable&period;
| xref:folly/is_invocable_r.adoc[`is&lowbar;invocable&lowbar;r`] 
| Trait testing whether the result of invoking `F` is convertible to `R`&semi; mimics std&colon;&colon;is&lowbar;invocable&lowbar;r&period;
| xref:folly/is_non_bool_integral.adoc[`is&lowbar;non&lowbar;bool&lowbar;integral`] 
| A trait type that is true when Int is integral but not bool&period;
| xref:folly/is_nothrow_invocable.adoc[`is&lowbar;nothrow&lowbar;invocable`] 
| Trait testing whether `F` is nothrow&hyphen;invocable with `A&period;&period;&period;`&semi; mimics std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&period;
| xref:folly/is_nothrow_invocable_r.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r`] 
| Trait testing the nothrow invocation of `F` with result convertible to `R`&semi; mimics std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r&period;
| xref:folly/is_nothrow_tag_invocable.adoc[`is&lowbar;nothrow&lowbar;tag&lowbar;invocable`] 
| Trait testing whether the `tag&lowbar;invoke` CPO is nothrow&hyphen;invocable&period;
| xref:folly/is_result-04.adoc[`is&lowbar;result`] 
| Type trait to test if a type is a `result`&period;
| xref:folly/is_signed-05.adoc[`is&lowbar;signed`] 
| A trait type that is true when T is a signed type&period;
| xref:folly/is_small_sorted_vector_map.adoc[`is&lowbar;small&lowbar;sorted&lowbar;vector&lowbar;map`] 
| Trait that detects a small&lowbar;sorted&lowbar;vector&lowbar;map specialization&period;
| xref:folly/is_small_sorted_vector_set.adoc[`is&lowbar;small&lowbar;sorted&lowbar;vector&lowbar;set`] 
| Trait that detects a small&lowbar;sorted&lowbar;vector&lowbar;set specialization&period;
| xref:folly/is_small_vector-08.adoc[`is&lowbar;small&lowbar;vector`] 
| Trait that detects whether a type is a folly&colon;&colon;small&lowbar;vector&period;
| xref:folly/is_sorted_vector_map.adoc[`is&lowbar;sorted&lowbar;vector&lowbar;map`] 
| Trait that detects a sorted&lowbar;vector&lowbar;map specialization&period;
| xref:folly/is_sorted_vector_set.adoc[`is&lowbar;sorted&lowbar;vector&lowbar;set`] 
| Trait that detects a sorted&lowbar;vector&lowbar;set specialization&period;
| xref:folly/is_tag_invocable.adoc[`is&lowbar;tag&lowbar;invocable`] 
| Trait testing whether the `tag&lowbar;invoke` CPO can be invoked with `Tag` and `Args`&period;
| xref:folly/is_transparent.adoc[`is&lowbar;transparent`] 
| A trait type to test whether a type follows the is&hyphen;transparent protocol&period;
| xref:folly/is_unbounded_array.adoc[`is&lowbar;unbounded&lowbar;array`] 
| A type to check if a given type is an unbounded array&period;
| xref:folly/is_unsigned-06.adoc[`is&lowbar;unsigned`] 
| A trait type that is true when T is an unsigned type&period;
| xref:folly/json_patch.adoc[`json&lowbar;patch`] 
| A parsed JSON Patch document, as described in RFC 6902 &quot;JSON Patch&quot;&period;
| xref:folly/json_pointer.adoc[`json&lowbar;pointer`] 
| A parsed JSON Pointer, as described in RFC 6901 &quot;JSON Pointer&quot;&period;
| xref:folly/kahan_accumulator.adoc[`kahan&lowbar;accumulator`] 
| Kahan (Kahan&hyphen;Babushka&hyphen;Neumaier) compensated summation accumulator&period;
| xref:folly/lift_unit-07.adoc[`lift&lowbar;unit`] 
| Maps a type to itself, and maps `void` to Unit&period;
| xref:folly/like.adoc[`like`] 
| A trait to replace the cvref category of `Dst` with that of `Src`&period;
| xref:folly/literal_c_str.adoc[`literal&lowbar;c&lowbar;str`] 
| literal&lowbar;c&lowbar;str
| xref:folly/literal_string.adoc[`literal&lowbar;string`] 
| literal&lowbar;string
| xref:folly/make_signed-0c.adoc[`make&lowbar;signed`] 
| A trait that yields the signed integer type corresponding to T&period;
| xref:folly/make_unsigned-01.adoc[`make&lowbar;unsigned`] 
| A trait that yields the unsigned integer type corresponding to T&period;
| xref:folly/manual_safe_callable_t.adoc[`manual&lowbar;safe&lowbar;callable&lowbar;t`] 
| A callable wrapper that manually asserts the `safe&lowbar;alias` level `S`&period;
| xref:folly/manual_safe_ref_t.adoc[`manual&lowbar;safe&lowbar;ref&lowbar;t`] 
| A reference wrapper that manually asserts the `safe&lowbar;alias` level `S`&period;
| xref:folly/manual_safe_val_t.adoc[`manual&lowbar;safe&lowbar;val&lowbar;t`] 
| A value wrapper that manually asserts the `safe&lowbar;alias` level `S`&period;
| xref:folly/max_align_t.adoc[`max&lowbar;align&lowbar;t`] 
| A type aligned at least as strictly as the most&hyphen;aligned fundamental type&period;
| xref:folly/member_pointer_traits-00.adoc[`member&lowbar;pointer&lowbar;traits`] 
| member&lowbar;pointer&lowbar;traits
| xref:folly/nestable_coded_rich_error.adoc[`nestable&lowbar;coded&lowbar;rich&lowbar;error`] 
| nestable&lowbar;coded&lowbar;rich&lowbar;error
| xref:folly/nonesuch.adoc[`nonesuch`] 
| nonesuch
| xref:folly/not_null-07.adoc[`not&lowbar;null`] 
| not&lowbar;null specializable class&period;
| xref:folly/not_null_base.adoc[`not&lowbar;null&lowbar;base`] 
| not&lowbar;null&lowbar;base, the common interface for all not&lowbar;null subclasses&period; &hyphen; Implicitly constructs and casts just like a PtrT&period; &hyphen; Has unwrap() function to access the underlying PtrT&period;
| xref:folly/or_unwind-02e.adoc[`or&lowbar;unwind`] 
| Awaitable that unwinds a `result` on the error path, holding a reference&period;
| xref:folly/or_unwind_owning-0f.adoc[`or&lowbar;unwind&lowbar;owning`] 
| Awaitable that unwinds an owned `result` on the error path&period;
| xref:folly/order_preserving_reinsertion_view_fn.adoc[`order&lowbar;preserving&lowbar;reinsertion&lowbar;view&lowbar;fn`] 
| Extension point yielding an order&hyphen;preserving reinsertion view of a container&period;
| xref:folly/order_preserving_reinsertion_view_or_default_fn.adoc[`order&lowbar;preserving&lowbar;reinsertion&lowbar;view&lowbar;or&lowbar;default&lowbar;fn`] 
| Extension point returning a reinsertion view or the argument itself&period;
| xref:folly/partial_ordering.adoc[`partial&lowbar;ordering`] 
| mimic&colon; std&colon;&colon;partial&lowbar;ordering, c&plus;&plus;20 (partial)
| xref:folly/propagate_const.adoc[`propagate&lowbar;const`] 
| A const&hyphen;propagating wrapper around a pointer&hyphen;like type&period;
| xref:folly/rcu_domain.adoc[`rcu&lowbar;domain`] 
| Defines an RCU domain that scopes readers and updaters together&period;
| xref:folly/rcu_obj_base.adoc[`rcu&lowbar;obj&lowbar;base`] 
| Base class giving derived objects preallocated RCU retirement storage&period;
| xref:folly/reentrant_allocator.adoc[`reentrant&lowbar;allocator`] 
| A reentrant mmap&hyphen;based allocator&period;
| xref:folly/reentrant_allocator_options.adoc[`reentrant&lowbar;allocator&lowbar;options`] 
| Configuration options for `reentrant&lowbar;allocator`&period;
| xref:folly/relaxed_atomic-0f.adoc[`relaxed&lowbar;atomic`] 
| Like `std&colon;&colon;atomic`, but without the `std&colon;&colon;memory&lowbar;order` parameters on any member function&period;
| xref:folly/remove_cvref.adoc[`remove&lowbar;cvref`] 
| A type trait to remove all const volatile and reference qualifiers on a type T
| xref:folly/reproducible_accumulator-07.adoc[`reproducible&lowbar;accumulator`] 
| Reproducible floating&hyphen;point accumulator via binned floating&hyphen;point arithmetic&period;
| xref:folly/reproducible_accumulator-06.adoc[`reproducible&lowbar;accumulator`] 
| Reproducible floating&hyphen;point accumulator via binned floating&hyphen;point arithmetic&period;
| xref:folly/result-06.adoc[`result`] 
| A value, an error (`std&colon;&colon;exception&lowbar;ptr`), or a &quot;stopped&quot;&sol;cancellation state&period;
| xref:folly/rich_error.adoc[`rich&lowbar;error`] 
| A rich error carrying a user&hyphen;defined base type and a formatted message&period;
| xref:folly/rich_error_base.adoc[`rich&lowbar;error&lowbar;base`] 
| Base class for exceptions that carry a queryable rich error code&period;
| xref:folly/rich_error_bases_and_own_codes.adoc[`rich&lowbar;error&lowbar;bases&lowbar;and&lowbar;own&lowbar;codes`] 
| Aggregates a rich error&apos;s base types with the codes it owns&period;
| xref:folly/rich_error_code-08.adoc[`rich&lowbar;error&lowbar;code`] 
| Maps an error&hyphen;code enum onto the rich&hyphen;error machinery&period;
| xref:folly/rich_error_code_query.adoc[`rich&lowbar;error&lowbar;code&lowbar;query`] 
| Query object used to retrieve the rich error code from an exception&period;
| xref:folly/rich_exception_ptr.adoc[`rich&lowbar;exception&lowbar;ptr`] 
| `rich&lowbar;exception&lowbar;ptr` is an analog of `exception&lowbar;wrapper` or `std&colon;&colon;exception&lowbar;ptr`, with some extra efficiency optimizations, and integration with `rich&lowbar;error` &sol; `epitaph`&period; It was designed to support rich&hyphen;error features in `result&period;h`&period;
| xref:folly/rich_msg.adoc[`rich&lowbar;msg`] 
| A message that can automatically capture source locations&period;
| xref:folly/rich_ptr_to_underlying_error.adoc[`rich&lowbar;ptr&lowbar;to&lowbar;underlying&lowbar;error`] 
| Quacks like `Ex&ast;`, but shows an epitaph stack when formatted&period;
| xref:folly/rvalue_reference_wrapper.adoc[`rvalue&lowbar;reference&lowbar;wrapper`] 
| Class template that wraps a reference to an rvalue&period; Similar to std&colon;&colon;reference&lowbar;wrapper but with three important differences&colon;
| xref:folly/safe_alias_of-0c.adoc[`safe&lowbar;alias&lowbar;of`] 
| Primary trait template that measures the `safe&lowbar;alias` level of a type&period;
| xref:folly/safe_alias_of_pack.adoc[`safe&lowbar;alias&lowbar;of&lowbar;pack`] 
| Computes the `safe&lowbar;alias` level of a composite type&period;
| xref:folly/shared_from_this_ptr.adoc[`shared&lowbar;from&lowbar;this&lowbar;ptr`] 
| shared&lowbar;from&lowbar;this&lowbar;ptr
| xref:folly/shared_lock_base.adoc[`shared&lowbar;lock&lowbar;base`] 
| A lock&hyphen;holder base which holds shared locks, usable with any shared mutex&period;
| xref:folly/shared_lock_guard.adoc[`shared&lowbar;lock&lowbar;guard`] 
| A lock&hyphen;guard which holds shared locks, usable with any shared mutex type&period;
| xref:folly/small_heap_vector_map.adoc[`small&lowbar;heap&lowbar;vector&lowbar;map`] 
| Specialize heap&lowbar;vector&lowbar;map to integral key type and std&colon;&colon;less comparaison&period; small&lowbar;heap&lowbar;map achieve a very fast find for small map &lt; 200 elements&period;
| xref:folly/small_vector.adoc[`small&lowbar;vector`] 
| Forward declaration of the small&lowbar;vector container&period;
| xref:folly/sorted_equivalent_t.adoc[`sorted&lowbar;equivalent&lowbar;t`] 
| Tag type indicating a container is sorted but not necessarily unique&period;
| xref:folly/sorted_unique_t.adoc[`sorted&lowbar;unique&lowbar;t`] 
| Tag type indicating a container is sorted and unique&period;
| xref:folly/sorted_vector_map.adoc[`sorted&lowbar;vector&lowbar;map`] 
| A sorted&lowbar;vector&lowbar;map is similar to a sorted&lowbar;vector&lowbar;set but stores &lt;key,value&gt; pairs instead of single elements&period;
| xref:folly/sorted_vector_set.adoc[`sorted&lowbar;vector&lowbar;set`] 
| A sorted&lowbar;vector&lowbar;set is a container similar to std&colon;&colon;set&lt;&gt;, but implemented as a sorted array with std&colon;&colon;vector&lt;&gt;&period;
| xref:folly/splitmix64_engine.adoc[`splitmix64&lowbar;engine`] 
| splitmix64&lowbar;engine
| xref:folly/static_function_deleter.adoc[`static&lowbar;function&lowbar;deleter`] 
| static&lowbar;function&lowbar;deleter
| xref:folly/stopped_result_t.adoc[`stopped&lowbar;result&lowbar;t`] 
| Tag type signaling that a work&hyphen;tree was stopped (aka cancelled)&period;
| xref:folly/strong.adoc[`strong`] 
| `strong&lt;T, Tag&gt;` &hyphen; prevent accidental mixing of semantically different uses of the same underlying type&period; Known as &quot;newtype&quot; in some languages&period; C&plus;&plus;20&period; Default&hyphen;construction value&hyphen;initializes `T`, even if it&apos;s a primitive type&period;
| xref:folly/strong_derefable.adoc[`strong&lowbar;derefable`] 
| `strong&lowbar;derefable&lt;T, Tag&gt;` &hyphen; a strong type with pointer&hyphen;like dereference operators&period; Inherits all functionality from `strong` and adds `operator&ast;` and `operator&hyphen;&gt;` for convenient access to the underlying value&period; Usage&colon;
| xref:folly/tag_invoke_result.adoc[`tag&lowbar;invoke&lowbar;result`] 
| Holds the result type of a valid `tag&lowbar;invoke` call, or is empty otherwise&period;
| xref:folly/tag_t.adoc[`tag&lowbar;t`] 
| tag&lowbar;t tag
| xref:folly/tape.adoc[`tape`] 
| A container adapter that builds a version of `vector&lt;vector&gt;` on top of a random access underlying container&period;
| xref:folly/thread_cached_synchronized.adoc[`thread&lowbar;cached&lowbar;synchronized`] 
| A synchronized value with a per&hyphen;thread cache for accelerated reads&period;
| xref:folly/to_ascii_alphabet.adoc[`to&lowbar;ascii&lowbar;alphabet`] 
| Alphabet mapping a digit value to its ASCII character, lower&hyphen; or upper&hyphen;case&period;
| xref:folly/to_floating_point_convertible.adoc[`to&lowbar;floating&lowbar;point&lowbar;convertible`] 
| Holds an integral value for conversion to a floating&hyphen;point target type&period;
| xref:folly/to_integral_convertible.adoc[`to&lowbar;integral&lowbar;convertible`] 
| Holds a floating&hyphen;point value for conversion to an integral target type&period;
| xref:folly/to_narrow_convertible.adoc[`to&lowbar;narrow&lowbar;convertible`] 
| Holds an integral value for possibly&hyphen;narrowing conversion to a target type&period;
| xref:folly/transparent.adoc[`transparent`] 
| Adapter that marks a type as transparent for heterogeneous lookup&period;
| xref:folly/uint_division_result.adoc[`uint&lowbar;division&lowbar;result`] 
| uint&lowbar;division&lowbar;result
| xref:folly/uint_divisor.adoc[`uint&lowbar;divisor`] 
| uint&lowbar;divisor
| xref:folly/unicode_code_point_utf8.adoc[`unicode&lowbar;code&lowbar;point&lowbar;utf8`] 
| A UTF&hyphen;8 encoding of a single Unicode code point&period;
| xref:folly/unicode_error.adoc[`unicode&lowbar;error`] 
| Exception thrown when Unicode decoding or encoding fails&period;
| xref:folly/unique_hash_key.adoc[`unique&lowbar;hash&lowbar;key`] 
| unique&lowbar;hash&lowbar;key
| xref:folly/unique_hash_key_with.adoc[`unique&lowbar;hash&lowbar;key&lowbar;with`] 
| unique&lowbar;hash&lowbar;key&lowbar;with
| xref:folly/unique_lock_base.adoc[`unique&lowbar;lock&lowbar;base`] 
| A lock&hyphen;holder base which holds exclusive locks, usable with any mutex type&period;
| xref:folly/unique_lock_guard_base.adoc[`unique&lowbar;lock&lowbar;guard&lowbar;base`] 
| A lock&hyphen;guard which holds exclusive locks, usable with any mutex type&period;
| xref:folly/unsafe_default_initialized_cv.adoc[`unsafe&lowbar;default&lowbar;initialized&lowbar;cv`] 
| Convertible to any default&hyphen;constructible type, yielding a default&hyphen;initialized value on conversion&period;
| xref:folly/unsafe_for_async_usage.adoc[`unsafe&lowbar;for&lowbar;async&lowbar;usage`] 
| Convenience base or member that tags a type as unsafe for async usage&period;
| xref:folly/unsafe_for_async_usage_if-0b.adoc[`unsafe&lowbar;for&lowbar;async&lowbar;usage&lowbar;if`] 
| Conditionally tags a type as unsafe for async usage&period;
| xref:folly/upgrade_lock-0b.adoc[`upgrade&lowbar;lock`] 
| A lock&hyphen;holder type which holds upgrade locks, usable with any upgrade mutex&period;
| xref:folly/upgrade_lock_base.adoc[`upgrade&lowbar;lock&lowbar;base`] 
| A lock&hyphen;holder base which holds upgrade locks, usable with any upgrade mutex&period;
| xref:folly/value_only_result-04.adoc[`value&lowbar;only&lowbar;result`] 
| A `result`&hyphen;like type that always holds a value (never error or stopped)&period;
| xref:folly/variadic_constant_of_fn.adoc[`variadic&lowbar;constant&lowbar;of&lowbar;fn`] 
| variadic&lowbar;constant&lowbar;of variadic&lowbar;constant&lowbar;of&lowbar;fn
| xref:folly/vtag_t.adoc[`vtag&lowbar;t`] 
| vtag&lowbar;t vtag
| xref:folly/x86_cpuid_cache_info.adoc[`x86&lowbar;cpuid&lowbar;cache&lowbar;info`] 
| Decoded x86 cpuid cache descriptor for one cache level&period;
| xref:folly/x86_cpuid_vendor_name.adoc[`x86&lowbar;cpuid&lowbar;vendor&lowbar;name`] 
| Vendor identification string as returned by the cpuid instruction&period;
| xref:folly/xoshiro256pp-01.adoc[`xoshiro256pp`] 
| xoshiro256&plus;&plus; pseudo&hyphen;random number generator&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/ArenaAllocator.adoc[`ArenaAllocator`] 
| Standard&hyphen;conforming allocator that draws memory from an Arena&period;
| xref:folly/AsyncIOQueue.adoc[`AsyncIOQueue`] 
| A queue of operations backed by an AsyncIO context&period;
| xref:folly/AsyncSocketObserverContainerBaseT.adoc[`AsyncSocketObserverContainerBaseT`] 
| Base observer&hyphen;container type for AsyncSocket observers&period;
| xref:folly/AsyncTransportWrapper.adoc[`AsyncTransportWrapper`] 
| Alias kept for backward compatibility with older transport wrapper names&period;
| xref:folly/AtomicUnorderedInsertMap64.adoc[`AtomicUnorderedInsertMap64`] 
| AtomicUnorderedInsertMap64 is just a type alias that makes it easier to select a 64 bit slot index type&period; Use this if you need a capacity bigger than 2&circ;30 (about a billion)&period; This increases memory overheads, obviously&period;
| xref:folly/BaseFormatter.adoc[`BaseFormatter`] 
| Alias for BaseFormatterImpl with an index sequence built from `Args`&period;
| xref:folly/ByteArray16.adoc[`ByteArray16`] 
| Specialization for `std&colon;&colon;array` for IPv6 addresses
| xref:folly/ByteArray4.adoc[`ByteArray4`] 
| Specialization of `std&colon;&colon;array` for IPv4 addresses
| xref:folly/ByteRange.adoc[`ByteRange`] 
| A read&hyphen;only view over a sequence of bytes&period;
| xref:folly/CIDRNetwork.adoc[`CIDRNetwork`] 
| Pair of IPAddress, netmask
| xref:folly/CIDRNetworkV4.adoc[`CIDRNetworkV4`] 
| Pair of IPAddressV4, netmask
| xref:folly/CIDRNetworkV6.adoc[`CIDRNetworkV6`] 
| Pair of IPAddressV6, netmask
| xref:folly/Cob.adoc[`Cob`] 
| Callback type for functions scheduled on an executor&period;
| xref:folly/ConcurrentBSkipInlineMap.adoc[`ConcurrentBSkipInlineMap`] 
| A concurrent sorted map with payloads stored inline in the leaves&period;
| xref:folly/ConcurrentBSkipMap.adoc[`ConcurrentBSkipMap`] 
| A concurrent sorted map with separately stored payloads&period;
| xref:folly/ConcurrentBSkipSet.adoc[`ConcurrentBSkipSet`] 
| A concurrent sorted set built on ConcurrentBSkipList&period;
| xref:folly/ConcurrentHashMapSIMD.adoc[`ConcurrentHashMapSIMD`] 
| SIMD&hyphen;backed ConcurrentHashMap based on F14ValueMap&period;
| xref:folly/CountedIntrusiveList.adoc[`CountedIntrusiveList`] 
| An intrusive list with const&hyphen;time size() method&period;
| xref:folly/DMPMCQueue.adoc[`DMPMCQueue`] 
| DMPMCQueue
| xref:folly/DMPSCQueue.adoc[`DMPSCQueue`] 
| DMPSCQueue
| xref:folly/DSPMCQueue.adoc[`DSPMCQueue`] 
| DSPMCQueue
| xref:folly/DSPSCQueue.adoc[`DSPSCQueue`] 
| DSPSCQueue
| xref:folly/DefaultRefCount.adoc[`DefaultRefCount`] 
| Default reference&hyphen;count type used by the read&hyphen;mostly smart pointers&period;
| xref:folly/DefaultVectorType.adoc[`DefaultVectorType`] 
| Alias for the default vector type used by xoshiro256pp&period;
| xref:folly/DelayedDestructionUniquePtr.adoc[`DelayedDestructionUniquePtr`] 
| Unique pointer that destroys a DelayedDestruction object via destroy()&period;
| xref:folly/DistributedMutex.adoc[`DistributedMutex`] 
| The default distributed mutex, ready to use without template arguments&period;
| xref:folly/Duration.adoc[`Duration`] 
| folly&colon;&colon;Duration is an alias for the best resolution we offer&sol;work with&period; However, it is not intended to be used for client code &hyphen; you should use a descriptive std&colon;&colon;chrono&colon;&colon;duration type instead&period; e&period;g&period; do not write this&colon;
| xref:folly/DynamicTokenBucket.adoc[`DynamicTokenBucket`] 
| Dynamic token bucket with an adjustable rate and burst size using the default policy&period;
| xref:folly/ExpectedErrorType.adoc[`ExpectedErrorType`] 
| Alias for an Expected type&apos;s associated error&lowbar;type
| xref:folly/ExpectedValueType.adoc[`ExpectedValueType`] 
| Alias for an Expected type&apos;s associated value&lowbar;type
| xref:folly/FallbackArenaAllocator.adoc[`FallbackArenaAllocator`] 
| Arena allocator that falls back to std&colon;&colon;allocator when the arena is exhausted&period;
| xref:folly/FallbackGetcpuType.adoc[`FallbackGetcpuType`] 
| The FallbackGetcpu specialization selected for the current platform&period;
| xref:folly/FallbackSysArenaAllocator.adoc[`FallbackSysArenaAllocator`] 
| SysArena allocator that falls back to std&colon;&colon;allocator when exhausted&period;
| xref:folly/FixedString.adoc[`FixedString`] 
| A fixed&hyphen;capacity string of `char` with capacity for `N` characters&period;
| xref:folly/Func.adoc[`Func`] 
| A move&hyphen;only callable holding a unit of work with no arguments or result&period;
| xref:folly/GetDeadlockDetectorFactoryInstance.adoc[`GetDeadlockDetectorFactoryInstance`] 
| Function type that returns the deadlock detector factory instance&period;
| xref:folly/GroupVarint32.adoc[`GroupVarint32`] 
| GroupVarint codec for 32&hyphen;bit values&period;
| xref:folly/GroupVarint32Decoder.adoc[`GroupVarint32Decoder`] 
| GroupVarint decoder for 32&hyphen;bit values&period;
| xref:folly/GroupVarint64.adoc[`GroupVarint64`] 
| GroupVarint codec for 64&hyphen;bit values&period;
| xref:folly/GroupVarint64Decoder.adoc[`GroupVarint64Decoder`] 
| GroupVarint decoder for 64&hyphen;bit values&period;
| xref:folly/HHWheelTimer.adoc[`HHWheelTimer`] 
| A hashed hierarchical wheel timer with millisecond resolution&period;
| xref:folly/HHWheelTimerHighRes.adoc[`HHWheelTimerHighRes`] 
| A hashed hierarchical wheel timer with microsecond resolution&period;
| xref:folly/HighResDuration.adoc[`HighResDuration`] 
| A higher&hyphen;resolution duration alias used where microsecond precision is needed&period;
| xref:folly/HugePageSizeVec.adoc[`HugePageSizeVec`] 
| Vector of (huge&lowbar;page&lowbar;size, mount&lowbar;point), sorted by huge&lowbar;page&lowbar;size&period; mount&lowbar;point might be empty if no hugetlbfs file system is mounted for that size&period;
| xref:folly/IOBufFactory.adoc[`IOBufFactory`] 
| Callable that creates an IOBuf with the requested capacity&period;
| xref:folly/Identity-07.adoc[`Identity`] 
| Type of the identity function object&period;
| xref:folly/Ignored.adoc[`Ignored`] 
| An alias for Ignore that accepts and ignores any type arguments&period;
| xref:folly/IndexedMemPoolTraitsEagerRecycle.adoc[`IndexedMemPoolTraitsEagerRecycle`] 
| IndexedMemPool traits that implements the eager lifecycle strategy&period; In this strategy elements are constructed when they are allocated from the pool and destroyed when recycled&period;
| xref:folly/IndexedMemPoolTraitsLazyRecycle.adoc[`IndexedMemPoolTraitsLazyRecycle`] 
| IndexedMemPool traits that implements the lazy lifecycle strategy&period; In this strategy elements are default&hyphen;constructed the first time they are allocated, and destroyed when the pool itself is destroyed&period;
| xref:folly/IntrusiveList.adoc[`IntrusiveList`] 
| An intrusive list&period;
| xref:folly/IntrusiveListHook.adoc[`IntrusiveListHook`] 
| An auto&hyphen;unlink intrusive list hook&period;
| xref:folly/IsOneOf.adoc[`IsOneOf`] 
| A trait to test whether T is one of the types T1, T2, &period;&period;&period;, Tn&period;
| xref:folly/LaggingQueueInfoFunc.adoc[`LaggingQueueInfoFunc`] 
| Callable that returns information about lagging queues&period;
| xref:folly/LifoSem.adoc[`LifoSem`] 
| LifoSem is a semaphore that wakes its waiters in a manner intended to maximize performance rather than fairness&period; It should be preferred to a mutex&plus;condvar or POSIX sem&lowbar;t solution when all of the waiters are equivalent&period; It is faster than a condvar or sem&lowbar;t, and it has a shutdown state that might save you a lot of complexity when it comes time to shut down your work pipelines&period; LifoSem is larger than sem&lowbar;t, but that is only because it uses padding and alignment to avoid false sharing&period;
| xref:folly/MSLGuard.adoc[`MSLGuard`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/MakeQueueObserverFactory.adoc[`MakeQueueObserverFactory`] 
| Function type that builds a QueueObserverFactory&period;
| xref:folly/MallctlMibExchangeCache.adoc[`MallctlMibExchangeCache`] 
| Caches the resolved MIB for a `mallctl` command that exchanges a value of a single type&period;
| xref:folly/MeteredExecutor.adoc[`MeteredExecutor`] 
| Executor that meters how many tasks it feeds into a wrapped executor&period;
| xref:folly/MicroLock.adoc[`MicroLock`] 
| Default MicroLock specialization with the standard spin and yield budget&period;
| xref:folly/MutableByteRange.adoc[`MutableByteRange`] 
| A mutable view over a sequence of bytes&period;
| xref:folly/MutableStringPiece.adoc[`MutableStringPiece`] 
| A mutable view over a sequence of `char`&period;
| xref:folly/PolyDecay.adoc[`PolyDecay`] 
| When used in conjunction with `PolySelf`, controls how to construct `Poly` types related to the one currently being instantiated&period;
| xref:folly/PolySelf.adoc[`PolySelf`] 
| Within the definition of interface `I`, `PolySelf&lt;Base&gt;` is an alias for the instance of `Poly` that is currently being instantiated&period; It is one of&colon; `Poly&lt;J&gt;`, `Poly&lt;J&amp;&amp;&gt;`, `Poly&lt;J&amp;&gt;`, or `Poly&lt;J const&amp;&gt;`&semi; where `J` is either `I` or some interface that extends `I`&period;
| xref:folly/PriorityUMPMCQueueSet.adoc[`PriorityUMPMCQueueSet`] 
| Priority queue set with multi&hyphen;producer, multi&hyphen;consumer queues&period;
| xref:folly/PriorityUMPSCQueueSet.adoc[`PriorityUMPSCQueueSet`] 
| Priority queue set with multi&hyphen;producer, single&hyphen;consumer queues&period;
| xref:folly/PriorityUSPMCQueueSet.adoc[`PriorityUSPMCQueueSet`] 
| Priority queue set with single&hyphen;producer, multi&hyphen;consumer queues&period;
| xref:folly/PriorityUSPSCQueueSet.adoc[`PriorityUSPSCQueueSet`] 
| Priority queue set with single&hyphen;producer, single&hyphen;consumer queues&period;
| xref:folly/QuadraticProbingAtomicHashMap.adoc[`QuadraticProbingAtomicHashMap`] 
| An `AtomicHashMap` alias that uses quadratic probing&period;
| xref:folly/RegexMatchCacheKeyBase.adoc[`RegexMatchCacheKeyBase`] 
| The base hash&hyphen;key type underlying RegexMatchCacheKey&period;
| xref:folly/RequestDataItem.adoc[`RequestDataItem`] 
| A token&sol;data pair used to populate a RequestContext&period;
| xref:folly/ResolveNapiIdCallback.adoc[`ResolveNapiIdCallback`] 
| 
| xref:folly/SPSerialExecutor.adoc[`SPSerialExecutor`] 
| Single&hyphen;producer version of SmallExecutor&period; It is the responsibility of the caller to guarantee that calls to add() are externally serialized, but it can be slightly faster&period;
| xref:folly/SSLContextPtr.adoc[`SSLContextPtr`] 
| Shared&hyphen;ownership pointer to an SSLContext&period;
| xref:folly/SafeIntrusiveList.adoc[`SafeIntrusiveList`] 
| A safe intrusive list&period;
| xref:folly/SafeIntrusiveListHook.adoc[`SafeIntrusiveListHook`] 
| A safe&hyphen;link intrusive list hook&period;
| xref:folly/SerialExecutor.adoc[`SerialExecutor`] 
| Executor that runs added tasks serially and in order on a parent executor&period;
| xref:folly/SharedMutex.adoc[`SharedMutex`] 
| Default SharedMutex&semi; an alias for the write&hyphen;priority variant&period;
| xref:folly/SharedMutexReadPriority.adoc[`SharedMutexReadPriority`] 
| SharedMutex variant that gives priority to readers&period;
| xref:folly/SharedMutexSuppressTSAN.adoc[`SharedMutexSuppressTSAN`] 
| SharedMutex variant that suppresses ThreadSanitizer rwlock annotations&period;
| xref:folly/SharedMutexTracked.adoc[`SharedMutexTracked`] 
| SharedMutex variant that tracks the id of the owning thread&period;
| xref:folly/SharedMutexWritePriority.adoc[`SharedMutexWritePriority`] 
| SharedMutex variant that gives priority to writers&period;
| xref:folly/SocketCmsgMap.adoc[`SocketCmsgMap`] 
| Maps socket option keys to integer control&hyphen;message values&period;
| xref:folly/SocketNontrivialCmsgMap.adoc[`SocketNontrivialCmsgMap`] 
| Maps socket option keys to string control&hyphen;message values&period;
| xref:folly/SocketOptionMap.adoc[`SocketOptionMap`] 
| Maps socket option keys to their values&period;
| xref:folly/SrcPortForQueueIdCallback.adoc[`SrcPortForQueueIdCallback`] 
| 
| xref:folly/StringPiece.adoc[`StringPiece`] 
| A read&hyphen;only view over a sequence of `char`&period;
| xref:folly/SysArenaAllocator.adoc[`SysArenaAllocator`] 
| Standard&hyphen;conforming allocator backed by a SysArena&period;
| xref:folly/SysBufferUniquePtr.adoc[`SysBufferUniquePtr`] 
| A unique&lowbar;ptr owning a `std&colon;&colon;malloc`&hyphen;allocated buffer freed with `std&colon;&colon;free`&period;
| xref:folly/ThreadCachedArenaAllocator.adoc[`ThreadCachedArenaAllocator`] 
| Standard&hyphen;conforming allocator backed by a ThreadCachedArena&period;
| xref:folly/TokenBucket.adoc[`TokenBucket`] 
| Token bucket with a fixed rate and burst size using the default policy&period;
| xref:folly/UMPMCQueue.adoc[`UMPMCQueue`] 
| Unbounded multi&hyphen;producer, multi&hyphen;consumer queue&period;
| xref:folly/UMPSCQueue.adoc[`UMPSCQueue`] 
| Unbounded multi&hyphen;producer, single&hyphen;consumer queue&period;
| xref:folly/USPMCQueue.adoc[`USPMCQueue`] 
| Unbounded single&hyphen;producer, multi&hyphen;consumer queue&period;
| xref:folly/USPSCQueue.adoc[`USPSCQueue`] 
| Unbounded single&hyphen;producer, single&hyphen;consumer queue&period;
| xref:folly/UserCounters.adoc[`UserCounters`] 
| Maps user&hyphen;defined counter names to their metric values&period;
| xref:folly/_t.adoc[`&lowbar;t`] 
| &ast; &lowbar;t
| xref:folly/aligned_hazptr_holder.adoc[`aligned&lowbar;hazptr&lowbar;holder`] 
| Type used by hazptr&lowbar;array and hazptr&lowbar;local&period;
| xref:folly/aligned_storage_for_t.adoc[`aligned&lowbar;storage&lowbar;for&lowbar;t`] 
| An uninitialized storage type suitable for holding an object of type T&period;
| xref:folly/aligned_storage_t.adoc[`aligned&lowbar;storage&lowbar;t`] 
| An uninitialized storage type of the given length and alignment&period;
| xref:folly/apply_result.adoc[`apply&lowbar;result`] 
| Mimic the invoke suite of traits for tuple based apply invocation
| xref:folly/apply_result_t.adoc[`apply&lowbar;result&lowbar;t`] 
| The result type of applying `F` to the elements of `Tuple`&period;
| xref:folly/atomic_value_type_t.adoc[`atomic&lowbar;value&lowbar;type&lowbar;t`] 
| The effective value type of an atomic&hyphen;like type&period;
| xref:folly/back_emplace_iterator.adoc[`back&lowbar;emplace&lowbar;iterator`] 
| Behaves just like std&colon;&colon;back&lowbar;insert&lowbar;iterator except that it calls emplace&lowbar;back() instead of insert()&period; Uses perfect forwarding&period;
| xref:folly/cacheline_aligned.adoc[`cacheline&lowbar;aligned`] 
| An aligned wrapper for T using at least cache&hyphen;line alignment&period;
| xref:folly/coarse_stop_watch.adoc[`coarse&lowbar;stop&lowbar;watch`] 
| A type alias for `custom&lowbar;stop&lowbar;watch` that uses a coarse monotonic clock as the time source&period; Refer to the documentation of `custom&lowbar;stop&lowbar;watch` for full documentation&period;
| xref:folly/conditional_t.adoc[`conditional&lowbar;t`] 
| conditional&lowbar;t
| xref:folly/copy_cvref_t.adoc[`copy&lowbar;cvref&lowbar;t`] 
| copy&lowbar;cvref&lowbar;t
| xref:folly/cpo_t.adoc[`cpo&lowbar;t`] 
| Type of a customization&hyphen;point object, deduced from its tag value&period;
| xref:folly/cstring_view.adoc[`cstring&lowbar;view`] 
| A null&hyphen;terminated string view over char&period;
| xref:folly/detected_or.adoc[`detected&lowbar;or`] 
| detected&lowbar;or
| xref:folly/detected_or_t.adoc[`detected&lowbar;or&lowbar;t`] 
| detected&lowbar;or&lowbar;t
| xref:folly/detected_t.adoc[`detected&lowbar;t`] 
| detected&lowbar;t
| xref:folly/drop_unit_t.adoc[`drop&lowbar;unit&lowbar;t`] 
| Alias for the type produced by drop&lowbar;unit&period;
| xref:folly/emplace_iterator.adoc[`emplace&lowbar;iterator`] 
| Behaves just like std&colon;&colon;insert&lowbar;iterator except that it calls emplace() instead of insert()&period; Uses perfect forwarding&period;
| xref:folly/enable_hasher_helper.adoc[`enable&lowbar;hasher&lowbar;helper`] 
| A helper for defining partial specializations of a hasher class that rely on other partial specializations of that hasher class being usable&period;
| xref:folly/enable_std_hash_helper.adoc[`enable&lowbar;std&lowbar;hash&lowbar;helper`] 
| A helper for defining partial specializations of a hasher class that rely on other partial specializations of that hasher class being usable&period;
| xref:folly/erased_unique_ptr.adoc[`erased&lowbar;unique&lowbar;ptr`] 
| erased&lowbar;unique&lowbar;ptr
| xref:folly/errc_rich_error.adoc[`errc&lowbar;rich&lowbar;error`] 
| The rich&hyphen;error counterpart to `std&colon;&colon;system&lowbar;error`, coding a `std&colon;&colon;errc`&period;
| xref:folly/fbstring.adoc[`fbstring`] 
| A `basic&lowbar;fbstring` specialized for `char`, the common string type&period;
| xref:folly/fmt_vformat_mangle_format_string_options.adoc[`fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string&lowbar;options`] 
| Options type for fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string&period;
| xref:folly/format_string_for_each_named_arg_options.adoc[`format&lowbar;string&lowbar;for&lowbar;each&lowbar;named&lowbar;arg&lowbar;options`] 
| Options type for format&lowbar;string&lowbar;for&lowbar;each&lowbar;named&lowbar;arg&period;
| xref:folly/front_emplace_iterator.adoc[`front&lowbar;emplace&lowbar;iterator`] 
| Behaves just like std&colon;&colon;front&lowbar;insert&lowbar;iterator except that it calls emplace&lowbar;front() instead of insert()&period; Uses perfect forwarding&period;
| xref:folly/function_arguments_element_t.adoc[`function&lowbar;arguments&lowbar;element&lowbar;t`] 
| The type of the argument at index `Idx` of the given function type&period;
| xref:folly/function_arguments_size_t.adoc[`function&lowbar;arguments&lowbar;size&lowbar;t`] 
| The argument&hyphen;list size of the given function type, as an integral&lowbar;constant&period;
| xref:folly/function_like_value_t.adoc[`function&lowbar;like&lowbar;value&lowbar;t`] 
| The function type formed by transporting the cvref of `Src` onto `Dst`&period;
| xref:folly/function_remove_cvref_t.adoc[`function&lowbar;remove&lowbar;cvref&lowbar;t`] 
| The function type `F` with its cvref&hyphen;qualifications removed&period;
| xref:folly/function_result_t.adoc[`function&lowbar;result&lowbar;t`] 
| The result type of the given function type&period;
| xref:folly/hazard_pointer.adoc[`hazard&lowbar;pointer`] 
| hazard&lowbar;pointer class name consistent with standard proposal
| xref:folly/hazard_pointer_domain.adoc[`hazard&lowbar;pointer&lowbar;domain`] 
| hazard&lowbar;pointer&lowbar;domain class name consistent with standard proposal
| xref:folly/hazard_pointer_obj_base.adoc[`hazard&lowbar;pointer&lowbar;obj&lowbar;base`] 
| hazard&lowbar;pointer&lowbar;obj&lowbar;base class template name consistent with standard proposal
| xref:folly/hint_emplace_iterator.adoc[`hint&lowbar;emplace&lowbar;iterator`] 
| Behaves just like std&colon;&colon;insert&lowbar;iterator except that it calls emplace&lowbar;hint() instead of insert()&period; Uses perfect forwarding&period;
| xref:folly/index_constant.adoc[`index&lowbar;constant`] 
| An alias for a std&colon;&colon;integral&lowbar;constant of type std&colon;&colon;size&lowbar;t&period;
| xref:folly/index_sequence_for_tuple.adoc[`index&lowbar;sequence&lowbar;for&lowbar;tuple`] 
| Helper to generate an index sequence from a tuple like type
| xref:folly/int128_t.adoc[`int128&lowbar;t`] 
| A signed 128&hyphen;bit integer type, where the compiler supports one&period;
| xref:folly/int_bits_lg_t.adoc[`int&lowbar;bits&lowbar;lg&lowbar;t`] 
| An alias for the signed integer type with `2&circ;lg&lowbar;bits` bits&period;
| xref:folly/int_bits_t.adoc[`int&lowbar;bits&lowbar;t`] 
| An alias for the signed integer type with the given number of bits&period;
| xref:folly/invoke_result.adoc[`invoke&lowbar;result`] 
| Holds the result type of invoking `F` with `A&period;&period;&period;`&semi; mimics std&colon;&colon;invoke&lowbar;result&period;
| xref:folly/is_applicable.adoc[`is&lowbar;applicable`] 
| Trait testing whether `F` is invocable with the elements of `Tuple`&period;
| xref:folly/is_applicable_r.adoc[`is&lowbar;applicable&lowbar;r`] 
| Trait testing whether applying `F` to `Tuple` yields a result convertible to `R`&period;
| xref:folly/is_cleanup.adoc[`is&lowbar;cleanup`] 
| Trait constant that is true when T models the async cleanup concept&period;
| xref:folly/is_enable_master_from_this.adoc[`is&lowbar;enable&lowbar;master&lowbar;from&lowbar;this`] 
| Trait that reports whether T publicly derives from EnablePrimaryFromThis&period;
| xref:folly/is_hashable.adoc[`is&lowbar;hashable`] 
| Checks that the given hasher template&apos;s specialization for the given type is usable with the standard library containters, for example `std&colon;&colon;unordered&lowbar;set&lt;T, Hasher&lt;T&gt;&gt;`&period;
| xref:folly/is_hasher_usable.adoc[`is&lowbar;hasher&lowbar;usable`] 
| Checks the requirements that the Hasher class must satisfy in order to be used with the standard library containers, for example `std&colon;&colon;unordered&lowbar;set&lt;T, Hasher&gt;`&period;
| xref:folly/is_nothrow_applicable.adoc[`is&lowbar;nothrow&lowbar;applicable`] 
| Trait testing whether `F` is nothrow&hyphen;invocable with the elements of `Tuple`&period;
| xref:folly/is_nothrow_applicable_r.adoc[`is&lowbar;nothrow&lowbar;applicable&lowbar;r`] 
| Trait testing the nothrow application of `F` to `Tuple` with result convertible to `R`&period;
| xref:folly/is_nothrow_tag_invocable_r.adoc[`is&lowbar;nothrow&lowbar;tag&lowbar;invocable&lowbar;r`] 
| Trait testing whether a nothrow `tag&lowbar;invoke` yields a result convertible to `R`&period;
| xref:folly/is_replaceable.adoc[`is&lowbar;replaceable`] 
| Trait that is true if `T` is an instantiation of `Replaceable`&period;
| xref:folly/is_tag_invocable_r.adoc[`is&lowbar;tag&lowbar;invocable&lowbar;r`] 
| Trait testing whether a `tag&lowbar;invoke` call yields a result convertible to `R`&period;
| xref:folly/iterator_category_t.adoc[`iterator&lowbar;category&lowbar;t`] 
| Extracts iterator&lowbar;category from an iterator&period;
| xref:folly/iterator_key_type_t.adoc[`iterator&lowbar;key&lowbar;type&lowbar;t`] 
| Extracts a key type from an iterator, leverages the knowledge that key&sol;value containers usually use std&colon;&colon;pair&lt;const K, V&gt; as a value&lowbar;type&period;
| xref:folly/iterator_mapped_type_t.adoc[`iterator&lowbar;mapped&lowbar;type&lowbar;t`] 
| Extracts a mapped type from an iterator&period;
| xref:folly/iterator_reference_t.adoc[`iterator&lowbar;reference&lowbar;t`] 
| Extracts reference from an iterator (C&plus;&plus;20 iter&lowbar;reference&lowbar;t backported)
| xref:folly/iterator_value_type_t.adoc[`iterator&lowbar;value&lowbar;type&lowbar;t`] 
| Extracts a value type from an iterator&period;
| xref:folly/libevent_fd_t.adoc[`libevent&lowbar;fd&lowbar;t`] 
| Portable type of a libevent event file descriptor&period;
| xref:folly/lift_unit_t.adoc[`lift&lowbar;unit&lowbar;t`] 
| Alias for the type produced by lift&lowbar;unit&period;
| xref:folly/like_t.adoc[`like&lowbar;t`] 
| like like&lowbar;t
| xref:folly/make_signed_t.adoc[`make&lowbar;signed&lowbar;t`] 
| An alias for the signed integer type corresponding to T&period;
| xref:folly/make_unsigned_t.adoc[`make&lowbar;unsigned&lowbar;t`] 
| An alias for the unsigned integer type corresponding to T&period;
| xref:folly/member_pointer_member_t.adoc[`member&lowbar;pointer&lowbar;member&lowbar;t`] 
| member&lowbar;pointer&lowbar;member&lowbar;t
| xref:folly/member_pointer_object_t.adoc[`member&lowbar;pointer&lowbar;object&lowbar;t`] 
| member&lowbar;pointer&lowbar;object&lowbar;t
| xref:folly/monotonic_clock.adoc[`monotonic&lowbar;clock`] 
| Monotonic clock used as the default time source for stop watches&period;
| xref:folly/non_value_result.adoc[`non&lowbar;value&lowbar;result`] 
| Backwards&hyphen;compatible alias for `error&lowbar;or&lowbar;stopped`&period;
| xref:folly/once_flag.adoc[`once&lowbar;flag`] 
| The flag type to be used with call&lowbar;once&period;
| xref:folly/register_pass_t.adoc[`register&lowbar;pass&lowbar;t`] 
| register&lowbar;pass&lowbar;t
| xref:folly/relaxed_atomic_bool.adoc[`relaxed&lowbar;atomic&lowbar;bool`] 
| A `relaxed&lowbar;atomic` over `bool`&period;
| xref:folly/relaxed_atomic_char.adoc[`relaxed&lowbar;atomic&lowbar;char`] 
| A `relaxed&lowbar;atomic` over `char`&period;
| xref:folly/relaxed_atomic_char16_t.adoc[`relaxed&lowbar;atomic&lowbar;char16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `char16&lowbar;t`&period;
| xref:folly/relaxed_atomic_char32_t.adoc[`relaxed&lowbar;atomic&lowbar;char32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `char32&lowbar;t`&period;
| xref:folly/relaxed_atomic_int.adoc[`relaxed&lowbar;atomic&lowbar;int`] 
| A `relaxed&lowbar;atomic` over `int`&period;
| xref:folly/relaxed_atomic_int16_t.adoc[`relaxed&lowbar;atomic&lowbar;int16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int16&lowbar;t`&period;
| xref:folly/relaxed_atomic_int32_t.adoc[`relaxed&lowbar;atomic&lowbar;int32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int32&lowbar;t`&period;
| xref:folly/relaxed_atomic_int64_t.adoc[`relaxed&lowbar;atomic&lowbar;int64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int64&lowbar;t`&period;
| xref:folly/relaxed_atomic_int8_t.adoc[`relaxed&lowbar;atomic&lowbar;int8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int8&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_fast16_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;fast16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;fast16&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_fast32_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;fast32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;fast32&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_fast64_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;fast64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;fast64&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_fast8_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;fast8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;fast8&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_least16_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;least16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;least16&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_least32_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;least32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;least32&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_least64_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;least64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;least64&lowbar;t`&period;
| xref:folly/relaxed_atomic_int_least8_t.adoc[`relaxed&lowbar;atomic&lowbar;int&lowbar;least8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;int&lowbar;least8&lowbar;t`&period;
| xref:folly/relaxed_atomic_intmax_t.adoc[`relaxed&lowbar;atomic&lowbar;intmax&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;intmax&lowbar;t`&period;
| xref:folly/relaxed_atomic_intptr_t.adoc[`relaxed&lowbar;atomic&lowbar;intptr&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;intptr&lowbar;t`&period;
| xref:folly/relaxed_atomic_llong.adoc[`relaxed&lowbar;atomic&lowbar;llong`] 
| A `relaxed&lowbar;atomic` over `long long`&period;
| xref:folly/relaxed_atomic_long.adoc[`relaxed&lowbar;atomic&lowbar;long`] 
| A `relaxed&lowbar;atomic` over `long`&period;
| xref:folly/relaxed_atomic_ptrdiff_t.adoc[`relaxed&lowbar;atomic&lowbar;ptrdiff&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;ptrdiff&lowbar;t`&period;
| xref:folly/relaxed_atomic_schar.adoc[`relaxed&lowbar;atomic&lowbar;schar`] 
| A `relaxed&lowbar;atomic` over `signed char`&period;
| xref:folly/relaxed_atomic_short.adoc[`relaxed&lowbar;atomic&lowbar;short`] 
| A `relaxed&lowbar;atomic` over `short`&period;
| xref:folly/relaxed_atomic_size_t.adoc[`relaxed&lowbar;atomic&lowbar;size&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;size&lowbar;t`&period;
| xref:folly/relaxed_atomic_uchar.adoc[`relaxed&lowbar;atomic&lowbar;uchar`] 
| A `relaxed&lowbar;atomic` over `unsigned char`&period;
| xref:folly/relaxed_atomic_uint.adoc[`relaxed&lowbar;atomic&lowbar;uint`] 
| A `relaxed&lowbar;atomic` over `unsigned int`&period;
| xref:folly/relaxed_atomic_uint16_t.adoc[`relaxed&lowbar;atomic&lowbar;uint16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint16&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint32_t.adoc[`relaxed&lowbar;atomic&lowbar;uint32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint32&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint64_t.adoc[`relaxed&lowbar;atomic&lowbar;uint64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint64&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint8_t.adoc[`relaxed&lowbar;atomic&lowbar;uint8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint8&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_fast16_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;fast16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;fast16&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_fast32_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;fast32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;fast32&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_fast64_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;fast64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;fast64&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_fast8_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;fast8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;fast8&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_least16_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;least16&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;least16&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_least32_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;least32&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;least32&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_least64_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;least64&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;least64&lowbar;t`&period;
| xref:folly/relaxed_atomic_uint_least8_t.adoc[`relaxed&lowbar;atomic&lowbar;uint&lowbar;least8&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uint&lowbar;least8&lowbar;t`&period;
| xref:folly/relaxed_atomic_uintmax_t.adoc[`relaxed&lowbar;atomic&lowbar;uintmax&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uintmax&lowbar;t`&period;
| xref:folly/relaxed_atomic_uintptr_t.adoc[`relaxed&lowbar;atomic&lowbar;uintptr&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `std&colon;&colon;uintptr&lowbar;t`&period;
| xref:folly/relaxed_atomic_ullong.adoc[`relaxed&lowbar;atomic&lowbar;ullong`] 
| A `relaxed&lowbar;atomic` over `unsigned long long`&period;
| xref:folly/relaxed_atomic_ulong.adoc[`relaxed&lowbar;atomic&lowbar;ulong`] 
| A `relaxed&lowbar;atomic` over `unsigned long`&period;
| xref:folly/relaxed_atomic_ushort.adoc[`relaxed&lowbar;atomic&lowbar;ushort`] 
| A `relaxed&lowbar;atomic` over `unsigned short`&period;
| xref:folly/relaxed_atomic_wchar_t.adoc[`relaxed&lowbar;atomic&lowbar;wchar&lowbar;t`] 
| A `relaxed&lowbar;atomic` over `wchar&lowbar;t`&period;
| xref:folly/remove_cvref_t.adoc[`remove&lowbar;cvref&lowbar;t`] 
| An alias for the type T with all cv and reference qualifiers removed&period;
| xref:folly/rich_error_hints.adoc[`rich&lowbar;error&lowbar;hints`] 
| Alias for rich error types to declare fast exception&hyphen;lookup hints&period;
| xref:folly/safe_alias_constant.adoc[`safe&lowbar;alias&lowbar;constant`] 
| An `std&colon;&colon;integral&lowbar;constant` holding the given `safe&lowbar;alias` level&period;
| xref:folly/small_sorted_vector_map.adoc[`small&lowbar;sorted&lowbar;vector&lowbar;map`] 
| A sorted&lowbar;vector&lowbar;map backed by a small&lowbar;vector with inline capacity N&period;
| xref:folly/small_sorted_vector_set.adoc[`small&lowbar;sorted&lowbar;vector&lowbar;set`] 
| A sorted&lowbar;vector&lowbar;set backed by a small&lowbar;vector with inline capacity N&period;
| xref:folly/source_location.adoc[`source&lowbar;location`] 
| Portable alias for the standard `source&lowbar;location` type&period;
| xref:folly/stop_watch.adoc[`stop&lowbar;watch`] 
| A type alias for `custom&lowbar;stop&lowbar;watch` that uses a monotonic clock as the time source&period; Refer to the documentation of `custom&lowbar;stop&lowbar;watch` for full documentation&period;
| xref:folly/string_tape.adoc[`string&lowbar;tape`] 
| string&lowbar;tape &hyphen; a common usecase&period;
| xref:folly/to_ascii_alphabet_lower.adoc[`to&lowbar;ascii&lowbar;alphabet&lowbar;lower`] 
| Digit alphabet producing lowercase letters&period;
| xref:folly/to_ascii_alphabet_upper.adoc[`to&lowbar;ascii&lowbar;alphabet&lowbar;upper`] 
| Digit alphabet producing uppercase letters&period;
| xref:folly/type_list_concat_t.adoc[`type&lowbar;list&lowbar;concat&lowbar;t`] 
| type&lowbar;list&lowbar;concat&lowbar;t
| xref:folly/type_list_element_t.adoc[`type&lowbar;list&lowbar;element&lowbar;t`] 
| type&lowbar;list&lowbar;element&lowbar;t
| xref:folly/type_list_find_t.adoc[`type&lowbar;list&lowbar;find&lowbar;t`] 
| type&lowbar;list&lowbar;find&lowbar;t
| xref:folly/type_list_size_t.adoc[`type&lowbar;list&lowbar;size&lowbar;t`] 
| type&lowbar;list&lowbar;size&lowbar;t
| xref:folly/type_pack_element_t.adoc[`type&lowbar;pack&lowbar;element&lowbar;t`] 
| In the type pack Ts&period;&period;&period;, the Ith element&period;
| xref:folly/type_pack_find_t.adoc[`type&lowbar;pack&lowbar;find&lowbar;t`] 
| type&lowbar;pack&lowbar;find&lowbar;t
| xref:folly/type_pack_size_t.adoc[`type&lowbar;pack&lowbar;size&lowbar;t`] 
| type&lowbar;pack&lowbar;size&lowbar;t
| xref:folly/type_t.adoc[`type&lowbar;t`] 
| A type alias for the first template type argument&period;
| xref:folly/uint128_t.adoc[`uint128&lowbar;t`] 
| An unsigned 128&hyphen;bit integer type, where the compiler supports one&period;
| xref:folly/uint_bits_lg_t.adoc[`uint&lowbar;bits&lowbar;lg&lowbar;t`] 
| An alias for the unsigned integer type with `2&circ;lg&lowbar;bits` bits&period;
| xref:folly/uint_bits_t.adoc[`uint&lowbar;bits&lowbar;t`] 
| An alias for the unsigned integer type with the given number of bits&period;
| xref:folly/unexpected_t.adoc[`unexpected&lowbar;t`] 
| Function&hyphen;reference type used as the `unexpected` disambiguation tag&period;
| xref:folly/unique_hash_key_strong_sha256.adoc[`unique&lowbar;hash&lowbar;key&lowbar;strong&lowbar;sha256`] 
| unique&lowbar;hash&lowbar;key&lowbar;strong&lowbar;sha256
| xref:folly/unique_lock_guard.adoc[`unique&lowbar;lock&lowbar;guard`] 
| Alias to `std&colon;&colon;lock&lowbar;guard`&period;
| xref:folly/value_list_concat_t.adoc[`value&lowbar;list&lowbar;concat&lowbar;t`] 
| value&lowbar;list&lowbar;concat&lowbar;t
| xref:folly/value_list_element_type_t.adoc[`value&lowbar;list&lowbar;element&lowbar;type&lowbar;t`] 
| value&lowbar;list&lowbar;element&lowbar;type&lowbar;t
| xref:folly/value_list_size_t.adoc[`value&lowbar;list&lowbar;size&lowbar;t`] 
| value&lowbar;list&lowbar;size&lowbar;t
| xref:folly/value_pack_element_type_t.adoc[`value&lowbar;pack&lowbar;element&lowbar;type&lowbar;t`] 
| value&lowbar;pack&lowbar;element&lowbar;type&lowbar;t
| xref:folly/value_pack_size_t.adoc[`value&lowbar;pack&lowbar;size&lowbar;t`] 
| value&lowbar;pack&lowbar;size&lowbar;t
| xref:folly/vector_bool.adoc[`vector&lowbar;bool`] 
| Convenience alias to use instead of `std&colon;&colon;vector&lt;bool&gt;` to avoid infamous `std&colon;&colon;vector&lt;bool&gt;` specialization&period;
| xref:folly/void_t.adoc[`void&lowbar;t`] 
| A type alias for `void` that depends on the given template arguments&period;
| xref:folly/xoshiro256pp_32.adoc[`xoshiro256pp&lowbar;32`] 
| xoshiro256&plus;&plus; generator producing 32&hyphen;bit results&period;
| xref:folly/xoshiro256pp_64.adoc[`xoshiro256pp&lowbar;64`] 
| xoshiro256&plus;&plus; generator producing 64&hyphen;bit results&period;
|===


== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/AcquireMallocatedString.adoc[`AcquireMallocatedString`] 
| Defines a special acquisition method for constructing fbstring objects&period; AcquireMallocatedString means that the user passes a pointer to a malloc&hyphen;allocated string that the fbstring object will take into custody&period;
| xref:folly/AtomicNotificationQueueTaskStatus.adoc[`AtomicNotificationQueueTaskStatus`] 
| Consumer&colon;&colon;operator() can optionally return AtomicNotificationQueueTaskStatus to indicate if the provided task should be considered consumed or discarded&period; Discarded tasks are not counted towards maxReadAtOnce&lowbar;&period;
| xref:folly/BSkipInsertOutcome.adoc[`BSkipInsertOutcome`] 
| Detailed result of an insertion into a ConcurrentBSkipList&period;
| xref:folly/CIDRNetworkError.adoc[`CIDRNetworkError`] 
| Wraps errors from parsing IP&sol;MASK string
| xref:folly/ConversionCode.adoc[`ConversionCode`] 
| Error codes describing why a string&hyphen;to&hyphen;value conversion failed&period;
| xref:folly/DecodeVarintError.adoc[`DecodeVarintError`] 
| Error reported when a varint cannot be decoded&period;
| xref:folly/GoogleLoggerStyle.adoc[`GoogleLoggerStyle`] 
| Output style for the default glog&hyphen;based `AutoTimer` logger&period;
| xref:folly/IPAddressFormatError.adoc[`IPAddressFormatError`] 
| Error codes for non&hyphen;throwing interface of IPAddress family of functions&period;
| xref:folly/KeyReadPolicy.adoc[`KeyReadPolicy`] 
| Selects how Skipper reads a key slot under concurrent writes&period;
| xref:folly/LeafStoragePolicy.adoc[`LeafStoragePolicy`] 
| Selects how leaf key&sol;payload data is laid out in memory&period;
| xref:folly/LogLevel.adoc[`LogLevel`] 
| Log level values&period;
| xref:folly/MacAddressFormatError.adoc[`MacAddressFormatError`] 
| Error codes reported when parsing or constructing a MacAddress fails&period;
| xref:folly/ParkResult.adoc[`ParkResult`] 
| The outcome of a park operation&period;
| xref:folly/PrettyType.adoc[`PrettyType`] 
| Unit families understood by prettyPrint and prettyToDouble&period;
| xref:folly/ProcessPhase.adoc[`ProcessPhase`] 
| Process phases
| xref:folly/QueueBehaviorIfFull.adoc[`QueueBehaviorIfFull`] 
| Behavior of a queue when an item is added while the queue is full&period;
| xref:folly/SSLError.adoc[`SSLError`] 
| Categories of SSL failure reported by SSLException&period;
| xref:folly/SyncType.adoc[`SyncType`] 
| Whether an atomic write syncs to storage to guarantee ordering&period;
| xref:folly/TLPDestructionMode.adoc[`TLPDestructionMode`] 
| Selects which threads&apos; thread&hyphen;local instances are destroyed&period;
| xref:folly/UnparkControl.adoc[`UnparkControl`] 
| Controls whether a wait node is retained and whether unparking continues&period;
| xref:folly/UriEscapeMode.adoc[`UriEscapeMode`] 
| overloadbrief URI&hyphen;escape a string&period;
| xref:folly/UriFormatError.adoc[`UriFormatError`] 
| Error codes for parsing issues&period; Used by tryFromString()
| xref:folly/UuidParseCode.adoc[`UuidParseCode`] 
| Result code returned by UUID parsing functions&period;
| xref:folly/WriteFlags.adoc[`WriteFlags`] 
| Flags given by the application for write&ast; calls&period;
| xref:folly/annotate_rwlock_level.adoc[`annotate&lowbar;rwlock&lowbar;level`] 
| The lock mode reported to ThreadSanitizer rwlock annotations&period;
| xref:folly/cli_apply_args_files_errc.adoc[`cli&lowbar;apply&lowbar;args&lowbar;files&lowbar;errc`] 
| Error codes reported by args&hyphen;file expansion&period;
| xref:folly/ordering.adoc[`ordering`] 
| Three&hyphen;way comparison result&colon; less&hyphen;than, equal, or greater&hyphen;than&period;
| xref:folly/safe_alias.adoc[`safe&lowbar;alias`] 
| A hierarchy of memory&hyphen;safety levels for a type, from least to most safe&period;
| xref:folly/x86_cpuid_vendor.adoc[`x86&lowbar;cpuid&lowbar;vendor`] 
| Recognized x86 CPU vendors&period;
|===


== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/PrintTo.adoc[`PrintTo`] 
| Printer for GTest&period;
| xref:folly/__folly_memcpy.adoc[`&lowbar;&lowbar;folly&lowbar;memcpy`] 
| Folly&apos;s tuned `memcpy` entry point (C linkage inside the `folly` namespace)&period;
| xref:folly/__folly_memset.adoc[`&lowbar;&lowbar;folly&lowbar;memset`] 
| Set the first `count` bytes of the block pointed to by `dest` to `ch&period;`
| xref:folly/accurate_sum-02.adoc[`accurate&lowbar;sum`] 
| `accurate&lowbar;sum` overloads
| xref:folly/acquireLocked.adoc[`acquireLocked`] 
| Acquire locks for multiple Synchronized&lt;T&gt; objects, in a deadlock&hyphen;safe manner&period;
| xref:folly/acquireLockedPair.adoc[`acquireLockedPair`] 
| A version of acquireLocked() that returns a std&colon;&colon;pair rather than a std&colon;&colon;tuple, which is easier to use in many places&period;
| xref:folly/activateAsyncStackFrame.adoc[`activateAsyncStackFrame`] 
| Activate the specified AsyncStackFrame on the specified AsyncStackRoot, setting it as the current &apos;topFrame&apos;&period;
| xref:folly/activateSuspendedLeaf.adoc[`activateSuspendedLeaf`] 
| Push a dummy &quot;leaf&quot; frame into the stack to annotate the stack as &quot;suspended&quot;&period;
| xref:folly/addBenchmark.adoc[`addBenchmark`] 
| Adds a benchmark&period; Usually not called directly but instead through the macro BENCHMARK defined below&period; The lambda function involved can have one of the following forms&colon; &ast; take zero parameters, and the benchmark calls it repeatedly &ast; take exactly one parameter of type unsigned, and the benchmark uses it with counter semantics (iteration occurs inside the function)&period; &ast; 2 versions of the above cases but also accept UserCounters&amp; as as their first parameter&period;
| xref:folly/align_ceil-06.adoc[`align&lowbar;ceil`] 
| `align&lowbar;ceil` overloads
| xref:folly/align_floor-0b.adoc[`align&lowbar;floor`] 
| `align&lowbar;floor` overloads
| xref:folly/alignedForwardMemcpy.adoc[`alignedForwardMemcpy`] 
| A special case of memcpy() that always copies memory forwards&period; (libc&apos;s memcpy() is allowed to copy memory backwards, and will do so when using SSSE3 instructions)&period;
| xref:folly/aligned_free.adoc[`aligned&lowbar;free`] 
| Free memory previously obtained from `aligned&lowbar;malloc`&period;
| xref:folly/aligned_malloc.adoc[`aligned&lowbar;malloc`] 
| Allocate `size` bytes aligned to `align`, returning null on failure&period;
| xref:folly/allocateOverAligned.adoc[`allocateOverAligned`] 
| Allocate storage for `n` values through `alloc`, honoring over&hyphen;alignment&period;
| xref:folly/allocate_not_null_shared.adoc[`allocate&lowbar;not&lowbar;null&lowbar;shared`] 
| Creates a not&lowbar;null&lowbar;shared&lowbar;ptr using an allocator, like std&colon;&colon;allocate&lowbar;shared&period;
| xref:folly/allocate_sys_buffer.adoc[`allocate&lowbar;sys&lowbar;buffer`] 
| Allocate a `size`&hyphen;byte buffer with `std&colon;&colon;malloc`, throwing on failure&period;
| xref:folly/allocate_unique.adoc[`allocate&lowbar;unique`] 
| allocate&lowbar;unique, like std&colon;&colon;allocate&lowbar;shared but for std&colon;&colon;unique&lowbar;ptr
| xref:folly/allocationBytesForOverAligned.adoc[`allocationBytesForOverAligned`] 
| Return the number of bytes `allocateOverAligned` requests for `n` values&period;
| xref:folly/appendCodePointToUtf8.adoc[`appendCodePointToUtf8`] 
| Encode a single Unicode code point into a UTF&hyphen;8 byte sequence&period;
| xref:folly/applySocketOptions.adoc[`applySocketOptions`] 
| Applies the given socket options to a socket at the given position&period;
| xref:folly/apply_visitor-06.adoc[`apply&lowbar;visitor`] 
| `apply&lowbar;visitor` overloads
| xref:folly/asm_volatile_memory.adoc[`asm&lowbar;volatile&lowbar;memory`] 
| Emits a compiler barrier preventing reordering of memory accesses&period;
| xref:folly/asm_volatile_pause.adoc[`asm&lowbar;volatile&lowbar;pause`] 
| Emits a CPU pause&sol;yield hint suitable for spin&hyphen;wait loops&period;
| xref:folly/assume.adoc[`assume`] 
| assume(cond) informs the compiler that cond can be assumed true&period; If cond is not true at runtime the behavior is undefined&period;
| xref:folly/assume_unreachable.adoc[`assume&lowbar;unreachable`]  [.small]#[noreturn]#
| assume&lowbar;unreachable() informs the compiler that the statement is not reachable at runtime&period; It is undefined behavior if the statement is actually reached&period;
| xref:folly/asymmetric_thread_fence_heavy.adoc[`asymmetric&lowbar;thread&lowbar;fence&lowbar;heavy`] 
| Issue a heavyweight asymmetric thread fence&period;
| xref:folly/asymmetric_thread_fence_light.adoc[`asymmetric&lowbar;thread&lowbar;fence&lowbar;light`] 
| Issue a lightweight asymmetric thread fence&period;
| xref:folly/async.adoc[`async`] 
| Run a callable asynchronously on the global CPU executor&period;
| xref:folly/atomic_compare_exchange_strong_explicit.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;strong&lowbar;explicit`] 
| Compare&hyphen;exchange (strong) that works around a TSAN bug in the standard library version&period;
| xref:folly/atomic_compare_exchange_weak_explicit.adoc[`atomic&lowbar;compare&lowbar;exchange&lowbar;weak&lowbar;explicit`] 
| Compare&hyphen;exchange (weak) that works around a TSAN bug in the standard library version&period;
| xref:folly/attach-05c.adoc[`attach`] 
| `attach` overloads
| xref:folly/available_concurrency.adoc[`available&lowbar;concurrency`] 
| available&lowbar;concurrency
| xref:folly/back_emplacer.adoc[`back&lowbar;emplacer`] 
| Convenience function to construct a folly&colon;&colon;back&lowbar;emplace&lowbar;iterator, analogous to std&colon;&colon;back&lowbar;inserter()&period;
| xref:folly/backslashify-05.adoc[`backslashify`] 
| `backslashify` overloads
| xref:folly/base64Decode-02.adoc[`base64Decode`] 
| `base64Decode` overloads
| xref:folly/base64DecodeRuntime-00.adoc[`base64DecodeRuntime`] 
| `base64DecodeRuntime` overloads
| xref:folly/base64DecodedSize-07.adoc[`base64DecodedSize`] 
| `base64DecodedSize` overloads
| xref:folly/base64Encode-0d.adoc[`base64Encode`] 
| `base64Encode` overloads
| xref:folly/base64EncodeRuntime.adoc[`base64EncodeRuntime`] 
| Encode a byte range to standard base64 at runtime&period;
| xref:folly/base64EncodedSize.adoc[`base64EncodedSize`] 
| Compute the encoded size for standard base64&period;
| xref:folly/base64PHPStrictDecode-02.adoc[`base64PHPStrictDecode`] 
| `base64PHPStrictDecode` overloads
| xref:folly/base64PHPStrictDecodeRequiredOutputSize-02.adoc[`base64PHPStrictDecodeRequiredOutputSize`] 
| `base64PHPStrictDecodeRequiredOutputSize` overloads
| xref:folly/base64URLDecode-0f.adoc[`base64URLDecode`] 
| `base64URLDecode` overloads
| xref:folly/base64URLDecodeRuntime-02.adoc[`base64URLDecodeRuntime`] 
| `base64URLDecodeRuntime` overloads
| xref:folly/base64URLDecodedSize-00.adoc[`base64URLDecodedSize`] 
| `base64URLDecodedSize` overloads
| xref:folly/base64URLEncode-00.adoc[`base64URLEncode`] 
| `base64URLEncode` overloads
| xref:folly/base64URLEncodeRuntime.adoc[`base64URLEncodeRuntime`] 
| Encode a byte range to URL&hyphen;safe base64 at runtime&period;
| xref:folly/base64URLEncodedSize.adoc[`base64URLEncodedSize`] 
| Compute the encoded size for URL&hyphen;safe base64&period;
| xref:folly/benchmarkResultsFromDynamic.adoc[`benchmarkResultsFromDynamic`] 
| Deserialize benchmark results from a dynamic value&period;
| xref:folly/benchmarkResultsToDynamic.adoc[`benchmarkResultsToDynamic`] 
| Serialize benchmark results into a dynamic value&period;
| xref:folly/bitReverse.adoc[`bitReverse`] 
| Reverse the order of the bits in n&period;
| xref:folly/bm_llc_evict.adoc[`bm&lowbar;llc&lowbar;evict`] 
| Evict cache lines by writing to a large block of memory&period;
| xref:folly/bm_llc_size.adoc[`bm&lowbar;llc&lowbar;size`] 
| Calculates the size of the LLC (Last Level Cache, typically L3 on x86&hyphen;64)&period;
| xref:folly/cEscape-04.adoc[`cEscape`] 
| `cEscape` overloads
| xref:folly/cUnescape-09.adoc[`cUnescape`] 
| `cUnescape` overloads
| xref:folly/call_once-06.adoc[`call&lowbar;once`] 
| `call&lowbar;once` overloads
| xref:folly/canNallocx.adoc[`canNallocx`] 
| Return whether nallocx() is supported by the current allocator&period;
| xref:folly/canSdallocx.adoc[`canSdallocx`] 
| Return whether sdallocx() is supported by the current allocator&period;
| xref:folly/canSetCurrentThreadName.adoc[`canSetCurrentThreadName`] 
| This returns true if the current platform supports setting the name of the current thread&period;
| xref:folly/canSetOtherThreadName.adoc[`canSetOtherThreadName`] 
| This returns true if the current platform supports setting the name of threads other than the one currently executing&period;
| xref:folly/cancellation_token_merge.adoc[`cancellation&lowbar;token&lowbar;merge`] 
| Merge the given tokens into a single CancellationToken&period;
| xref:folly/catch_exception-0413.adoc[`catch&lowbar;exception`] 
| `catch&lowbar;exception` overloads
| xref:folly/checkAsyncStackFrameIsActive.adoc[`checkAsyncStackFrameIsActive`] 
| Perform some consistency checks on the specified AsyncStackFrame, assuming that it is the currently active AsyncStackFrame&period;
| xref:folly/checkFopenError.adoc[`checkFopenError`] 
| Checks the return value from a fopen&hyphen;style function (non&hyphen;null `FILE&ast;` on success, null on error) and throws on error&period;
| xref:folly/checkFopenErrorExplicit.adoc[`checkFopenErrorExplicit`] 
| Checks the return value from a fopen&hyphen;style function and throws using an explicit saved `errno`&period;
| xref:folly/checkKernelError.adoc[`checkKernelError`] 
| Checks a Linux kernel&hyphen;style return code (&gt;&equals; 0 on success, negative error number on error) and throws on error&period;
| xref:folly/checkPosixError.adoc[`checkPosixError`] 
| Checks a POSIX return code (0 on success, error number on error) and throws on error&period;
| xref:folly/checkUnixError.adoc[`checkUnixError`] 
| Checks a traditional Unix return code (&hyphen;1 and sets `errno` on error) and throws on error&period;
| xref:folly/checkUnixErrorExplicit.adoc[`checkUnixErrorExplicit`] 
| Checks a traditional Unix return code (&hyphen;1 on error) and throws using an explicit saved `errno`&period;
| xref:folly/checkedAlignedMalloc.adoc[`checkedAlignedMalloc`] 
| Allocate `size` bytes aligned to `align`, throwing std&colon;&colon;bad&lowbar;alloc on failure&period;
| xref:folly/checkedArrayMalloc.adoc[`checkedArrayMalloc`] 
| Allocate uninitialized storage for `n` instances of `T`, suitably aligned for `T`&period;
| xref:folly/checkedCalloc.adoc[`checkedCalloc`] 
| Trivial wrapper around calloc that check for allocation failure and throw std&colon;&colon;bad&lowbar;alloc in that case&period;
| xref:folly/checkedMalloc.adoc[`checkedMalloc`] 
| Trivial wrapper around malloc that check for allocation failure and throw std&colon;&colon;bad&lowbar;alloc in that case&period;
| xref:folly/checkedRealloc.adoc[`checkedRealloc`] 
| Trivial wrapper around realloc that check for allocation failure and throw std&colon;&colon;bad&lowbar;alloc in that case&period;
| xref:folly/checked_add-0fa.adoc[`checked&lowbar;add`] 
| `checked&lowbar;add` overloads
| xref:folly/checked_div.adoc[`checked&lowbar;div`] 
| Divide two integers, reporting division by zero&period;
| xref:folly/checked_mod.adoc[`checked&lowbar;mod`] 
| Compute the remainder of integer division, reporting division by zero&period;
| xref:folly/checked_mul.adoc[`checked&lowbar;mul`] 
| Multiply two unsigned integers, reporting overflow instead of wrapping&period;
| xref:folly/checked_muladd.adoc[`checked&lowbar;muladd`] 
| Compute base &ast; mul &plus; add for unsigned integers, reporting overflow&period;
| xref:folly/clear_n_least_significant_bits.adoc[`clear&lowbar;n&lowbar;least&lowbar;significant&lowbar;bits`] 
| Clear the n least significant bits of x, leaving the others unchanged&period;
| xref:folly/clear_n_most_significant_bits.adoc[`clear&lowbar;n&lowbar;most&lowbar;significant&lowbar;bits`] 
| Clear the n most significant bits of x, leaving the others unchanged&period;
| xref:folly/cli_apply_args_files-07.adoc[`cli&lowbar;apply&lowbar;args&lowbar;files`] 
| `cli&lowbar;apply&lowbar;args&lowbar;files` overloads
| xref:folly/cli_args_strings_to_c_strings.adoc[`cli&lowbar;args&lowbar;strings&lowbar;to&lowbar;c&lowbar;strings`] 
| Converts a list of strings into a null&hyphen;pointer&hyphen;terminated array of C strings borrowing the storage of the input strings&period;
| xref:folly/closeNoInt-0f.adoc[`closeNoInt`] 
| `closeNoInt` overloads
| xref:folly/codePointToUtf8.adoc[`codePointToUtf8`] 
| Encodes a single Unicode code point as a UTF&hyphen;8 string&period;
| xref:folly/compactResize.adoc[`compactResize`] 
| Resize a vector and shrink its capacity to fit&period;
| xref:folly/compareDynamicWithNestedJson.adoc[`compareDynamicWithNestedJson`] 
| Like compareJson, but with dynamic instances&period;
| xref:folly/compareDynamicWithTolerance.adoc[`compareDynamicWithTolerance`] 
| Like compareJsonWithTolerance, but operates directly on the dynamics&period;
| xref:folly/compareJson.adoc[`compareJson`] 
| Compares two JSON strings and returns whether they represent the same document (thus ignoring things like object ordering or multiple representations of the same number)&period;
| xref:folly/compareJsonWithNestedJson.adoc[`compareJsonWithNestedJson`] 
| Like compareJson, but if strNestingDepth &gt; 0 then contained strings that are valid JSON will be compared using compareJsonWithNestedJson(str1, str2, strNestingDepth &hyphen; 1)&period;
| xref:folly/compareJsonWithTolerance.adoc[`compareJsonWithTolerance`] 
| Like compareJson, but allows for the given tolerance when comparing numbers&period;
| xref:folly/compiler_may_unsafely_assume.adoc[`compiler&lowbar;may&lowbar;unsafely&lowbar;assume`] 
| Permits the compiler to assume the truth of the provided expression&period;
| xref:folly/compiler_may_unsafely_assume_separate_storage.adoc[`compiler&lowbar;may&lowbar;unsafely&lowbar;assume&lowbar;separate&lowbar;storage`] 
| Permits the compiler to assume the two pointers address separate storage&period;
| xref:folly/compiler_may_unsafely_assume_unreachable.adoc[`compiler&lowbar;may&lowbar;unsafely&lowbar;assume&lowbar;unreachable`]  [.small]#[noreturn]#
| Permits the compiler to assume that this statement cannot be reached&period;
| xref:folly/compiler_must_not_elide.adoc[`compiler&lowbar;must&lowbar;not&lowbar;elide`] 
| Marks `t` as used so its computation is not elided&period;
| xref:folly/compiler_must_not_predict.adoc[`compiler&lowbar;must&lowbar;not&lowbar;predict`] 
| Marks `t` as unpredictable so the compiler cannot optimize on its value&period;
| xref:folly/concurrent_lazy.adoc[`concurrent&lowbar;lazy`] 
| Creates a `ConcurrentLazy` with a type deduced from the callable&period;
| xref:folly/constCastFunction-0c.adoc[`constCastFunction`] 
| `constCastFunction` overloads
| xref:folly/const_pointer_cast-01.adoc[`const&lowbar;pointer&lowbar;cast`] 
| `const&lowbar;pointer&lowbar;cast` overloads
| xref:folly/const_span_cast-07.adoc[`const&lowbar;span&lowbar;cast`] 
| Casts `in` to a span of `U` over the same memory using const&lowbar;cast&period;
| xref:folly/constexprLoadUnaligned.adoc[`constexprLoadUnaligned`] 
| Read an unaligned value of type T and return it&period; Constexpr, but not optimized&period; Accepts inputs either of char&hyphen;array types or char&hyphen;backed enum&hyphen;array types&period;
| xref:folly/constexprPartialLoadUnaligned.adoc[`constexprPartialLoadUnaligned`] 
| Read an unaligned value of type T and return it&period; Constexpr, but not optimized&period; Accepts inputs either of char&hyphen;array types or char&hyphen;backed enum&hyphen;array types&period;
| xref:folly/constexpr_abs.adoc[`constexpr&lowbar;abs`] 
| Compute the absolute value of a number&period;
| xref:folly/constexpr_add_overflow_clamped.adoc[`constexpr&lowbar;add&lowbar;overflow&lowbar;clamped`] 
| Add two values, clamping to the type&apos;s range on overflow&period;
| xref:folly/constexpr_ceil-0e.adoc[`constexpr&lowbar;ceil`] 
| constexpr&lowbar;ceil
| xref:folly/constexpr_clamp-00.adoc[`constexpr&lowbar;clamp`] 
| `constexpr&lowbar;clamp` overloads
| xref:folly/constexpr_clamp_cast-01.adoc[`constexpr&lowbar;clamp&lowbar;cast`] 
| `constexpr&lowbar;clamp&lowbar;cast` overloads
| xref:folly/constexpr_exp-07.adoc[`constexpr&lowbar;exp`] 
| `constexpr&lowbar;exp` overloads
| xref:folly/constexpr_find_first_set.adoc[`constexpr&lowbar;find&lowbar;first&lowbar;set`] 
| constexpr&lowbar;find&lowbar;first&lowbar;set
| xref:folly/constexpr_find_last_set.adoc[`constexpr&lowbar;find&lowbar;last&lowbar;set`] 
| constexpr&lowbar;find&lowbar;last&lowbar;set
| xref:folly/constexpr_floor.adoc[`constexpr&lowbar;floor`] 
| constexpr&lowbar;floor
| xref:folly/constexpr_isnan.adoc[`constexpr&lowbar;isnan`] 
| Test whether a value is NaN&period;
| xref:folly/constexpr_log.adoc[`constexpr&lowbar;log`] 
| constexpr&lowbar;log
| xref:folly/constexpr_log2.adoc[`constexpr&lowbar;log2`] 
| Compute the integer base&hyphen;2 logarithm of a value&period;
| xref:folly/constexpr_log2_ceil.adoc[`constexpr&lowbar;log2&lowbar;ceil`] 
| Compute the ceiling of the integer base&hyphen;2 logarithm of a value&period;
| xref:folly/constexpr_max.adoc[`constexpr&lowbar;max`] 
| Return the maximum of the given values&period;
| xref:folly/constexpr_min.adoc[`constexpr&lowbar;min`] 
| Return the minimum of the given values&period;
| xref:folly/constexpr_mult.adoc[`constexpr&lowbar;mult`] 
| constexpr&lowbar;mult
| xref:folly/constexpr_pow-09.adoc[`constexpr&lowbar;pow`] 
| `constexpr&lowbar;pow` overloads
| xref:folly/constexpr_round.adoc[`constexpr&lowbar;round`] 
| constexpr&lowbar;round
| xref:folly/constexpr_strcmp.adoc[`constexpr&lowbar;strcmp`] 
| Compares two null&hyphen;terminated strings at compile time&period;
| xref:folly/constexpr_strlen.adoc[`constexpr&lowbar;strlen`] 
| Computes the length of a null&hyphen;terminated string at compile time&period;
| xref:folly/constexpr_sub_overflow_clamped.adoc[`constexpr&lowbar;sub&lowbar;overflow&lowbar;clamped`] 
| Subtract two values, clamping to the type&apos;s range on overflow&period;
| xref:folly/constexpr_trunc-05.adoc[`constexpr&lowbar;trunc`] 
| `constexpr&lowbar;trunc` overloads
| xref:folly/contains.adoc[`contains`] 
| This function checks whether container contains given key&period; Use container specific &period;contains() implementation if available, otherwise uses &period;find() implementation&period;
| xref:folly/convertTo.adoc[`convertTo`] 
| Return a well&hyphen;typed representation of a dynamic&period;
| xref:folly/copy.adoc[`copy`] 
| copy
| xref:folly/copy_through_shared_ptr.adoc[`copy&lowbar;through&lowbar;shared&lowbar;ptr`] 
| copy&lowbar;through&lowbar;shared&lowbar;ptr
| xref:folly/copy_through_unique_ptr.adoc[`copy&lowbar;through&lowbar;unique&lowbar;ptr`] 
| copy&lowbar;through&lowbar;unique&lowbar;ptr
| xref:folly/copy_to_erased_unique_ptr.adoc[`copy&lowbar;to&lowbar;erased&lowbar;unique&lowbar;ptr`] 
| copy&lowbar;to&lowbar;erased&lowbar;unique&lowbar;ptr
| xref:folly/copy_to_shared_ptr.adoc[`copy&lowbar;to&lowbar;shared&lowbar;ptr`] 
| copy&lowbar;to&lowbar;shared&lowbar;ptr
| xref:folly/copy_to_unique_ptr.adoc[`copy&lowbar;to&lowbar;unique&lowbar;ptr`] 
| copy&lowbar;to&lowbar;unique&lowbar;ptr
| xref:folly/coreFree.adoc[`coreFree`] 
| Frees memory allocated with coreMalloc()&period;
| xref:folly/coreMalloc.adoc[`coreMalloc`] 
| An allocator that can be used with AccessSpreader to allocate core&hyphen;local memory&period;
| xref:folly/crange-087.adoc[`crange`] 
| `crange` overloads
| xref:folly/crc32.adoc[`crc32`] 
| Compute the CRC&hyphen;32 checksum of a buffer, using a hardware&hyphen;accelerated implementation if available or a portable software implementation as a default&period;
| xref:folly/crc32_combine.adoc[`crc32&lowbar;combine`] 
| Given two checksums, combine them in to one checksum&period;
| xref:folly/crc32_type.adoc[`crc32&lowbar;type`] 
| Compute the CRC&hyphen;32 checksum of a buffer, using a hardware&hyphen;accelerated implementation if available or a portable software implementation as a default&period;
| xref:folly/crc32c.adoc[`crc32c`] 
| Compute the CRC&hyphen;32C checksum of a buffer, using a hardware&hyphen;accelerated implementation if available or a portable software implementation as a default&period;
| xref:folly/crc32c_combine.adoc[`crc32c&lowbar;combine`] 
| Combine two CRC&hyphen;32C checksums into one, like crc32&lowbar;combine() but using the CRC&hyphen;32C polynomial&period;
| xref:folly/crc32c_combine_seed.adoc[`crc32c&lowbar;combine&lowbar;seed`] 
| crc32c&lowbar;combine&lowbar;seed is the same as crc32c&lowbar;combine&period; Unlike crc32c&lowbar;combine that only works for crc32c computed using a starting checksum 0U, this method works for any starting checksum that is an uint32&lowbar;t&period;
| xref:folly/current_exception.adoc[`current&lowbar;exception`] 
| current&lowbar;exception
| xref:folly/current_exception_wrapper.adoc[`current&lowbar;exception&lowbar;wrapper`] 
| A convenience shorthand for `exception&lowbar;wrapper(current&lowbar;exception())`&period;
| xref:folly/deactivateAsyncStackFrame.adoc[`deactivateAsyncStackFrame`] 
| Deactivate the specified AsyncStackFrame, clearing the current &apos;topFrame&apos;&period;
| xref:folly/deactivateSuspendedLeaf.adoc[`deactivateSuspendedLeaf`] 
| Pop the dummy &quot;leaf&quot; frame off the stack to annotate the stack as having resumed&period;
| xref:folly/deallocateOverAligned.adoc[`deallocateOverAligned`] 
| Free storage for `n` values obtained from `allocateOverAligned`&period;
| xref:folly/decodeVarint.adoc[`decodeVarint`] 
| Decode a value from a given buffer, advances data past the returned value&period; Throws on error&period;
| xref:folly/decodeZigZag.adoc[`decodeZigZag`] 
| Reverse the ZigZag encoding produced by encodeZigZag&period;
| xref:folly/default_hazptr_domain.adoc[`default&lowbar;hazptr&lowbar;domain`] 
| Access the process&hyphen;wide default hazard pointer domain&period;
| xref:folly/defaulted.adoc[`defaulted`] 
| Wraps `c` so missing&hyphen;key lookups return `v` instead of throwing&period;
| xref:folly/demangle-07.adoc[`demangle`] 
| `demangle` overloads
| xref:folly/demangle_build_has_cxxabi.adoc[`demangle&lowbar;build&lowbar;has&lowbar;cxxabi`] 
| Report whether demangling was built with cxxabi support&period;
| xref:folly/demangle_build_has_liberty.adoc[`demangle&lowbar;build&lowbar;has&lowbar;liberty`] 
| Report whether demangling was built with libiberty support&period;
| xref:folly/didInsert.adoc[`didInsert`] 
| Returns whether an outcome represents a fresh insert or a revive&period;
| xref:folly/divCeil.adoc[`divCeil`] 
| Returns num&sol;denom, rounded toward positive infinity&period; Put another way, returns the smallest integral value that is greater than or equal to the exact (not rounded) fraction num&sol;denom&period;
| xref:folly/divFloor.adoc[`divFloor`] 
| Returns num&sol;denom, rounded toward negative infinity&period; Put another way, returns the largest integral value that is less than or equal to the exact (not rounded) fraction num&sol;denom&period;
| xref:folly/divRoundAway.adoc[`divRoundAway`] 
| Returns num&sol;denom, rounded away from zero&period; If num and denom are non&hyphen;zero and have different signs (so the unrounded fraction num&sol;denom is negative), returns divFloor, otherwise returns divCeil&period; If T is an unsigned type then this is always equal to divCeil&period;
| xref:folly/divTrunc.adoc[`divTrunc`] 
| Returns num&sol;denom, rounded toward zero&period; If num and denom are non&hyphen;zero and have different signs (so the unrounded fraction num&sol;denom is negative), returns divCeil, otherwise returns divFloor&period; If T is an unsigned type then this is always equal to divFloor&period;
| xref:folly/doNotOptimizeAway.adoc[`doNotOptimizeAway`] 
| Ensure that a value is computed even after optimization&period;
| xref:folly/down_cast-09.adoc[`down&lowbar;cast`] 
| `down&lowbar;cast` overloads
| xref:folly/down_heap-01.adoc[`down&lowbar;heap`] 
| `down&lowbar;heap` overloads
| xref:folly/dup2NoInt.adoc[`dup2NoInt`] 
| Duplicates a file descriptor onto another, retrying on EINTR&period;
| xref:folly/dupNoInt.adoc[`dupNoInt`] 
| Duplicates a file descriptor, retrying on EINTR&period;
| xref:folly/dynamic_pointer_cast-00.adoc[`dynamic&lowbar;pointer&lowbar;cast`] 
| `dynamic&lowbar;pointer&lowbar;cast` overloads
| xref:folly/emplacer.adoc[`emplacer`] 
| Convenience function to construct a folly&colon;&colon;emplace&lowbar;iterator, analogous to std&colon;&colon;inserter()&period;
| xref:folly/empty_erased_unique_ptr.adoc[`empty&lowbar;erased&lowbar;unique&lowbar;ptr`] 
| empty&lowbar;erased&lowbar;unique&lowbar;ptr
| xref:folly/enable_hazptr_thread_pool_executor.adoc[`enable&lowbar;hazptr&lowbar;thread&lowbar;pool&lowbar;executor`] 
| Route hazard pointer reclamation through the global CPU thread pool executor&period;
| xref:folly/encodeVarint.adoc[`encodeVarint`] 
| Encode a value in the given buffer, returning the number of bytes used for encoding&period; buf must have enough space to represent the value (at least kMaxVarintLength64 bytes to encode arbitrary 64&hyphen;bit values)
| xref:folly/encodeVarintSize.adoc[`encodeVarintSize`] 
| Determine the number of bytes needed to represent &quot;val&quot;&period; 32&hyphen;bit values need at most 5 bytes&period; 64&hyphen;bit values need at most 10 bytes&period;
| xref:folly/encodeZigZag.adoc[`encodeZigZag`] 
| ZigZag encoding that maps signed integers with a small absolute value to unsigned integers with a small (positive) values&period; Without this, encoding negative values using Varint would use up 9 or 10 bytes&period;
| xref:folly/ensureCleanupAfterTask.adoc[`ensureCleanupAfterTask`] 
| Composes a task with an async cleanup that always runs after it&period;
| xref:folly/enumerate.adoc[`enumerate`] 
| Adapts a range so a range&hyphen;based for loop can also observe the iteration index&period;
| xref:folly/epitaph-0e.adoc[`epitaph`] 
| `epitaph` overloads
| xref:folly/erase-0e6.adoc[`erase`] 
| `erase` overloads
| xref:folly/erase_if-000.adoc[`erase&lowbar;if`] 
| `erase&lowbar;if` overloads
| xref:folly/errnoStr.adoc[`errnoStr`] 
| Pretty print an errno&period;
| xref:folly/errorCategoryForErrnoDomain.adoc[`errorCategoryForErrnoDomain`] 
| Returns the most appropriate error category for `errno`&hyphen;domain codes on the current platform&period;
| xref:folly/estimateSpaceNeeded-0c1.adoc[`estimateSpaceNeeded`] 
| `estimateSpaceNeeded` overloads
| xref:folly/exceptionStr-08.adoc[`exceptionStr`] 
| `exceptionStr` overloads
| xref:folly/exception_ptr_access.adoc[`exception&lowbar;ptr&lowbar;access`] 
| Whether exception&hyphen;ptr object inspection is supported on this platform&period;
| xref:folly/exception_ptr_get_object-01.adoc[`exception&lowbar;ptr&lowbar;get&lowbar;object`] 
| `exception&lowbar;ptr&lowbar;get&lowbar;object` overloads
| xref:folly/exception_ptr_get_object_hint-02.adoc[`exception&lowbar;ptr&lowbar;get&lowbar;object&lowbar;hint`] 
| `exception&lowbar;ptr&lowbar;get&lowbar;object&lowbar;hint` overloads
| xref:folly/exception_ptr_get_type.adoc[`exception&lowbar;ptr&lowbar;get&lowbar;type`] 
| Returns the true runtime type info of the exception as stored&period;
| xref:folly/exception_ptr_try_get_object_exact_fast.adoc[`exception&lowbar;ptr&lowbar;try&lowbar;get&lowbar;object&lowbar;exact&lowbar;fast`] 
| exception&lowbar;ptr&lowbar;try&lowbar;get&lowbar;object&lowbar;exact&lowbar;fast
| xref:folly/exception_ptr_unique.adoc[`exception&lowbar;ptr&lowbar;unique`] 
| Returns whether the stored exception is uniquely referenced&period;
| xref:folly/exception_ptr_use_count.adoc[`exception&lowbar;ptr&lowbar;use&lowbar;count`] 
| Returns the reference count of the stored exception&period;
| xref:folly/exchange.adoc[`exchange`] 
| Replaces the state of a PrimaryPtr with a new value and returns the old one&period;
| xref:folly/exchangeCurrentAsyncStackRoot.adoc[`exchangeCurrentAsyncStackRoot`] 
| Exchange the current thread&apos;s active AsyncStackRoot with the specified AsyncStackRoot pointer, returning the old AsyncStackRoot pointer&period;
| xref:folly/extractFirstSet.adoc[`extractFirstSet`] 
| extractFirstSet
| xref:folly/fdatasyncNoInt.adoc[`fdatasyncNoInt`] 
| Synchronizes a file&apos;s data to storage, retrying on EINTR&period;
| xref:folly/fetch.adoc[`fetch`] 
| Utility method to help access elements of a sequence with one uniform interface&period;
| xref:folly/findFirstSet-0f.adoc[`findFirstSet`] 
| `findFirstSet` overloads
| xref:folly/findFixed.adoc[`findFixed`] 
| Linear search for a value in a range whose size is known at compile time&period;
| xref:folly/findLastSet.adoc[`findLastSet`] 
| findLastSet
| xref:folly/fingerprint128.adoc[`fingerprint128`] 
| Compute the 128&hyphen;bit Rabin fingerprint of a string&period; Return the 64 most significant bits in &ast;msb, and the 64 least significant bits in &ast;lsb&period;
| xref:folly/fingerprint64.adoc[`fingerprint64`] 
| Return the 64&hyphen;bit Rabin fingerprint of a string&period;
| xref:folly/fingerprint96.adoc[`fingerprint96`] 
| Compute the 96&hyphen;bit Rabin fingerprint of a string&period; Return the 64 most significant bits in &ast;msb, and the 32 least significant bits in &ast;lsb&period;
| xref:folly/flockNoInt.adoc[`flockNoInt`] 
| Applies an advisory lock, retrying on EINTR&period;
| xref:folly/fmap_shared_ptr_aliasing-07.adoc[`fmap&lowbar;shared&lowbar;ptr&lowbar;aliasing`] 
| `fmap&lowbar;shared&lowbar;ptr&lowbar;aliasing` overloads
| xref:folly/fmt_make_format_args_from_map.adoc[`fmt&lowbar;make&lowbar;format&lowbar;args&lowbar;from&lowbar;map`] 
| Builds a dynamic format&hyphen;args store from the key&sol;value pairs in `map`&period;
| xref:folly/fmt_vformat_mangle_name-0b.adoc[`fmt&lowbar;vformat&lowbar;mangle&lowbar;name`] 
| `fmt&lowbar;vformat&lowbar;mangle&lowbar;name` overloads
| xref:folly/for_each.adoc[`for&lowbar;each`] 
| folly&colon;&colon;for&lowbar;each is a generalized iteration algorithm&period; Example&colon;
| xref:folly/format-0af.adoc[`format`] 
| `format` overloads
| xref:folly/forward_like.adoc[`forward&lowbar;like`] 
| Forwards a value with the value category of another type&period;
| xref:folly/forward_tuple.adoc[`forward&lowbar;tuple`] 
| Get a tuple of references from the passed tuple, forwarding will be applied on the individual types of the tuple based on the value category of the passed tuple
| xref:folly/front_emplacer.adoc[`front&lowbar;emplacer`] 
| Convenience function to construct a folly&colon;&colon;front&lowbar;emplace&lowbar;iterator, analogous to std&colon;&colon;front&lowbar;inserter()&period;
| xref:folly/fsyncNoInt.adoc[`fsyncNoInt`] 
| Synchronizes a file&apos;s state to storage, retrying on EINTR&period;
| xref:folly/ftruncateNoInt.adoc[`ftruncateNoInt`] 
| Truncates a file by descriptor, retrying on EINTR&period;
| xref:folly/getAsyncStackTraceFromInitialFrame.adoc[`getAsyncStackTraceFromInitialFrame`] 
| Given an initial AsyncStackFrame, this will write `addresses` with the return addresses of the frames in this async stack trace, up to `maxAddresses` written&period; This assumes `addresses` has `maxAddresses` allocated space available&period;
| xref:folly/getBaseLoggingConfig.adoc[`getBaseLoggingConfig`] 
| folly&colon;&colon;getBaseLoggingConfig() allows individual executables to easily customize their default logging configuration&period;
| xref:folly/getCPUExecutor.adoc[`getCPUExecutor`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/getCurrentAsyncStackRoot.adoc[`getCurrentAsyncStackRoot`] 
| Get access to the current thread&apos;s top&hyphen;most AsyncStackRoot&period;
| xref:folly/getCurrentThreadID.adoc[`getCurrentThreadID`] 
| Get a process&hyphen;specific identifier for the current thread&period;
| xref:folly/getCurrentThreadName.adoc[`getCurrentThreadName`] 
| Equivalent to getThreadName(std&colon;&colon;this&lowbar;thread&colon;&colon;get&lowbar;id())&semi;
| xref:folly/getDetachedRootAsyncStackFrame.adoc[`getDetachedRootAsyncStackFrame`] 
| Get a pointer to a special frame that can be used as the root&hyphen;frame for a chain of AsyncStackFrame that does not chain onto a normal call&hyphen;stack&period;
| xref:folly/getEventBase.adoc[`getEventBase`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/getExecutorBlockingContext.adoc[`getExecutorBlockingContext`] 
| Returns the current thread&apos;s executor blocking context, if any is active&period;
| xref:folly/getGlobalCPUExecutor.adoc[`getGlobalCPUExecutor`] 
| methodset Executors
| xref:folly/getGlobalCPUExecutorCounters.adoc[`getGlobalCPUExecutorCounters`] 
| methodset Executors
| xref:folly/getGlobalCPUExecutorWeakRef.adoc[`getGlobalCPUExecutorWeakRef`] 
| methodset Executors
| xref:folly/getGlobalIOExecutor.adoc[`getGlobalIOExecutor`] 
| methodset Executors
| xref:folly/getHugePageSize.adoc[`getHugePageSize`] 
| Return the mount point for the requested huge page size&period; 0 &equals; use smallest available&period; Returns nullptr if the requested huge page size is not available&period;
| xref:folly/getHugePageSizeForDevice.adoc[`getHugePageSizeForDevice`] 
| Return the huge page size for a device&period; returns nullptr if device does not refer to a huge page filesystem&period;
| xref:folly/getHugePageSizes.adoc[`getHugePageSizes`] 
| Get list of supported huge page sizes and their mount points, if hugetlbfs file systems are mounted for those sizes&period;
| xref:folly/getIOExecutor.adoc[`getIOExecutor`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/getJEMallocMallctlArenasAll.adoc[`getJEMallocMallctlArenasAll`] 
| Return value of MALLCTL&lowbar;ARENAS&lowbar;ALL defined in jemalloc&apos;s header&period;
| xref:folly/getKeepAliveToken-0e.adoc[`getKeepAliveToken`] 
| `getKeepAliveToken` overloads
| xref:folly/getOSThreadID.adoc[`getOSThreadID`] 
| Get the operating&hyphen;system level thread ID for the current thread&period;
| xref:folly/getRefOrDefault-0a.adoc[`getRefOrDefault`] 
| `getRefOrDefault` overloads
| xref:folly/getTCMallocNumericProperty.adoc[`getTCMallocNumericProperty`] 
| Gets the named property&period;
| xref:folly/getTerminateCancellationToken.adoc[`getTerminateCancellationToken`] 
| Returns a CancellationToken that can be used to schedule callbacks&period; The CancellationToken is cancelled when any of SIGTERM and SIGINT signal is received&period;
| xref:folly/getThreadName.adoc[`getThreadName`] 
| Get the name of the given thread, or nothing if an error occurs or the functionality is not available&period;
| xref:folly/getUnsafeMutableGlobalCPUExecutor.adoc[`getUnsafeMutableGlobalCPUExecutor`] 
| methodset Executors
| xref:folly/getUnsafeMutableGlobalEventBase.adoc[`getUnsafeMutableGlobalEventBase`] 
| methodset Executors
| xref:folly/getUnsafeMutableGlobalIOExecutor.adoc[`getUnsafeMutableGlobalIOExecutor`] 
| methodset Executors
| xref:folly/getWeakRef.adoc[`getWeakRef`] 
| Returns a weak keep&hyphen;alive to `executor` that does not extend its lifetime&period;
| xref:folly/getXlogCategoryNameForFile.adoc[`getXlogCategoryNameForFile`] 
| Get the default XLOG() category name for the given filename&period;
| xref:folly/get_bit_at.adoc[`get&lowbar;bit&lowbar;at`] 
| Read the bit at position idx from an array of unsigned integers&period;
| xref:folly/get_cached_pid.adoc[`get&lowbar;cached&lowbar;pid`] 
| Calls getpid() and returns the returned value, with a thread&hyphen;safe cache in front&period; The cache is updated in the child after fork()&period;
| xref:folly/get_deadlock_detector_factory_instance.adoc[`get&lowbar;deadlock&lowbar;detector&lowbar;factory&lowbar;instance`] 
| Weak hook resolving to the deadlock detector factory instance getter&period;
| xref:folly/get_default-0f.adoc[`get&lowbar;default`] 
| `get&lowbar;default` overloads
| xref:folly/get_deleter.adoc[`get&lowbar;deleter`] 
| Getters
| xref:folly/get_emplace_arg-07.adoc[`get&lowbar;emplace&lowbar;arg`] 
| `get&lowbar;emplace&lowbar;arg` overloads
| xref:folly/get_exception-0e.adoc[`get&lowbar;exception`] 
| `get&lowbar;exception` overloads
| xref:folly/get_mutable_exception-04.adoc[`get&lowbar;mutable&lowbar;exception`] 
| `get&lowbar;mutable&lowbar;exception` overloads
| xref:folly/get_optional-07.adoc[`get&lowbar;optional`] 
| `get&lowbar;optional` overloads
| xref:folly/get_or_throw-0a.adoc[`get&lowbar;or&lowbar;throw`] 
| `get&lowbar;or&lowbar;throw` overloads
| xref:folly/get_pointer-090.adoc[`get&lowbar;pointer`] 
| `get&lowbar;pointer` overloads
| xref:folly/get_process_phase.adoc[`get&lowbar;process&lowbar;phase`] 
| Get the current process phase&period;
| xref:folly/get_ptr-0fe.adoc[`get&lowbar;ptr`] 
| `get&lowbar;ptr` overloads
| xref:folly/get_ptr2-04.adoc[`get&lowbar;ptr2`] 
| Same as `get&lowbar;ptr` but for `find` variants that search for two keys at once&period;
| xref:folly/get_ref_default-04.adoc[`get&lowbar;ref&lowbar;default`] 
| `get&lowbar;ref&lowbar;default` overloads
| xref:folly/get_rich_error-032.adoc[`get&lowbar;rich&lowbar;error`] 
| `get&lowbar;rich&lowbar;error` overloads
| xref:folly/get_underlying-08.adoc[`get&lowbar;underlying`] 
| `get&lowbar;underlying` overloads
| xref:folly/getline-04.adoc[`getline`] 
| `getline` overloads
| xref:folly/globalJemallocNodumpAllocator.adoc[`globalJemallocNodumpAllocator`] 
| JemallocNodumpAllocator singleton&period;
| xref:folly/goodMallocSize.adoc[`goodMallocSize`] 
| Simple wrapper around nallocx
| xref:folly/greater_than.adoc[`greater&lowbar;than`] 
| Safely compares whether `lhs` is greater than the compile&hyphen;time constant `rhs`&period;
| xref:folly/grow_capacity_by.adoc[`grow&lowbar;capacity&lowbar;by`] 
| Grows `c` to accommodate `n` additional elements with geometric growth&period;
| xref:folly/hardware_timestamp.adoc[`hardware&lowbar;timestamp`] 
| Returns a hardware timestamp counter value&period;
| xref:folly/hardware_timestamp_measurement_start.adoc[`hardware&lowbar;timestamp&lowbar;measurement&lowbar;start`] 
| hardware&lowbar;timestamp&lowbar;measurement&lowbar;start hardware&lowbar;timestamp&lowbar;measurement&lowbar;stop
| xref:folly/hardware_timestamp_measurement_stop.adoc[`hardware&lowbar;timestamp&lowbar;measurement&lowbar;stop`] 
| Ends precise measurement of a region of code and returns a timestamp&period;
| xref:folly/hasSpaceOrCntrlSymbols.adoc[`hasSpaceOrCntrlSymbols`] 
| Returns if string contains std&colon;&colon;isspace or std&colon;&colon;iscntrl characters&period;
| xref:folly/hash_value-0a.adoc[`hash&lowbar;value`] 
| `hash&lowbar;value` overloads
| xref:folly/hazard_pointer_clean_up.adoc[`hazard&lowbar;pointer&lowbar;clean&lowbar;up`] 
| Reclaim all retired objects in a domain that are no longer protected&period;
| xref:folly/hazard_pointer_default_domain.adoc[`hazard&lowbar;pointer&lowbar;default&lowbar;domain`] 
| Access the process&hyphen;wide default hazard pointer domain&period;
| xref:folly/hazptr_cleanup.adoc[`hazptr&lowbar;cleanup`] 
| Reclaim all retired objects in a domain that are no longer protected&period;
| xref:folly/hazptr_domain_push_retired-04.adoc[`hazptr&lowbar;domain&lowbar;push&lowbar;retired`] 
| Push a list of retired objects into a domain for later reclamation&period;
| xref:folly/hazptr_retire.adoc[`hazptr&lowbar;retire`] 
| Retire an object so it is reclaimed once no hazard pointer protects it&period;
| xref:folly/hazptr_tc_evict-08.adoc[`hazptr&lowbar;tc&lowbar;evict`] 
| hazptr&lowbar;tc&lowbar;evict &hyphen;&hyphen; Used only for benchmarking
| xref:folly/hazptr_tc_tls.adoc[`hazptr&lowbar;tc&lowbar;tls`] 
| Access the thread&hyphen;local hazard pointer cache&period;
| xref:folly/hazptr_use_executor.adoc[`hazptr&lowbar;use&lowbar;executor`] 
| Report whether hazard pointer reclamation may use an executor&period;
| xref:folly/hexDump-05.adoc[`hexDump`] 
| `hexDump` overloads
| xref:folly/hex_decode_digit.adoc[`hex&lowbar;decode&lowbar;digit`] 
| hex&lowbar;decode&lowbar;digit
| xref:folly/hex_decode_digit_flavor_aarch64.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;flavor&lowbar;aarch64`] 
| hex&lowbar;decode&lowbar;digit&lowbar;flavor&lowbar;aarch64
| xref:folly/hex_decode_digit_flavor_x86_64.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;flavor&lowbar;x86&lowbar;64`] 
| hex&lowbar;decode&lowbar;digit&lowbar;flavor&lowbar;x86&lowbar;64
| xref:folly/hex_decode_digit_raw.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;raw`] 
| hex&lowbar;decode&lowbar;digit&lowbar;raw
| xref:folly/hex_decode_digit_raw_flavor_aarch64.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;raw&lowbar;flavor&lowbar;aarch64`] 
| hex&lowbar;decode&lowbar;digit&lowbar;raw&lowbar;flavor&lowbar;aarch64
| xref:folly/hex_decode_digit_raw_flavor_x86_64.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;raw&lowbar;flavor&lowbar;x86&lowbar;64`] 
| hex&lowbar;decode&lowbar;digit&lowbar;raw&lowbar;flavor&lowbar;x86&lowbar;64
| xref:folly/hex_decode_digit_table.adoc[`hex&lowbar;decode&lowbar;digit&lowbar;table`] 
| hex&lowbar;decode&lowbar;digit&lowbar;table
| xref:folly/hex_decoded_digit_is_valid.adoc[`hex&lowbar;decoded&lowbar;digit&lowbar;is&lowbar;valid`] 
| hex&lowbar;decoded&lowbar;digit&lowbar;is&lowbar;valid
| xref:folly/hex_is_digit.adoc[`hex&lowbar;is&lowbar;digit`] 
| hex&lowbar;is&lowbar;digit
| xref:folly/hex_is_digit_flavor_aarch64.adoc[`hex&lowbar;is&lowbar;digit&lowbar;flavor&lowbar;aarch64`] 
| hex&lowbar;is&lowbar;digit&lowbar;flavor&lowbar;aarch64
| xref:folly/hex_is_digit_flavor_x86_64.adoc[`hex&lowbar;is&lowbar;digit&lowbar;flavor&lowbar;x86&lowbar;64`] 
| hex&lowbar;is&lowbar;digit&lowbar;flavor&lowbar;x86&lowbar;64
| xref:folly/hex_is_digit_table.adoc[`hex&lowbar;is&lowbar;digit&lowbar;table`] 
| hex&lowbar;is&lowbar;digit&lowbar;table
| xref:folly/hexlify-0b8.adoc[`hexlify`] 
| `hexlify` overloads
| xref:folly/hint_emplacer.adoc[`hint&lowbar;emplacer`] 
| Convenience function to construct a folly&colon;&colon;hint&lowbar;emplace&lowbar;iterator, analogous to std&colon;&colon;inserter()&period;
| xref:folly/humanify-0d.adoc[`humanify`] 
| `humanify` overloads
| xref:folly/identity-08.adoc[`identity`] 
| Returns the argument unchanged&period;
| xref:folly/init-0b.adoc[`init`]  [.small]#[deprecated]#
| Initializes folly (deprecated non&hyphen;RAII form)&period;
| xref:folly/initLogging-06.adoc[`initLogging`] 
| `initLogging` overloads
| xref:folly/initLoggingOrDie-0d.adoc[`initLoggingOrDie`] 
| `initLoggingOrDie` overloads
| xref:folly/initializeLoggerDB.adoc[`initializeLoggerDB`] 
| initializeLoggerDB() will be called to configure the main LoggerDB singleton the first time that LoggerDB&colon;&colon;get() is called&period;
| xref:folly/invocable_to.adoc[`invocable&lowbar;to`] 
| Wraps the invocable for lazy conversion to its result type&period;
| xref:folly/invoke_cold-0ab.adoc[`invoke&lowbar;cold`] 
| `invoke&lowbar;cold` overloads
| xref:folly/invoke_noreturn_cold.adoc[`invoke&lowbar;noreturn&lowbar;cold`]  [.small]#[noreturn]#
| invoke&lowbar;noreturn&lowbar;cold
| xref:folly/irange-0f.adoc[`irange`] 
| `irange` overloads
| xref:folly/isLogLevelFatal.adoc[`isLogLevelFatal`] 
| Returns true if and only if a LogLevel is fatal&period;
| xref:folly/isPowTwo.adoc[`isPowTwo`] 
| Return true if and only if v is a power of two&period;
| xref:folly/isSet.adoc[`isSet`] 
| Tests whether all flags of `b` are set in `a&period;`
| xref:folly/isSuspendedLeafActive.adoc[`isSuspendedLeafActive`] 
| Returns whether the given leaf frame is currently an active suspended leaf&period;
| xref:folly/is_constant_evaluated_or.adoc[`is&lowbar;constant&lowbar;evaluated&lowbar;or`] 
| Reports whether evaluation occurs in a constant context, with a default&period;
| xref:folly/is_negative.adoc[`is&lowbar;negative`] 
| Determines whether a value is negative, the same as `x &lt; 0`&period;
| xref:folly/is_non_negative.adoc[`is&lowbar;non&lowbar;negative`] 
| Determines whether a value is non&hyphen;negative, the same as `x &gt;&equals; 0`&period;
| xref:folly/is_non_positive.adoc[`is&lowbar;non&lowbar;positive`] 
| Determines whether a value is non&hyphen;positive, the same as `x &lt;&equals; 0`&period;
| xref:folly/is_positive.adoc[`is&lowbar;positive`] 
| Determines whether a value is positive, the same as `x &gt; 0`&period;
| xref:folly/join-03a.adoc[`join`] 
| `join` overloads
| xref:folly/kahan_sum-0a.adoc[`kahan&lowbar;sum`] 
| `kahan&lowbar;sum` overloads
| xref:folly/lazy.adoc[`lazy`] 
| Creates a lazy value whose initialization is deferred until first use&period;
| xref:folly/less_than.adoc[`less&lowbar;than`] 
| Safely compares whether `lhs` is less than the compile&hyphen;time constant `rhs`&period;
| xref:folly/linux_syscall_openat2.adoc[`linux&lowbar;syscall&lowbar;openat2`] 
| linux&lowbar;syscall&lowbar;openat2
| xref:folly/loadUnaligned.adoc[`loadUnaligned`] 
| Read an unaligned value of type T and return it&period;
| xref:folly/lock-00.adoc[`lock`] 
| `lock` overloads
| xref:folly/logConfigToDynamic-04.adoc[`logConfigToDynamic`] 
| `logConfigToDynamic` overloads
| xref:folly/logDisabledHelper-0e.adoc[`logDisabledHelper`] 
| `logDisabledHelper` overloads
| xref:folly/logLevelToString.adoc[`logLevelToString`] 
| Get a human&hyphen;readable string representing the LogLevel&period;
| xref:folly/ltrim.adoc[`ltrim`] 
| Specify characters to ltrim&period;
| xref:folly/ltrimWhitespace.adoc[`ltrimWhitespace`] 
| Remove leading whitespace&period;
| xref:folly/makeAutoTimer.adoc[`makeAutoTimer`] 
| Creates an `AutoTimer` with deduced logger and clock types&period;
| xref:folly/makeBitIterator.adoc[`makeBitIterator`] 
| Helper function, so you can write auto bi &equals; makeBitIterator(container&period;begin())&semi;
| xref:folly/makeConversionError.adoc[`makeConversionError`] 
| Custom Error Translation
| xref:folly/makeDelayedDestructionUniquePtr.adoc[`makeDelayedDestructionUniquePtr`] 
| Creates a DelayedDestructionUniquePtr owning a new object&period;
| xref:folly/makeDismissedGuard.adoc[`makeDismissedGuard`] 
| Create a scope guard in the dismissed state&period;
| xref:folly/makeExpected.adoc[`makeExpected`] 
| For constructing an Expected object from a value, with the specified Error type&period; Usage is as follows&colon;
| xref:folly/makeFixedString.adoc[`makeFixedString`] 
| &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; Construct a `BasicFixedString` object from a null&hyphen;terminated array of characters&period; The capacity and size of the string will be equal to one less than the size of the array&period;
| xref:folly/makeGuard.adoc[`makeGuard`] 
| Create a scope guard&period;
| xref:folly/makeMoveWrapper.adoc[`makeMoveWrapper`] 
| Make a MoveWrapper from the argument&period; Because the name &quot;makeMoveWrapper&quot; is already quite transparent in its intent, this will work for lvalues as if you had wrapped them in std&colon;&colon;move&period;
| xref:folly/makeSystemError-02.adoc[`makeSystemError`] 
| `makeSystemError` overloads
| xref:folly/makeSystemErrorExplicit-07.adoc[`makeSystemErrorExplicit`] 
| `makeSystemErrorExplicit` overloads
| xref:folly/makeTryWith-02.adoc[`makeTryWith`] 
| `makeTryWith` overloads
| xref:folly/makeTryWithNoUnwrap-01.adoc[`makeTryWithNoUnwrap`] 
| `makeTryWithNoUnwrap` overloads
| xref:folly/makeUnexpected.adoc[`makeUnexpected`] 
| For constructing an Unexpected object from an error code&period; Unexpected objects are implicitly convertible to Expected object in the error state&period; Usage is as follows&colon;
| xref:folly/makeUnpredictable.adoc[`makeUnpredictable`] 
| Hide a value from the optimizer so it cannot shape the following code&period;
| xref:folly/make_array.adoc[`make&lowbar;array`] 
| Constructs a std&colon;&colon;array with the given argument list&period;
| xref:folly/make_array_with.adoc[`make&lowbar;array&lowbar;with`] 
| Generates a std&colon;&colon;array&lt;&period;&period;&period;, Size&gt; with elements m(i) for i in &lsqb;0, Size)&period;&rsqb;
| xref:folly/make_atomic_ref.adoc[`make&lowbar;atomic&lowbar;ref`] 
| Build an atomic&lowbar;ref referring to the given object&period;
| xref:folly/make_coded_rich_error-0a.adoc[`make&lowbar;coded&lowbar;rich&lowbar;error`] 
| `make&lowbar;coded&lowbar;rich&lowbar;error` overloads
| xref:folly/make_dynamic_view-03c.adoc[`make&lowbar;dynamic&lowbar;view`] 
| `make&lowbar;dynamic&lowbar;view` overloads
| xref:folly/make_emplace_args.adoc[`make&lowbar;emplace&lowbar;args`] 
| Pack arguments in a tuple for assignment to a folly&colon;&colon;emplace&lowbar;iterator, folly&colon;&colon;front&lowbar;emplace&lowbar;iterator, or folly&colon;&colon;back&lowbar;emplace&lowbar;iterator&period; The iterator&apos;s operator&equals; will unpack the tuple and pass the unpacked arguments to the container&apos;s emplace function, which in turn forwards the arguments to the (multi&hyphen;argument) constructor of the target class&period;
| xref:folly/make_erased_unique.adoc[`make&lowbar;erased&lowbar;unique`] 
| make&lowbar;erased&lowbar;unique
| xref:folly/make_error_code.adoc[`make&lowbar;error&lowbar;code`] 
| Builds a std&colon;&colon;error&lowbar;code from an args&hyphen;file expansion error code&period;
| xref:folly/make_exception_ptr_with-0f.adoc[`make&lowbar;exception&lowbar;ptr&lowbar;with`] 
| `make&lowbar;exception&lowbar;ptr&lowbar;with` overloads
| xref:folly/make_exception_wrapper.adoc[`make&lowbar;exception&lowbar;wrapper`] 
| Builds an `exception&lowbar;wrapper` wrapping a newly constructed exception&period;
| xref:folly/make_hazard_pointer-0c.adoc[`make&lowbar;hazard&lowbar;pointer`] 
| `make&lowbar;hazard&lowbar;pointer` overloads
| xref:folly/make_hazard_pointer_array-00.adoc[`make&lowbar;hazard&lowbar;pointer&lowbar;array`] 
| `make&lowbar;hazard&lowbar;pointer&lowbar;array` overloads
| xref:folly/make_inheriting_coded_rich_error-0a.adoc[`make&lowbar;inheriting&lowbar;coded&lowbar;rich&lowbar;error`] 
| `make&lowbar;inheriting&lowbar;coded&lowbar;rich&lowbar;error` overloads
| xref:folly/make_nestable_coded_rich_error-06.adoc[`make&lowbar;nestable&lowbar;coded&lowbar;rich&lowbar;error`] 
| `make&lowbar;nestable&lowbar;coded&lowbar;rich&lowbar;error` overloads
| xref:folly/make_not_null_shared.adoc[`make&lowbar;not&lowbar;null&lowbar;shared`] 
| Creates a not&lowbar;null&lowbar;shared&lowbar;ptr, like std&colon;&colon;make&lowbar;shared&period;
| xref:folly/make_not_null_unique.adoc[`make&lowbar;not&lowbar;null&lowbar;unique`] 
| Creates a not&lowbar;null&lowbar;unique&lowbar;ptr, like std&colon;&colon;make&lowbar;unique&period;
| xref:folly/make_optional-07.adoc[`make&lowbar;optional`] 
| `make&lowbar;optional` overloads
| xref:folly/make_replaceable-0d.adoc[`make&lowbar;replaceable`] 
| `make&lowbar;replaceable` overloads
| xref:folly/make_std_seed_seq.adoc[`make&lowbar;std&lowbar;seed&lowbar;seq`] 
| Constructs a std&colon;&colon;seed&lowbar;seq from the given seed value&period;
| xref:folly/mallctlCall.adoc[`mallctlCall`] 
| Invokes a `mallctl` command that neither reads nor writes a value&period;
| xref:folly/mallctlRead.adoc[`mallctlRead`] 
| Reads a value from jemalloc through the named `mallctl` command&period;
| xref:folly/mallctlReadWrite.adoc[`mallctlReadWrite`] 
| Writes a value and reads the previous one through the named `mallctl` command&period;
| xref:folly/mallctlWrite.adoc[`mallctlWrite`] 
| Writes a value to jemalloc through the named `mallctl` command&period;
| xref:folly/manual_safe_callable.adoc[`manual&lowbar;safe&lowbar;callable`] 
| Wraps a callable, asserting the given safety level&semi; see `manual&lowbar;safe&lowbar;callable&lowbar;t`&period;
| xref:folly/manual_safe_ref.adoc[`manual&lowbar;safe&lowbar;ref`] 
| Wraps a reference, asserting the given safety level&semi; see `manual&lowbar;safe&lowbar;ref&lowbar;t`&period;
| xref:folly/manual_safe_val.adoc[`manual&lowbar;safe&lowbar;val`] 
| Wraps a value, asserting the given safety level&semi; see `manual&lowbar;safe&lowbar;val&lowbar;t`&period;
| xref:folly/manual_safe_with.adoc[`manual&lowbar;safe&lowbar;with`] 
| Wraps the result of `fn`, asserting the given safety level&period;
| xref:folly/match_empty_function_protocol-046.adoc[`match&lowbar;empty&lowbar;function&lowbar;protocol`] 
| `match&lowbar;empty&lowbar;function&lowbar;protocol` overloads
| xref:folly/memory_order_load.adoc[`memory&lowbar;order&lowbar;load`] 
| The load part of a possibly&hyphen;composite memory order&period;
| xref:folly/memory_order_store.adoc[`memory&lowbar;order&lowbar;store`] 
| The store part of a possibly&hyphen;composite memory order&period;
| xref:folly/memrchr-0c.adoc[`memrchr`] 
| `memrchr` overloads
| xref:folly/merge-0b.adoc[`merge`] 
| `merge` overloads
| xref:folly/midpoint-06.adoc[`midpoint`] 
| `midpoint` overloads
| xref:folly/mlock2wrapper.adoc[`mlock2wrapper`] 
| mlock2 is Linux&hyphen;only and exists since Linux 4&period;4 On Linux pre&hyphen;4&period;4 and other platforms fail with ENOSYS&period; glibc added the mlock2 wrapper in 2&period;27 https&colon;&sol;&sol;lists&period;gnu&period;org&sol;archive&sol;html&sol;info&hyphen;gnu&sol;2018&hyphen;02&sol;msg00000&period;html
| xref:folly/mmapFileCopy.adoc[`mmapFileCopy`] 
| Copy a file using mmap()&period; Overwrites dest&period;
| xref:folly/n_least_significant_bits.adoc[`n&lowbar;least&lowbar;significant&lowbar;bits`] 
| Return a value of type T with the n least significant bits set&period;
| xref:folly/n_most_significant_bits.adoc[`n&lowbar;most&lowbar;significant&lowbar;bits`] 
| Return a value of type T with the n most significant bits set&period;
| xref:folly/nextPowTwo.adoc[`nextPowTwo`] 
| Return the smallest power of two that is greater than or equal to v&period;
| xref:folly/object_from_member-0a.adoc[`object&lowbar;from&lowbar;member`] 
| `object&lowbar;from&lowbar;member` overloads
| xref:folly/openNoInt.adoc[`openNoInt`] 
| Convenience wrappers around some commonly used system calls&period; The &ast;NoInt wrappers retry on EINTR&period; The &ast;Full wrappers retry on EINTR and also loop until all data is written&period; Note that &ast;Full wrappers weaken the thread semantics of underlying system calls&period;
| xref:folly/operator_coawait-0b.adoc[`operator co&lowbar;await`] 
| Coawait operators
| xref:folly/operator_csv.adoc[`operator&quot;&quot;&lowbar;csv`] 
| User&hyphen;defined literal building a cstring&lowbar;view from a string literal&period;
| xref:folly/operator_fs.adoc[`operator&quot;&quot;&lowbar;fs`] 
| &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast;&ast; &ast; User&hyphen;defined literals for creating FixedString objects from string literals on the compilers that support it&period;
| xref:folly/operator_fs128.adoc[`operator&quot;&quot;&lowbar;fs128`] 
| Creates a `FixedString&lt;128&gt;` from a string literal&period;
| xref:folly/operator_fs16.adoc[`operator&quot;&quot;&lowbar;fs16`] 
| Creates a `FixedString&lt;16&gt;` from a string literal&period;
| xref:folly/operator_fs32.adoc[`operator&quot;&quot;&lowbar;fs32`] 
| Creates a `FixedString&lt;32&gt;` from a string literal&period;
| xref:folly/operator_fs4.adoc[`operator&quot;&quot;&lowbar;fs4`] 
| Creates a `FixedString&lt;4&gt;` from a string literal&period;
| xref:folly/operator_fs64.adoc[`operator&quot;&quot;&lowbar;fs64`] 
| Creates a `FixedString&lt;64&gt;` from a string literal&period;
| xref:folly/operator_fs8.adoc[`operator&quot;&quot;&lowbar;fs8`] 
| Creates a `FixedString&lt;8&gt;` from a string literal&period;
| xref:folly/operator_lit.adoc[`operator&quot;&quot;&lowbar;lit`] 
| User&hyphen;defined literal yielding the literal string value&period;
| xref:folly/operator_litv.adoc[`operator&quot;&quot;&lowbar;litv`] 
| User&hyphen;defined literal yielding a value tag of the literal string&period;
| xref:folly/operator_shellify.adoc[`operator&quot;&quot;&lowbar;shellify`] 
| Creates a shell command formatter from a string literal&period;
| xref:folly/operator_sp-0d.adoc[`operator&quot;&quot;&lowbar;sp`] 
| `operator&quot;&quot;&lowbar;sp` overloads
| xref:folly/operator_uzic.adoc[`operator&quot;&quot;&lowbar;uzic`] 
| operator&quot;&quot;&lowbar;uzic
| xref:folly/operator_mod-06.adoc[`operator%`] 
| Modulus operators
| xref:folly/operator_mod_eq.adoc[`operator%&equals;`] 
| operator%&equals;
| xref:folly/operator_bitand-05.adoc[`operator&amp;`] 
| Bitwise conjunction operators
| xref:folly/operator_and_eq.adoc[`operator&amp;&equals;`] 
| Intersects `a` with `b` in place&period;
| xref:folly/operator_star.adoc[`operator&ast;`] 
| Multiplies two dynamics&period;
| xref:folly/operator_plus-0bb.adoc[`operator&plus;`] 
| Addition operators
| xref:folly/operator_plus_eq.adoc[`operator&plus;&equals;`] 
| Add an integer to a LogLevel in place, capping at LogLevel&colon;&colon;MAX&lowbar;LEVEL&period;
| xref:folly/operator_minus-07.adoc[`operator&hyphen;`] 
| Subtraction operators
| xref:folly/operator_minus_eq.adoc[`operator&hyphen;&equals;`] 
| Subtract an integer from a LogLevel in place&period;
| xref:folly/operator_slash-06.adoc[`operator&sol;`] 
| Division operators
| xref:folly/operator_slash_eq.adoc[`operator&sol;&equals;`] 
| operator&sol;&equals;
| xref:folly/operator_rshift-072.adoc[`operator&gt;&gt;`] 
| Right shift operators
| xref:folly/operator_xor.adoc[`operator&circ;`] 
| Bitwise&hyphen;XORs two dynamics&period;
| xref:folly/operator_delete-07.adoc[`operator&lowbar;delete`] 
| `operator&lowbar;delete` overloads
| xref:folly/operator_new-0b.adoc[`operator&lowbar;new`] 
| `operator&lowbar;new` overloads
| xref:folly/operator_bitor-0e.adoc[`operator&verbar;`] 
| Bitwise disjunction operators
| xref:folly/operator_or_eq.adoc[`operator&verbar;&equals;`] 
| Unions `b` into `a` in place&period;
| xref:folly/operator_bitnot.adoc[`operator&#126;`] 
| Computes the complement of a flag set&period;
| xref:folly/or_unwind_epitaph-0f.adoc[`or&lowbar;unwind&lowbar;epitaph`] 
| `or&lowbar;unwind&lowbar;epitaph` overloads
| xref:folly/overload.adoc[`overload`] 
| Combine multiple `Cases` in one function object
| xref:folly/parseJson-0c.adoc[`parseJson`] 
| Parse a json blob out of a range and produce a dynamic representing it&period;
| xref:folly/parseJson5.adoc[`parseJson5`]  [.small]#[deprecated]#
| Parse an experimental json5 blob and produce a dynamic representing it&period;
| xref:folly/parseJsonWithMetadata-05.adoc[`parseJsonWithMetadata`] 
| `parseJsonWithMetadata` overloads
| xref:folly/parseLogConfig.adoc[`parseLogConfig`] 
| Parse a log configuration string&period;
| xref:folly/parseLogConfigDynamic.adoc[`parseLogConfigDynamic`] 
| Parse a folly&colon;&colon;dynamic object&period;
| xref:folly/parseLogConfigJson.adoc[`parseLogConfigJson`] 
| Parse a JSON configuration string&period;
| xref:folly/parseNestedCommandLine-0f.adoc[`parseNestedCommandLine`] 
| `parseNestedCommandLine` overloads
| xref:folly/parseTo-0ff.adoc[`parseTo`] 
| `parseTo` overloads
| xref:folly/partialLoadUnaligned.adoc[`partialLoadUnaligned`] 
| Read l bytes into the low bits of a value of an unsigned integral type T, where l &lt; sizeof(T)&period;
| xref:folly/poly_call-09.adoc[`poly&lowbar;call`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/poly_cast-07.adoc[`poly&lowbar;cast`] 
| `poly&lowbar;cast` overloads
| xref:folly/poly_empty-0f.adoc[`poly&lowbar;empty`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/poly_move-07.adoc[`poly&lowbar;move`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/poly_type-07a.adoc[`poly&lowbar;type`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/popAsyncStackFrameCallee.adoc[`popAsyncStackFrameCallee`] 
| Pop the &apos;callee&apos; frame off the stack, restoring the parent frame as the current frame&period;
| xref:folly/popcount.adoc[`popcount`] 
| popcount
| xref:folly/preadFull.adoc[`preadFull`] 
| Like readFull but reads at a given offset&period;
| xref:folly/preadNoInt.adoc[`preadNoInt`] 
| Reads from a file descriptor at an offset, retrying on EINTR&period;
| xref:folly/preadv.adoc[`preadv`] 
| Reads into multiple buffers from a file at a given offset&period;
| xref:folly/preadvFull.adoc[`preadvFull`] 
| Like readvFull but scatter&hyphen;reads at a given offset&period;
| xref:folly/preadvNoInt.adoc[`preadvNoInt`] 
| Scatter&hyphen;reads from a file descriptor at an offset, retrying on EINTR&period;
| xref:folly/prettyPrint.adoc[`prettyPrint`] 
| Pretty printer for numbers with units&period;
| xref:folly/prettyToDouble-0ec.adoc[`prettyToDouble`] 
| `prettyToDouble` overloads
| xref:folly/pretty_name.adoc[`pretty&lowbar;name`] 
| Returns a statically&hyphen;allocated C string containing the pretty name of T&period;
| xref:folly/printResultComparison.adoc[`printResultComparison`] 
| Print a comparison between two sets of benchmark results&period;
| xref:folly/processLocalUniqueId.adoc[`processLocalUniqueId`] 
| Generates a 64&hyphen;bit id that is unique within the process&period; The returned ids should not be persisted or passed to other processes, and there are no ordering guarantees&period;
| xref:folly/pushAsyncStackFrameCallerCallee.adoc[`pushAsyncStackFrameCallerCallee`] 
| Push the &apos;callee&apos; frame onto the current thread&apos;s async stack, deactivating the &apos;caller&apos; frame and setting up the &apos;caller&apos; to be the parent&hyphen;frame of the &apos;callee&apos;&period;
| xref:folly/pwriteFull.adoc[`pwriteFull`] 
| Like writeFull but writes at a given offset&period;
| xref:folly/pwriteNoInt.adoc[`pwriteNoInt`] 
| Writes to a file descriptor at an offset, retrying on EINTR&period;
| xref:folly/pwritev.adoc[`pwritev`] 
| Writes multiple buffers to a file at a given offset&period;
| xref:folly/pwritevFull.adoc[`pwritevFull`] 
| Like writevFull but gather&hyphen;writes at a given offset&period;
| xref:folly/pwritevNoInt.adoc[`pwritevNoInt`] 
| Gather&hyphen;writes to a file descriptor at an offset, retrying on EINTR&period;
| xref:folly/qfind-067.adoc[`qfind`] 
| `qfind` overloads
| xref:folly/qfind_first_of-07.adoc[`qfind&lowbar;first&lowbar;of`] 
| `qfind&lowbar;first&lowbar;of` overloads
| xref:folly/randomNumberSeed.adoc[`randomNumberSeed`] 
| Return a good seed for a random number generator&period;
| xref:folly/range-0a0.adoc[`range`] 
| `range` overloads
| xref:folly/rcu_barrier.adoc[`rcu&lowbar;barrier`] 
| Waits for all in&hyphen;flight deleters in the domain to complete&period;
| xref:folly/rcu_default_domain.adoc[`rcu&lowbar;default&lowbar;domain`] 
| Returns the process&hyphen;wide default RCU domain&period;
| xref:folly/rcu_retire.adoc[`rcu&lowbar;retire`] 
| Retires a pointer, invoking its deleter after a grace period&period;
| xref:folly/rcu_synchronize.adoc[`rcu&lowbar;synchronize`] 
| Waits for all pre&hyphen;existing RCU readers in the domain to complete&period;
| xref:folly/readFile-0f.adoc[`readFile`] 
| `readFile` overloads
| xref:folly/readFull.adoc[`readFull`] 
| Wrapper around read() (and pread()) that, in addition to retrying on EINTR, will loop until all data is read&period;
| xref:folly/readNoInt.adoc[`readNoInt`] 
| Reads from a file descriptor, retrying on EINTR&period;
| xref:folly/readvFull.adoc[`readvFull`] 
| Like readFull but scatter&hyphen;reads into multiple buffers&period;
| xref:folly/readvNoInt.adoc[`readvNoInt`] 
| Scatter&hyphen;reads from a file descriptor, retrying on EINTR&period;
| xref:folly/reinterpret_function_cast-08.adoc[`reinterpret&lowbar;function&lowbar;cast`] 
| `reinterpret&lowbar;function&lowbar;cast` overloads
| xref:folly/reinterpret_pointer_cast-05.adoc[`reinterpret&lowbar;pointer&lowbar;cast`] 
| `reinterpret&lowbar;pointer&lowbar;cast` overloads
| xref:folly/reinterpret_span_cast-0b.adoc[`reinterpret&lowbar;span&lowbar;cast`] 
| Casts `in` to a span of `U` over the same memory using reinterpret&lowbar;cast&period;
| xref:folly/relinquish-06.adoc[`relinquish`] 
| `relinquish` overloads
| xref:folly/reserve_if_available.adoc[`reserve&lowbar;if&lowbar;available`] 
| Reserves space for `n` elements when `C` provides a reserve() member&period;
| xref:folly/reset_once-0f.adoc[`reset&lowbar;once`] 
| `reset&lowbar;once` overloads
| xref:folly/result_catch_all.adoc[`result&lowbar;catch&lowbar;all`] 
| Wraps the return value from the lambda `fn` in a `result`, putting any thrown exception into its &quot;error&quot; state&period;
| xref:folly/result_to_try.adoc[`result&lowbar;to&lowbar;try`] 
| Converts a `result&lt;T&gt;` to a `Try&lt;T&gt;`&period;
| xref:folly/resumeCoroutineWithNewAsyncStackRoot-0c.adoc[`resumeCoroutineWithNewAsyncStackRoot`] 
| `resumeCoroutineWithNewAsyncStackRoot` overloads
| xref:folly/rethrow_current_exception.adoc[`rethrow&lowbar;current&lowbar;exception`]  [.small]#[noreturn]#
| rethrow&lowbar;current&lowbar;exception
| xref:folly/rfind-0b.adoc[`rfind`] 
| Finds the last occurrence of needle in haystack&period; The result is the offset reported to the beginning of haystack, or string&colon;&colon;npos if needle wasn&apos;t found&period;
| xref:folly/rlock.adoc[`rlock`] 
| Make a shared locking helper for a const object&period;
| xref:folly/rref-06.adoc[`rref`] 
| `rref` overloads
| xref:folly/rtrim.adoc[`rtrim`] 
| Specify characters to rtrim&period;
| xref:folly/rtrimWhitespace.adoc[`rtrimWhitespace`] 
| Remove trailing whitespace&period;
| xref:folly/runBenchmarks.adoc[`runBenchmarks`] 
| Runs all benchmarks defined&period; Usually put in main()&period;
| xref:folly/runBenchmarksOnFlag.adoc[`runBenchmarksOnFlag`] 
| Runs all benchmarks defined if and only if the &hyphen;&hyphen;benchmark flag has been passed to the program&period; Usually put in main()&period;
| xref:folly/seed_seq_generate.adoc[`seed&lowbar;seq&lowbar;generate`] 
| Fills the destination buffer with data generated from the seed sequence&period;
| xref:folly/select64-02b.adoc[`select64`] 
| Returns the position of the k&hyphen;th 1 in the 64&hyphen;bit word x&period; k is 0&hyphen;based, so k&equals;0 returns the position of the first 1&period;
| xref:folly/setCPUExecutor.adoc[`setCPUExecutor`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/setCPUExecutorToGlobalCPUExecutor.adoc[`setCPUExecutorToGlobalCPUExecutor`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/setIOExecutor.adoc[`setIOExecutor`]  [.small]#[deprecated]#
| methodset Deprecated
| xref:folly/setKeepAliveObjTraceHooks.adoc[`setKeepAliveObjTraceHooks`] 
| Install (or, with all&hyphen;null arguments, remove) the keep&hyphen;alive object tracing hooks&period;
| xref:folly/setThreadName-03.adoc[`setThreadName`] 
| `setThreadName` overloads
| xref:folly/setUnsafeMutableGlobalCPUExecutor.adoc[`setUnsafeMutableGlobalCPUExecutor`] 
| methodset Executors
| xref:folly/setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor.adoc[`setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor`] 
| methodset Executors
| xref:folly/setUnsafeMutableGlobalIOExecutor.adoc[`setUnsafeMutableGlobalIOExecutor`] 
| methodset Executors
| xref:folly/set_n_least_significant_bits.adoc[`set&lowbar;n&lowbar;least&lowbar;significant&lowbar;bits`] 
| Set the n least significant bits of x, leaving the others unchanged&period;
| xref:folly/set_n_most_significant_bits.adoc[`set&lowbar;n&lowbar;most&lowbar;significant&lowbar;bits`] 
| Set the n most significant bits of x, leaving the others unchanged&period;
| xref:folly/set_once-0a.adoc[`set&lowbar;once`] 
| `set&lowbar;once` overloads
| xref:folly/set_process_phases.adoc[`set&lowbar;process&lowbar;phases`] 
| Start Regular phase and register handler to set Exit phase&period; To be called exactly once in each program that uses Folly&period; Ideally, it is to be called from folly&colon;&colon;init(), which in turn is to be called by every program that uses Folly&period;
| xref:folly/setupIoUringBufferPoolSharing-01.adoc[`setupIoUringBufferPoolSharing`] 
| `setupIoUringBufferPoolSharing` overloads
| xref:folly/sformat-0b.adoc[`sformat`] 
| `sformat` overloads
| xref:folly/shellQuote.adoc[`shellQuote`] 
| Quotes an argument to make it suitable for use as shell command arguments&period;
| xref:folly/shellify.adoc[`shellify`]  [.small]#[deprecated]#
| Create argument array for `Subprocess()` for a process running in a shell&period;
| xref:folly/shutdownNoInt.adoc[`shutdownNoInt`] 
| Shuts down a socket, retrying on EINTR&period;
| xref:folly/sizedAlignedFree.adoc[`sizedAlignedFree`] 
| Free a buffer previously returned by checkedAlignedMalloc&period;
| xref:folly/sizedArrayFree.adoc[`sizedArrayFree`] 
| Free a buffer previously returned by checkedArrayMalloc&lt;T&gt;&period;
| xref:folly/sizedFree.adoc[`sizedFree`] 
| Frees&apos;s memory using sdallocx if possible
| xref:folly/skipWhitespace.adoc[`skipWhitespace`] 
| DEPRECATED&colon; Use ltrimWhitespace instead
| xref:folly/smartRealloc.adoc[`smartRealloc`] 
| Reallocs if there is less slack in the buffer, else performs malloc&hyphen;copy&hyphen;free&period;
| xref:folly/sourceLocationToString.adoc[`sourceLocationToString`] 
| Formats a source location as `&quot;file&colon;line &lsqb;function&rsqb;&quot;`&period;
| xref:folly/split-06.adoc[`split`] 
| `split` overloads
| xref:folly/splitFuture.adoc[`splitFuture`] 
| Convenience function, allowing us to exploit template argument deduction to improve readability&period;
| xref:folly/splitTo.adoc[`splitTo`] 
| split, to an output iterator
| xref:folly/splitmix64.adoc[`splitmix64`] 
| splitmix64
| xref:folly/stable_radix_sort-06.adoc[`stable&lowbar;radix&lowbar;sort`] 
| `stable&lowbar;radix&lowbar;sort` overloads
| xref:folly/stable_radix_sort_descending-03.adoc[`stable&lowbar;radix&lowbar;sort&lowbar;descending`] 
| `stable&lowbar;radix&lowbar;sort&lowbar;descending` overloads
| xref:folly/stack_epitaph-01.adoc[`stack&lowbar;epitaph`] 
| `stack&lowbar;epitaph` overloads
| xref:folly/static_pointer_cast-07.adoc[`static&lowbar;pointer&lowbar;cast`] 
| `static&lowbar;pointer&lowbar;cast` overloads
| xref:folly/static_span_cast-02.adoc[`static&lowbar;span&lowbar;cast`] 
| Casts `in` to a span of `U` over the same memory using static&lowbar;cast&period;
| xref:folly/std_bitset_find_first.adoc[`std&lowbar;bitset&lowbar;find&lowbar;first`] 
| Return the index of the first set bit in a bitset, or bitset&period;size() if none&period;
| xref:folly/std_bitset_find_next.adoc[`std&lowbar;bitset&lowbar;find&lowbar;next`] 
| Return the index of the first set bit in a bitset after the given index, or bitset&period;size() if none&period;
| xref:folly/storeUnaligned.adoc[`storeUnaligned`] 
| Write an unaligned value of type T&period;
| xref:folly/strictNextPowTwo.adoc[`strictNextPowTwo`] 
| Return the smallest power of two that is strictly greater than v&period;
| xref:folly/strictPrevPowTwo.adoc[`strictPrevPowTwo`] 
| Return the largest power of two that is strictly less than v&period;
| xref:folly/stringAppendf.adoc[`stringAppendf`] 
| Append printf&hyphen;style output to string&period;
| xref:folly/stringPrintf-02.adoc[`stringPrintf`] 
| `stringPrintf` overloads
| xref:folly/stringToLogLevel.adoc[`stringToLogLevel`] 
| Construct a LogLevel from a string name&period;
| xref:folly/stringVAppendf.adoc[`stringVAppendf`] 
| Append va&lowbar;list printf&hyphen;style output to string&period;
| xref:folly/stringVPrintf-0f.adoc[`stringVPrintf`] 
| `stringVPrintf` overloads
| xref:folly/stripLeftMargin.adoc[`stripLeftMargin`] 
| De&hyphen;indent a string&period;
| xref:folly/strlcpy.adoc[`strlcpy`] 
| Copy a C string, size&hyphen;bounded and always null&hyphen;terminated (mimics BSD strlcpy)&period;
| xref:folly/swap-085.adoc[`swap`] 
| `swap` overloads
| xref:folly/sweepSuspendedLeafFrames.adoc[`sweepSuspendedLeafFrames`] 
| Apply `fn` on all suspended leaf frames&period; Note&colon; Avoid performing async work within `fn` as it may cause deadlocks&period;
| xref:folly/synchronized-06.adoc[`synchronized`] 
| Acquire locks for multiple Synchronized&lt;&gt; objects, in a deadlock&hyphen;safe manner&period;
| xref:folly/tag_invoke-0c.adoc[`tag&lowbar;invoke`] 
| `tag&lowbar;invoke` overloads
| xref:folly/terminate_with-0a.adoc[`terminate&lowbar;with`]  [.small]#[noreturn]#
| terminate&lowbar;with
| xref:folly/terminate_with_fmt_format.adoc[`terminate&lowbar;with&lowbar;fmt&lowbar;format`]  [.small]#[noreturn]#
| Formats a message with fmt and terminates with an exception built from it&period;
| xref:folly/test_once-02.adoc[`test&lowbar;once`] 
| `test&lowbar;once` overloads
| xref:folly/throwSystemError.adoc[`throwSystemError`]  [.small]#[noreturn]#
| Throws a `std&colon;&colon;system&lowbar;error` from the current `errno` and components of a string&period;
| xref:folly/throwSystemErrorExplicit-0e.adoc[`throwSystemErrorExplicit`]  [.small]#[noreturn]#
| `throwSystemErrorExplicit` overloads
| xref:folly/throw_exception-02b.adoc[`throw&lowbar;exception`]  [.small]#[noreturn]#
| throw&lowbar;exception
| xref:folly/throw_exception_fmt_format.adoc[`throw&lowbar;exception&lowbar;fmt&lowbar;format`]  [.small]#[noreturn]#
| Formats a message with fmt and throws an exception constructed from it&period;
| xref:folly/to-0a.adoc[`to`] 
| `to` overloads
| xref:folly/toAppend-09.adoc[`toAppend`] 
| `toAppend` overloads
| xref:folly/toAppendDelim-02.adoc[`toAppendDelim`] 
| `toAppendDelim` overloads
| xref:folly/toAppendDelimFit-0e.adoc[`toAppendDelimFit`] 
| `toAppendDelimFit` overloads
| xref:folly/toAppendFit-09.adoc[`toAppendFit`] 
| `toAppendFit` overloads
| xref:folly/toDelim-0f.adoc[`toDelim`] 
| `toDelim` overloads
| xref:folly/toDynamic.adoc[`toDynamic`] 
| Turn an arbitrary type into a dynamic&period;
| xref:folly/toJson.adoc[`toJson`] 
| Serialize a dynamic into a json string&period;
| xref:folly/toLowerAscii-02.adoc[`toLowerAscii`] 
| `toLowerAscii` overloads
| xref:folly/toPrettyJson.adoc[`toPrettyJson`] 
| Serialize a dynamic into a json string with indentation&period; Note that the keys of all objects will be sorted&period;
| xref:folly/toStdString-0d.adoc[`toStdString`] 
| `toStdString` overloads
| xref:folly/toUpperAscii-07.adoc[`toUpperAscii`] 
| `toUpperAscii` overloads
| xref:folly/to_ascii_decimal-07.adoc[`to&lowbar;ascii&lowbar;decimal`] 
| `to&lowbar;ascii&lowbar;decimal` overloads
| xref:folly/to_ascii_lower-0d.adoc[`to&lowbar;ascii&lowbar;lower`] 
| `to&lowbar;ascii&lowbar;lower` overloads
| xref:folly/to_ascii_size.adoc[`to&lowbar;ascii&lowbar;size`] 
| Number of digits in the base&hyphen;Base representation of v&period;
| xref:folly/to_ascii_size_decimal.adoc[`to&lowbar;ascii&lowbar;size&lowbar;decimal`] 
| Number of decimal digits in v&semi; alias of to&lowbar;ascii&lowbar;size&lt;10&gt;&period;
| xref:folly/to_ascii_upper-09.adoc[`to&lowbar;ascii&lowbar;upper`] 
| `to&lowbar;ascii&lowbar;upper` overloads
| xref:folly/to_ascii_with-04.adoc[`to&lowbar;ascii&lowbar;with`] 
| `to&lowbar;ascii&lowbar;with` overloads
| xref:folly/to_bool.adoc[`to&lowbar;bool`] 
| Constructs a boolean from the argument&period;
| xref:folly/to_erased_unique_ptr-0f.adoc[`to&lowbar;erased&lowbar;unique&lowbar;ptr`] 
| to&lowbar;erased&lowbar;unique&lowbar;ptr
| xref:folly/to_floating_point.adoc[`to&lowbar;floating&lowbar;point`] 
| Wraps the argument for floating&hyphen;point conversion&period;
| xref:folly/to_integral.adoc[`to&lowbar;integral`] 
| Wraps the argument for integral conversion&period;
| xref:folly/to_narrow.adoc[`to&lowbar;narrow`] 
| Wraps the argument for narrowing conversion&period;
| xref:folly/to_ordering.adoc[`to&lowbar;ordering`] 
| Convert a signed comparison value into the matching `ordering`&period;
| xref:folly/to_shared_ptr.adoc[`to&lowbar;shared&lowbar;ptr`] 
| to&lowbar;shared&lowbar;ptr
| xref:folly/to_shared_ptr_aliasing-06.adoc[`to&lowbar;shared&lowbar;ptr&lowbar;aliasing`] 
| `to&lowbar;shared&lowbar;ptr&lowbar;aliasing` overloads
| xref:folly/to_shared_ptr_non_owning.adoc[`to&lowbar;shared&lowbar;ptr&lowbar;non&lowbar;owning`] 
| to&lowbar;shared&lowbar;ptr&lowbar;non&lowbar;owning
| xref:folly/to_signed.adoc[`to&lowbar;signed`] 
| Converts the argument to the corresponding signed type&period;
| xref:folly/to_underlying.adoc[`to&lowbar;underlying`] 
| Converts an enum value to its underlying type&period;
| xref:folly/to_unsigned.adoc[`to&lowbar;unsigned`] 
| Converts the argument to the corresponding unsigned type&period;
| xref:folly/to_weak_ptr.adoc[`to&lowbar;weak&lowbar;ptr`] 
| to&lowbar;weak&lowbar;ptr
| xref:folly/to_weak_ptr_aliasing.adoc[`to&lowbar;weak&lowbar;ptr&lowbar;aliasing`] 
| to&lowbar;weak&lowbar;ptr&lowbar;aliasing
| xref:folly/transition_lock.adoc[`transition&lowbar;lock`] 
| Atomically transitions from the from&hyphen;lock to the to&hyphen;lock, waiting unboundedly for the transition to become available&period;
| xref:folly/transition_to_shared_lock-05.adoc[`transition&lowbar;to&lowbar;shared&lowbar;lock`] 
| `transition&lowbar;to&lowbar;shared&lowbar;lock` overloads
| xref:folly/transition_to_unique_lock.adoc[`transition&lowbar;to&lowbar;unique&lowbar;lock`] 
| Eventually and atomically upgrades an upgrade lock to an exclusive lock&period;
| xref:folly/transition_to_upgrade_lock.adoc[`transition&lowbar;to&lowbar;upgrade&lowbar;lock`] 
| Immediately and atomically downgrades an exclusive lock to an upgrade lock&period;
| xref:folly/trim.adoc[`trim`] 
| Specify characters to trim&period;
| xref:folly/trimWhitespace.adoc[`trimWhitespace`] 
| Remove leading and trailing whitespace&period;
| xref:folly/truncateNoInt.adoc[`truncateNoInt`] 
| Truncates a file by path, retrying on EINTR&period;
| xref:folly/tryAssign.adoc[`tryAssign`] 
| Try to move the value&sol;exception from another `Try` object&period;
| xref:folly/tryDecodeVarint.adoc[`tryDecodeVarint`] 
| A variant of decodeVarint() that does not throw on error&period; Useful in contexts where only part of a serialized varint may be attempted to be decoded, e&period;g&period;, when a serialized varint arrives on the boundary of a network packet&period;
| xref:folly/tryEmplace-07.adoc[`tryEmplace`] 
| `tryEmplace` overloads
| xref:folly/tryEmplaceWith-02.adoc[`tryEmplaceWith`] 
| `tryEmplaceWith` overloads
| xref:folly/tryGetCurrentAsyncStackRoot.adoc[`tryGetCurrentAsyncStackRoot`] 
| Get access to the current thread&apos;s top&hyphen;most AsyncStackRoot&period;
| xref:folly/tryGetShutdownSocketSet.adoc[`tryGetShutdownSocketSet`] 
| Returns the process&hyphen;global shutdown socket set, if one has been installed&period;
| xref:folly/tryGetShutdownSocketSetFast.adoc[`tryGetShutdownSocketSetFast`] 
| Returns the process&hyphen;global shutdown socket set using a read&hyphen;mostly pointer&period;
| xref:folly/trySplitTo.adoc[`trySplitTo`] 
| Try to split a string into a fixed number of fields by delimiter, using folly&colon;&colon;tryTo&lt;&gt; for conversions&period; types by delimiter&period; &hyphen; On success, all output values will be initialized and the &apos;Unit&lcub;&rcub;&apos; value is returned&period; Arguments are assigned in reverse order&period; &hyphen; On failure, the first failing &apos;ConversionCode&apos; is returned with its associated substring in a &apos;SubstringConversionCode&apos;&period; &hyphen; String splitting is performed prior to each conversion&semi; field values will not contain the delimiter&period; &hyphen; All custom error codes are mapped to ConversionCode&colon;&colon;CUSTOM&period;
| xref:folly/tryTo-0f4.adoc[`tryTo`] 
| `tryTo` overloads
| xref:folly/tryUriUnescape-01.adoc[`tryUriUnescape`] 
| `tryUriUnescape` overloads
| xref:folly/try_and_catch.adoc[`try&lowbar;and&lowbar;catch`] 
| `try&lowbar;and&lowbar;catch` is a convenience for `try &lcub;&rcub; catch(&period;&period;&period;) &lcub;&rcub;`&grave; that returns an `exception&lowbar;wrapper` with the thrown exception, if any&period;
| xref:folly/try_call_once-00.adoc[`try&lowbar;call&lowbar;once`] 
| `try&lowbar;call&lowbar;once` overloads
| xref:folly/try_to_result-0f.adoc[`try&lowbar;to&lowbar;result`] 
| `try&lowbar;to&lowbar;result` overloads
| xref:folly/try_transition_lock.adoc[`try&lowbar;transition&lowbar;lock`] 
| Attempts an atomic transition from the from&hyphen;lock to the to&hyphen;lock, without waiting if the transition is not immediately available&period;
| xref:folly/try_transition_lock_for.adoc[`try&lowbar;transition&lowbar;lock&lowbar;for`] 
| Attempts an atomic transition from the from&hyphen;lock to the to&hyphen;lock, waiting up to the given timeout for the transition to become available&period;
| xref:folly/try_transition_lock_until.adoc[`try&lowbar;transition&lowbar;lock&lowbar;until`] 
| Attempts an atomic transition from the from&hyphen;lock to the to&hyphen;lock, waiting up to the given deadline for the transition to become available&period;
| xref:folly/try_transition_to_unique_lock-0a.adoc[`try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock`] 
| `try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock` overloads
| xref:folly/try_transition_to_unique_lock_for-02f.adoc[`try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock&lowbar;for`] 
| `try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock&lowbar;for` overloads
| xref:folly/try_transition_to_unique_lock_until-0e.adoc[`try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock&lowbar;until`] 
| `try&lowbar;transition&lowbar;to&lowbar;unique&lowbar;lock&lowbar;until` overloads
| xref:folly/try_transition_to_upgrade_lock.adoc[`try&lowbar;transition&lowbar;to&lowbar;upgrade&lowbar;lock`] 
| Immediately attempts to atomically upgrade a shared lock to an upgrade lock&period;
| xref:folly/try_transition_to_upgrade_lock_for.adoc[`try&lowbar;transition&lowbar;to&lowbar;upgrade&lowbar;lock&lowbar;for`] 
| Attempts, up to a timeout, to atomically upgrade a shared lock to an upgrade lock&period;
| xref:folly/try_transition_to_upgrade_lock_until.adoc[`try&lowbar;transition&lowbar;to&lowbar;upgrade&lowbar;lock&lowbar;until`] 
| Attempts, up to a deadline, to atomically upgrade a shared lock to an upgrade lock&period;
| xref:folly/type_info_of-01.adoc[`type&lowbar;info&lowbar;of`] 
| `type&lowbar;info&lowbar;of` overloads
| xref:folly/ulock.adoc[`ulock`] 
| Make an upgrade locking helper&period;
| xref:folly/unSet.adoc[`unSet`] 
| Clears the flags of `b` from `a&period;`
| xref:folly/uncaught_exceptions.adoc[`uncaught&lowbar;exceptions`] 
| uncaught&lowbar;exceptions
| xref:folly/uncurry.adoc[`uncurry`] 
| Wraps a function taking N arguments into a function which accepts a tuple of N arguments&period; Note&colon; This function will also accept an std&colon;&colon;pair if N &equals;&equals; 2&period;
| xref:folly/unexpected-02.adoc[`unexpected`] 
| Disambiguation tag for constructing an Expected in the error state&period;
| xref:folly/unhexlify-04.adoc[`unhexlify`] 
| `unhexlify` overloads
| xref:folly/unicode_code_point_from_utf16_surrogate_pair.adoc[`unicode&lowbar;code&lowbar;point&lowbar;from&lowbar;utf16&lowbar;surrogate&lowbar;pair`] 
| Combines a UTF&hyphen;16 surrogate pair into a single code point&period;
| xref:folly/unicode_code_point_to_utf8.adoc[`unicode&lowbar;code&lowbar;point&lowbar;to&lowbar;utf8`] 
| Encodes a single Unicode code point into a UTF&hyphen;8 byte sequence&period;
| xref:folly/unique_hash_key_algo_strong_sha256.adoc[`unique&lowbar;hash&lowbar;key&lowbar;algo&lowbar;strong&lowbar;sha256`] 
| Hash the input items with SHA256, returning a Size&hyphen;byte digest&period;
| xref:folly/unsafe_unscoped_init-01.adoc[`unsafe&lowbar;unscoped&lowbar;init`] 
| Initializes folly without an RAII scope guard&period;
| xref:folly/unwrapTryTuple.adoc[`unwrapTryTuple`] 
| Unwrap a tuple of `Try` values into a tuple of values&period;
| xref:folly/uriEscape-00.adoc[`uriEscape`] 
| `uriEscape` overloads
| xref:folly/uriUnescape-005.adoc[`uriUnescape`] 
| `uriUnescape` overloads
| xref:folly/usingJEMalloc.adoc[`usingJEMalloc`] 
| Determines whether the process is using jemalloc&period;
| xref:folly/usingTCMalloc.adoc[`usingTCMalloc`] 
| Determines whether the process is using tcmalloc&period;
| xref:folly/utf16_code_unit_is_bmp.adoc[`utf16&lowbar;code&lowbar;unit&lowbar;is&lowbar;bmp`] 
| Returns whether a UTF&hyphen;16 code unit lies in the Basic Multilingual Plane&period;
| xref:folly/utf16_code_unit_is_high_surrogate.adoc[`utf16&lowbar;code&lowbar;unit&lowbar;is&lowbar;high&lowbar;surrogate`] 
| Returns whether a UTF&hyphen;16 code unit is a high surrogate&period;
| xref:folly/utf16_code_unit_is_low_surrogate.adoc[`utf16&lowbar;code&lowbar;unit&lowbar;is&lowbar;low&lowbar;surrogate`] 
| Returns whether a UTF&hyphen;16 code unit is a low surrogate&period;
| xref:folly/utf8ToCodePoint.adoc[`utf8ToCodePoint`] 
| Decode a single Unicode code point from UTF&hyphen;8 byte sequence&period;
| xref:folly/uuid_parse-09.adoc[`uuid&lowbar;parse`] 
| `uuid&lowbar;parse` overloads
| xref:folly/uuid_parse_buffer_to_buffer.adoc[`uuid&lowbar;parse&lowbar;buffer&lowbar;to&lowbar;buffer`] 
| Parses a 36&hyphen;byte UUID string into a 16&hyphen;byte buffer&period;
| xref:folly/valid_align_value-0c.adoc[`valid&lowbar;align&lowbar;value`] 
| Returns whether the given alignment value is valid&period;
| xref:folly/validateSocketOptions.adoc[`validateSocketOptions`] 
| Returns the subset of options that apply to the given family and position&period;
| xref:folly/variadic_noop.adoc[`variadic&lowbar;noop`] 
| Does nothing regardless of the arguments passed&period;
| xref:folly/variant_match-00.adoc[`variant&lowbar;match`] 
| `variant&lowbar;match` overloads
| xref:folly/wlock-00.adoc[`wlock`] 
| `wlock` overloads
| xref:folly/writeFile-07.adoc[`writeFile`] 
| `writeFile` overloads
| xref:folly/writeFileAtomic-0a.adoc[`writeFileAtomic`] 
| `writeFileAtomic` overloads
| xref:folly/writeFileAtomicNoThrow-00a.adoc[`writeFileAtomicNoThrow`] 
| `writeFileAtomicNoThrow` overloads
| xref:folly/writeFull.adoc[`writeFull`] 
| Similar to readFull and preadFull above, wrappers around write() and pwrite() that loop until all data is written&period;
| xref:folly/writeNoInt.adoc[`writeNoInt`] 
| Writes to a file descriptor, retrying on EINTR&period;
| xref:folly/writevFull.adoc[`writevFull`] 
| Like writeFull but gather&hyphen;writes from multiple buffers&period;
| xref:folly/writevNoInt.adoc[`writevNoInt`] 
| Gather&hyphen;writes to a file descriptor, retrying on EINTR&period;
| xref:folly/x86_cpuid.adoc[`x86&lowbar;cpuid`] 
| x86&lowbar;cpuid
| xref:folly/x86_cpuid_get_cache_info.adoc[`x86&lowbar;cpuid&lowbar;get&lowbar;cache&lowbar;info`] 
| Returns cache info for the cache with the given id for the given vendor&period;
| xref:folly/x86_cpuid_get_llc_cache_info-08.adoc[`x86&lowbar;cpuid&lowbar;get&lowbar;llc&lowbar;cache&lowbar;info`] 
| `x86&lowbar;cpuid&lowbar;get&lowbar;llc&lowbar;cache&lowbar;info` overloads
| xref:folly/x86_cpuid_get_vendor.adoc[`x86&lowbar;cpuid&lowbar;get&lowbar;vendor`] 
| Detects the CPU vendor via the cpuid instruction&period;
| xref:folly/x86_cpuid_max.adoc[`x86&lowbar;cpuid&lowbar;max`] 
| Returns the maximum supported cpuid leaf for the given leaf group&period;
| xref:folly/xlogIsDirSeparator.adoc[`xlogIsDirSeparator`] 
| Tests whether a character is a directory separator&period;
| xref:folly/xlogStripFilename.adoc[`xlogStripFilename`] 
| Strip directory prefixes from a filename before using it in XLOG macros&period;
| xref:folly/operator_lshift-02d.adoc[`operator&lt;&lt;`] 
| Left shift operators
| xref:folly/operator_eq-029.adoc[`operator&equals;&equals;`] 
| Equality operators
| xref:folly/operator_not_eq-0eeb.adoc[`operator!&equals;`] 
| Inequality operators
| xref:folly/operator_lt-0e9.adoc[`operator&lt;`] 
| Less&hyphen;than operators
| xref:folly/operator_le-0a6.adoc[`operator&lt;&equals;`] 
| Less&hyphen;than&hyphen;or&hyphen;equal operators
| xref:folly/operator_gt-0e1.adoc[`operator&gt;`] 
| Greater&hyphen;than operators
| xref:folly/operator_ge-0617.adoc[`operator&gt;&equals;`] 
| Greater&hyphen;than&hyphen;or&hyphen;equal operators
| xref:folly/operator_3way-07c.adoc[`operator&lt;&equals;&gt;`] 
| Three&hyphen;way comparison operators
|===


== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/adopt_lock_state.adoc[`adopt&lowbar;lock&lowbar;state`] 
| Tag value indicating that a lock transition should adopt existing lock state&period;
| xref:folly/always_false.adoc[`always&lowbar;false`] 
| always&lowbar;false
| xref:folly/atomic_fetch_flip.adoc[`atomic&lowbar;fetch&lowbar;flip`] 
| Customization point object that flips a bit and returns its previous value&period;
| xref:folly/atomic_fetch_modify.adoc[`atomic&lowbar;fetch&lowbar;modify`] 
| Customization point object that atomically transforms an atomic value&period;
| xref:folly/atomic_fetch_reset.adoc[`atomic&lowbar;fetch&lowbar;reset`] 
| Customization point object that resets a bit and returns its previous value&period;
| xref:folly/atomic_fetch_set.adoc[`atomic&lowbar;fetch&lowbar;set`] 
| Customization point object that sets a bit and returns its previous value&period;
| xref:folly/atomic_notify_all.adoc[`atomic&lowbar;notify&lowbar;all`] 
| Wakes all threads waiting on the atomic, like futex wake with max count&period;
| xref:folly/atomic_notify_one.adoc[`atomic&lowbar;notify&lowbar;one`] 
| Wakes one thread waiting on the atomic, like futex wake with count 1&period;
| xref:folly/atomic_wait.adoc[`atomic&lowbar;wait`] 
| Blocks until the atomic changes from an expected value, like futex wait&period;
| xref:folly/atomic_wait_until.adoc[`atomic&lowbar;wait&lowbar;until`] 
| Blocks until the atomic changes or a deadline passes, returning cv&lowbar;status&period;
| xref:folly/available_concurrency_max_env.adoc[`available&lowbar;concurrency&lowbar;max&lowbar;env`] 
| The environment variable name used to cap available&lowbar;concurrency()&period;
| xref:folly/cacheline_align_v.adoc[`cacheline&lowbar;align&lowbar;v`] 
| A value corresponding to hardware&lowbar;constructive&lowbar;interference&lowbar;size but which may be used with alignas, since hardware&lowbar;constructive&lowbar;interference&lowbar;size may be too large on some platforms to be used with alignas&period;
| xref:folly/constexpr_iterated_squares_desc_2_v.adoc[`constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;2&lowbar;v`] 
| constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;2&lowbar;v
| xref:folly/constexpr_iterated_squares_desc_size_v.adoc[`constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;size&lowbar;v`] 
| constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;size&lowbar;v
| xref:folly/constexpr_iterated_squares_desc_v.adoc[`constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;v`] 
| constexpr&lowbar;iterated&lowbar;squares&lowbar;desc&lowbar;v
| xref:folly/default_domain.adoc[`default&lowbar;domain`] 
| Global default domain defined in Hazptr&period;cpp
| xref:folly/demangle_max_symbol_size.adoc[`demangle&lowbar;max&lowbar;symbol&lowbar;size`] 
| Maximum symbol size that demangling will attempt, or 0 for no limit&period;
| xref:folly/emptySocketOptionMap.adoc[`emptySocketOptionMap`] 
| An empty socket option map&period;
| xref:folly/empty_try_as_error.adoc[`empty&lowbar;try&lowbar;as&lowbar;error`] 
| The empty&hyphen;`Try`&hyphen;as&hyphen;error policy value&period;
| xref:folly/factory_constructor.adoc[`factory&lowbar;constructor`] 
| Tag value selecting the factory constructor of `Indestructible`&period;
| xref:folly/fmt_vformat_mangle_format_string.adoc[`fmt&lowbar;vformat&lowbar;mangle&lowbar;format&lowbar;string`] 
| Callable that mangles the content of vformat format&hyphen;strings&period;
| xref:folly/format_string_for_each_named_arg.adoc[`format&lowbar;string&lowbar;for&lowbar;each&lowbar;named&lowbar;arg`] 
| Callable object enumerating the named arguments of a format string&period;
| xref:folly/function_arguments_size_v.adoc[`function&lowbar;arguments&lowbar;size&lowbar;v`] 
| The number of arguments in the given function type&period;
| xref:folly/function_is_nothrow_v.adoc[`function&lowbar;is&lowbar;nothrow&lowbar;v`] 
| True precisely when the given function type is marked noexcept&period;
| xref:folly/function_is_variadic_v.adoc[`function&lowbar;is&lowbar;variadic&lowbar;v`] 
| True precisely when the given function type is C&hyphen;style variadic&period;
| xref:folly/hardware_constructive_interference_size.adoc[`hardware&lowbar;constructive&lowbar;interference&lowbar;size`] 
| The cache line size for true sharing, from the standard library&period;
| xref:folly/hardware_destructive_interference_size.adoc[`hardware&lowbar;destructive&lowbar;interference&lowbar;size`] 
| The minimum spacing to avoid false sharing, from the standard library&period;
| xref:folly/has_extended_alignment.adoc[`has&lowbar;extended&lowbar;alignment`] 
| has&lowbar;extended&lowbar;alignment
| xref:folly/hex_alphabet_lower.adoc[`hex&lowbar;alphabet&lowbar;lower`] 
| hex&lowbar;alphabet&lowbar;lower
| xref:folly/hex_alphabet_table.adoc[`hex&lowbar;alphabet&lowbar;table`] 
| hex&lowbar;alphabet&lowbar;table
| xref:folly/hex_alphabet_upper.adoc[`hex&lowbar;alphabet&lowbar;upper`] 
| hex&lowbar;alphabet&lowbar;upper
| xref:folly/initlist_construct.adoc[`initlist&lowbar;construct`] 
| Tag value used to disambiguate initializer&hyphen;list construction&period;
| xref:folly/is_allocator_v.adoc[`is&lowbar;allocator&lowbar;v`] 
| is&lowbar;allocator&lowbar;v is&lowbar;allocator
| xref:folly/is_applicable_r_v.adoc[`is&lowbar;applicable&lowbar;r&lowbar;v`] 
| True if applying `F` to the elements of `Tuple` yields a result convertible to `R`&period;
| xref:folly/is_applicable_v.adoc[`is&lowbar;applicable&lowbar;v`] 
| True if `F` is invocable with the elements of `Tuple`&period;
| xref:folly/is_arithmetic_v.adoc[`is&lowbar;arithmetic&lowbar;v`] 
| A trait variable that is true when T is an arithmetic type&period;
| xref:folly/is_bounded_array_v-0c.adoc[`is&lowbar;bounded&lowbar;array&lowbar;v`] 
| is&lowbar;bounded&lowbar;array&lowbar;v is&lowbar;bounded&lowbar;array
| xref:folly/is_bounded_array_v-0a.adoc[`is&lowbar;bounded&lowbar;array&lowbar;v`] 
| A specialization of is&lowbar;bounded&lowbar;array&lowbar;v for bounded array types&period;
| xref:folly/is_cleanup_v.adoc[`is&lowbar;cleanup&lowbar;v`] 
| True when T models the async cleanup concept (has a conforming cleanup())&period;
| xref:folly/is_complete_v.adoc[`is&lowbar;complete&lowbar;v`] 
| See is&lowbar;complete&period;
| xref:folly/is_constexpr_default_constructible_v.adoc[`is&lowbar;constexpr&lowbar;default&lowbar;constructible&lowbar;v`] 
| is&lowbar;constexpr&lowbar;default&lowbar;constructible&lowbar;v is&lowbar;constexpr&lowbar;default&lowbar;constructible
| xref:folly/is_contiguous_range_v.adoc[`is&lowbar;contiguous&lowbar;range&lowbar;v`] 
| True when `R` is a contiguous range&period;
| xref:folly/is_coro_aware_mutex_v.adoc[`is&lowbar;coro&lowbar;aware&lowbar;mutex&lowbar;v`] 
| Whether a type declares a `folly&lowbar;coro&lowbar;aware&lowbar;mutex` nested typedef&period;
| xref:folly/is_detected_v.adoc[`is&lowbar;detected&lowbar;v`] 
| A trait variable to test whether a metafunction succeeds in substitution&period;
| xref:folly/is_enable_master_from_this_v.adoc[`is&lowbar;enable&lowbar;master&lowbar;from&lowbar;this&lowbar;v`] 
| True if T publicly derives from EnablePrimaryFromThis&period;
| xref:folly/is_hashable_v.adoc[`is&lowbar;hashable&lowbar;v`] 
| Checks that the given hasher template&apos;s specialization for the given type is usable with the standard library containters, for example `std&colon;&colon;unordered&lowbar;set&lt;T, Hasher&lt;T&gt;&gt;`&period;
| xref:folly/is_hasher_usable_v.adoc[`is&lowbar;hasher&lowbar;usable&lowbar;v`] 
| Checks the requirements that the Hasher class must satisfy in order to be used with the standard library containers, for example `std&colon;&colon;unordered&lowbar;set&lt;T, Hasher&gt;`&period;
| xref:folly/is_heap_vector_map_v.adoc[`is&lowbar;heap&lowbar;vector&lowbar;map&lowbar;v`] 
| True if T is an instantiation of heap&lowbar;vector&lowbar;map&period;
| xref:folly/is_heap_vector_set_v.adoc[`is&lowbar;heap&lowbar;vector&lowbar;set&lowbar;v`] 
| True if T is an instantiation of heap&lowbar;vector&lowbar;set&period;
| xref:folly/is_instantiation_of_v-05.adoc[`is&lowbar;instantiation&lowbar;of&lowbar;v`] 
| is&lowbar;instantiation&lowbar;of&lowbar;v is&lowbar;instantiation&lowbar;of instantiated&lowbar;from uncvref&lowbar;instantiated&lowbar;from
| xref:folly/is_instantiation_of_v-0d.adoc[`is&lowbar;instantiation&lowbar;of&lowbar;v`] 
| A specialization of is&lowbar;instantiation&lowbar;of&lowbar;v for matching instantiations&period;
| xref:folly/is_integral_v.adoc[`is&lowbar;integral&lowbar;v`] 
| A trait variable that is true when T is an integral type&period;
| xref:folly/is_invocable_r_v.adoc[`is&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if invoking `F` yields a result convertible to `R`&semi; mimics std&colon;&colon;is&lowbar;invocable&lowbar;r&lowbar;v&period;
| xref:folly/is_invocable_v.adoc[`is&lowbar;invocable&lowbar;v`] 
| True if `F` is invocable with `A&period;&period;&period;`&semi; mimics std&colon;&colon;is&lowbar;invocable&lowbar;v&period;
| xref:folly/is_non_bool_integral_v.adoc[`is&lowbar;non&lowbar;bool&lowbar;integral&lowbar;v`] 
| is&lowbar;non&lowbar;bool&lowbar;integral&lowbar;v
| xref:folly/is_nothrow_applicable_r_v.adoc[`is&lowbar;nothrow&lowbar;applicable&lowbar;r&lowbar;v`] 
| True if the nothrow application of `F` to `Tuple` yields a result convertible to `R`&period;
| xref:folly/is_nothrow_applicable_v.adoc[`is&lowbar;nothrow&lowbar;applicable&lowbar;v`] 
| True if `F` is nothrow&hyphen;invocable with the elements of `Tuple`&period;
| xref:folly/is_nothrow_invocable_r_v.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if a nothrow invocation of `F` yields a result convertible to `R`&semi; mimics std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v&period;
| xref:folly/is_nothrow_invocable_v.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;v`] 
| True if `F` is nothrow&hyphen;invocable with `A&period;&period;&period;`&semi; mimics std&colon;&colon;is&lowbar;nothrow&lowbar;invocable&lowbar;v&period;
| xref:folly/is_nothrow_tag_invocable_r_v.adoc[`is&lowbar;nothrow&lowbar;tag&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if a nothrow `tag&lowbar;invoke` call yields a result convertible to `R`&period;
| xref:folly/is_nothrow_tag_invocable_v.adoc[`is&lowbar;nothrow&lowbar;tag&lowbar;invocable&lowbar;v`] 
| True if the `tag&lowbar;invoke` CPO is nothrow&hyphen;invocable with `Tag` and `Args`&period;
| xref:folly/is_one_of_v.adoc[`is&lowbar;one&lowbar;of&lowbar;v`] 
| A trait variable that is true when T is one of the types Ts&period;
| xref:folly/is_register_pass_v-07.adoc[`is&lowbar;register&lowbar;pass&lowbar;v`] 
| is&lowbar;register&lowbar;pass&lowbar;v
| xref:folly/is_register_pass_v-0b.adoc[`is&lowbar;register&lowbar;pass&lowbar;v`] 
| Whether an lvalue reference may be passed in a register&semi; always true&period;
| xref:folly/is_register_pass_v-0a.adoc[`is&lowbar;register&lowbar;pass&lowbar;v`] 
| Whether an rvalue reference may be passed in a register&semi; always true&period;
| xref:folly/is_signed_v.adoc[`is&lowbar;signed&lowbar;v`] 
| A trait variable that is true when T is a signed type&period;
| xref:folly/is_small_sorted_vector_map_v.adoc[`is&lowbar;small&lowbar;sorted&lowbar;vector&lowbar;map&lowbar;v`] 
| True if T is a sorted&lowbar;vector&lowbar;map backed by a small&lowbar;vector&period;
| xref:folly/is_small_sorted_vector_set_v.adoc[`is&lowbar;small&lowbar;sorted&lowbar;vector&lowbar;set&lowbar;v`] 
| True if T is a sorted&lowbar;vector&lowbar;set backed by a small&lowbar;vector&period;
| xref:folly/is_small_vector_v.adoc[`is&lowbar;small&lowbar;vector&lowbar;v`] 
| `true` if `T` is a specialization of folly&colon;&colon;small&lowbar;vector&period;
| xref:folly/is_sorted_vector_map_v.adoc[`is&lowbar;sorted&lowbar;vector&lowbar;map&lowbar;v`] 
| True if T is a sorted&lowbar;vector&lowbar;map specialization&period;
| xref:folly/is_sorted_vector_set_v.adoc[`is&lowbar;sorted&lowbar;vector&lowbar;set&lowbar;v`] 
| True if T is a sorted&lowbar;vector&lowbar;set specialization&period;
| xref:folly/is_tag_invocable_r_v.adoc[`is&lowbar;tag&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if a `tag&lowbar;invoke` call yields a result convertible to `R`&period;
| xref:folly/is_tag_invocable_v.adoc[`is&lowbar;tag&lowbar;invocable&lowbar;v`] 
| True if the `tag&lowbar;invoke` CPO can be invoked with `Tag` and `Args`&period;
| xref:folly/is_transparent_v.adoc[`is&lowbar;transparent&lowbar;v`] 
| is&lowbar;transparent&lowbar;v is&lowbar;transparent
| xref:folly/is_unbounded_array_v-03.adoc[`is&lowbar;unbounded&lowbar;array&lowbar;v`] 
| is&lowbar;unbounded&lowbar;array&lowbar;v is&lowbar;unbounded&lowbar;array
| xref:folly/is_unbounded_array_v-07.adoc[`is&lowbar;unbounded&lowbar;array&lowbar;v`] 
| A specialization of is&lowbar;unbounded&lowbar;array&lowbar;v for unbounded array types&period;
| xref:folly/is_unsigned_v.adoc[`is&lowbar;unsigned&lowbar;v`] 
| A trait variable that is true when T is an unsigned type&period;
| xref:folly/is_vector_bool_reference_v-08.adoc[`is&lowbar;vector&lowbar;bool&lowbar;reference&lowbar;v`] 
| True when T is the proxy reference type of a std&colon;&colon;vector&lt;bool&gt;&period;
| xref:folly/is_vector_bool_reference_v-02.adoc[`is&lowbar;vector&lowbar;bool&lowbar;reference&lowbar;v`] 
| Specialization recognizing the libc&plus;&plus; std&colon;&colon;vector&lt;bool&gt; bit reference&period;
| xref:folly/iterator_category_matches_v.adoc[`iterator&lowbar;category&lowbar;matches&lowbar;v`] 
| Whether an iterator&apos;s category matches Category (std&colon;&colon;input&lowbar;iterator&lowbar;tag, std&colon;&colon;output&lowbar;iterator&lowbar;tag, etc)&period; Defined for non&hyphen;iterator types as well&period;
| xref:folly/iterator_has_known_distance_v-00.adoc[`iterator&lowbar;has&lowbar;known&lowbar;distance&lowbar;v`] 
| Whether std&colon;&colon;distance over a pair of iterators is reasonably known to give the distance without advancing the iterators or copies of them&period;
| xref:folly/iterator_has_known_distance_v-08.adoc[`iterator&lowbar;has&lowbar;known&lowbar;distance&lowbar;v`] 
| Specialization for a matching iterator and sentinel type&period;
| xref:folly/kClangVerMajor.adoc[`kClangVerMajor`] 
| The Clang major version, or zero when not compiling with Clang&period;
| xref:folly/kCoreCachedSharedPtrDefaultMaxSlots.adoc[`kCoreCachedSharedPtrDefaultMaxSlots`] 
| Default maximum number of core&hyphen;local slots used by the cached pointers&period;
| xref:folly/kCpplibVer.adoc[`kCpplibVer`] 
| The Dinkumware cpplib version, or zero when not using cpplib&period;
| xref:folly/kDefaultLogLevel.adoc[`kDefaultLogLevel`] 
| The default log level used when none is specified&period;
| xref:folly/kGlibcxxAssertions.adoc[`kGlibcxxAssertions`] 
| True when libstdc&plus;&plus; assertions are enabled&period;
| xref:folly/kGlibcxxVer.adoc[`kGlibcxxVer`] 
| The libstdc&plus;&plus; release version, or zero when not using libstdc&plus;&plus;&period;
| xref:folly/kGnuc.adoc[`kGnuc`] 
| The GCC major version, or zero when not compiling with GCC&period;
| xref:folly/kHasExceptions.adoc[`kHasExceptions`] 
| True when the current build supports C&plus;&plus; exceptions&period;
| xref:folly/kHasRtti.adoc[`kHasRtti`] 
| True when run&hyphen;time type information (RTTI) is enabled for this build&period;
| xref:folly/kHasUnalignedAccess.adoc[`kHasUnalignedAccess`] 
| True when the target platform supports unaligned loads and stores&period;
| xref:folly/kHasWeakSymbols.adoc[`kHasWeakSymbols`] 
| True when the toolchain supports weak symbols&period;
| xref:folly/kIntegerDivisionGivesRemainder.adoc[`kIntegerDivisionGivesRemainder`] 
| True if integer division on this platform yields a remainder, i&period;e&period; the hardware division instruction produces both quotient and remainder&period;
| xref:folly/kIovMax.adoc[`kIovMax`] 
| Maximum number of `iovec` buffers accepted by a scatter&sol;gather call&period;
| xref:folly/kIsAndroid.adoc[`kIsAndroid`] 
| True when the target operating system is Android&period;
| xref:folly/kIsApple.adoc[`kIsApple`] 
| True when the target operating system is an Apple platform&period;
| xref:folly/kIsAppleIOS.adoc[`kIsAppleIOS`] 
| True when the target Apple platform is iOS&period;
| xref:folly/kIsAppleMacOS.adoc[`kIsAppleMacOS`] 
| True when the target Apple platform is macOS&period;
| xref:folly/kIsAppleTVOS.adoc[`kIsAppleTVOS`] 
| True when the target Apple platform is tvOS&period;
| xref:folly/kIsAppleWatchOS.adoc[`kIsAppleWatchOS`] 
| True when the target Apple platform is watchOS&period;
| xref:folly/kIsArchAArch64.adoc[`kIsArchAArch64`] 
| True when targeting the 64&hyphen;bit ARM (AArch64) architecture&period;
| xref:folly/kIsArchAmd64.adoc[`kIsArchAmd64`] 
| True when targeting the 64&hyphen;bit x86 (amd64) architecture&period;
| xref:folly/kIsArchArm.adoc[`kIsArchArm`] 
| True when targeting the 32&hyphen;bit ARM architecture&period;
| xref:folly/kIsArchPPC64.adoc[`kIsArchPPC64`] 
| True when targeting the 64&hyphen;bit PowerPC architecture&period;
| xref:folly/kIsArchRISCV64.adoc[`kIsArchRISCV64`] 
| True when targeting the 64&hyphen;bit RISC&hyphen;V architecture&period;
| xref:folly/kIsArchS390X.adoc[`kIsArchS390X`] 
| True when targeting the 64&hyphen;bit IBM Z (s390x) architecture&period;
| xref:folly/kIsArchWasm.adoc[`kIsArchWasm`] 
| True when targeting WebAssembly&period;
| xref:folly/kIsArchWasm32.adoc[`kIsArchWasm32`] 
| True when targeting 32&hyphen;bit WebAssembly&period;
| xref:folly/kIsArchWasm64.adoc[`kIsArchWasm64`] 
| True when targeting 64&hyphen;bit WebAssembly&period;
| xref:folly/kIsArchX86.adoc[`kIsArchX86`] 
| True when targeting the 32&hyphen;bit x86 architecture&period;
| xref:folly/kIsBigEndian.adoc[`kIsBigEndian`] 
| True when the target platform is big&hyphen;endian&period;
| xref:folly/kIsClang.adoc[`kIsClang`] 
| True when compiling with Clang&period;
| xref:folly/kIsDebug.adoc[`kIsDebug`] 
| True when the current build is a debug build&period;
| xref:folly/kIsFreeBSD.adoc[`kIsFreeBSD`] 
| True when the target operating system is FreeBSD&period;
| xref:folly/kIsGlibcxx.adoc[`kIsGlibcxx`] 
| True when the standard library is GNU libstdc&plus;&plus;&period;
| xref:folly/kIsLibcpp.adoc[`kIsLibcpp`] 
| True when the standard library is LLVM libc&plus;&plus;&period;
| xref:folly/kIsLibrarySanitizeAddress.adoc[`kIsLibrarySanitizeAddress`] 
| True when folly itself was compiled with AddressSanitizer enabled&period;
| xref:folly/kIsLibstdcpp.adoc[`kIsLibstdcpp`] 
| True when the standard library is GNU libstdc&plus;&plus;&period;
| xref:folly/kIsLinux.adoc[`kIsLinux`] 
| True when the target operating system is non&hyphen;mobile Linux&period;
| xref:folly/kIsLinuxActual.adoc[`kIsLinuxActual`] 
| True when the target operating system is Linux, mobile included&period;
| xref:folly/kIsLittleEndian.adoc[`kIsLittleEndian`] 
| True when the target platform is little&hyphen;endian&period;
| xref:folly/kIsMobile.adoc[`kIsMobile`] 
| True when targeting a mobile platform&period;
| xref:folly/kIsObjC.adoc[`kIsObjC`] 
| True when the current translation unit is compiled as Objective&hyphen;C&period;
| xref:folly/kIsOptimize.adoc[`kIsOptimize`] 
| True when the current build is optimized&period;
| xref:folly/kIsOptimizeSize.adoc[`kIsOptimizeSize`] 
| True when the current build is optimized for size&period;
| xref:folly/kIsSanitize.adoc[`kIsSanitize`] 
| True when the current build uses any sanitizer&period;
| xref:folly/kIsSanitizeAddress.adoc[`kIsSanitizeAddress`] 
| True when the current build uses AddressSanitizer&period;
| xref:folly/kIsSanitizeDataflow.adoc[`kIsSanitizeDataflow`] 
| True when the current build uses DataFlowSanitizer&period;
| xref:folly/kIsSanitizeThread.adoc[`kIsSanitizeThread`] 
| True when the current build uses ThreadSanitizer&period;
| xref:folly/kIsWindows.adoc[`kIsWindows`] 
| True when the target operating system is Windows&period;
| xref:folly/kLoggingEnvVarName.adoc[`kLoggingEnvVarName`] 
| Environment variable name that controls folly logging configuration&period;
| xref:folly/kLoggingMinLevel.adoc[`kLoggingMinLevel`] 
| The compile&hyphen;time minimum log level below which XLOG() statements compile out&period;
| xref:folly/kMaxVarintLength32.adoc[`kMaxVarintLength32`] 
| Maximum length (in bytes) of the varint encoding of a 32&hyphen;bit value&period;
| xref:folly/kMaxVarintLength64.adoc[`kMaxVarintLength64`] 
| Maximum length (in bytes) of the varint encoding of a 64&hyphen;bit value&period;
| xref:folly/kMicrosoftAbiVer.adoc[`kMicrosoftAbiVer`] 
| The Microsoft ABI version, or zero when not targeting the Microsoft ABI&period;
| xref:folly/kMinFatalLogLevel.adoc[`kMinFatalLogLevel`] 
| The lowest log level considered fatal for the current build&period;
| xref:folly/kMinValidAddress.adoc[`kMinValidAddress`] 
| The lowest address that may be a valid mapped pointer on this platform&period;
| xref:folly/kMscVer.adoc[`kMscVer`] 
| The MSVC compiler version, or zero when not compiling with MSVC&period;
| xref:folly/kWordSize.adoc[`kWordSize`] 
| Number of bits in a machine word used by the bitset scanning routines&period;
| xref:folly/kWriteFlagsForTimestamping.adoc[`kWriteFlagsForTimestamping`] 
| Write flags that are related to timestamping&period;
| xref:folly/lenient_safe_alias_of_v.adoc[`lenient&lowbar;safe&lowbar;alias&lowbar;of&lowbar;v`] 
| The `safe&lowbar;alias` level of T, defaulting unannotated types to `maybe&lowbar;value`&period;
| xref:folly/loop_break.adoc[`loop&lowbar;break`] 
| Return value that tells for&lowbar;each to stop iterating&period;
| xref:folly/loop_continue.adoc[`loop&lowbar;continue`] 
| Return value that tells for&lowbar;each to continue iterating&period;
| xref:folly/match_safely_invocable_as_protocol_v.adoc[`match&lowbar;safely&lowbar;invocable&lowbar;as&lowbar;protocol&lowbar;v`] 
| True if `F` matches the safely&hyphen;invocable&hyphen;as protocol for signature `Sig`&period;
| xref:folly/match_static_lambda_protocol_v.adoc[`match&lowbar;static&lowbar;lambda&lowbar;protocol&lowbar;v`] 
| True if type `F` matches the static&hyphen;lambda protocol (empty and trivially copyable)&period;
| xref:folly/max_align_v.adoc[`max&lowbar;align&lowbar;v`] 
| max&lowbar;align&lowbar;v is the alignment of max&lowbar;align&lowbar;t&period;
| xref:folly/none-09.adoc[`none`] 
| Constant tag used to clear or construct an empty Optional&period;
| xref:folly/npos.adoc[`npos`] 
| The sentinel value returned by search functions when no match is found&period;
| xref:folly/range_has_known_distance_v.adoc[`range&lowbar;has&lowbar;known&lowbar;distance&lowbar;v`] 
| Whether std&colon;&colon;distance over the begin and end iterators is reasonably known to give the distance without advancing the iterators or copies of them&period;
| xref:folly/rcu_default_domain_.adoc[`rcu&lowbar;default&lowbar;domain&lowbar;`] 
| The pointer to the process&hyphen;wide default RCU domain&period;
| xref:folly/register_pass_max_size.adoc[`register&lowbar;pass&lowbar;max&lowbar;size`] 
| register&lowbar;pass&lowbar;max&lowbar;size
| xref:folly/require_sizeof.adoc[`require&lowbar;sizeof`] 
| require&lowbar;sizeof
| xref:folly/resizeWithoutInitialization.adoc[`resizeWithoutInitialization`] 
| Resizes a container without initializing newly added elements&period;
| xref:folly/sig.adoc[`sig`] 
| Pseudo&hyphen;function template handy for disambiguating function overloads&period;
| xref:folly/sorted_equivalent.adoc[`sorted&lowbar;equivalent`] 
| Tag value indicating a container is sorted but not necessarily unique&period;
| xref:folly/sorted_unique.adoc[`sorted&lowbar;unique`] 
| Tag value indicating a container is sorted and unique&period;
| xref:folly/stopped_result.adoc[`stopped&lowbar;result`] 
| The stopped&sol;cancellation signal value&period;
| xref:folly/strict_safe_alias_of_v.adoc[`strict&lowbar;safe&lowbar;alias&lowbar;of&lowbar;v`] 
| The `safe&lowbar;alias` level of T, defaulting unannotated types to `unsafe`&period;
| xref:folly/tag.adoc[`tag`] 
| A generic type&hyphen;list value&period;
| xref:folly/to_ascii_size_max.adoc[`to&lowbar;ascii&lowbar;size&lowbar;max`] 
| Maximum buffer size to hold the base&hyphen;Base ASCII form of any value of unsigned type Int&period;
| xref:folly/to_ascii_size_max_decimal.adoc[`to&lowbar;ascii&lowbar;size&lowbar;max&lowbar;decimal`] 
| Maximum buffer size for the decimal ASCII form of Int&semi; alias of to&lowbar;ascii&lowbar;size&lowbar;max&lt;10&gt;&period;
| xref:folly/type_list_find_v.adoc[`type&lowbar;list&lowbar;find&lowbar;v`] 
| type&lowbar;list&lowbar;find&lowbar;v
| xref:folly/type_list_size_v.adoc[`type&lowbar;list&lowbar;size&lowbar;v`] 
| type&lowbar;list&lowbar;size&lowbar;v
| xref:folly/type_pack_find_v.adoc[`type&lowbar;pack&lowbar;find&lowbar;v`] 
| type&lowbar;pack&lowbar;find&lowbar;v
| xref:folly/type_pack_size_v.adoc[`type&lowbar;pack&lowbar;size&lowbar;v`] 
| type&lowbar;pack&lowbar;size&lowbar;v
| xref:folly/unique_hash_key_algo_size_v.adoc[`unique&lowbar;hash&lowbar;key&lowbar;algo&lowbar;size&lowbar;v`] 
| Digest size in bytes produced by the given hash algorithm object&period;
| xref:folly/unit-0c.adoc[`unit`] 
| The single value of type Unit&period;
| xref:folly/unsafe_default_initialized.adoc[`unsafe&lowbar;default&lowbar;initialized`] 
| Object yielding a default&hyphen;initialized value on conversion&period;
| xref:folly/value_list_element_v.adoc[`value&lowbar;list&lowbar;element&lowbar;v`] 
| value&lowbar;list&lowbar;element&lowbar;v
| xref:folly/value_list_size_v.adoc[`value&lowbar;list&lowbar;size&lowbar;v`] 
| value&lowbar;list&lowbar;size&lowbar;v
| xref:folly/value_pack_element_v.adoc[`value&lowbar;pack&lowbar;element&lowbar;v`] 
| value&lowbar;pack&lowbar;element&lowbar;type&lowbar;t
| xref:folly/value_pack_size_v.adoc[`value&lowbar;pack&lowbar;size&lowbar;v`] 
| value&lowbar;pack&lowbar;size&lowbar;v
| xref:folly/variadic_constant_of.adoc[`variadic&lowbar;constant&lowbar;of`] 
| An invocable object that ignores its arguments and returns a constant&period;
| xref:folly/vtag.adoc[`vtag`] 
| A generic value&hyphen;list value&period;
| xref:folly/x86_cpuid_vendor_names.adoc[`x86&lowbar;cpuid&lowbar;vendor&lowbar;names`] 
| Vendor identification strings indexed by `x86&lowbar;cpuid&lowbar;vendor`&period;
|===


== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/FollyFindFixedSupportedType.adoc[`FollyFindFixedSupportedType`] 
| Concept for types supported by folly&colon;&colon;findFixed&colon; fixed&hyphen;width integers and enums with such an underlying type&period;
| xref:folly/IsOptionalLike.adoc[`IsOptionalLike`] 
| Concept matching types with optional&hyphen;like semantics (has&lowbar;value&sol;value), such as std&colon;&colon;optional, folly&colon;&colon;Optional, and Thrift optional fields&period;
| xref:folly/instantiated_from.adoc[`instantiated&lowbar;from`] 
| A concept satisfied when T is an instantiation of the class template Templ&period;
| xref:folly/is_strong.adoc[`is&lowbar;strong`] 
| Satisfied when `T` derives from `strong` instantiated with its own tag&period;
| xref:folly/passable_to.adoc[`passable&lowbar;to`] 
| passable&lowbar;to
| xref:folly/uncvref_instantiated_from.adoc[`uncvref&lowbar;instantiated&lowbar;from`] 
| Like instantiated&lowbar;from, but after stripping cvref qualifiers from T&period;
| xref:folly/uncvref_same_as.adoc[`uncvref&lowbar;same&lowbar;as`] 
| Concept to check that a type is same as a given type, when stripping qualifiers and refernces&period; Especially useful for perfect forwarding of a specific type&period;
| xref:folly/vector_bool_reference.adoc[`vector&lowbar;bool&lowbar;reference`] 
| Concept satisfied by the proxy reference type of a std&colon;&colon;vector&lt;bool&gt;&period;
|===


== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/FlagSaver.adoc[`FlagSaver`] 
| Imported `gflags&colon;&colon;FlagSaver`&period;
| xref:folly/IsEqualityComparable.adoc[`IsEqualityComparable`] 
| A trait to test whether values of T and U can be compared with operator&equals;&equals;&period;
| xref:folly/IsLessThanComparable.adoc[`IsLessThanComparable`] 
| A trait to test whether values of T and U can be compared with operator&lt;&period;
| xref:folly/MoveOnly.adoc[`MoveOnly`] 
| Base that disallows copy but allows move in derived types&period;
| xref:folly/NonCopyableNonMovable.adoc[`NonCopyableNonMovable`] 
| Base that disallows both copy and move in derived types&period;
| xref:folly/apply.adoc[`apply`] 
| &sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;&sol;
| xref:folly/decay_t.adoc[`decay&lowbar;t`] 
| Like std&colon;&colon;decay&lowbar;t but possibly faster to compile&period;
| xref:folly/dynamic_extent.adoc[`dynamic&lowbar;extent`] 
| Sentinel extent value marking a span whose size is known only at runtime&period;
| xref:folly/invoke_result_t.adoc[`invoke&lowbar;result&lowbar;t`] 
| The result type of invoking `F` with `A&period;&period;&period;`&semi; mimics std&colon;&colon;invoke&lowbar;result&lowbar;t&period;
| xref:folly/is_nothrow_convertible.adoc[`is&lowbar;nothrow&lowbar;convertible`] 
| A trait type that is true when one type is nothrow&hyphen;convertible to another&period;
| xref:folly/is_nothrow_convertible_v.adoc[`is&lowbar;nothrow&lowbar;convertible&lowbar;v`] 
| A trait variable that is true when one type is nothrow&hyphen;convertible to another&period;
| xref:folly/nextafter.adoc[`nextafter`] 
| Most platforms hopefully provide std&colon;&colon;nextafter, std&colon;&colon;remainder&period;
| xref:folly/remainder.adoc[`remainder`] 
| Imported `std&colon;&colon;remainder`&period;
| xref:folly/shared_lock.adoc[`shared&lowbar;lock`] 
| Alias to `std&colon;&colon;shared&lowbar;lock`&period;
| xref:folly/tag_invoke_result_t.adoc[`tag&lowbar;invoke&lowbar;result&lowbar;t`] 
| The result type of invoking the `tag&lowbar;invoke` CPO with `Tag` and `Args`&period;
| xref:folly/unique_lock.adoc[`unique&lowbar;lock`] 
| Alias to `std&colon;&colon;unique&lowbar;lock`&period;
|===



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