[#index]
= Global namespace
:mrdocs:

== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:example.adoc[`example`] 
| Example code demonstrating the Folly logging library&period;
| xref:fmt.adoc[`fmt`] 
| The &lcub;fmt&rcub; formatting library namespace&period;
| xref:folly.adoc[`folly`] 
| 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
| xref:ranges.adoc[`ranges`] 
| The range&hyphen;v3 library namespace&period;
| xref:std.adoc[`std`] 
| Standard library specializations of std&colon;&colon;hash for Folly and standard types&period;
|===


== Types

[cols="1,4"]
|===
| Name| Description
| xref:DynamicRingQueueTestHelper.adoc[`DynamicRingQueueTestHelper`] 
| Test helper granting access to DynamicRingQueue internals&period;
| xref:io_uring_cqe.adoc[`io&lowbar;uring&lowbar;cqe`] 
| A completion queue entry (CQE) from the liburing C API&period;
| xref:io_uring_sqe.adoc[`io&lowbar;uring&lowbar;sqe`] 
| A submission queue entry (SQE) from the liburing C API&period;
| xref:open_how.adoc[`open&lowbar;how`] 
| Linux openat2 syscall options structure&period;
| xref:r_debug.adoc[`r&lowbar;debug`] 
| The dynamic linker&apos;s debug rendezvous structure&period;
|===


== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly_port_struct_timezone.adoc[`folly&lowbar;port&lowbar;struct&lowbar;timezone`] 
| Portable alias for the system `struct timezone`&period;
|===


== Macros

[cols="1,4"]
|===
| Name| Description
| xref:BENCHMARK.adoc[`BENCHMARK`] 
| Introduces a benchmark function&period; Use with either one or two arguments&period; The first is the name of the benchmark&period; Use something descriptive, such as insertVectorBegin&period; The second argument may be missing, or could be a symbolic counter&period; The counter dictates how many internal iteration the benchmark does&period; Example&colon;
| xref:BENCHMARK_COUNTERS.adoc[`BENCHMARK&lowbar;COUNTERS`] 
| Allow users to record customized counter during benchmarking, there will be one extra column showing in the output result for each counter
| xref:BENCHMARK_COUNTERS_NAMED_PARAM.adoc[`BENCHMARK&lowbar;COUNTERS&lowbar;NAMED&lowbar;PARAM`] 
| Like BENCHMARK&lowbar;NAMED&lowbar;PARAM, but passes a UserCounters&amp; parameter to the benchmark function for recording custom counters&period;
| xref:BENCHMARK_COUNTERS_PARAM.adoc[`BENCHMARK&lowbar;COUNTERS&lowbar;PARAM`] 
| Like BENCHMARK&lowbar;PARAM, but passes a UserCounters&amp; parameter&period;
| xref:BENCHMARK_DRAW_LINE.adoc[`BENCHMARK&lowbar;DRAW&lowbar;LINE`] 
| Draws a line of dashes&period;
| xref:BENCHMARK_DRAW_TEXT.adoc[`BENCHMARK&lowbar;DRAW&lowbar;TEXT`] 
| Prints arbitrary text&period;
| xref:BENCHMARK_IMPL.adoc[`BENCHMARK&lowbar;IMPL`] 
| Introduces a benchmark function&period; Used internally, see BENCHMARK and friends below&period;
| xref:BENCHMARK_MULTI.adoc[`BENCHMARK&lowbar;MULTI`] 
| Like BENCHMARK above, but allows the user to return the actual number of iterations executed in the function body&period; This can be useful if the benchmark function doesn&apos;t know upfront how many iterations it&apos;s going to run or if it runs through a certain number of test cases, e&period;g&period;&colon;
| xref:BENCHMARK_MULTI_IMPL.adoc[`BENCHMARK&lowbar;MULTI&lowbar;IMPL`] 
| Introduces a benchmark function with support for returning the actual number of iterations&period; Used internally, see BENCHMARK&lowbar;MULTI and friends below&period;
| xref:BENCHMARK_NAMED_PARAM_MULTI.adoc[`BENCHMARK&lowbar;NAMED&lowbar;PARAM&lowbar;MULTI`] 
| Same as BENCHMARK&lowbar;NAMED&lowbar;PARAM, but allows one to return the actual number of iterations that have been run&period;
| xref:BENCHMARK_PARAM.adoc[`BENCHMARK&lowbar;PARAM`] 
| Defines a benchmark that passes a parameter to another one&period; This is common for benchmarks that need a &quot;problem size&quot; in addition to &quot;number of iterations&quot;&period; Consider&colon;
| xref:BENCHMARK_PARAM_MULTI.adoc[`BENCHMARK&lowbar;PARAM&lowbar;MULTI`] 
| Same as BENCHMARK&lowbar;PARAM, but allows one to return the actual number of iterations that have been run&period;
| xref:BENCHMARK_RELATIVE.adoc[`BENCHMARK&lowbar;RELATIVE`] 
| Just like BENCHMARK, but prints the time relative to a baseline&period; The baseline is the most recent BENCHMARK() seen in the current scope&period; Example&colon;
| xref:BENCHMARK_RELATIVE_MULTI.adoc[`BENCHMARK&lowbar;RELATIVE&lowbar;MULTI`] 
| Same as BENCHMARK&lowbar;RELATIVE, but allows one to return the actual number of iterations that have been run&period;
| xref:BENCHMARK_RELATIVE_NAMED_PARAM.adoc[`BENCHMARK&lowbar;RELATIVE&lowbar;NAMED&lowbar;PARAM`] 
| A combination of BENCHMARK&lowbar;RELATIVE and BENCHMARK&lowbar;NAMED&lowbar;PARAM&period;
| xref:BENCHMARK_RELATIVE_NAMED_PARAM_MULTI.adoc[`BENCHMARK&lowbar;RELATIVE&lowbar;NAMED&lowbar;PARAM&lowbar;MULTI`] 
| Same as BENCHMARK&lowbar;RELATIVE&lowbar;NAMED&lowbar;PARAM, but allows one to return the actual number of iterations that have been run&period;
| xref:BENCHMARK_RELATIVE_PARAM.adoc[`BENCHMARK&lowbar;RELATIVE&lowbar;PARAM`] 
| A combination of BENCHMARK&lowbar;RELATIVE and BENCHMARK&lowbar;PARAM&period;
| xref:BENCHMARK_RELATIVE_PARAM_MULTI.adoc[`BENCHMARK&lowbar;RELATIVE&lowbar;PARAM&lowbar;MULTI`] 
| Same as BENCHMARK&lowbar;RELATIVE&lowbar;PARAM, but allows one to return the actual number of iterations that have been run&period;
| xref:BENCHMARK_SUSPEND.adoc[`BENCHMARK&lowbar;SUSPEND`] 
| Allows execution of code that doesn&apos;t count toward the benchmark&apos;s time budget&period; Example&colon;
| xref:CHECK_THROW.adoc[`CHECK&lowbar;THROW`] 
| If cond is not true, raise an exception of type E&period; E must have a ctor that works with const char&ast; (a description of the failure)&period;
| xref:EXPECT_PCRE_MATCH.adoc[`EXPECT&lowbar;PCRE&lowbar;MATCH`] 
| Easy PCRE regex matching&period; Note that pattern must match the ENTIRE target, so use &period;&ast; at the start and end of the pattern, as appropriate&period; See http&colon;&sol;&sol;regex101&period;com&sol; for a PCRE simulator&period;
| xref:FB_ARG_1.adoc[`FB&lowbar;ARG&lowbar;1`] 
| Helper macro that extracts the first argument out of a list of any number of arguments&period;
| xref:FB_LOG.adoc[`FB&lowbar;LOG`] 
| Log a message to the specified logger&period;
| xref:FB_LOGF.adoc[`FB&lowbar;LOGF`] 
| Log a message to the specified logger, using a fmt&colon;&colon;format() string&period;
| xref:FB_LOGF_RAW.adoc[`FB&lowbar;LOGF&lowbar;RAW`] 
| FB&lowbar;LOGF&lowbar;RAW() is similar to FB&lowbar;LOG&lowbar;RAW(), but formats the log arguments using fmt&colon;&colon;format()&period;
| xref:FB_LOG_EVERY_MS.adoc[`FB&lowbar;LOG&lowbar;EVERY&lowbar;MS`] 
| Issues a LOG(severity) no more often than every milliseconds&period; Example&colon;
| xref:FB_LOG_IMPL.adoc[`FB&lowbar;LOG&lowbar;IMPL`] 
| Helper macro for implementing FB&lowbar;LOG() and FB&lowbar;LOGF()&period;
| xref:FB_LOG_RAW.adoc[`FB&lowbar;LOG&lowbar;RAW`] 
| FB&lowbar;LOG&lowbar;RAW() can be used by callers that want to pass in the log level as a variable, and&sol;or who want to explicitly specify the filename and line number&period;
| xref:FB_LOG_RAW_IMPL.adoc[`FB&lowbar;LOG&lowbar;RAW&lowbar;IMPL`] 
| Helper macro for implementing FB&lowbar;LOG&lowbar;RAW() and FB&lowbar;LOGF&lowbar;RAW()&period;
| xref:FB_NOT_NULL_MK_OP.adoc[`FB&lowbar;NOT&lowbar;NULL&lowbar;MK&lowbar;OP`] 
| Comparison&colon; &hyphen; Forwards to underlying PtrT&period; &hyphen; Works when one of the operands is not not&lowbar;null&period; &hyphen; Works when one of the operands is nullptr&period;
| xref:FB_ONE_OR_NONE.adoc[`FB&lowbar;ONE&lowbar;OR&lowbar;NONE`] 
| FB&lowbar;ONE&lowbar;OR&lowbar;NONE(hello, world) expands to hello and FB&lowbar;ONE&lowbar;OR&lowbar;NONE(hello) expands to nothing&period; This macro is used to insert or eliminate text based on the presence of another argument&period;
| xref:FB_SINGLE_ARG.adoc[`FB&lowbar;SINGLE&lowbar;ARG`] 
| Helper macro that provides a way to pass argument with commas in it to some other macro whose syntax doesn&apos;t allow using extra parentheses&period; Example&colon;
| xref:FB_VA_GLUE.adoc[`FB&lowbar;VA&lowbar;GLUE`] 
| Concatenate two preprocessor tokens by juxtaposition, forcing an extra expansion pass&period;
| xref:FOLLY_ASSUME_FBVECTOR_COMPATIBLE.adoc[`FOLLY&lowbar;ASSUME&lowbar;FBVECTOR&lowbar;COMPATIBLE`] 
| The FOLLY&lowbar;ASSUME&lowbar;FBVECTOR&lowbar;COMPATIBLE&ast; macros below encode the assumption that the type is relocatable per IsRelocatable above&period; Many types can be assumed to satisfy this condition, but it is the responsibility of the user to state that assumption&period; User&hyphen;defined classes will not be optimized for use with fbvector (see FBVector&period;h) unless they state that assumption&period;
| xref:FOLLY_ASSUME_RELOCATABLE.adoc[`FOLLY&lowbar;ASSUME&lowbar;RELOCATABLE`] 
| Use this macro ONLY inside namespace folly&period; When using it with a regular type, use it like this&colon;
| xref:FOLLY_ASSUME_UNREACHABLE.adoc[`FOLLY&lowbar;ASSUME&lowbar;UNREACHABLE`] 
| Inform the compiler that the statement is not reachable at runtime, and disable compiler warnings&period;
| xref:FOLLY_COMPRESSION_HAS_CONTEXT_POOL_SINGLETONS.adoc[`FOLLY&lowbar;COMPRESSION&lowbar;HAS&lowbar;CONTEXT&lowbar;POOL&lowbar;SINGLETONS`] 
| Added here so users of folly can figure out whether the header folly&sol;compression&sol;CompressionContextPoolSingletons&period;h is present, and therefore whether it can be included&period;
| xref:FOLLY_CREATE_FREE_INVOKER.adoc[`FOLLY&lowbar;CREATE&lowbar;FREE&lowbar;INVOKER`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;FREE&lowbar;INVOKER
| xref:FOLLY_CREATE_FREE_INVOKER_SUITE.adoc[`FOLLY&lowbar;CREATE&lowbar;FREE&lowbar;INVOKER&lowbar;SUITE`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;FREE&lowbar;INVOKER&lowbar;SUITE
| xref:FOLLY_CREATE_MEMBER_ACCESSOR.adoc[`FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;ACCESSOR`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;ACCESSOR
| xref:FOLLY_CREATE_MEMBER_ACCESSOR_SUITE.adoc[`FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;ACCESSOR&lowbar;SUITE`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;ACCESSOR&lowbar;SUITE
| xref:FOLLY_CREATE_MEMBER_INVOKER.adoc[`FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;INVOKER`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;INVOKER
| xref:FOLLY_CREATE_MEMBER_INVOKER_SUITE.adoc[`FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;INVOKER&lowbar;SUITE`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;MEMBER&lowbar;INVOKER&lowbar;SUITE
| xref:FOLLY_CREATE_QUAL_INVOKER.adoc[`FOLLY&lowbar;CREATE&lowbar;QUAL&lowbar;INVOKER`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;QUAL&lowbar;INVOKER
| xref:FOLLY_CREATE_QUAL_INVOKER_SUITE.adoc[`FOLLY&lowbar;CREATE&lowbar;QUAL&lowbar;INVOKER&lowbar;SUITE`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;QUAL&lowbar;INVOKER&lowbar;SUITE
| xref:FOLLY_CREATE_STATIC_MEMBER_INVOKER.adoc[`FOLLY&lowbar;CREATE&lowbar;STATIC&lowbar;MEMBER&lowbar;INVOKER`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;STATIC&lowbar;MEMBER&lowbar;INVOKER
| xref:FOLLY_CREATE_STATIC_MEMBER_INVOKER_SUITE.adoc[`FOLLY&lowbar;CREATE&lowbar;STATIC&lowbar;MEMBER&lowbar;INVOKER&lowbar;SUITE`] 
| &ast; FOLLY&lowbar;CREATE&lowbar;STATIC&lowbar;MEMBER&lowbar;INVOKER&lowbar;SUITE
| xref:FOLLY_DECLARE_REUSED.adoc[`FOLLY&lowbar;DECLARE&lowbar;REUSED`] 
| FOLLY&lowbar;DECLARE&lowbar;REUSED
| xref:FOLLY_DETAIL_LITE_TUPLE_ADJUST_WARNINGS.adoc[`FOLLY&lowbar;DETAIL&lowbar;LITE&lowbar;TUPLE&lowbar;ADJUST&lowbar;WARNINGS`] 
| Any file constructing `lite&lowbar;tuple` should contain this after `&num;include`s&colon; FOLLY&lowbar;PUSH&lowbar;WARNINGS FOLLY&lowbar;DETAIL&lowbar;LITE&lowbar;TUPLE&lowbar;ADJUST&lowbar;WARNINGS Followed by `FOLLY&lowbar;POP&lowbar;WARNING` at the bottom&period; The reason is that `&hyphen;Wmissing&hyphen;braces` otherwise breaks deduction guides, and makes aggregate initialization a real headache to use&colon; lite&lowbar;tuple&colon;&colon;tuple t&lcub;1, 2, 3&rcub;&semi; &sol;&sol; before &colon;) lite&lowbar;tuple&colon;&colon;tuple&lt;int&gt; t&lcub;&lcub;&lcub;1&rcub;, &lcub;2&rcub;, &lcub;3&rcub;&rcub;&rcub;&semi; &sol;&sol; after &colon;&apos;(
| xref:FOLLY_EXHAUSTIVE_SWITCH.adoc[`FOLLY&lowbar;EXHAUSTIVE&lowbar;SWITCH`] 
| C&plus;&plus; switch&hyphen;case statements enable writing conditional statements that are checked for exhaustiveness by the compiler&period; However, C&plus;&plus; compilers don&apos;t enforce exhaustiveness very well&period; These macros enable you to explicitly opt into truly exhaustive switch&hyphen;cases, that are useful for scenarios where you may want to deal with enums that are inputs, rather than internal invariants&period;
| xref:FOLLY_EXPECT_JSON_EQ.adoc[`FOLLY&lowbar;EXPECT&lowbar;JSON&lowbar;EQ`] 
| GTest predicate asserting two JSON strings are equal documents&period;
| xref:FOLLY_EXPECT_JSON_NEAR.adoc[`FOLLY&lowbar;EXPECT&lowbar;JSON&lowbar;NEAR`] 
| GTest predicate asserting two JSON strings are equal within a tolerance&period;
| xref:FOLLY_EXPECT_JSON_WITH_NESTED_JSON_EQ.adoc[`FOLLY&lowbar;EXPECT&lowbar;JSON&lowbar;WITH&lowbar;NESTED&lowbar;JSON&lowbar;EQ`] 
| GTest predicate asserting two JSON strings are equal, comparing one level of nested JSON&hyphen;in&hyphen;string&period;
| xref:FOLLY_FOR_EACH_THIS_OVERLOAD_IN_CLASS_BODY_DELEGATE.adoc[`FOLLY&lowbar;FOR&lowbar;EACH&lowbar;THIS&lowbar;OVERLOAD&lowbar;IN&lowbar;CLASS&lowbar;BODY&lowbar;DELEGATE`] 
| FOLLY&lowbar;FOR&lowbar;EACH&lowbar;THIS&lowbar;OVERLOAD&lowbar;IN&lowbar;CLASS&lowbar;BODY&lowbar;DELEGATE
| xref:FOLLY_IGNORE.adoc[`FOLLY&lowbar;IGNORE`] 
| Helper macro that just ignores its parameters&period;
| xref:FOLLY_INIT_LOGGING_CONFIG.adoc[`FOLLY&lowbar;INIT&lowbar;LOGGING&lowbar;CONFIG`] 
| A helper macro to set the default logging configuration in a program&period;
| xref:FOLLY_INVOKE_MEMBER.adoc[`FOLLY&lowbar;INVOKE&lowbar;MEMBER`] 
| &ast; FOLLY&lowbar;INVOKE&lowbar;MEMBER
| xref:FOLLY_INVOKE_QUAL.adoc[`FOLLY&lowbar;INVOKE&lowbar;QUAL`] 
| &ast; FOLLY&lowbar;INVOKE&lowbar;QUAL
| xref:FOLLY_LIKELY.adoc[`FOLLY&lowbar;LIKELY`] 
| Treat the condition as likely&period;
| xref:FOLLY_PP_FOR_EACH.adoc[`FOLLY&lowbar;PP&lowbar;FOR&lowbar;EACH`] 
| FOLLY&lowbar;PP&lowbar;FOR&lowbar;EACH
| xref:FOLLY_PP_STRINGIZE.adoc[`FOLLY&lowbar;PP&lowbar;STRINGIZE`] 
| Use FOLLY&lowbar;PP&lowbar;STRINGIZE(x) when you&apos;d want to do what &num;x does inside another macro expansion&period;
| xref:FOLLY_PP_STRINGIZE_MACRO.adoc[`FOLLY&lowbar;PP&lowbar;STRINGIZE&lowbar;MACRO`] 
| Use FOLLY&lowbar;PP&lowbar;STRINGIZE&lowbar;MACRO(x) when you want the string representation of a non&hyphen;string c&plus;&plus; preprocessing macro value, ex FOLLY&lowbar;PP&lowbar;STRINGIZE&lowbar;MACRO(*LINE*)&period;
| xref:FOLLY_SEMICOLON.adoc[`FOLLY&lowbar;SEMICOLON`] 
| Helper macro that just ignores its parameters and inserts a semicolon&period;
| xref:FOLLY_SETTING.adoc[`FOLLY&lowbar;SETTING`] 
| Accesses a defined setting&period; Rationale for the macro&colon; 1) Searchability, all settings access is done via FOLLY&lowbar;SETTING(&period;&period;&period;) 2) Prevents omitting trailing () by accident, which could lead to bugs like `auto value &equals; &ast;FOLLY&lowbar;SETTING&lowbar;project&lowbar;name&semi;`, which compiles but dereferences the function pointer instead of the setting itself&period;
| xref:FOLLY_SETTING_DECLARE.adoc[`FOLLY&lowbar;SETTING&lowbar;DECLARE`] 
| Declares a setting that&apos;s defined elsewhere&period;
| xref:FOLLY_SETTING_DEFINE.adoc[`FOLLY&lowbar;SETTING&lowbar;DEFINE`] 
| Defines a setting&period;
| xref:FOLLY_SETTING_REGISTER.adoc[`FOLLY&lowbar;SETTING&lowbar;REGISTER`] 
| Registers a setting without defining an Accessor&period; This should rarely be used directly and most use cases will want FOLLY&lowbar;SETTING&lowbar;DEFINE instead&period;
| xref:FOLLY_UNLIKELY.adoc[`FOLLY&lowbar;UNLIKELY`] 
| Treat the condition as unlikely&period;
| xref:SCOPE_EXIT.adoc[`SCOPE&lowbar;EXIT`] 
| Capture code that shall be run when the current scope exits&period;
| xref:SCOPE_FAIL.adoc[`SCOPE&lowbar;FAIL`] 
| Capture code to run if the scope exits with an exception&period;
| xref:SCOPE_SUCCESS.adoc[`SCOPE&lowbar;SUCCESS`] 
| Capture code to run if the scope exits without an exception&period;
| xref:SO_SET_NAMESPACE.adoc[`SO&lowbar;SET&lowbar;NAMESPACE`] 
| Sets a specific tcp personality Available only on kernels 3&period;2 and greater
| xref:SYNCHRONIZED.adoc[`SYNCHRONIZED`] 
| NOTE&colon; This API is deprecated&period; Use lock(), wlock(), rlock() or the withLock functions instead&period; In the future it will be marked with a deprecation attribute to emit build&hyphen;time warnings, and then it will be removed entirely&period;
| xref:SYNCHRONIZED_CONST.adoc[`SYNCHRONIZED&lowbar;CONST`] 
| NOTE&colon; This API is deprecated&period; Use lock(), wlock(), rlock() or the withLock functions instead&period; In the future it will be marked with a deprecation attribute to emit build&hyphen;time warnings, and then it will be removed entirely&period;
| xref:SYNCHRONIZED_DUAL.adoc[`SYNCHRONIZED&lowbar;DUAL`] 
| NOTE&colon; This API is deprecated&period; Use lock(), wlock(), rlock() or the withLock functions instead&period; In the future it will be marked with a deprecation attribute to emit build&hyphen;time warnings, and then it will be removed entirely&period;
| xref:SYNCHRONIZED_VAR.adoc[`SYNCHRONIZED&lowbar;VAR`] 
| Disambiguate the name var by concatenating the line number of the original point of expansion&period; This avoids shadowing warnings for nested SYNCHRONIZEDs&period; The name is consistent if used multiple times within another macro&period; Only for internal use&period;
| xref:XCHECK.adoc[`XCHECK`] 
| Assert that a condition is true&period;
| xref:XCHECK_EQ.adoc[`XCHECK&lowbar;EQ`] 
| Assert a comparison relationship between two arguments&period;
| xref:XDCHECK.adoc[`XDCHECK`] 
| Assert that a condition is true in debug builds only&period;
| xref:XDCHECK_EQ.adoc[`XDCHECK&lowbar;EQ`] 
| Assert a comparison relationship between two arguments in debug builds&period;
| xref:XLOGF.adoc[`XLOGF`] 
| Log a message to this file&apos;s default log category, using a format string&period;
| xref:XLOGF_EVERY_MS.adoc[`XLOGF&lowbar;EVERY&lowbar;MS`] 
| Similar to XLOGF(&period;&period;&period;) except only log a message every
| xref:XLOGF_EVERY_MS_IF.adoc[`XLOGF&lowbar;EVERY&lowbar;MS&lowbar;IF`] 
| Similar to XLOGF(&period;&period;&period;) except only log a message every
| xref:XLOGF_EVERY_MS_OR.adoc[`XLOGF&lowbar;EVERY&lowbar;MS&lowbar;OR`] 
| Similar to XLOGF(&period;&period;&period;) except log a message if the specified condition predicate evaluates to true or every
| xref:XLOGF_EVERY_N.adoc[`XLOGF&lowbar;EVERY&lowbar;N`] 
| Similar to XLOGF(&period;&period;&period;) except only log a message every
| xref:XLOGF_EVERY_N_IF.adoc[`XLOGF&lowbar;EVERY&lowbar;N&lowbar;IF`] 
| Similar to XLOGF(&period;&period;&period;) except only log a message every
| xref:XLOGF_EVERY_N_OR.adoc[`XLOGF&lowbar;EVERY&lowbar;N&lowbar;OR`] 
| Similar to XLOGF(&period;&period;&period;) except it logs a message if the condition predicate evaluates to true or approximately every
| xref:XLOGF_FIRST_N.adoc[`XLOGF&lowbar;FIRST&lowbar;N`] 
| Similar to XLOGF(&period;&period;&period;) except only log a message the first n times, exactly&period;
| xref:XLOGF_IF.adoc[`XLOGF&lowbar;IF`] 
| Log a message using a format string if and only if the specified condition predicate evaluates to true&period; Note that the condition is _only_ evaluated if the log&hyphen;level check passes&period;
| xref:XLOG_ACTUAL_IMPL.adoc[`XLOG&lowbar;ACTUAL&lowbar;IMPL`] 
| Helper macro used to implement XLOG() and XLOGF()
| xref:XLOG_EVERY_MS.adoc[`XLOG&lowbar;EVERY&lowbar;MS`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_EVERY_MS_IF.adoc[`XLOG&lowbar;EVERY&lowbar;MS&lowbar;IF`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_EVERY_MS_OR.adoc[`XLOG&lowbar;EVERY&lowbar;MS&lowbar;OR`] 
| Similar to XLOG(&period;&period;&period;) except log a message if the specified condition predicate evaluates to true or every
| xref:XLOG_EVERY_N.adoc[`XLOG&lowbar;EVERY&lowbar;N`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_EVERY_N_EXACT.adoc[`XLOG&lowbar;EVERY&lowbar;N&lowbar;EXACT`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_EVERY_N_IF.adoc[`XLOG&lowbar;EVERY&lowbar;N&lowbar;IF`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_EVERY_N_OR.adoc[`XLOG&lowbar;EVERY&lowbar;N&lowbar;OR`] 
| Similar to XLOG(&period;&period;&period;) except it logs a message if the condition predicate evaluates to true or approximately every
| xref:XLOG_EVERY_N_THREAD.adoc[`XLOG&lowbar;EVERY&lowbar;N&lowbar;THREAD`] 
| Similar to XLOG(&period;&period;&period;) except only log a message every
| xref:XLOG_FIRST_N.adoc[`XLOG&lowbar;FIRST&lowbar;N`] 
| Similar to XLOG(&period;&period;&period;) except only log a message the first n times, exactly&period;
| xref:XLOG_GET_CATEGORY.adoc[`XLOG&lowbar;GET&lowbar;CATEGORY`] 
| Get a pointer to the LogCategory that will be used by XLOG() statements in this file&period;
| xref:XLOG_GET_CATEGORY_NAME.adoc[`XLOG&lowbar;GET&lowbar;CATEGORY&lowbar;NAME`] 
| Get the name of the log category that will be used by XLOG() statements in this file&period;
| xref:XLOG_IF.adoc[`XLOG&lowbar;IF`] 
| Log a message if and only if the specified condition predicate evaluates to true&period; Note that the condition is _only_ evaluated if the log&hyphen;level check passes&period;
| xref:XLOG_IS_ON.adoc[`XLOG&lowbar;IS&lowbar;ON`] 
| Check if an XLOG() statement with the given log level would be enabled&period;
| xref:XLOG_IS_ON_IMPL.adoc[`XLOG&lowbar;IS&lowbar;ON&lowbar;IMPL`] 
| Expects a fully qualified LogLevel enum value&period;
| xref:XLOG_IS_ON_IMPL_HELPER.adoc[`XLOG&lowbar;IS&lowbar;ON&lowbar;IMPL&lowbar;HELPER`] 
| Helper macro to implement of XLOG&lowbar;IS&lowbar;ON()
| xref:XLOG_N_PER_MS.adoc[`XLOG&lowbar;N&lowbar;PER&lowbar;MS`] 
| Similar to XLOG(&period;&period;&period;) except only log at most
| xref:_FE_ANON.adoc[`&lowbar;FE&lowbar;ANON`] 
| Forms a local variable name from &quot;FOR&lowbar;EACH&lowbar;&quot;, `x`, and *LINE*&period;
|===


== xref:example.adoc[example] namespace

Example code demonstrating the Folly logging library&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:example/ExampleObject.adoc[`ExampleObject`] 
| Example object that logs to the folly&period;logging&period;example&period;lib category&period;
|===


== xref:fmt.adoc[fmt] namespace

The &lcub;fmt&rcub; formatting library namespace&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:fmt/formatter-075.adoc[`formatter&lt;folly::StringPiece&gt;`] 
| &lcub;fmt&rcub; formatter specialization for folly&colon;&colon;StringPiece&period;
| xref:fmt/formatter-09.adoc[`formatter&lt;&sol;&ast; implementation-defined &ast;&sol;&gt;`] 
| Formats an `errc&lowbar;format&lowbar;as` tag for use with `fmt`&period;
| xref:fmt/formatter-07b.adoc[`formatter&lt;folly::error&lowbar;or&lowbar;stopped&gt;`] 
| `fmt&colon;&colon;format` support for `folly&colon;&colon;error&lowbar;or&lowbar;stopped`&period;
| xref:fmt/formatter-0ce.adoc[`formatter&lt;folly::exception&lowbar;wrapper&gt;`] 
| Formatter specialization that formats an `exception&lowbar;wrapper` via `what()`&period;
| xref:fmt/formatter-0d.adoc[`formatter&lt;folly::fbstring&gt;`] 
| &lcub;fmt&rcub; formatter specialization that formats fbstring as a string view&period;
| xref:fmt/formatter-0a.adoc[`formatter&lt;folly::rich&lowbar;error&lowbar;base::fmt&lowbar;all&lowbar;codes&lowbar;t&gt;`] 
| `fmt&colon;&colon;format` support that renders all codes of a rich error&period;
| xref:fmt/formatter-063.adoc[`formatter&lt;folly::rich&lowbar;error&lowbar;base&gt;`] 
| `fmt&colon;&colon;format` support for `rich&lowbar;error&lowbar;base` and derived classes&period;
| xref:fmt/formatter-060.adoc[`formatter&lt;folly::rich&lowbar;exception&lowbar;ptr&gt;`] 
| Formats a `rich&lowbar;exception&lowbar;ptr` for use with `fmt`&period;
| xref:fmt/formatter-03.adoc[`formatter&lt;T&gt;`] 
| `fmt&colon;&colon;format` support for any type convertible to `rich&lowbar;error&lowbar;base&ast;`&period;
| xref:fmt/formatter-047.adoc[`formatter&lt;folly::rich&lowbar;ptr&lowbar;to&lowbar;underlying&lowbar;error&lt;Ex&gt;&gt;`] 
| `fmt&colon;&colon;format` support for the pointer&hyphen;like returned by `get&lowbar;exception&lt;Ex&gt;()`&period;
| xref:fmt/formatter-0f.adoc[`formatter&lt;folly::reproducible&lowbar;accumulator&lt;ftype, Fold&gt;&gt;`] 
| fmt formatter specialization for reproducible&lowbar;accumulator&period;
| xref:fmt/formatter-044.adoc[`formatter&lt;folly::basic&lowbar;cstring&lowbar;view&lt;Char, Traits&gt;, Char&gt;`] 
| Formatter specialization for basic&lowbar;cstring&lowbar;view, reusing string&lowbar;view formatting&period;
|===


== xref:folly.adoc[folly] namespace

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`] 
| Per&hyphen;request context associated with an enqueued item&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-09.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
| 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;
|===


== xref:folly/array_detail.adoc[folly::array&lowbar;detail] namespace

Implementation helpers for make&lowbar;array and make&lowbar;array&lowbar;with&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/array_detail/return_type_helper-063.adoc[`return&lowbar;type&lowbar;helper`] 
| Resolves the element type of the array produced by make&lowbar;array&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/array_detail/is_ref_wrapper.adoc[`is&lowbar;ref&lowbar;wrapper`] 
| Trait that is true when `T` is a std&colon;&colon;reference&lowbar;wrapper&period;
| xref:folly/array_detail/not_ref_wrapper.adoc[`not&lowbar;ref&lowbar;wrapper`] 
| Trait that is true when the decayed `T` is not a std&colon;&colon;reference&lowbar;wrapper&period;
| xref:folly/array_detail/return_type.adoc[`return&lowbar;type`] 
| The std&colon;&colon;array type make&lowbar;array returns for the given element types&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/array_detail/make_array_with_.adoc[`make&lowbar;array&lowbar;with&lowbar;`] 
| Builds a std&colon;&colon;array by invoking `make` for each index in the sequence&period;
|===


== xref:folly/async_tracing.adoc[folly::async&lowbar;tracing] namespace

Implementation details&period;

=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/async_tracing/DiscardHasDeferred.adoc[`DiscardHasDeferred`] 
| Whether a discarded SemiFuture carried a deferred executor&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/async_tracing/logBlockingOperation.adoc[`logBlockingOperation`] 
| Trace hook invoked for a blocking operation&period;
| xref:folly/async_tracing/logFutureVia.adoc[`logFutureVia`] 
| Trace hook invoked when a Future is rescheduled onto an executor&period;
| xref:folly/async_tracing/logGetGlobalCPUExecutor.adoc[`logGetGlobalCPUExecutor`] 
| Trace hook invoked when the global CPU executor is retrieved&period;
| xref:folly/async_tracing/logGetGlobalIOExecutor.adoc[`logGetGlobalIOExecutor`] 
| Trace hook invoked when the global IO executor is retrieved&period;
| xref:folly/async_tracing/logGetImmutableCPUExecutor.adoc[`logGetImmutableCPUExecutor`] 
| Trace hook invoked when the immutable CPU executor is retrieved&period;
| xref:folly/async_tracing/logGetImmutableIOExecutor.adoc[`logGetImmutableIOExecutor`] 
| Trace hook invoked when the immutable IO executor is retrieved&period;
| xref:folly/async_tracing/logSemiFutureDiscard.adoc[`logSemiFutureDiscard`] 
| Trace hook invoked when a SemiFuture is discarded&period;
| xref:folly/async_tracing/logSemiFutureVia.adoc[`logSemiFutureVia`] 
| Trace hook invoked when a SemiFuture is rescheduled onto an executor&period;
| xref:folly/async_tracing/logSetGlobalCPUExecutor.adoc[`logSetGlobalCPUExecutor`] 
| Trace hook invoked when the global CPU executor is set&period;
| xref:folly/async_tracing/logSetGlobalCPUExecutorToImmutable.adoc[`logSetGlobalCPUExecutorToImmutable`] 
| Trace hook invoked when the global CPU executor is set to the immutable one&period;
| xref:folly/async_tracing/logSetGlobalIOExecutor.adoc[`logSetGlobalIOExecutor`] 
| Trace hook invoked when the global IO executor is set&period;
|===


== xref:folly/bind.adoc[folly::bind] namespace

READ ME&colon; The docs for this library are in `Bind&period;md`&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext.adoc[`ext`] 
| Implements standard storage semantics for `folly&colon;&colon;bind`&period; This is used (with some additional constraints &amp; tweaks) by `async&lowbar;closure` captures&period; It can also be used for other single&hyphen;use data structurs &hyphen;&hyphen; this makes it easy to simultaneously define the types for, and construct, tuples, named tuples, structs, etc&period; Some examples of this are given in `Bind&period;md`&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/args-05.adoc[`args`] 
| The primitive for representing lists of bound args&period;
| xref:folly/bind/capture-0b.adoc[`capture`] 
| `bind&colon;&colon;capture()` and `bind&colon;&colon;capture&lowbar;indirect()` work much like other `folly&colon;&colon;bind` modifiers&period; However, since they&apos;re primarily intended for `async&lowbar;closure` arguments, you will practically only use them&colon; &hyphen; alone, for non&hyphen;`co&lowbar;cleanup` arguments&semi; &hyphen; with `bind&colon;&colon;in&lowbar;place()` or `bind&colon;&colon;in&lowbar;place&lowbar;with()`, for `co&lowbar;cleanup` arguments&semi; &hyphen; with `constant()`, for either&period;
| xref:folly/bind/capture_const_ref-03.adoc[`capture&lowbar;const&lowbar;ref`] 
| Sugar for `capture&lcub;const&lowbar;ref&lcub;&period;&period;&period;&rcub;&rcub;`, capturing a const reference&period;
| xref:folly/bind/capture_indirect-02.adoc[`capture&lowbar;indirect`] 
| Binds an async&hyphen;closure capture whose pointer&hyphen;like value is dereferenced once to expose the underlying object&period;
| xref:folly/bind/capture_mut_ref-0c.adoc[`capture&lowbar;mut&lowbar;ref`] 
| Sugar for `capture&lcub;mut&lowbar;ref&lcub;&period;&period;&period;&rcub;&rcub;`, capturing a mutable reference&period;
| xref:folly/bind/const_ref-03.adoc[`const&lowbar;ref`] 
| Binding modifier that binds a const reference to each argument&period;
| xref:folly/bind/constant-0b.adoc[`constant`] 
| Binding modifier that makes each argument `const`&period;
| xref:folly/bind/copy-03.adoc[`copy`] 
| Binding modifier that passes its arguments as decay&hyphen;copied prvalues&period;
| xref:folly/bind/id_type.adoc[`id&lowbar;type`] 
| The &quot;identifier tag &hyphen;&gt; storage type&quot; signature for a named binding&period;
| xref:folly/bind/move-0d.adoc[`move`] 
| Binding modifier that passes its arguments as rvalue references&period;
| xref:folly/bind/mut-0b1.adoc[`mut`] 
| Binding modifier that keeps each argument mutable&period;
| xref:folly/bind/mut_ref-06.adoc[`mut&lowbar;ref`] 
| Binding modifier that binds a mutable reference to each argument&period;
| xref:folly/bind/self_id_type.adoc[`self&lowbar;id&lowbar;type`] 
| The self&hyphen;reference &quot;identifier tag &hyphen;&gt; storage type&quot; binding signature&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/capture_in_place.adoc[`capture&lowbar;in&lowbar;place`] 
| Bind an in&hyphen;place&hyphen;constructed capture of type `T`&period;
| xref:folly/bind/capture_in_place_with.adoc[`capture&lowbar;in&lowbar;place&lowbar;with`] 
| Bind an in&hyphen;place&hyphen;constructed capture built by a factory function&period;
| xref:folly/bind/in_place.adoc[`in&lowbar;place`] 
| Binds in&hyphen;place construction of `T` from the given arguments&period;
| xref:folly/bind/in_place_with.adoc[`in&lowbar;place&lowbar;with`] 
| Binds in&hyphen;place construction via a maker callable plus the given arguments&period;
| xref:folly/bind/operator_id.adoc[`operator&quot;&quot;&lowbar;id`] 
| User&hyphen;defined literal building a `bind&colon;&colon;id&lt;Str&gt;` from `&quot;x&quot;&lowbar;id`&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/id.adoc[`id`] 
| The identifier for the compile&hyphen;time string `Str`&semi; also spelled `&quot;x&quot;&lowbar;id`&period;
| xref:folly/bind/self_id.adoc[`self&lowbar;id`] 
| A special `identifier` tag that works just like `&quot;x&quot;&lowbar;id`&period;
|===


== xref:folly/bind/ext.adoc[folly::bind::ext] namespace

Implements standard storage semantics for `folly&colon;&colon;bind`&period; This is used (with some additional constraints &amp; tweaks) by `async&lowbar;closure` captures&period; It can also be used for other single&hyphen;use data structurs &hyphen;&hyphen; this makes it easy to simultaneously define the types for, and construct, tuples, named tuples, structs, etc&period; Some examples of this are given in `Bind&period;md`&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/bind_info_t.adoc[`bind&lowbar;info&lowbar;t`] 
| The binding flags for a bound argument&period;
| xref:folly/bind/ext/bind_to_storage_policy-06.adoc[`bind&lowbar;to&lowbar;storage&lowbar;policy`] 
| Policy that maps a binding to the storage type used to hold its value&period;
| xref:folly/bind/ext/binding_t.adoc[`binding&lowbar;t`] 
| Metadata for a single bound argument&colon; its binding type plus binding flags&period;
| xref:folly/bind/ext/id_arg.adoc[`id&lowbar;arg`] 
| A bound&hyphen;args list tagged with the identifier string `Str`&period;
| xref:folly/bind/ext/identifier.adoc[`identifier`] 
| A binding identifier tag, such as `&quot;x&quot;&lowbar;id` or the self&hyphen;reference tag&period;
| xref:folly/bind/ext/like_args.adoc[`like&lowbar;args`] 
| Base class for any type modeling a list of bound args with modifiers&period;
| xref:folly/bind/ext/merge_update_args.adoc[`merge&lowbar;update&lowbar;args`] 
| Concatenates several `like&lowbar;args` lists, mapping each `bind&lowbar;info&lowbar;t` through `BindInfoFn`&period;
| xref:folly/bind/ext/named_bind_info_t.adoc[`named&lowbar;bind&lowbar;info&lowbar;t`] 
| A `bind&lowbar;info&lowbar;t` extended with a compile&hyphen;time identifier `Tag`&period;
| xref:folly/bind/ext/no_tag_t.adoc[`no&lowbar;tag&lowbar;t`] 
| Placeholder tag meaning a binding carries no name tag&period;
| xref:folly/bind/ext/self_id_arg.adoc[`self&lowbar;id&lowbar;arg`] 
| A bound&hyphen;args list tagged with the self&hyphen;reference identifier&period;
| xref:folly/bind/ext/self_id_t.adoc[`self&lowbar;id&lowbar;t`] 
| Tag type marking the self&hyphen;reference identifier&period;
| xref:folly/bind/ext/unsafe_move_args.adoc[`unsafe&lowbar;move&lowbar;args`] 
| Tag and factory for unsafely moving the contents of a `like&lowbar;args` list&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/deduce_args_t.adoc[`deduce&lowbar;args&lowbar;t`] 
| Deduces the stored binding type for a value passed to `args` and friends&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/category_t.adoc[`category&lowbar;t`] 
| Category flag controlling how a bound argument is passed or stored&period;
| xref:folly/bind/ext/constness_t.adoc[`constness&lowbar;t`] 
| Constness flag applied to a bound argument&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/bind_as_argument.adoc[`bind&lowbar;as&lowbar;argument`] 
| Forward a bound storage reference as the argument implied by its bind&hyphen;info category&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/named_bind_info_tag_v-06.adoc[`named&lowbar;bind&lowbar;info&lowbar;tag&lowbar;v`] 
| The name tag of a binding, or no&lowbar;tag&lowbar;t when the binding is unnamed&period;
| xref:folly/bind/ext/named_bind_info_tag_v-02.adoc[`named&lowbar;bind&lowbar;info&lowbar;tag&lowbar;v`] 
| Specialization extracting the tag from a named binding info&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/bind/ext/is_binding_t_type_in_place.adoc[`is&lowbar;binding&lowbar;t&lowbar;type&lowbar;in&lowbar;place`] 
| True when the binding type `BT` denotes in&hyphen;place construction (a value type)&period;
|===


== xref:folly/bititerator_detail.adoc[folly::bititerator&lowbar;detail] namespace

Implementation details for BitIterator&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/bititerator_detail/BitIteratorBase.adoc[`BitIteratorBase`] 
| Provides the boost&colon;&colon;iterator&lowbar;adaptor base type used by BitIterator&period;
| xref:folly/bititerator_detail/BitReference.adoc[`BitReference`] 
| Reference to a bit&period;
|===


== xref:folly/bser.adoc[folly::bser] namespace

BSER binary serialization for dynamic values&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/bser/BserDecodeError.adoc[`BserDecodeError`] 
| Exception thrown when BSER&hyphen;encoded input cannot be decoded&period;
| xref:folly/bser/bser_deserialization_options.adoc[`bser&lowbar;deserialization&lowbar;options`] 
| Options controlling how a BSER stream is deserialized&period;
| xref:folly/bser/serialization_opts.adoc[`serialization&lowbar;opts`] 
| Options controlling how a dynamic value is serialized to BSER&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/bser/BserType.adoc[`BserType`] 
| Type tags used in the BSER wire format&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/bser/decodePduLength.adoc[`decodePduLength`] 
| Determine how much data is needed to fully decode a BSER pdu&period;
| xref:folly/bser/parseBser-0a.adoc[`parseBser`] 
| `parseBser` overloads
| xref:folly/bser/toBser.adoc[`toBser`] 
| Serialize a dynamic value to a BSER&hyphen;encoded string&period;
| xref:folly/bser/toBserIOBuf.adoc[`toBserIOBuf`] 
| Serialize a dynamic value to a BSER&hyphen;encoded IOBuf&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/bser/kMagic.adoc[`kMagic`] 
| The two&hyphen;byte magic prefix that identifies a BSER stream&period;
|===


== xref:folly/bskip_detail.adoc[folly::bskip&lowbar;detail] namespace

Internal implementation details for ConcurrentBSkipList&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/detail_hw_atomic.adoc[`detail&lowbar;hw&lowbar;atomic`] 
| Detects whether a type qualifies as a hardware&hyphen;atomic key&sol;payload type&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/AdaptiveReadGuard.adoc[`AdaptiveReadGuard`] 
| RAII read guard that starts optimistic and escalates to the shared lock when a writer is in flight&period;
| xref:folly/bskip_detail/AtomicSlot.adoc[`AtomicSlot`] 
| Lock&hyphen;free read slot for hardware&hyphen;atomic T&period;
| xref:folly/bskip_detail/BSkipAllocator.adoc[`BSkipAllocator`] 
| Node allocator wrapper that rebinds a byte allocator per node type&period;
| xref:folly/bskip_detail/BSkipNode.adoc[`BSkipNode`] 
| Common base of leaf and internal nodes&colon; next pointer, seqlock, and mutex&period;
| xref:folly/bskip_detail/BSkipNodeInternal.adoc[`BSkipNodeInternal`] 
| Internal (routing) node holding separator keys and child pointers&period;
| xref:folly/bskip_detail/BSkipNodeLeaf.adoc[`BSkipNodeLeaf`] 
| Leaf node holding sorted keys, optional payloads, and tombstone bits&period;
| xref:folly/bskip_detail/BSkipTuning.adoc[`BSkipTuning`] 
| Tuning knobs separated from InternalTraits so they can be adjusted without touching the Traits template parameter set&period;
| xref:folly/bskip_detail/InlineLeafRecord.adoc[`InlineLeafRecord`] 
| Interleaved &lcub;key, payload&rcub; record for inline (AoS) leaf storage&period;
| xref:folly/bskip_detail/InternalTraits.adoc[`InternalTraits`] 
| Derived compile&hyphen;time traits for a ConcurrentBSkipList instantiation&period;
| xref:folly/bskip_detail/LeafStorage-00.adoc[`LeafStorage`] 
| Leaf key&sol;payload storage policy dispatcher&period;
| xref:folly/bskip_detail/Seqlock.adoc[`Seqlock`] 
| Seqlock used to bracket OLC reader&sol;writer access to a node&apos;s fields&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/BSkipTestHook.adoc[`BSkipTestHook`] 
| Function&hyphen;pointer type for a BSkipList test hook&period;
| xref:folly/bskip_detail/Empty.adoc[`Empty`] 
| Zero&hyphen;size payload slot for &lsqb;&lsqb;no&lowbar;unique&lowbar;address&rsqb;&rsqb;in void&hyphen;payload templates&period;
| xref:folly/bskip_detail/KeyStorage.adoc[`KeyStorage`] 
| Picks the leaf&hyphen;slot storage type for a key&sol;value type T&period;
| xref:folly/bskip_detail/PayloadStorage.adoc[`PayloadStorage`] 
| Same as KeyStorage but Empty when there&apos;s no payload at all&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/BSkipTestHookEvent.adoc[`BSkipTestHookEvent`] 
| Test&hyphen;hook event points fired along the concurrent read&sol;split paths&period;
| xref:folly/bskip_detail/InsertSemantics.adoc[`InsertSemantics`] 
| How an insertion treats an existing live exact&hyphen;match key&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/findFirstGreaterLinear.adoc[`findFirstGreaterLinear`] 
| Finds the first slot in &lsqb;begin, end) whose key sorts after target&period;&rsqb;
| xref:folly/bskip_detail/invokeBSkipTestHook.adoc[`invokeBSkipTestHook`] 
| Fires the global BSkipList test hook (no&hyphen;op unless test hooks are built)&period;
| xref:folly/bskip_detail/loadValidated.adoc[`loadValidated`] 
| Reads a slot optimistically, then validates the read&period;
| xref:folly/bskip_detail/setBSkipTestHook.adoc[`setBSkipTestHook`] 
| Installs the global BSkipList test hook (no&hyphen;op unless test hooks are built)&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/kDefaultReadPolicy.adoc[`kDefaultReadPolicy`] 
| Default key&hyphen;read policy for T&colon; RelaxedAtomic if hardware&hyphen;atomic, else Locked&period;
| xref:folly/bskip_detail/kIsHardwareAtomic.adoc[`kIsHardwareAtomic`] 
| True when T is a hardware&hyphen;atomic (lock&hyphen;free, trivially copyable) type&period;
|===


== xref:folly/bskip_detail/detail_hw_atomic.adoc[folly::bskip&lowbar;detail::detail&lowbar;hw&lowbar;atomic] namespace

Detects whether a type qualifies as a hardware&hyphen;atomic key&sol;payload type&period;

=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/bskip_detail/detail_hw_atomic/Check.adoc[`Check`] 
| Satisfied when T is trivially copyable and always lock&hyphen;free as an atomic&period;
|===


== xref:folly/channels.adoc[folly::channels] namespace

Sender&sol;receiver channel primitives for asynchronous value streams&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/channels/Channel.adoc[`Channel`] 
| A channel is a sender and receiver pair that allows one component to send values to another&period; A sender and receiver pair is similar to an AsyncPipe and AsyncGenerator pair&period; However, unlike AsyncPipe&sol;AsyncGenerator, senders and receivers can be used by memory&hyphen;efficient higher level transformation abstractions&period;
| xref:folly/channels/ChannelCallbackHandle.adoc[`ChannelCallbackHandle`] 
| A callback handle for a consumption operation on a channel&period; The consumption operation will be cancelled when this handle is destroyed&period;
| xref:folly/channels/ChannelCallbackHandleList.adoc[`ChannelCallbackHandleList`] 
| A list of channel callback handles&period; When consumeChannelWithCallback is invoked with a list, a cancellation handle is automatically added to the list for the consumption operation&period; Similarly, when a consumption operation is completed, the handle is automatically removed from the lists&period;
| xref:folly/channels/FanoutChannel.adoc[`FanoutChannel`] 
| A fanout channel allows fanning out updates from a single input receiver to multiple output receivers&period;
| xref:folly/channels/FanoutSender.adoc[`FanoutSender`] 
| A FanoutSender allows fanning out updates to multiple output receivers&period; Values can be written as with a normal Sender&period; When there is only one output receiver, the memory used by a FanoutSender (and the corresponding output receiver) is the same as the memory used by a normal channel&period;
| xref:folly/channels/MaxConcurrentRateLimiter.adoc[`MaxConcurrentRateLimiter`] 
| A rate limiter that caps the number of concurrently running operations&period;
| xref:folly/channels/MergeChannel.adoc[`MergeChannel`] 
| A merge channel allows one to merge multiple receivers into a single output receiver&period; The set of receivers being merged can be changed at runtime&period; Each receiver is added with a key that can be used to remove the receiver at a later point&period;
| xref:folly/channels/MergeChannelEvent.adoc[`MergeChannelEvent`] 
| An event emitted by a merge channel, tagged with the source receiver key&period;
| xref:folly/channels/MergeChannelReceiverAdded.adoc[`MergeChannelReceiverAdded`] 
| Event signaling that a receiver was added to the merge channel&period;
| xref:folly/channels/MergeChannelReceiverClosed.adoc[`MergeChannelReceiverClosed`] 
| Event signaling that a merged receiver closed&period;
| xref:folly/channels/MergeChannelReceiverRemoved.adoc[`MergeChannelReceiverRemoved`] 
| Event signaling that a receiver was removed from the merge channel&period;
| xref:folly/channels/NoContext.adoc[`NoContext`] 
| Empty context used by FanoutChannel when no context is needed&period;
| xref:folly/channels/OnClosedException.adoc[`OnClosedException`] 
| An OnClosedException passed to a transform or multiplex callback indicates that the input channel was closed&period; An OnClosedException can also be thrown by a transform or multiplex callback, which will close the output channel&period;
| xref:folly/channels/RateLimiter.adoc[`RateLimiter`] 
| A rate&hyphen;limiter used by the channels framework to limit the number of in&hyphen;flight requests&period;
| xref:folly/channels/Receiver.adoc[`Receiver`] 
| A receiver that receives values sent by a sender&period; There are several ways that a receiver can be consumed&colon;
| xref:folly/channels/ReinitializeException.adoc[`ReinitializeException`] 
| A ReinitializeException thrown by a transform callback indicates that the resumable transform needs to be re&hyphen;initialized&period;
| xref:folly/channels/Sender.adoc[`Sender`] 
| A sender sends values to be consumed by a receiver&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/channels/consumeChannelWithCallback.adoc[`consumeChannelWithCallback`] 
| This function takes a Receiver, and consumes updates from that receiver with a callback&period;
| xref:folly/channels/createFanoutChannel.adoc[`createFanoutChannel`] 
| Creates a new fanout channel that fans out updates from an input receiver&period;
| xref:folly/channels/createMergeChannel.adoc[`createMergeChannel`] 
| Creates a new merge channel&period;
| xref:folly/channels/merge.adoc[`merge`] 
| Merge takes a list of receivers, and returns a new receiver that receives all updates from all input receivers&period; If any input receiver closes with an exception, the exception is forwarded and the channel is closed&period; If any input receiver closes without an exception, the channel continues to merge values from the other input receivers until all input receivers are closed&period;
| xref:folly/channels/resumableTransform-0f.adoc[`resumableTransform`] 
| `resumableTransform` overloads
| xref:folly/channels/transform-02.adoc[`transform`] 
| `transform` overloads
|===


== xref:folly/chrono.adoc[folly::chrono] namespace

Time&hyphen;related wrappers and clock utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/chrono/Clock.adoc[`Clock`] 
| Clock interface&period;
| xref:folly/chrono/ClockImpl.adoc[`ClockImpl`] 
| Implementation of ClockInterface for given std&colon;&colon;chrono ClockType&period;
| xref:folly/chrono/clock_traits-036.adoc[`clock&lowbar;traits`] 
| Detects and re&hyphen;exports per&hyphen;clock traits&period;
| xref:folly/chrono/coarse_steady_clock.adoc[`coarse&lowbar;steady&lowbar;clock`] 
| A coarse&hyphen;resolution steady clock backed by CLOCK&lowbar;MONOTONIC&lowbar;COARSE&period;
| xref:folly/chrono/coarse_system_clock.adoc[`coarse&lowbar;system&lowbar;clock`] 
| A coarse&hyphen;resolution system clock backed by CLOCK&lowbar;REALTIME&lowbar;COARSE&period;
| xref:folly/chrono/steady_clock_spec.adoc[`steady&lowbar;clock&lowbar;spec`] 
| Spec tag shared by all steady clocks with the same epoch and tick rate&period;
| xref:folly/chrono/system_clock_spec.adoc[`system&lowbar;clock&lowbar;spec`] 
| Spec tag shared by all system clocks with the same epoch and tick rate&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/chrono/SteadyClock.adoc[`SteadyClock`] 
| Clock interface backed by std&colon;&colon;chrono&colon;&colon;steady&lowbar;clock&period;
| xref:folly/chrono/SteadyClockImpl.adoc[`SteadyClockImpl`] 
| Clock implementation backed by std&colon;&colon;chrono&colon;&colon;steady&lowbar;clock&period;
| xref:folly/chrono/SystemClock.adoc[`SystemClock`] 
| Clock interface backed by std&colon;&colon;chrono&colon;&colon;system&lowbar;clock&period;
| xref:folly/chrono/SystemClockImpl.adoc[`SystemClockImpl`] 
| Clock implementation backed by std&colon;&colon;chrono&colon;&colon;system&lowbar;clock&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/chrono/clock_gettime.adoc[`clock&lowbar;gettime`] 
| Pointer to a `clock&lowbar;gettime`&hyphen;style function returning the time of a clock via a `timespec`&period;
| xref:folly/chrono/clock_gettime_ns.adoc[`clock&lowbar;gettime&lowbar;ns`] 
| Pointer to a function returning the time of a clock in nanoseconds&period;
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/chrono/abs.adoc[`abs`] 
| Re&hyphen;export of `std&colon;&colon;chrono&colon;&colon;abs`&period;
| xref:folly/chrono/ceil.adoc[`ceil`] 
| Re&hyphen;export of `std&colon;&colon;chrono&colon;&colon;ceil`&period;
| xref:folly/chrono/floor.adoc[`floor`] 
| Re&hyphen;export of `std&colon;&colon;chrono&colon;&colon;floor`&period;
| xref:folly/chrono/round.adoc[`round`] 
| Re&hyphen;export of `std&colon;&colon;chrono&colon;&colon;round`&period;
|===


== xref:folly/compression.adoc[folly::compression] namespace

Compression and decompression codecs over IOBufs&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/contexts.adoc[`contexts`] 
| Process&hyphen;wide singleton ZSTD compression context pools&period;
| xref:folly/compression/instructions.adoc[`instructions`] 
| CPU instruction&hyphen;set backends for Elias&hyphen;Fano bit operations&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/BitVectorCompressedListBase.adoc[`BitVectorCompressedListBase`] 
| Non&hyphen;owning view over a bit&hyphen;vector&hyphen;encoded list and its sub&hyphen;sections&period;
| xref:folly/compression/BitVectorEncoder.adoc[`BitVectorEncoder`] 
| Encodes a strictly increasing sequence of unsigned integers as a bit vector&period;
| xref:folly/compression/BitVectorReader.adoc[`BitVectorReader`] 
| Forward&sol;random&hyphen;access reader over a bit&hyphen;vector&hyphen;encoded integer sequence&period;
| xref:folly/compression/Codec.adoc[`Codec`] 
| Base class for a compression&sol;decompression codec&period;
| xref:folly/compression/CompressionContextPool.adoc[`CompressionContextPool`] 
| This implementation is slow under contention&period; Except under uncontended scenarios, you shouldn&apos;t use it directly&period; You likely want to use the CompressionCoreLocalContextPool instead, which, behind the fast cache slots, is backed by this implementation&period;
| xref:folly/compression/CompressionContextPoolDefaultCallback.adoc[`CompressionContextPoolDefaultCallback`] 
| Default no&hyphen;op callback invoked periodically by CompressionContextPool&period;
| xref:folly/compression/CompressionCoreLocalContextPool.adoc[`CompressionCoreLocalContextPool`] 
| This class is intended to reduce contention on reserving a compression context and improve cache locality (but maybe not hotness) of the contexts it manages&period;
| xref:folly/compression/CompressionCoreLocalContextPoolBase.adoc[`CompressionCoreLocalContextPoolBase`] 
| Non&hyphen;templated base class which allows for generic interaction with context pool instances&period;
| xref:folly/compression/EliasFanoCompressedListBase.adoc[`EliasFanoCompressedListBase`] 
| Non&hyphen;owning view over an Elias&hyphen;Fano&hyphen;encoded list and its sub&hyphen;sections&period;
| xref:folly/compression/EliasFanoEncoder.adoc[`EliasFanoEncoder`] 
| Encodes a sorted sequence of unsigned integers using Elias&hyphen;Fano coding&period;
| xref:folly/compression/EliasFanoReader.adoc[`EliasFanoReader`] 
| Forward&sol;random&hyphen;access reader over an Elias&hyphen;Fano&hyphen;encoded, non&hyphen;decreasing sequence of integers produced by EliasFanoEncoder&period;
| xref:folly/compression/StreamCodec.adoc[`StreamCodec`] 
| Base class for a codec that also supports a stateful streaming API&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/BitVectorCompressedList.adoc[`BitVectorCompressedList`] 
| Read&hyphen;only bit&hyphen;vector compressed list&period;
| xref:folly/compression/EliasFanoCompressedList.adoc[`EliasFanoCompressedList`] 
| Read&hyphen;only Elias&hyphen;Fano compressed list&period;
| xref:folly/compression/MutableBitVectorCompressedList.adoc[`MutableBitVectorCompressedList`] 
| Mutable bit&hyphen;vector compressed list&period;
| xref:folly/compression/MutableEliasFanoCompressedList.adoc[`MutableEliasFanoCompressedList`] 
| Mutable Elias&hyphen;Fano compressed list&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/CodecType.adoc[`CodecType`] 
| Identifies a compression algorithm&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/copyCompressedList.adoc[`copyCompressedList`] 
| Returns a deep copy of a compressed list, owning a freshly allocated buffer&period;
| xref:folly/compression/getAutoUncompressionCodec.adoc[`getAutoUncompressionCodec`] 
| Returns a codec that can uncompress any of the given codec types as well as &lcub;LZ4&lowbar;FRAME, ZSTD, ZLIB, GZIP, LZMA2, BZIP2&rcub;&period; Appends each default codec to customCodecs in order, so long as a codec with the same type() isn&apos;t already present in customCodecs or as the terminalCodec&period; When uncompress() is called, each codec&apos;s canUncompress() is called in the order that they are given&period; Appended default codecs are checked last&period; uncompress() is called on the first codec whose canUncompress() returns true&period;
| xref:folly/compression/getCodec.adoc[`getCodec`] 
| Return a codec for the given type&period; Throws on error&period; The level is a non&hyphen;negative codec&hyphen;dependent integer indicating the level of compression desired, or one of the following constants&colon;
| xref:folly/compression/getStreamCodec.adoc[`getStreamCodec`] 
| Return a codec for the given type&period; Throws on error&period; The level is a non&hyphen;negative codec&hyphen;dependent integer indicating the level of compression desired, or one of the following constants&colon;
| xref:folly/compression/hasCodec.adoc[`hasCodec`] 
| Check if a specified codec is supported&period;
| xref:folly/compression/hasStreamCodec.adoc[`hasStreamCodec`] 
| Check if a specified codec is supported and supports streaming&period;
| xref:folly/compression/zstdConvertLevel.adoc[`zstdConvertLevel`] 
| Convert a folly abstract compression level (COMPRESSION&lowbar;LEVEL&lowbar;FASTEST, COMPRESSION&lowbar;LEVEL&lowbar;DEFAULT, COMPRESSION&lowbar;LEVEL&lowbar;BEST) to a raw ZSTD compression level (1&hyphen;22)&period; Passes through raw levels in &lsqb;1, ZSTD&lowbar;maxCLevel()&rsqb; unchanged&period; Throws std&colon;&colon;invalid&lowbar;argument for out&hyphen;of&hyphen;range levels&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/COMPRESSION_CONTEXT_POOL_CALLBACK_INTERVAL.adoc[`COMPRESSION&lowbar;CONTEXT&lowbar;POOL&lowbar;CALLBACK&lowbar;INTERVAL`] 
| Number of pool checkouts between successive callback invocations&period;
| xref:folly/compression/COMPRESSION_LEVEL_BEST.adoc[`COMPRESSION&lowbar;LEVEL&lowbar;BEST`] 
| Abstract level selecting the best compression&period;
| xref:folly/compression/COMPRESSION_LEVEL_DEFAULT.adoc[`COMPRESSION&lowbar;LEVEL&lowbar;DEFAULT`] 
| Abstract level selecting the codec&apos;s default compression&period;
| xref:folly/compression/COMPRESSION_LEVEL_FASTEST.adoc[`COMPRESSION&lowbar;LEVEL&lowbar;FASTEST`] 
| Abstract level selecting the fastest compression&period;
| xref:folly/compression/kCacheLineSize.adoc[`kCacheLineSize`] 
| Size in bytes of a cache line, used to size prefetches&period;
| xref:folly/compression/kLowerTrailingBytes.adoc[`kLowerTrailingBytes`] 
| Trailing bytes that must be readable past the end of the lower bit sequence, required by loadUnaligned&lt;uint64&lowbar;t&gt; reads in the lower accessor&period;
| xref:folly/compression/kUpperTrailingBytes.adoc[`kUpperTrailingBytes`] 
| Trailing bytes that must be readable past the end of the upper bit sequence, required by loadUnaligned&lt;uint64&lowbar;t&gt; reads in the upper accessor&period;
|===


== xref:folly/compression/contexts.adoc[folly::compression::contexts] namespace

Process&hyphen;wide singleton ZSTD compression context pools&period;

== xref:folly/compression/instructions.adoc[folly::compression::instructions] namespace

CPU instruction&hyphen;set backends for Elias&hyphen;Fano bit operations&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/instructions/Default.adoc[`Default`] 
| Portable bit&hyphen;operation backend using compiler builtins&period;
| xref:folly/compression/instructions/Haswell.adoc[`Haswell`] 
| 
| xref:folly/compression/instructions/Nehalem.adoc[`Nehalem`] 
| 
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/instructions/Type.adoc[`Type`] 
| Selects an instruction&hyphen;set backend at runtime&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/compression/instructions/detect.adoc[`detect`] 
| Detects the best supported instruction&hyphen;set backend for this CPU&period;
| xref:folly/compression/instructions/dispatch-0a7.adoc[`dispatch`] 
| `dispatch` overloads
|===


== xref:folly/coro.adoc[folly::coro] namespace

Coroutine primitives and combinators&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/ext.adoc[`ext`] 
| Tools for library authors who are building new `co&lowbar;cleanup` types&period;
|===


=== Namespace Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/impl.adoc[`impl`] 
| Alias for the standard namespace providing coroutine support&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/AsyncGenerator.adoc[`AsyncGenerator`] 
| The AsyncGenerator class represents a sequence of asynchronously produced values where the values are produced by a coroutine&period;
| xref:folly/coro/AsyncObject.adoc[`AsyncObject`] 
| Base class for objects whose lifetime is managed by an `async&lowbar;closure`&period;
| xref:folly/coro/AsyncObjectNonSlotPtr.adoc[`AsyncObjectNonSlotPtr`] 
| Owning pointer to an `AsyncObject` that does not live in a scope slot&period;
| xref:folly/coro/AsyncObjectTag.adoc[`AsyncObjectTag`] 
| Tag type identifying an async object owned by an `async&lowbar;closure`&period;
| xref:folly/coro/AsyncPipe.adoc[`AsyncPipe`] 
| An AsyncGenerator with a write end
| xref:folly/coro/AsyncScope.adoc[`AsyncScope`] 
| Starts and later joins a dynamic, unbounded set of concurrent tasks&period;
| xref:folly/coro/AsyncScopeSlotObject.adoc[`AsyncScopeSlotObject`] 
| An `AsyncObject` stored in a slot of an async scope&period;
| xref:folly/coro/AsyncStackTraceAwaitable.adoc[`AsyncStackTraceAwaitable`] 
| Awaitable that yields the current async stack trace&period;
| xref:folly/coro/AutoCleanup.adoc[`AutoCleanup`] 
| The user can use AutoCleanup to wrap arguments passed to a CleanableAsyncGenerator&period; When the coroutine promise of CleanableAsyncGenerator is created it will automatically attach co&lowbar;scope&lowbar;exit task that performs async cleanup for all the arguments wrapped in AutoCleanup&period; This allows to ensure cleanup of the arguments even when next() of the CleanableAsyncGenerator is never co&lowbar;awaited&period;
| xref:folly/coro/BackgroundTask.adoc[`BackgroundTask`] 
| A task that runs detached in the background&semi; forward&hyphen;declared here&period;
| xref:folly/coro/Baton.adoc[`Baton`] 
| A baton is a synchronisation primitive for coroutines that allows a coroutine to co&lowbar;await the baton and suspend until the baton is posted by some thread via a call to &period;post()&period;
| xref:folly/coro/BoundedAsyncPipe.adoc[`BoundedAsyncPipe`] 
| Bounded variant of AsyncPipe which buffers a fixed number of writes before blocking new attempts to write until the buffer is drained&period;
| xref:folly/coro/BoundedQueue.adoc[`BoundedQueue`] 
| A coroutine version of bounded queue with given capacity&period; Both enqueue and dequeue are async awaitable&period;
| xref:folly/coro/CancellableAsyncScope.adoc[`CancellableAsyncScope`] 
| A cancellable version of AsyncScope&period; Work added to this scope will be provided a cancellation token for cancelling during join&period;
| xref:folly/coro/ConnectCallback.adoc[`ConnectCallback`] 
| Handles the connect operation for an AsyncSocketTransport&period;
| xref:folly/coro/ExtendedCoroutineHandle.adoc[`ExtendedCoroutineHandle`] 
| Extended `coroutine&lowbar;handle&lt;void&gt;` assuming the handle is a pointer&period;
| xref:folly/coro/ExtendedCoroutinePromiseCrtp.adoc[`ExtendedCoroutinePromiseCrtp`] 
| CRTP base letting a promise expose a more efficient error&hyphen;resumption path&period;
| xref:folly/coro/Future.adoc[`Future`] 
| The awaitable read side of a promise&sol;future contract&period;
| xref:folly/coro/Generator.adoc[`Generator`] 
| A synchronous coroutine generator that lazily yields a sequence of values&period;
| xref:folly/coro/Mutex.adoc[`Mutex`] 
| A mutex that can be locked asynchronously using &apos;co&lowbar;await&apos;&period;
| xref:folly/coro/PollFuture.adoc[`PollFuture`] 
| A Rust&hyphen;style pollable adaptor over a `Task` or `SemiFuture`&period;
| xref:folly/coro/PollStream.adoc[`PollStream`] 
| A Rust&hyphen;style pollable adaptor over an `AsyncGenerator` stream&period;
| xref:folly/coro/Promise.adoc[`Promise`] 
| The write side of a promise&sol;future contract used to fulfill a Future&period;
| xref:folly/coro/ReadCallback.adoc[`ReadCallback`] 
| Handles data reads for an AsyncTransport&period;
| xref:folly/coro/SerialQueueRunner.adoc[`SerialQueueRunner`] 
| SerialQueueRunner
| xref:folly/coro/ServerSocket.adoc[`ServerSocket`] 
| A coroutine server socket that accepts connections on the same event base as the underlying socket itself&period;
| xref:folly/coro/SharedLock-01.adoc[`SharedLock`] 
| This type mirrors the interface of std&colon;&colon;shared&lowbar;lock as much as possible&period;
| xref:folly/coro/SharedMutexFair.adoc[`SharedMutexFair`] 
| The folly&colon;&colon;coro&colon;&colon;SharedMutexFair class provides a thread synchronisation primitive that allows a coroutine to asynchronously acquire a lock on the mutex&period;
| xref:folly/coro/SharedPromise.adoc[`SharedPromise`] 
| SharedPromise is a simple wrapper around folly&colon;&colon;coro&colon;&colon;Promise and folly&colon;&colon;coro&colon;&colon;Future that allows for fetching cancellable and awaitable futures from a single promise&period;
| xref:folly/coro/SmallUnboundedQueue.adoc[`SmallUnboundedQueue`] 
| Low&hyphen;memory unbounded multi&hyphen;producer&sol;consumer queue with lower throughput&period;
| xref:folly/coro/StackAwareViaIfAsyncAwaitable.adoc[`StackAwareViaIfAsyncAwaitable`] 
| Async&hyphen;stack&hyphen;aware awaitable that reschedules onto an executor&period;
| xref:folly/coro/StackAwareViaIfAsyncAwaiter.adoc[`StackAwareViaIfAsyncAwaiter`] 
| Async&hyphen;stack&hyphen;aware awaiter that reschedules its inner awaiter onto an executor&period;
| xref:folly/coro/Synchronized.adoc[`Synchronized`] 
| This class is an adaptation of the folly&colon;&colon;Synchronized class but is designed to work with coro&hyphen;compatible mutexes like coro&colon;&colon;SharedMutexFair instead&period;
| xref:folly/coro/Task.adoc[`Task`] 
| Represents an allocated, but not&hyphen;started coroutine, which is not yet been bound to an executor&period;
| xref:folly/coro/TaskWithExecutor.adoc[`TaskWithExecutor`] 
| Represents an allocated but not yet started coroutine that has already been bound to an executor&period;
| xref:folly/coro/TaskWithExecutorWrapperCrtp.adoc[`TaskWithExecutorWrapperCrtp`] 
| CRTP base implementing the shared behavior of task&hyphen;with&hyphen;executor wrappers&period;
| xref:folly/coro/TaskWrapperCrtp.adoc[`TaskWrapperCrtp`] 
| CRTP base implementing the shared behavior of task wrappers&period;
| xref:folly/coro/Transport.adoc[`Transport`] 
| Coroutine transport backed by an AsyncTransport socket&period;
| xref:folly/coro/TransportCallbackBase.adoc[`TransportCallbackBase`] 
| Common base for all transport callbacks&period;
| xref:folly/coro/TransportIf.adoc[`TransportIf`] 
| Abstract interface for a coroutine&hyphen;based socket transport&period;
| xref:folly/coro/UnboundedQueue.adoc[`UnboundedQueue`] 
| Wrapper around folly&colon;&colon;UnboundedQueue that supports async dequeue&period;
| xref:folly/coro/UpgradeLock-04.adoc[`UpgradeLock`] 
| An upgradable lock guard held over a coroutine&hyphen;aware mutex&period;
| xref:folly/coro/ViaIfAsyncAwaitable.adoc[`ViaIfAsyncAwaitable`] 
| Awaitable that reschedules its inner awaitable onto an executor&period;
| xref:folly/coro/ViaIfAsyncAwaiter.adoc[`ViaIfAsyncAwaiter`] 
| Awaiter that reschedules its inner awaiter onto an executor&period;
| xref:folly/coro/WriteCallback.adoc[`WriteCallback`] 
| Handles data writes for an AsyncTransport&period;
| xref:folly/coro/after_cleanup_capture-03.adoc[`after&lowbar;cleanup&lowbar;capture`] 
| Capture wrapper marked `after&lowbar;cleanup&lowbar;` to bar refs from outliving cleanup&period;
| xref:folly/coro/after_cleanup_capture-0a.adoc[`after&lowbar;cleanup&lowbar;capture`] 
| Capture wrapper marked `after&lowbar;cleanup&lowbar;` to bar refs from outliving cleanup&period;
| xref:folly/coro/after_cleanup_capture_heap.adoc[`after&lowbar;cleanup&lowbar;capture&lowbar;heap`] 
| Heap&hyphen;backed `after&lowbar;cleanup&lowbar;capture` for cleanup&hyphen;free in&hyphen;place arguments&period;
| xref:folly/coro/after_cleanup_capture_indirect.adoc[`after&lowbar;cleanup&lowbar;capture&lowbar;indirect`] 
| Pointer&hyphen;holding `after&lowbar;cleanup&lowbar;capture` with reach&hyphen;through dereference sugar&period;
| xref:folly/coro/async_closure_config.adoc[`async&lowbar;closure&lowbar;config`] 
| Learn more about `coro&sol;safe` tools by browsing `docs&sol;`&period; Start with `README&period;md` and `AsyncClosure&period;md`&period; Here&apos;s a tl&semi;dr for `AsyncClosure&period;h`&period;
| xref:folly/coro/async_closure_private_t.adoc[`async&lowbar;closure&lowbar;private&lowbar;t`] 
| Tag type used by `async&lowbar;closure` to trigger cleanup of `capture`s that have an `co&lowbar;cleanup(async&lowbar;closure&lowbar;private&lowbar;t)` overload&period;
| xref:folly/coro/await_result-01.adoc[`await&lowbar;result`] 
| Metafunction yielding the result type of co&lowbar;awaiting an Awaitable&period;
| xref:folly/coro/awaiter_type-07.adoc[`awaiter&lowbar;type`] 
| awaiter&lowbar;type&lt;Awaitable&gt;
| xref:folly/coro/capture-0e.adoc[`capture`] 
| Lifetime&hyphen;safe wrapper owning a captured value or reference for coroutines&period;
| xref:folly/coro/capture-04.adoc[`capture`] 
| Lifetime&hyphen;safe wrapper owning a captured value or reference for coroutines&period;
| xref:folly/coro/capture_heap.adoc[`capture&lowbar;heap`] 
| Heap&hyphen;backed `capture` letting cleanup&hyphen;free closures take in&hyphen;place arguments&period;
| xref:folly/coro/capture_indirect.adoc[`capture&lowbar;indirect`] 
| Capture over a pointer, adding sugar so `&ast;`&sol;`&hyphen;&gt;` reach through one level&period;
| xref:folly/coro/co_cleanup_capture-05.adoc[`co&lowbar;cleanup&lowbar;capture`] 
| Capture of a cleanup arg, whose refs downgrade dependents to after&hyphen;cleanup&period;
| xref:folly/coro/co_cleanup_capture-04.adoc[`co&lowbar;cleanup&lowbar;capture`] 
| Capture of a cleanup arg, whose refs downgrade dependents to after&hyphen;cleanup&period;
| xref:folly/coro/co_cleanup_fn.adoc[`co&lowbar;cleanup&lowbar;fn`] 
| A customization point that allows to provide an async cleanup function for a type&period; folly&colon;&colon;coro&colon;&colon;AutoCleanup uses co&lowbar;cleanup&lowbar;fn as the default cleanup function, so it is enough to define co&lowbar;cleanup for a type to be able to use it with AutoCleanup&period;
| xref:folly/coro/co_error.adoc[`co&lowbar;error`] 
| Wraps an exception to be thrown from a coroutine via `co&lowbar;yield`&period;
| xref:folly/coro/co_invoke_fn.adoc[`co&lowbar;invoke&lowbar;fn`] 
| Function object that invokes a callable and awaits its coroutine result&period;
| xref:folly/coro/co_result-061.adoc[`co&lowbar;result`] 
| Wraps a Try or result to be yielded from a coroutine as its completion&period;
| xref:folly/coro/co_result-03f.adoc[`co&lowbar;result`] 
| Wraps a Try or result to be yielded from a coroutine as its completion&period;
| xref:folly/coro/co_safe_point_t.adoc[`co&lowbar;safe&lowbar;point&lowbar;t`] 
| A semi&hyphen;awaitable type which, when awaited in an async coroutine supporting safe&hyphen;points, causes a safe&hyphen;point to be reached&period;
| xref:folly/coro/co_stopped_may_throw_t.adoc[`co&lowbar;stopped&lowbar;may&lowbar;throw&lowbar;t`] 
| Tag type that converts to a `co&lowbar;error` carrying `OperationCancelled`&period;
| xref:folly/coro/is_auto_cleanup-0d.adoc[`is&lowbar;auto&lowbar;cleanup`] 
| Trait detecting whether `T` is an AutoCleanup wrapper&period;
| xref:folly/coro/is_awaitable.adoc[`is&lowbar;awaitable`] 
| is&lowbar;awaitable&lt;T&gt;&colon;&colon;value is&lowbar;awaitable&lowbar;v&lt;T&gt;
| xref:folly/coro/is_awaiter-07.adoc[`is&lowbar;awaiter`] 
| is&lowbar;awaiter&lt;T&gt;&colon;&colon;value is&lowbar;awaiter&lowbar;v&lt;T&gt;
| xref:folly/coro/is_semi_awaitable-0e.adoc[`is&lowbar;semi&lowbar;awaitable`] 
| Trait detecting whether T is a semi&hyphen;awaitable&period;
| xref:folly/coro/now_task.adoc[`now&lowbar;task`] 
| An immovable `Task&lt;T&gt;` that must be `co&lowbar;await`ed in the expression that created it&period;
| xref:folly/coro/now_task_with_executor.adoc[`now&lowbar;task&lowbar;with&lowbar;executor`] 
| The executor&hyphen;bound, immovable counterpart of `now&lowbar;task` awaited in place&period;
| xref:folly/coro/on_stopped_and_error_t.adoc[`on&lowbar;stopped&lowbar;and&lowbar;error&lowbar;t`] 
| Primary policy struct&colon; specify behavior for stopped (cancellation) and error&period; Use via the variable templates below, not directly&period;
| xref:folly/coro/ready_awaitable-00.adoc[`ready&lowbar;awaitable`] 
| An awaitable that is immediately ready and yields a stored value on resume&period;
| xref:folly/coro/remove_reference_wrapper-07.adoc[`remove&lowbar;reference&lowbar;wrapper`] 
| A type trait to unwrap a std&colon;&colon;reference&lowbar;wrapper&lt;T&gt; to a type T
| xref:folly/coro/restricted_co_cleanup_capture-09.adoc[`restricted&lowbar;co&lowbar;cleanup&lowbar;capture`] 
| Restricted view on a `co&lowbar;cleanup&lowbar;capture` ref that avoids the safety downgrade by only accepting `maybe&lowbar;value` args&period;
| xref:folly/coro/restricted_co_cleanup_capture-0e.adoc[`restricted&lowbar;co&lowbar;cleanup&lowbar;capture`] 
| Restricted view on a `co&lowbar;cleanup&lowbar;capture` ref that avoids the safety downgrade by only accepting `maybe&lowbar;value` args&period;
| xref:folly/coro/safe_async_scope_context_proxy.adoc[`safe&lowbar;async&lowbar;scope&lowbar;context&lowbar;proxy`] 
| Proxy granting safe access to an async scope&apos;s context&period;
| xref:folly/coro/safe_task.adoc[`safe&lowbar;task`] 
| Why is `SafeTask&period;h` useful?
| xref:folly/coro/safe_task_with_executor.adoc[`safe&lowbar;task&lowbar;with&lowbar;executor`] 
| A `safe&lowbar;task` that has been bound to an executor and is ready to run&period;
| xref:folly/coro/value_or_fatal.adoc[`value&lowbar;or&lowbar;fatal`] 
| `value&lowbar;or&lowbar;fatal&lt;Task&lt;T&gt;, Policy&gt;` wraps a task to guarantee value&hyphen;only completion&period;
| xref:folly/coro/variant_awaitable.adoc[`variant&lowbar;awaitable`] 
| An awaitable backed by one of several possible underlying awaitables&period;
| xref:folly/coro/will_fatal_t.adoc[`will&lowbar;fatal&lowbar;t`] 
| Tag for &quot;terminate on this completion&quot;&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/CleanableAsyncGenerator.adoc[`CleanableAsyncGenerator`] 
| An AsyncGenerator that requires cleanup() to be called before destruction&period;
| xref:folly/coro/NowTask.adoc[`NowTask`] 
| Backwards&hyphen;compatibility alias for `now&lowbar;task`&period;
| xref:folly/coro/NowTaskWithExecutor.adoc[`NowTaskWithExecutor`] 
| Backwards&hyphen;compatibility alias for `now&lowbar;task&lowbar;with&lowbar;executor`&period;
| xref:folly/coro/SharedMutex.adoc[`SharedMutex`] 
| The default SharedMutex is SharedMutexFair&period;
| xref:folly/coro/auto_safe_task.adoc[`auto&lowbar;safe&lowbar;task`] 
| Coros declared as `safe&lowbar;task&lt;Safety, T&gt;` will satisfy the strong constraints above, or fail with a compile error&period;
| xref:folly/coro/await_result_t.adoc[`await&lowbar;result&lowbar;t`] 
| Alias for the result type of co&lowbar;awaiting an Awaitable&period;
| xref:folly/coro/awaiter_type_t.adoc[`awaiter&lowbar;type&lowbar;t`] 
| await&lowbar;result&lt;Awaitable&gt;
| xref:folly/coro/capture_ref_conversion_t.adoc[`capture&lowbar;ref&lowbar;conversion&lowbar;t`] 
| Given a cvref&hyphen;qualified `capture` type, what `capture` reference type is it convertible to? The input value category affects the output reference type exactly as you&apos;d expect for types NOT wrapped by `capture`&period; But, additionally, this knows to pick the correct wrapper&colon; &hyphen; `co&lowbar;cleanup&lowbar;capture` inputs become `co&lowbar;cleanup&lowbar;capture&lt;SomeRef&gt;` &hyphen; `after&lowbar;cleanup&lowbar;ref&lowbar;&ast;` inputs become `after&lowbar;cleanup&lowbar;capture&lt;SomeRef&gt;` &hyphen; everything else becomes just `capture&lt;SomeRef&gt;`
| xref:folly/coro/closure_task.adoc[`closure&lowbar;task`] 
| A `safe&lowbar;task` meant to be the inner coro wrapped in an `async&lowbar;closure`&period;
| xref:folly/coro/co_cleanup_safe_task.adoc[`co&lowbar;cleanup&lowbar;safe&lowbar;task`] 
| A `safe&lowbar;task` that can be added to `safe&lowbar;async&lowbar;scope`, and may run during closure cleanup&period; Its content must therefore be `co&lowbar;cleanup&lowbar;safe&lowbar;ref`&hyphen;safe&period;
| xref:folly/coro/co_current_cancellation_token_t.adoc[`co&lowbar;current&lowbar;cancellation&lowbar;token&lowbar;t`] 
| Placeholder type awaited to obtain the current coroutine&apos;s cancellation token&period;
| xref:folly/coro/co_current_executor_t.adoc[`co&lowbar;current&lowbar;executor&lowbar;t`] 
| Placeholder type awaited to obtain the current coroutine&apos;s executor&period;
| xref:folly/coro/co_reschedule_on_current_executor_t.adoc[`co&lowbar;reschedule&lowbar;on&lowbar;current&lowbar;executor&lowbar;t`] 
| Placeholder type awaited to reschedule the current coroutine onto its executor&period;
| xref:folly/coro/member_task.adoc[`member&lowbar;task`] 
| A `safe&lowbar;task` for non&hyphen;static member coroutines on stateful classes&period;
| xref:folly/coro/remove_reference_wrapper_t.adoc[`remove&lowbar;reference&lowbar;wrapper&lowbar;t`] 
| Alias for the unwrapped type of remove&lowbar;reference&lowbar;wrapper&period;
| xref:folly/coro/semi_await_result_t.adoc[`semi&lowbar;await&lowbar;result&lowbar;t`] 
| The result type of co&lowbar;awaiting a semi&hyphen;awaitable T&period;
| xref:folly/coro/semi_await_try_result_t.adoc[`semi&lowbar;await&lowbar;try&lowbar;result&lowbar;t`] 
| The result type of co&lowbar;awaiting the Try wrapper of a semi&hyphen;awaitable T&period;
| xref:folly/coro/value_only_awaitable_t.adoc[`value&lowbar;only&lowbar;awaitable&lowbar;t`] 
| True for awaitables that only complete with value (not stopped or error)
| xref:folly/coro/value_task.adoc[`value&lowbar;task`] 
| A `safe&lowbar;task` whose args and return type follow value semantics&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/accumulate-09.adoc[`accumulate`] 
| `accumulate` overloads
| xref:folly/coro/async_closure.adoc[`async&lowbar;closure`] 
| Creates a lifetime&hyphen;safe async closure task from bound args and a coroutine&period;
| xref:folly/coro/async_now_closure.adoc[`async&lowbar;now&lowbar;closure`] 
| Creates an immediately&hyphen;awaited async closure returning a `now&lowbar;task`&period;
| xref:folly/coro/blocking_wait-0e.adoc[`blocking&lowbar;wait`] 
| `blocking&lowbar;wait` overloads
| xref:folly/coro/co_awaitTry-00.adoc[`co&lowbar;awaitTry`] 
| `co&lowbar;awaitTry` overloads
| xref:folly/coro/co_nothrow-020.adoc[`co&lowbar;nothrow`] 
| Cheaply propagate exceptions from `awaitable` to the calling coroutine, bypassing the expensive throw&sol;catch stack unwinding mechanism&period;
| xref:folly/coro/co_scope_exit.adoc[`co&lowbar;scope&lowbar;exit`] 
| Creates a scope&hyphen;exit coroutine running `action` with the captured state&period;
| xref:folly/coro/co_transition_lock.adoc[`co&lowbar;transition&lowbar;lock`] 
| Async version of the folly&colon;&colon;transition&lowbar;lock TODO&colon; add more transition policies beyond just from upgrade to exclusive
| xref:folly/coro/co_viaIfAsync-0f.adoc[`co&lowbar;viaIfAsync`] 
| `co&lowbar;viaIfAsync` overloads
| xref:folly/coro/co_withCancellation-0f.adoc[`co&lowbar;withCancellation`] 
| `co&lowbar;withCancellation` overloads
| xref:folly/coro/co_withExecutor-05.adoc[`co&lowbar;withExecutor`] 
| `co&lowbar;withExecutor` overloads
| xref:folly/coro/collectAll.adoc[`collectAll`] 
| Concurrently await multiple awaitables and complete with a tuple of results&period;
| xref:folly/coro/collectAllRange-00.adoc[`collectAllRange`] 
| `collectAllRange` overloads
| xref:folly/coro/collectAllTry.adoc[`collectAllTry`] 
| Concurrently await multiple awaitables and complete with a tuple of Try results&period;
| xref:folly/coro/collectAllTryRange-05.adoc[`collectAllTryRange`] 
| `collectAllTryRange` overloads
| xref:folly/coro/collectAllTryWindowed-0d.adoc[`collectAllTryWindowed`] 
| `collectAllTryWindowed` overloads
| xref:folly/coro/collectAllWindowed-02.adoc[`collectAllWindowed`] 
| `collectAllWindowed` overloads
| xref:folly/coro/collectAny.adoc[`collectAny`] 
| Concurrently await awaitables and complete with the first result and index&period;
| xref:folly/coro/collectAnyNoDiscard.adoc[`collectAnyNoDiscard`] 
| Concurrently await awaitables and return every result once one finishes&period;
| xref:folly/coro/collectAnyNoDiscardRange-04.adoc[`collectAnyNoDiscardRange`] 
| `collectAnyNoDiscardRange` overloads
| xref:folly/coro/collectAnyRange-0d.adoc[`collectAnyRange`] 
| `collectAnyRange` overloads
| xref:folly/coro/collectAnyWithoutException.adoc[`collectAnyWithoutException`] 
| Concurrently await awaitables, returning the first success or last error&period;
| xref:folly/coro/collectAnyWithoutExceptionRange-05.adoc[`collectAnyWithoutExceptionRange`] 
| `collectAnyWithoutExceptionRange` overloads
| xref:folly/coro/concat.adoc[`concat`] 
| Concatenate the values from multiple streams into a single stream such that each stream is exhausted before the next one begins&period;
| xref:folly/coro/detachOnCancel.adoc[`detachOnCancel`] 
| detachOnCancel is used to handle operations that are hard to be cancelled&period; A typical use case is&colon; The caller starts a task with timeout (in this case, 1 sec timeout)&period; The task itself launches a long running job and the job doesn&apos;t handle cancellation (sleep&lowbar;for in this example)&period; The caller has timeout and the cancellation is propagated to the task&period; The detachOnCancel detects the cancellation and return immediately&period; However, the background task still runs until the thread join&period;
| xref:folly/coro/detect_promise_return_object_eager_conversion.adoc[`detect&lowbar;promise&lowbar;return&lowbar;object&lowbar;eager&lowbar;conversion`] 
| Returns whether the compiler converts a coroutine promise return object eagerly&period;
| xref:folly/coro/filter.adoc[`filter`] 
| Filters a stream, yielding only values that satisfy the predicate&period;
| xref:folly/coro/get_awaiter-0d.adoc[`get&lowbar;awaiter`] 
| `get&lowbar;awaiter` overloads
| xref:folly/coro/makeErrorTask.adoc[`makeErrorTask`] 
| Make a Task that will trivially yield an Exception&period;
| xref:folly/coro/makeFuture-0d.adoc[`makeFuture`] 
| `makeFuture` overloads
| xref:folly/coro/makePromiseContract-0f.adoc[`makePromiseContract`] 
| makePromiseContract can help you migrating your non&hyphen;coroutine code base to coroutine&period; If your code already uses Future&sol;SemiFuture, you don&apos;t need this tool&period; A common use case is with async callback functions&period; In the example, we can pass a callback function into the legacy code sleepAndNotify and sleepAndNotify sets the promise on completion&period; Consider to use detachOnCancel with this makePromiseContract to handle long running (longer than your timeout) tasks that don&apos;t handle cancellation properly&period;
| xref:folly/coro/makeResultTask.adoc[`makeResultTask`] 
| Make a Task out of a Try&period;
| xref:folly/coro/makeTask-0b.adoc[`makeTask`] 
| `makeTask` overloads
| xref:folly/coro/makeUnorderedAsyncGenerator-0a.adoc[`makeUnorderedAsyncGenerator`] 
| `makeUnorderedAsyncGenerator` overloads
| xref:folly/coro/makeUnorderedTryAsyncGenerator-061.adoc[`makeUnorderedTryAsyncGenerator`] 
| `makeUnorderedTryAsyncGenerator` overloads
| xref:folly/coro/make_error_now_task.adoc[`make&lowbar;error&lowbar;now&lowbar;task`] 
| Make a `now&lowbar;task` that will trivially yield an exception&period;
| xref:folly/coro/make_now_task-09.adoc[`make&lowbar;now&lowbar;task`] 
| `make&lowbar;now&lowbar;task` overloads
| xref:folly/coro/merge-0d.adoc[`merge`] 
| Merges a stream of input streams into a single interleaved output stream&period;
| xref:folly/coro/retryN-0e.adoc[`retryN`] 
| `retryN` overloads
| xref:folly/coro/retryWhen.adoc[`retryWhen`] 
| Execute a given asynchronous operation returned by func(), retrying it on failure, if desired, after awaiting retryDelay(error)&period;
| xref:folly/coro/retryWithExponentialBackoff-01d.adoc[`retryWithExponentialBackoff`] 
| `retryWithExponentialBackoff` overloads
| xref:folly/coro/scheduleAutoCleanupIfNeeded.adoc[`scheduleAutoCleanupIfNeeded`] 
| Schedules async cleanup for any AutoCleanup arguments on the coroutine&period;
| xref:folly/coro/sleep.adoc[`sleep`] 
| Return a task that, when awaited, will sleep for the specified duration&period;
| xref:folly/coro/sleepReturnEarlyOnCancel.adoc[`sleepReturnEarlyOnCancel`] 
| Return a task that, when awaited, will sleep for the specified duration&period;
| xref:folly/coro/swap.adoc[`swap`] 
| Swaps the state of two generators&period;
| xref:folly/coro/tag_invoke-072.adoc[`tag&lowbar;invoke`] 
| `tag&lowbar;invoke` overloads
| xref:folly/coro/timed_wait.adoc[`timed&lowbar;wait`] 
| Awaits `awaitable`, giving up after `duration` elapses&period;
| xref:folly/coro/timeout.adoc[`timeout`] 
| Returns a Task that, when started, starts a timer of duration &apos;timeoutDuration&apos; and awaits the passed SemiAwaitable&period;
| xref:folly/coro/timeoutNoDiscard.adoc[`timeoutNoDiscard`] 
| Returns a Task that, when started, starts a timer of duration &apos;timeoutDuration&apos; and awaits the passed SemiAwaitable (operation)&period;
| xref:folly/coro/toFuture.adoc[`toFuture`] 
| Converts the given SemiAwaitable to a Future, starting it on the Executor&period;
| xref:folly/coro/toSemiFuture.adoc[`toSemiFuture`] 
| Converts the given SemiAwaitable to a SemiFuture (without starting it)&period;
| xref:folly/coro/toTask-04.adoc[`toTask`] 
| `toTask` overloads
| xref:folly/coro/toTaskInterruptOnCancel-0c8.adoc[`toTaskInterruptOnCancel`] 
| `toTaskInterruptOnCancel` overloads
| xref:folly/coro/to_now_task-0c.adoc[`to&lowbar;now&lowbar;task`] 
| `to&lowbar;now&lowbar;task` overloads
| xref:folly/coro/value_or_error.adoc[`value&lowbar;or&lowbar;error`] 
| When awaited, returns a `result&lt;T&gt;` in a value or an error state, but never `has&lowbar;stopped()` (aka `OperationCancelled`)&period; If `awaitable` reports as &quot;stopped&quot;, the awaiting coroutine will be promptly torn down, &ast;&ast;without throwing&ast;&ast;, and its parent will in turn receive a &quot;stopped&quot; completion&period;
| xref:folly/coro/value_or_error_or_stopped.adoc[`value&lowbar;or&lowbar;error&lowbar;or&lowbar;stopped`] 
| When awaited, returns `result&lt;T&gt;` just like `value&lowbar;or&lowbar;error()`, but also captures &quot;stopped&quot; completions, so you *must* test for `has&lowbar;stopped()`&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/co_cancelled.adoc[`co&lowbar;cancelled`]  [.small]#[deprecated]#
| Deprecated alias for `co&lowbar;stopped&lowbar;may&lowbar;throw`&period;
| xref:folly/coro/co_current_async_stack_trace.adoc[`co&lowbar;current&lowbar;async&lowbar;stack&lowbar;trace`] 
| Awaitable yielding the current async stack trace when co&lowbar;awaited&period;
| xref:folly/coro/co_current_cancellation_token.adoc[`co&lowbar;current&lowbar;cancellation&lowbar;token`] 
| Placeholder value awaited to obtain the current coroutine&apos;s cancellation token&period;
| xref:folly/coro/co_current_executor.adoc[`co&lowbar;current&lowbar;executor`] 
| Special placeholder object that can be &apos;co&lowbar;await&apos;ed from within a Task&lt;T&gt; or an AsyncGenerator&lt;T&gt; to obtain the current folly&colon;&colon;Executor associated with the current coroutine&period;
| xref:folly/coro/co_reschedule_on_current_executor.adoc[`co&lowbar;reschedule&lowbar;on&lowbar;current&lowbar;executor`] 
| A SemiAwaitable object that allows you to reschedule the current coroutine onto the currently associated executor&period;
| xref:folly/coro/co_safe_point.adoc[`co&lowbar;safe&lowbar;point`] 
| A semi&hyphen;awaitable value that causes a safe&hyphen;point to be reached when awaited&period;
| xref:folly/coro/co_stopped_may_throw.adoc[`co&lowbar;stopped&lowbar;may&lowbar;throw`] 
| Tag that, when thrown via `co&lowbar;yield`, cancels the awaiting coroutine&period;
| xref:folly/coro/is_auto_cleanup_v.adoc[`is&lowbar;auto&lowbar;cleanup&lowbar;v`] 
| True when `T` is an AutoCleanup wrapper&period;
| xref:folly/coro/is_awaitable_async_stack_aware_v.adoc[`is&lowbar;awaitable&lowbar;async&lowbar;stack&lowbar;aware&lowbar;v`] 
| True if the awaitable customizes the co&lowbar;withAsyncStack CPO&period;
| xref:folly/coro/is_awaitable_v.adoc[`is&lowbar;awaitable&lowbar;v`] 
| True if T satisfies the awaitable interface&period;
| xref:folly/coro/is_awaiter_v.adoc[`is&lowbar;awaiter&lowbar;v`] 
| True if T satisfies the awaiter interface&period;
| xref:folly/coro/is_semi_awaitable_v.adoc[`is&lowbar;semi&lowbar;awaitable&lowbar;v`] 
| True if T is a semi&hyphen;awaitable&period;
| xref:folly/coro/on_stopped.adoc[`on&lowbar;stopped`] 
| Convenience&colon; stopped returns V, error terminates (fatal)&period;
| xref:folly/coro/on_stopped_and_error.adoc[`on&lowbar;stopped&lowbar;and&lowbar;error`] 
| Policy that returns `Stopped` on cancellation and `Error` on error&period;
| xref:folly/coro/on_stopped_void.adoc[`on&lowbar;stopped&lowbar;void`] 
| Convenience for void tasks&colon; stopped returns unit, error terminates&period;
| xref:folly/coro/value_only_awaitable_v.adoc[`value&lowbar;only&lowbar;awaitable&lowbar;v`] 
| True if T only completes with a value (not stopped or error)&period;
| xref:folly/coro/will_fatal.adoc[`will&lowbar;fatal`] 
| Policy value selecting termination on a stopped or error completion&period;
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/coroutine_handle.adoc[`coroutine&lowbar;handle`] 
| Re&hyphen;exports the standard coroutine handle type&period;
| xref:folly/coro/coroutine_traits.adoc[`coroutine&lowbar;traits`] 
| Re&hyphen;exports the standard coroutine traits template&period;
| xref:folly/coro/noop_coroutine.adoc[`noop&lowbar;coroutine`] 
| Re&hyphen;exports the standard no&hyphen;op coroutine factory&period;
| xref:folly/coro/noop_coroutine_handle.adoc[`noop&lowbar;coroutine&lowbar;handle`] 
| Re&hyphen;exports the standard no&hyphen;op coroutine handle type&period;
| xref:folly/coro/noop_coroutine_promise.adoc[`noop&lowbar;coroutine&lowbar;promise`] 
| Re&hyphen;exports the standard no&hyphen;op coroutine promise type&period;
| xref:folly/coro/suspend_always.adoc[`suspend&lowbar;always`] 
| Re&hyphen;exports the standard always&hyphen;suspend awaitable&period;
| xref:folly/coro/suspend_never.adoc[`suspend&lowbar;never`] 
| Re&hyphen;exports the standard never&hyphen;suspend awaitable&period;
|===


== xref:folly/coro/ext.adoc[folly::coro::ext] namespace

Tools for library authors who are building new `co&lowbar;cleanup` types&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/ext/capture_proxy_tag.adoc[`capture&lowbar;proxy&lowbar;tag`] 
| Passkey used with `capture&lowbar;proxy` methods&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/ext/capture_proxy_kind.adoc[`capture&lowbar;proxy&lowbar;kind`] 
| Selects which reference or pointer form a `capture&lowbar;proxy()` returns&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/coro/ext/const_or_not.adoc[`const&lowbar;or&lowbar;not`] 
| Satisfied when `T` is `U` or `const U`, matching both `U&amp;` and `const U&amp;`&period;
|===


== xref:folly/crypto.adoc[folly::crypto] namespace

Cryptographic hashing primitives&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/crypto/Blake2xb.adoc[`Blake2xb`] 
| An implementation of the BLAKE2x XOF (extendable output function) hash function using BLAKE2b as the underlying hash&period; This hash function can produce cryptographic hashes of arbitrary length (between 1 and 2&circ;32 &hyphen; 2 bytes) from inputs of arbitrary size&period; Like BLAKE2b, it can be keyed, and can accept optional salt and personlization parameters&period;
| xref:folly/crypto/LtHash.adoc[`LtHash`] 
| Templated homomorphic hash, using LtHash (lattice&hyphen;based crypto)&period; Template parameters&colon; B &equals; element size in bits, N &equals; number of elements&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/crypto/LtHash16_1024.adoc[`LtHash16&lowbar;1024`] 
| Fastest and smallest LtHash specialization, with over 200 bits of security&period;
| xref:folly/crypto/LtHash20_1008.adoc[`LtHash20&lowbar;1008`] 
| Higher&hyphen;security LtHash specialization&semi; slower and larger than LtHash16&lowbar;1024&period;
| xref:folly/crypto/LtHash32_1024.adoc[`LtHash32&lowbar;1024`] 
| Higher&hyphen;security LtHash specialization&semi; slower and larger than LtHash16&lowbar;1024&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/crypto/operator_plus-042.adoc[`operator&plus;`] 
| Addition operators
| xref:folly/crypto/operator_minus-0a.adoc[`operator&hyphen;`] 
| Subtraction operators
|===


== xref:folly/detail_tag_invoke_fn.adoc[folly::detail&lowbar;tag&lowbar;invoke&lowbar;fn] namespace

Implementation details of the `tag&lowbar;invoke` customization&hyphen;point machinery&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/detail_tag_invoke_fn/defer.adoc[`defer`] 
| Defers instantiation of `T&lt;Args&period;&period;&period;&gt;` to its member type alias&period;
| xref:folly/detail_tag_invoke_fn/empty.adoc[`empty`] 
| Empty placeholder type used when no result type is available&period;
| xref:folly/detail_tag_invoke_fn/tag_invoke_fn.adoc[`tag&lowbar;invoke&lowbar;fn`] 
| Function object dispatching to an ADL `tag&lowbar;invoke` call&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/detail_tag_invoke_fn/tag_invoke_result_t.adoc[`tag&lowbar;invoke&lowbar;result&lowbar;t`] 
| The result type of `tag&lowbar;invoke(Tag, Args&period;&period;&period;)`&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/detail_tag_invoke_fn/tag_invoke.adoc[`tag&lowbar;invoke`] 
| Poison&hyphen;pill declaration ensuring ADL lookup of `tag&lowbar;invoke`&period;
| xref:folly/detail_tag_invoke_fn/try_tag_invoke-05.adoc[`try&lowbar;tag&lowbar;invoke`] 
| `try&lowbar;tag&lowbar;invoke` overloads
|===


== xref:folly/dptr_detail.adoc[folly::dptr&lowbar;detail] namespace

Implementation details&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/dptr_detail/ApplyConstVisitor.adoc[`ApplyConstVisitor`] 
| Dispatches a visitor to a const pointer whose type is selected at runtime&period;
| xref:folly/dptr_detail/ApplyVisitor.adoc[`ApplyVisitor`] 
| Dispatches a visitor to a pointer whose type is selected at runtime&period;
| xref:folly/dptr_detail/ConstVisitorResult.adoc[`ConstVisitorResult`] 
| Determine the result type of applying a visitor of type V on const pointers of all types in Types&period;&period;&period;, asserting that the type is the same for all types in Types&period;&period;&period;
| xref:folly/dptr_detail/VisitorResult.adoc[`VisitorResult`] 
| Determine the result type of applying a visitor of type V on pointers of all types in Types&period;&period;&period;, asserting that the type is the same for all types in Types&period;&period;&period;
|===


== xref:folly/dynamic_detail.adoc[folly::dynamic&lowbar;detail] namespace

Implementation details for dynamic&period;

=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/dynamic_detail/detect_construct_string.adoc[`detect&lowbar;construct&lowbar;string`] 
| Detects whether a std&colon;&colon;string can be constructed from a T&apos;s data() and size()&period;
|===


== xref:folly/dynamicconverter_detail.adoc[folly::dynamicconverter&lowbar;detail] namespace

Implementation details for DynamicConverter and DynamicConstructor&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/dynamicconverter_detail/Dereferencer-09.adoc[`Dereferencer`] 
| Converts a dynamic iterator&apos;s value into a cached, well&hyphen;typed value&period;
| xref:folly/dynamicconverter_detail/Transformer.adoc[`Transformer`] 
| An iterator adaptor that dereferences to a converted value of type T&colon;&colon;value&lowbar;type&period;
| xref:folly/dynamicconverter_detail/iterator_class_is_container.adoc[`iterator&lowbar;class&lowbar;is&lowbar;container`] 
| Trait determining whether a class with an iterator behaves as a container&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/dynamicconverter_detail/class_is_container.adoc[`class&lowbar;is&lowbar;container`] 
| True when a class type is a container&period;
| xref:folly/dynamicconverter_detail/detect_like_optional.adoc[`detect&lowbar;like&lowbar;optional`] 
| Detects whether a type is constructible from its own value&lowbar;type&period;
| xref:folly/dynamicconverter_detail/detect_like_pointer.adoc[`detect&lowbar;like&lowbar;pointer`] 
| Detects whether a type is dereferenceable and contextually convertible to bool&period;
| xref:folly/dynamicconverter_detail/detect_member_type_iterator.adoc[`detect&lowbar;member&lowbar;type&lowbar;iterator`] 
| Detects a nested iterator member type&period;
| xref:folly/dynamicconverter_detail/detect_member_type_key_type.adoc[`detect&lowbar;member&lowbar;type&lowbar;key&lowbar;type`] 
| Detects a nested key&lowbar;type member type&period;
| xref:folly/dynamicconverter_detail/detect_member_type_mapped_type.adoc[`detect&lowbar;member&lowbar;type&lowbar;mapped&lowbar;type`] 
| Detects a nested mapped&lowbar;type member type&period;
| xref:folly/dynamicconverter_detail/detect_member_type_value_type.adoc[`detect&lowbar;member&lowbar;type&lowbar;value&lowbar;type`] 
| Detects a nested value&lowbar;type member type&period;
| xref:folly/dynamicconverter_detail/is_associative.adoc[`is&lowbar;associative`] 
| True when a type is an associative container with a key&lowbar;type&period;
| xref:folly/dynamicconverter_detail/is_container.adoc[`is&lowbar;container`] 
| True when a type is a container class&period;
| xref:folly/dynamicconverter_detail/is_like_pointer.adoc[`is&lowbar;like&lowbar;pointer`] 
| True when a type behaves like a pointer but is not a string literal&period;
| xref:folly/dynamicconverter_detail/is_map.adoc[`is&lowbar;map`] 
| True when a type is a map&hyphen;like container with a mapped&lowbar;type&period;
| xref:folly/dynamicconverter_detail/is_optional.adoc[`is&lowbar;optional`] 
| True when a type behaves like an optional value&period;
| xref:folly/dynamicconverter_detail/is_range.adoc[`is&lowbar;range`] 
| True when a type is a range with both value&lowbar;type and iterator&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/dynamicconverter_detail/conversionIterator.adoc[`conversionIterator`] 
| Build a converting iterator over a dynamic iterator&period;
|===


== xref:folly/exception_tracer.adoc[folly::exception&lowbar;tracer] namespace

Facilities for capturing and stacking exception stack traces&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/exception_tracer/ExceptionInfo.adoc[`ExceptionInfo`] 
| Information about a captured exception and its stack trace&period;
| xref:folly/exception_tracer/StackTrace.adoc[`StackTrace`] 
| A captured stack trace as a fixed&hyphen;capacity array of return addresses&period;
| xref:folly/exception_tracer/StackTraceStack.adoc[`StackTraceStack`] 
| An intrusive stack of captured stack traces&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/exception_tracer/CxaBeginCatchSig.adoc[`CxaBeginCatchSig`] 
| Signature of a callback invoked when a catch block begins via &lowbar;&lowbar;cxa&lowbar;begin&lowbar;catch&period;
| xref:folly/exception_tracer/CxaEndCatchSig.adoc[`CxaEndCatchSig`] 
| Signature of a callback invoked when a catch block ends via &lowbar;&lowbar;cxa&lowbar;end&lowbar;catch&period;
| xref:folly/exception_tracer/CxaRethrowSig.adoc[`CxaRethrowSig`] 
| Signature of a callback invoked when an exception is rethrown via &lowbar;&lowbar;cxa&lowbar;rethrow&period;
| xref:folly/exception_tracer/CxaThrowSig.adoc[`CxaThrowSig`] 
| Signature of a callback invoked when an exception is thrown via &lowbar;&lowbar;cxa&lowbar;throw&period;
| xref:folly/exception_tracer/RethrowExceptionSig.adoc[`RethrowExceptionSig`] 
| Signature of a callback invoked when an exception is rethrown via std&colon;&colon;rethrow&lowbar;exception&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/exception_tracer/registerCxaBeginCatchCallback.adoc[`registerCxaBeginCatchCallback`] 
| Register a callback invoked on each &lowbar;&lowbar;cxa&lowbar;begin&lowbar;catch&period;
| xref:folly/exception_tracer/registerCxaEndCatchCallback.adoc[`registerCxaEndCatchCallback`] 
| Register a callback invoked on each &lowbar;&lowbar;cxa&lowbar;end&lowbar;catch&period;
| xref:folly/exception_tracer/registerCxaRethrowCallback.adoc[`registerCxaRethrowCallback`] 
| Register a callback invoked on each &lowbar;&lowbar;cxa&lowbar;rethrow&period;
| xref:folly/exception_tracer/registerCxaThrowCallback.adoc[`registerCxaThrowCallback`] 
| Register a callback invoked on each &lowbar;&lowbar;cxa&lowbar;throw&period;
| xref:folly/exception_tracer/registerRethrowExceptionCallback.adoc[`registerRethrowExceptionCallback`] 
| Register a callback invoked on each std&colon;&colon;rethrow&lowbar;exception&period;
| xref:folly/exception_tracer/unregisterCxaBeginCatchCallback.adoc[`unregisterCxaBeginCatchCallback`] 
| Unregister a previously registered &lowbar;&lowbar;cxa&lowbar;begin&lowbar;catch callback&period;
| xref:folly/exception_tracer/unregisterCxaEndCatchCallback.adoc[`unregisterCxaEndCatchCallback`] 
| Unregister a previously registered &lowbar;&lowbar;cxa&lowbar;end&lowbar;catch callback&period;
| xref:folly/exception_tracer/unregisterCxaRethrowCallback.adoc[`unregisterCxaRethrowCallback`] 
| Unregister a previously registered &lowbar;&lowbar;cxa&lowbar;rethrow callback&period;
| xref:folly/exception_tracer/unregisterCxaThrowCallback.adoc[`unregisterCxaThrowCallback`] 
| Unregister a previously registered &lowbar;&lowbar;cxa&lowbar;throw callback&period;
| xref:folly/exception_tracer/unregisterRethrowExceptionCallback.adoc[`unregisterRethrowExceptionCallback`] 
| Unregister a previously registered std&colon;&colon;rethrow&lowbar;exception callback&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/exception_tracer/kMaxFrames.adoc[`kMaxFrames`] 
| Maximum number of frames captured in a single stack trace&period;
|===


== xref:folly/expected_detail.adoc[folly::expected&lowbar;detail] namespace

Implementation details for folly&colon;&colon;Expected&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/expected_detail_ExpectedHelper.adoc[`expected&lowbar;detail&lowbar;ExpectedHelper`] 
| Implementation details for the ExpectedHelper continuation machinery&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/CopyAssignable-00.adoc[`CopyAssignable`] 
| Mixin that adds a copy assignment which delegates to the derived assign&period;
| xref:folly/expected_detail/CopyConstructible-0e.adoc[`CopyConstructible`] 
| Mixin that adds a copy constructor which delegates to the derived assign&period;
| xref:folly/expected_detail/EmptyTag.adoc[`EmptyTag`] 
| Tag type selecting the empty&hyphen;state constructor&period;
| xref:folly/expected_detail/ErrorTag.adoc[`ErrorTag`] 
| Tag type selecting the error&hyphen;state constructor&period;
| xref:folly/expected_detail/ExpectedAwaitable.adoc[`ExpectedAwaitable`] 
| Awaitable that unwraps an Expected inside a coroutine&period;
| xref:folly/expected_detail/ExpectedStorage-00.adoc[`ExpectedStorage`] 
| Storage backing an Expected, holding either a value or an error&period;
| xref:folly/expected_detail/ExpectedUnion.adoc[`ExpectedUnion`] 
| Raw union of a value and an error with a discriminator&period;
| xref:folly/expected_detail/MoveAssignable-03.adoc[`MoveAssignable`] 
| Mixin that adds a move assignment which delegates to the derived assign&period;
| xref:folly/expected_detail/MoveConstructible-00.adoc[`MoveConstructible`] 
| Mixin that adds a move constructor which delegates to the derived assign&period;
| xref:folly/expected_detail/Promise.adoc[`Promise`] 
| Selects the appropriate coroutine promise for a value and error type&period;
| xref:folly/expected_detail/PromiseBase.adoc[`PromiseBase`] 
| Shared base of the Expected coroutine promise types&period;
| xref:folly/expected_detail/PromiseReturn.adoc[`PromiseReturn`] 
| Coroutine return object that materializes an Expected from a promise&period;
| xref:folly/expected_detail/PromiseReturnsValue.adoc[`PromiseReturnsValue`] 
| Coroutine promise for coroutines that produce a value&period;
| xref:folly/expected_detail/PromiseReturnsVoid.adoc[`PromiseReturnsVoid`] 
| Coroutine promise for coroutines with no meaningful return value&period;
| xref:folly/expected_detail/UnexpectedAwaitable.adoc[`UnexpectedAwaitable`] 
| Awaitable that short&hyphen;circuits a coroutine with an unexpected error&period;
| xref:folly/expected_detail/UnexpectedTag.adoc[`UnexpectedTag`] 
| Tag type used to disambiguate error&hyphen;state construction of Expected&period;
| xref:folly/expected_detail/ValueTag.adoc[`ValueTag`] 
| Tag type selecting the value&hyphen;state constructor&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/IsConvertible.adoc[`IsConvertible`] 
| True when `From` can both construct and assign to `To`&period;
| xref:folly/expected_detail/IsCopyable.adoc[`IsCopyable`] 
| True when `T` is both copy constructible and copy assignable&period;
| xref:folly/expected_detail/IsMovable.adoc[`IsMovable`] 
| True when `T` is both move constructible and move assignable&period;
| xref:folly/expected_detail/IsNothrowCopyable.adoc[`IsNothrowCopyable`] 
| True when `T` is nothrow copy constructible and nothrow copy assignable&period;
| xref:folly/expected_detail/IsNothrowMovable.adoc[`IsNothrowMovable`] 
| True when `T` is nothrow move constructible and nothrow move assignable&period;
| xref:folly/expected_detail/StrictAllOf.adoc[`StrictAllOf`] 
| True when `Trait` holds for every type in `Ts`&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/StorageType.adoc[`StorageType`] 
| Storage strategy chosen for an Expected&apos;s value and error&period;
| xref:folly/expected_detail/Which.adoc[`Which`] 
| Discriminator for which alternative an Expected currently holds&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/doEmplaceAssign-07.adoc[`doEmplaceAssign`] 
| `doEmplaceAssign` overloads
| xref:folly/expected_detail/getStorageType.adoc[`getStorageType`] 
| Selects the storage strategy for a given value and error type&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/ReturnsVoid.adoc[`ReturnsVoid`] 
| True when a coroutine over `Value` behaves as if it returns void&period;
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/ExpectedHelper.adoc[`ExpectedHelper`] 
| Introduces ExpectedHelper into the expected&lowbar;detail namespace&period;
|===


== xref:folly/expected_detail/expected_detail_ExpectedHelper.adoc[folly::expected&lowbar;detail::expected&lowbar;detail&lowbar;ExpectedHelper] namespace

Implementation details for the ExpectedHelper continuation machinery&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/expected_detail_ExpectedHelper/ExpectedHelper.adoc[`ExpectedHelper`] 
| Static helpers implementing the Expected continuation operations&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/expected_detail/expected_detail_ExpectedHelper/operator_comma.adoc[`operator,`] 
| Comma operator that lets Expected&colon;&colon;then handle lambdas returning void&period;
|===


== xref:folly/experimental.adoc[folly::experimental] namespace

Namespace for experimental Folly components&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/experimental/EnvironmentState.adoc[`EnvironmentState`] 
| Class to model the process environment in idiomatic C&plus;&plus;
| xref:folly/experimental/MalformedEnvironment.adoc[`MalformedEnvironment`] 
| Exception thrown when the process environment cannot be modeled&period;
|===


== xref:folly/ext.adoc[folly::ext] namespace

Extension namespace for library authors, a public analog of `folly&colon;&colon;detail`&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/ext/curried_unsafe_mover_private_t.adoc[`curried&lowbar;unsafe&lowbar;mover&lowbar;private&lowbar;t`] 
| Passkey that gates the reconstruction ctor used by `curried&lowbar;unsafe&lowbar;mover&lowbar;t`&period;
| xref:folly/ext/curried_unsafe_mover_t.adoc[`curried&lowbar;unsafe&lowbar;mover&lowbar;t`] 
| Mover returned from `unsafe&lowbar;mover` on typical must&hyphen;use&hyphen;immediately types&period;
| xref:folly/ext/default_unsafe_mover_t.adoc[`default&lowbar;unsafe&lowbar;mover&lowbar;t`] 
| Default impl of `must&lowbar;use&lowbar;immediately&lowbar;unsafe&lowbar;mover` for movable types&period;
| xref:folly/ext/format_string_and_location.adoc[`format&lowbar;string&lowbar;and&lowbar;location`] 
| ext&colon;&colon;format&lowbar;string&lowbar;and&lowbar;location
| xref:folly/ext/must_use_immediately_crtp-0d.adoc[`must&lowbar;use&lowbar;immediately&lowbar;crtp`] 
| CRTP base that makes a derived type must&hyphen;use&hyphen;immediately and immovable&period;
| xref:folly/ext/must_use_immediately_private_t.adoc[`must&lowbar;use&lowbar;immediately&lowbar;private&lowbar;t`] 
| Passkey for the static `unsafe&lowbar;mover` members of must&hyphen;use&hyphen;immediately types&period;
| xref:folly/ext/wrap_must_use_immediately_t.adoc[`wrap&lowbar;must&lowbar;use&lowbar;immediately&lowbar;t`] 
| Wrap a movable `Inner` type to make it must&hyphen;use&hyphen;immediately and immovable&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/ext/must_use_immediately_t.adoc[`must&lowbar;use&lowbar;immediately&lowbar;t`] 
| Trait giving `T`&apos;s must&hyphen;use&hyphen;immediately tag, or `std&colon;&colon;false&lowbar;type` if none&period;
| xref:folly/ext/test_find_resource_t.adoc[`test&lowbar;find&lowbar;resource&lowbar;t`] 
| Signature of a function that resolves a test resource path by name&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/ext/curried_unsafe_mover_from_bases_and_members.adoc[`curried&lowbar;unsafe&lowbar;mover&lowbar;from&lowbar;bases&lowbar;and&lowbar;members`] 
| Build a `curried&lowbar;unsafe&lowbar;mover&lowbar;t` from a type&apos;s bases and member pointers&period;
| xref:folly/ext/must_use_immediately_unsafe_mover.adoc[`must&lowbar;use&lowbar;immediately&lowbar;unsafe&lowbar;mover`] 
| Obtain a mover that destructively moves `t` out of a must&hyphen;use&hyphen;immediately type, so it can be reconstituted later via the mover&apos;s `operator()`&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/ext/must_use_immediately_v.adoc[`must&lowbar;use&lowbar;immediately&lowbar;v`] 
| `true` when `T` is a must&hyphen;use&hyphen;immediately type&period;
| xref:folly/ext/test_find_resource.adoc[`test&lowbar;find&lowbar;resource`] 
| Overridable hook used by tests to locate resource files&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/ext/must_use_immediately.adoc[`must&lowbar;use&lowbar;immediately`] 
| Satisfied when `T` is a must&hyphen;use&hyphen;immediately type&period;
|===


== xref:folly/external.adoc[folly::external] namespace

Vendored third&hyphen;party code adapted for use in Folly&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash.adoc[`farmhash`] 
| FarmHash family of hash and fingerprint functions&period;
| xref:folly/external/rapidhash_detail.adoc[`rapidhash&lowbar;detail`] 
| Implementation details of the rapidhash hashing algorithm&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/rapidhash.adoc[`rapidhash`] 
| rapidhash general purpose hash function&period;
| xref:folly/external/rapidhashMicro.adoc[`rapidhashMicro`] 
| rapidhashMicro hash function&period;
| xref:folly/external/rapidhashMicro_with_seed.adoc[`rapidhashMicro&lowbar;with&lowbar;seed`] 
| rapidhashMicro seeded hash function&period;
| xref:folly/external/rapidhashNano.adoc[`rapidhashNano`] 
| rapidhashNano hash function&period;
| xref:folly/external/rapidhashNano_with_seed.adoc[`rapidhashNano&lowbar;with&lowbar;seed`] 
| rapidhashNano seeded hash function&period;
| xref:folly/external/rapidhash_with_seed.adoc[`rapidhash&lowbar;with&lowbar;seed`] 
| rapidhash seeded hash function&period;
|===


== xref:folly/external/farmhash.adoc[folly::external::farmhash] namespace

FarmHash family of hash and fingerprint functions&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashcc.adoc[`farmhashcc`] 
| FarmHash &quot;cc&quot; variant, derived from CityHash&period;
| xref:folly/external/farmhash/farmhashmk.adoc[`farmhashmk`] 
| FarmHash &quot;mk&quot; variant&period;
| xref:folly/external/farmhash/farmhashna.adoc[`farmhashna`] 
| FarmHash &quot;na&quot; variant&period;
| xref:folly/external/farmhash/farmhashnt.adoc[`farmhashnt`] 
| FarmHash &quot;nt&quot; variant&period;
| xref:folly/external/farmhash/farmhashsa.adoc[`farmhashsa`] 
| FarmHash &quot;sa&quot; variant&period;
| xref:folly/external/farmhash/farmhashsu.adoc[`farmhashsu`] 
| FarmHash &quot;su&quot; variant&period;
| xref:folly/external/farmhash/farmhashte.adoc[`farmhashte`] 
| FarmHash &quot;te&quot; variant&period;
| xref:folly/external/farmhash/farmhashuo.adoc[`farmhashuo`] 
| FarmHash &quot;uo&quot; variant&period;
| xref:folly/external/farmhash/farmhashxo.adoc[`farmhashxo`] 
| FarmHash &quot;xo&quot; variant&period;
| xref:folly/external/farmhash/test.adoc[`test`] 
| &sol; internal variants
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/uint128_t.adoc[`uint128&lowbar;t`] 
| Unsigned 128&hyphen;bit integer type used for 128&hyphen;bit hashes&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/Fingerprint-00.adoc[`Fingerprint`] 
| `Fingerprint` overloads
| xref:folly/external/farmhash/Fingerprint128-0a.adoc[`Fingerprint128`] 
| `Fingerprint128` overloads
| xref:folly/external/farmhash/Fingerprint32-0c.adoc[`Fingerprint32`] 
| `Fingerprint32` overloads
| xref:folly/external/farmhash/Fingerprint64-07.adoc[`Fingerprint64`] 
| `Fingerprint64` overloads
| xref:folly/external/farmhash/Hash-0a.adoc[`Hash`] 
| `Hash` overloads
| xref:folly/external/farmhash/Hash128-0b.adoc[`Hash128`] 
| `Hash128` overloads
| xref:folly/external/farmhash/Hash128WithSeed-02.adoc[`Hash128WithSeed`] 
| `Hash128WithSeed` overloads
| xref:folly/external/farmhash/Hash128to64.adoc[`Hash128to64`] 
| Hashes 128 input bits down to 64 bits of output&period;
| xref:folly/external/farmhash/Hash32-0e.adoc[`Hash32`] 
| `Hash32` overloads
| xref:folly/external/farmhash/Hash32WithSeed-00.adoc[`Hash32WithSeed`] 
| `Hash32WithSeed` overloads
| xref:folly/external/farmhash/Hash64-0b.adoc[`Hash64`] 
| `Hash64` overloads
| xref:folly/external/farmhash/Hash64WithSeed-08.adoc[`Hash64WithSeed`] 
| `Hash64WithSeed` overloads
| xref:folly/external/farmhash/Hash64WithSeeds-02.adoc[`Hash64WithSeeds`] 
| `Hash64WithSeeds` overloads
| xref:folly/external/farmhash/Uint128.adoc[`Uint128`] 
| Builds a 128&hyphen;bit value from its low and high 64&hyphen;bit halves&period;
| xref:folly/external/farmhash/Uint128High64.adoc[`Uint128High64`] 
| Returns the high 64 bits of a 128&hyphen;bit value&period;
| xref:folly/external/farmhash/Uint128Low64.adoc[`Uint128Low64`] 
| Returns the low 64 bits of a 128&hyphen;bit value&period;
|===


== xref:folly/external/farmhash/farmhashcc.adoc[folly::external::farmhash::farmhashcc] namespace

FarmHash &quot;cc&quot; variant, derived from CityHash&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashcc/CityHash128WithSeed.adoc[`CityHash128WithSeed`] 
| Hashes a byte array to a 128&hyphen;bit value using CityHash, mixing in a 128&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashcc/Fingerprint128.adoc[`Fingerprint128`] 
| Fingerprints a byte array to a 128&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Fingerprint32.adoc[`Fingerprint32`] 
| Fingerprints a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Fingerprint64.adoc[`Fingerprint64`] 
| Fingerprints a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Hash.adoc[`Hash`] 
| Hashes a byte array to a size&lowbar;t value&period;
| xref:folly/external/farmhash/farmhashcc/Hash128.adoc[`Hash128`] 
| Hashes a byte array to a 128&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Hash128WithSeed.adoc[`Hash128WithSeed`] 
| Hashes a byte array to a 128&hyphen;bit value, mixing in a 128&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashcc/Hash32.adoc[`Hash32`] 
| Hashes a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Hash32WithSeed.adoc[`Hash32WithSeed`] 
| Hashes a byte array to a 32&hyphen;bit value, mixing in a 32&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashcc/Hash64.adoc[`Hash64`] 
| Hashes a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashcc/Hash64WithSeed.adoc[`Hash64WithSeed`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in a 64&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashcc/Hash64WithSeeds.adoc[`Hash64WithSeeds`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in two 64&hyphen;bit seeds&period;
|===


== xref:folly/external/farmhash/farmhashmk.adoc[folly::external::farmhash::farmhashmk] namespace

FarmHash &quot;mk&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashmk/Hash32.adoc[`Hash32`] 
| Hashes a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashmk/Hash32WithSeed.adoc[`Hash32WithSeed`] 
| Hashes a byte array to a 32&hyphen;bit value, mixing in a 32&hyphen;bit seed&period;
|===


== xref:folly/external/farmhash/farmhashna.adoc[folly::external::farmhash::farmhashna] namespace

FarmHash &quot;na&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashna/Hash64.adoc[`Hash64`] 
| Hashes a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashna/Hash64WithSeed.adoc[`Hash64WithSeed`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in a 64&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashna/Hash64WithSeeds.adoc[`Hash64WithSeeds`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in two 64&hyphen;bit seeds&period;
|===


== xref:folly/external/farmhash/farmhashnt.adoc[folly::external::farmhash::farmhashnt] namespace

FarmHash &quot;nt&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashnt/Hash32.adoc[`Hash32`] 
| Hashes a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashnt/Hash32WithSeed.adoc[`Hash32WithSeed`] 
| Hashes a byte array to a 32&hyphen;bit value, mixing in a 32&hyphen;bit seed&period;
|===


== xref:folly/external/farmhash/farmhashsa.adoc[folly::external::farmhash::farmhashsa] namespace

FarmHash &quot;sa&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashsa/Hash32.adoc[`Hash32`] 
| Hashes a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashsa/Hash32WithSeed.adoc[`Hash32WithSeed`] 
| Hashes a byte array to a 32&hyphen;bit value, mixing in a 32&hyphen;bit seed&period;
|===


== xref:folly/external/farmhash/farmhashsu.adoc[folly::external::farmhash::farmhashsu] namespace

FarmHash &quot;su&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashsu/Hash32.adoc[`Hash32`] 
| Hashes a byte array to a 32&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashsu/Hash32WithSeed.adoc[`Hash32WithSeed`] 
| Hashes a byte array to a 32&hyphen;bit value, mixing in a 32&hyphen;bit seed&period;
|===


== xref:folly/external/farmhash/farmhashte.adoc[folly::external::farmhash::farmhashte] namespace

FarmHash &quot;te&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashte/Hash64.adoc[`Hash64`] 
| Hashes a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashte/Hash64WithSeed.adoc[`Hash64WithSeed`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in a 64&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashte/Hash64WithSeeds.adoc[`Hash64WithSeeds`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in two 64&hyphen;bit seeds&period;
|===


== xref:folly/external/farmhash/farmhashuo.adoc[folly::external::farmhash::farmhashuo] namespace

FarmHash &quot;uo&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashuo/Hash64.adoc[`Hash64`] 
| Hashes a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashuo/Hash64WithSeed.adoc[`Hash64WithSeed`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in a 64&hyphen;bit seed&period;
|===


== xref:folly/external/farmhash/farmhashxo.adoc[folly::external::farmhash::farmhashxo] namespace

FarmHash &quot;xo&quot; variant&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/farmhashxo/Hash64.adoc[`Hash64`] 
| Hashes a byte array to a 64&hyphen;bit value&period;
| xref:folly/external/farmhash/farmhashxo/Hash64WithSeed.adoc[`Hash64WithSeed`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in a 64&hyphen;bit seed&period;
| xref:folly/external/farmhash/farmhashxo/Hash64WithSeeds.adoc[`Hash64WithSeeds`] 
| Hashes a byte array to a 64&hyphen;bit value, mixing in two 64&hyphen;bit seeds&period;
|===


== xref:folly/external/farmhash/test.adoc[folly::external::farmhash::test] namespace

&sol; internal variants

=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/farmhash/test/returnZeroIfMisconfigured.adoc[`returnZeroIfMisconfigured`] 
| When set, hash functions return zero if the build is misconfigured&period;
|===


== xref:folly/external/rapidhash_detail.adoc[folly::external::rapidhash&lowbar;detail] namespace

Implementation details of the rapidhash hashing algorithm&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/rapidhash_detail/rapidhashMicro_internal.adoc[`rapidhashMicro&lowbar;internal`] 
| rapidhashMicro main function&period;
| xref:folly/external/rapidhash_detail/rapidhashNano_internal.adoc[`rapidhashNano&lowbar;internal`] 
| rapidhashNano main function&period;
| xref:folly/external/rapidhash_detail/rapidhash_internal.adoc[`rapidhash&lowbar;internal`] 
| rapidhash main function&period;
| xref:folly/external/rapidhash_detail/rapidhash_mix.adoc[`rapidhash&lowbar;mix`] 
| Multiply and xor mix function&period;
| xref:folly/external/rapidhash_detail/rapidhash_mum.adoc[`rapidhash&lowbar;mum`] 
| 64&ast;64 &hyphen;&gt; 128&hyphen;bit multiply function&period;
| xref:folly/external/rapidhash_detail/rapidhash_read32.adoc[`rapidhash&lowbar;read32`] 
| Reads a 32&hyphen;bit value from an unaligned buffer&period;
| xref:folly/external/rapidhash_detail/rapidhash_read64.adoc[`rapidhash&lowbar;read64`] 
| Reads a 64&hyphen;bit value from an unaligned buffer&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/external/rapidhash_detail/rapidhash_secret.adoc[`rapidhash&lowbar;secret`] 
| Default secret parameters used to alter the hash result&period;
|===


== xref:folly/f14.adoc[folly::f14] namespace

Implementation details for the F14 hash table family&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/f14/test.adoc[`test`] 
| Test&hyphen;only helpers for F14 containers&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/f14/DefaultAlloc.adoc[`DefaultAlloc`] 
| Default allocator for F14 container elements of type `T`&period;
| xref:folly/f14/DefaultHasher.adoc[`DefaultHasher`] 
| Default hasher for F14 containers keyed on `T`&period;
| xref:folly/f14/DefaultKeyEqual.adoc[`DefaultKeyEqual`] 
| Default key&hyphen;equality comparator for F14 containers keyed on `T`&period;
|===


== xref:folly/f14/test.adoc[folly::f14::test] namespace

Test&hyphen;only helpers for F14 containers&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/f14/test/disableInsertOrderRandomization.adoc[`disableInsertOrderRandomization`] 
| Disables the randomized insertion ordering used in sanitizer and debug builds&period;
|===


== xref:folly/fallback.adoc[folly::fallback] namespace

A fallback implementation used when the standard trait is unavailable&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/fallback/is_nothrow_convertible.adoc[`is&lowbar;nothrow&lowbar;convertible`] 
| A trait type that is true when From is nothrow&hyphen;convertible to To&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/fallback/is_nothrow_convertible_v.adoc[`is&lowbar;nothrow&lowbar;convertible&lowbar;v`] 
| A trait variable that is true when From is nothrow&hyphen;convertible to To&period;
|===


== xref:folly/fbstring_detail.adoc[folly::fbstring&lowbar;detail] namespace

Implementation details for fbstring&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/fbstring_detail/copy_n.adoc[`copy&lowbar;n`] 
| Copies `n` elements from an input range to an output range&period;
| xref:folly/fbstring_detail/podCopy.adoc[`podCopy`] 
| Copies a range of POD elements to a non&hyphen;overlapping destination&period;
| xref:folly/fbstring_detail/podFill.adoc[`podFill`] 
| Fills a range of POD elements with a given value&period;
| xref:folly/fbstring_detail/podMove.adoc[`podMove`] 
| Moves a range of POD elements to a possibly overlapping destination&period;
|===


== xref:folly/fibers.adoc[folly::fibers] namespace

Lightweight cooperative userspace threads (fibers) and related primitives&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/async.adoc[`async`] 
| Async&sol;await&hyphen;style API for running fiber tasks&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/ABDCommitNotCalledException.adoc[`ABDCommitNotCalledException`] 
| An exception class that gets set on the promise for dispatched tokens, when the AtomicBatchDispatcher was destroyed before commit was called on it&period;
| xref:folly/fibers/ABDTokenNotDispatchedException.adoc[`ABDTokenNotDispatchedException`] 
| An exception class that gets set on the promise for dispatched tokens, when one or more other tokens in the batch were destroyed before dispatch was called on them&period; Only here so that the caller can distinguish the real failure cause rather than these subsequently thrown exceptions&period;
| xref:folly/fibers/ABDUsageException.adoc[`ABDUsageException`] 
| An exception class that gets thrown when the AtomicBatchDispatcher is used incorrectly&period; This is indicative of a bug in the user code&period; Examples are, multiple dispatch calls on the same token, trying to get more tokens from the dispatcher after commit has been called, etc&period;
| xref:folly/fibers/AtomicBatchDispatcher.adoc[`AtomicBatchDispatcher`] 
| AtomicBatchDispatcher should be used if you want to process fiber tasks in parallel, but require to synchronize them at some point&period; The canonical example is to create a database transaction dispatch round&period; This API notably enforces that all tasks in the batch have reached the synchronization point before the user provided dispatch function is called with all the inputs provided in one function call&period; It also provides a guarantee that the inputs in the vector of inputs passed to the user provided dispatch function will be in the same order as the order in which the token for the job was issued&period;
| xref:folly/fibers/BatchDispatcher.adoc[`BatchDispatcher`] 
| BatchDispatcher is useful for batching values while doing I&sol;O&period; For example, if you are launching multiple tasks which take a single id and each task fetches from database, you can use BatchDispatcher to batch those ids and do a single query requesting all those ids&period;
| xref:folly/fibers/BatchSemaphore.adoc[`BatchSemaphore`] 
| Fiber&hyphen;compatible batch semaphore with ability to perform batch token increment&sol;decrement&period; Will safely block fibers that wait when no tokens are available and wake fibers when signalled&period;
| xref:folly/fibers/Baton.adoc[`Baton`] 
| Primitive which allows one to put current Fiber to sleep and wake it from another Fiber&sol;thread&period;
| xref:folly/fibers/EventBaseLoopController.adoc[`EventBaseLoopController`] 
| A LoopController that drives a FiberManager loop from a folly EventBase&period;
| xref:folly/fibers/ExecutorBasedLoopController.adoc[`ExecutorBasedLoopController`] 
| Interface for LoopController with publicly acessible executor
| xref:folly/fibers/ExecutorLoopController.adoc[`ExecutorLoopController`] 
| A fiber loop controller that works for arbitrary folly&colon;&colon;Executor
| xref:folly/fibers/ExecutorTimeoutManager.adoc[`ExecutorTimeoutManager`] 
| A TimeoutManager that schedules timeouts on a folly&colon;&colon;Executor&period;
| xref:folly/fibers/Fiber.adoc[`Fiber`] 
| Fiber object used by FiberManager to execute tasks&period;
| xref:folly/fibers/FiberImpl.adoc[`FiberImpl`] 
| Low&hyphen;level fiber wrapper over Boost&period;Context that switches execution contexts&period;
| xref:folly/fibers/FiberManager.adoc[`FiberManager`] 
| Single&hyphen;threaded task execution engine&period;
| xref:folly/fibers/FirstArgOf-0a.adoc[`FirstArgOf`] 
| Trait that yields the type of the first argument of a callable `F`&period;
| xref:folly/fibers/GuardPageAllocator.adoc[`GuardPageAllocator`] 
| Stack allocator that protects an extra memory page after the end of the stack&period; Will only add extra memory pages up to a certain number of allocations to avoid creating too many memory maps for the process&period;
| xref:folly/fibers/LoopController.adoc[`LoopController`] 
| Interface driving the loop that runs a FiberManager&apos;s ready fibers&period;
| xref:folly/fibers/Semaphore.adoc[`Semaphore`] 
| Fiber&hyphen;compatible semaphore&period; Will safely block fibers that wait when no tokens are available and wake fibers when signalled&period;
| xref:folly/fibers/SemaphoreBase.adoc[`SemaphoreBase`] 
| Fiber&hyphen;compatible semaphore base&period; Will safely block fibers that wait when no tokens are available and wake fibers when signalled&period;
| xref:folly/fibers/SimpleLoopController.adoc[`SimpleLoopController`] 
| A LoopController that drives a FiberManager loop inline, mainly for tests&period;
| xref:folly/fibers/StackCacheEntry.adoc[`StackCacheEntry`] 
| Caches fiber stacks with guard pages for reuse across allocations&period;
| xref:folly/fibers/TaskIterator.adoc[`TaskIterator`] 
| Traverses tasks scheduled by addTasks in the order they complete&period;
| xref:folly/fibers/TaskOptions.adoc[`TaskOptions`] 
| Options controlling how a fiber task is executed&period;
| xref:folly/fibers/TimedMutex.adoc[`TimedMutex`] 
| Like mutex but allows timed&lowbar;lock in addition to lock and try&lowbar;lock&period;
| xref:folly/fibers/TimedRWMutexImpl.adoc[`TimedRWMutexImpl`] 
| A readers&hyphen;writer lock which allows multiple readers to hold the lock simultaneously or only one writer&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/GenericBaton.adoc[`GenericBaton`] 
| Alias for the fiber&hyphen;compatible `Baton` synchronization primitive&period;
| xref:folly/fibers/TimedRWMutex.adoc[`TimedRWMutex`] 
| A timed readers&hyphen;writer mutex, defaulting to reader priority&period;
| xref:folly/fibers/TimedRWMutexReadPriority.adoc[`TimedRWMutexReadPriority`] 
| A reader&hyphen;preferred timed readers&hyphen;writer mutex&period;
| xref:folly/fibers/TimedRWMutexWritePriority.adoc[`TimedRWMutexWritePriority`] 
| A writer&hyphen;preferred timed readers&hyphen;writer mutex&period;
| xref:folly/fibers/once_flag.adoc[`once&lowbar;flag`] 
| Fiber&hyphen;compatible once flag backed by a `TimedMutex`&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/addTasks-09.adoc[`addTasks`] 
| `addTasks` overloads
| xref:folly/fibers/collectAll-09.adoc[`collectAll`] 
| `collectAll` overloads
| xref:folly/fibers/collectAny-00.adoc[`collectAny`] 
| `collectAny` overloads
| xref:folly/fibers/collectN-0d.adoc[`collectN`] 
| `collectN` overloads
| xref:folly/fibers/createAtomicBatchDispatcher.adoc[`createAtomicBatchDispatcher`] 
| Creates an AtomicBatchDispatcher that uses the given dispatch function&period;
| xref:folly/fibers/forEach.adoc[`forEach`] 
| Schedules several tasks and blocks until all of them are completed&period; In the process of their successful completion given callback would be called for each of them with the index of the task and the result it returned (if not void)&period; If any of these n tasks throws an exception, this exception will be re&hyphen;thrown, but only when all tasks are complete&period; If several tasks throw exceptions one of them will be re&hyphen;thrown&period; Callback won&apos;t be called for tasks that throw exception&period;
| xref:folly/fibers/getFiberManagerT.adoc[`getFiberManagerT`] 
| Returns the fiber manager keyed by the local type `Local` for `evb`&period;
| xref:folly/fibers/installGuardPageSignalHandler.adoc[`installGuardPageSignalHandler`] 
| Unconditionally install the SIGSEGV handler that detects fiber stack overflow&period; Can be useful if the handler has been overridden by some other code overriding the SIGSEGV handler
|===


== xref:folly/fibers/async.adoc[folly::fibers::async] namespace

Async&sol;await&hyphen;style API for running fiber tasks&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/async/Async-06.adoc[`Async`] 
| Asynchronous fiber result wrapper
| xref:folly/fibers/async/async_inner_type-04.adoc[`async&lowbar;inner&lowbar;type`] 
| Trait that extracts the inner value type wrapped by an Async type&period;
| xref:folly/fibers/async/await_fn.adoc[`await&lowbar;fn`] 
| Callable type that awaits an Async wrapper via tag&lowbar;invoke&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/async/async_inner_type_t.adoc[`async&lowbar;inner&lowbar;type&lowbar;t`] 
| Inner value type wrapped by the Async type `T`&period;
| xref:folly/fibers/async/async_invocable_inner_type.adoc[`async&lowbar;invocable&lowbar;inner&lowbar;type`] 
| Maps the Async result of invoking `F` with `Args&period;&period;&period;` to its inner value type&period;
| xref:folly/fibers/async/async_invocable_inner_type_t.adoc[`async&lowbar;invocable&lowbar;inner&lowbar;type&lowbar;t`] 
| Inner value type produced by invoking `F` with `Args&period;&period;&period;` and unwrapping the resulting Async&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/async/addFiber.adoc[`addFiber`] 
| Schedule an async&hyphen;annotated functor to run on a fiber manager&period;
| xref:folly/fibers/async/addFiberFuture.adoc[`addFiberFuture`] 
| Schedule an async&hyphen;annotated functor to run on a fiber manager&period; Returns a Future for the result&period;
| xref:folly/fibers/async/addFiberRemote.adoc[`addFiberRemote`] 
| Schedule an async&hyphen;annotated functor to run on a remote thread&apos;s fiber manager&period;
| xref:folly/fibers/async/addFiberRemoteFuture.adoc[`addFiberRemoteFuture`] 
| Schedule an async&hyphen;annotated functor to run on a remote thread&apos;s fiber manager&period; Returns a future for the result&period;
| xref:folly/fibers/async/awaitTry.adoc[`awaitTry`] 
| Await an async&hyphen;annotated functor, capturing its result or exception in a Try&period;
| xref:folly/fibers/async/baton_try_wait_for.adoc[`baton&lowbar;try&lowbar;wait&lowbar;for`] 
| Async tagged wrapper that waits on a baton for a bounded duration&period;
| xref:folly/fibers/async/baton_try_wait_until.adoc[`baton&lowbar;try&lowbar;wait&lowbar;until`] 
| Async tagged wrapper that waits on a baton until a deadline&period;
| xref:folly/fibers/async/baton_wait.adoc[`baton&lowbar;wait`] 
| Async tagged wrapper that blocks on a baton until it is posted&period;
| xref:folly/fibers/async/collectAll-0d.adoc[`collectAll`] 
| `collectAll` overloads
| xref:folly/fibers/async/executeOnFiberAndWait-0c.adoc[`executeOnFiberAndWait`] 
| `executeOnFiberAndWait` overloads
| xref:folly/fibers/async/executeOnNewFiber.adoc[`executeOnNewFiber`] 
| Run an async&hyphen;annotated functor on a new fiber, blocking the current fiber&period;
| xref:folly/fibers/async/executeOnRemoteFiber.adoc[`executeOnRemoteFiber`] 
| Run an async&hyphen;annotated functor on a new fiber on remote thread, blocking the current fiber&period;
| xref:folly/fibers/async/executeOnRemoteFiberAndWait.adoc[`executeOnRemoteFiberAndWait`] 
| Run an async&hyphen;annotated functor `func`, to completion on a remote fiber manager, blocking the current thread&period;
| xref:folly/fibers/async/executeWithNewRoot.adoc[`executeWithNewRoot`] 
| Executes `F` with a new async&hyphen;stack&hyphen;root, making it possible to stitch stacks across async hops&period;
| xref:folly/fibers/async/fromTry.adoc[`fromTry`] 
| Convert a Try into an Async result, rethrowing any stored exception&period;
| xref:folly/fibers/async/futureWait-08.adoc[`futureWait`] 
| `futureWait` overloads
| xref:folly/fibers/async/init_await-08.adoc[`init&lowbar;await`] 
| `init&lowbar;await` overloads
| xref:folly/fibers/async/promiseWait.adoc[`promiseWait`] 
| Async annotated wrapper around fibers&colon;&colon;await
| xref:folly/fibers/async/runInMainContextWithTracing.adoc[`runInMainContextWithTracing`] 
| Connects the execution of synchronous function `F` (on the main thread context) to the calling fiber
| xref:folly/fibers/async/tag_invoke-009.adoc[`tag&lowbar;invoke`] 
| `tag&lowbar;invoke` overloads
| xref:folly/fibers/async/taskWait-0c.adoc[`taskWait`] 
| `taskWait` overloads
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/fibers/async/is_async_v.adoc[`is&lowbar;async&lowbar;v`] 
| True when `T` is an instantiation of the Async wrapper&period;
|===


== xref:folly/fileops.adoc[folly::fileops] namespace

Portable wrappers and imports for file&hyphen;descriptor operations&period;

=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/fileops/close.adoc[`close`] 
| Imported global `close`&period;
| xref:folly/fileops/open.adoc[`open`] 
| Imported global `open`&period;
| xref:folly/fileops/pipe.adoc[`pipe`] 
| Imported global `pipe`&period;
| xref:folly/fileops/read.adoc[`read`] 
| Imported global `read`&period;
| xref:folly/fileops/write.adoc[`write`] 
| Imported global `write`&period;
|===


== xref:folly/fileutil_detail.adoc[folly::fileutil&lowbar;detail] namespace

Implementation details&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/fileutil_detail/getTemporaryFilePathString.adoc[`getTemporaryFilePathString`] 
| Returns a string compatible for mkstemp()&period;
| xref:folly/fileutil_detail/incr-05.adoc[`incr`] 
| `incr` overloads
| xref:folly/fileutil_detail/wrapFull.adoc[`wrapFull`] 
| Wrap call to read&sol;pread&sol;write&sol;pwrite(fd, buf, count, offset?) to retry on incomplete reads &sol; writes&period; The variadic argument magic is there to support an additional argument (offset) for pread &sol; pwrite&semi; see the incr() functions above which do nothing if the offset is not present and increment it if it is&period;
| xref:folly/fileutil_detail/wrapNoInt.adoc[`wrapNoInt`] 
| Wrap call to f(args) in loop to retry on EINTR&period;
| xref:folly/fileutil_detail/wrapvFull.adoc[`wrapvFull`] 
| Retry reading&sol;writing iovec objects&period;
|===


== xref:folly/find_fixed_detail.adoc[folly::find&lowbar;fixed&lowbar;detail] namespace

Implementation details for folly&colon;&colon;findFixed&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/find_fixed_detail/find16ByteReg.adoc[`find16ByteReg`] 
| 
| xref:folly/find_fixed_detail/find16bytes.adoc[`find16bytes`] 
| Searches 16 bytes for a value using a SIMD register&period;
| xref:folly/find_fixed_detail/find2Overlaping.adoc[`find2Overlaping`] 
| Searches a fixed&hyphen;size range using two overlapping SIMD registers&period;
| xref:folly/find_fixed_detail/find32bytes.adoc[`find32bytes`] 
| Searches 32 bytes for a value using a SIMD register&period;
| xref:folly/find_fixed_detail/find8bytes.adoc[`find8bytes`] 
| Searches 8 bytes for a value using a SIMD register&period;
| xref:folly/find_fixed_detail/findFixedConstexpr.adoc[`findFixedConstexpr`] 
| Searches a range for a value with a constexpr&hyphen;friendly scalar loop&period;
| xref:folly/find_fixed_detail/findFixedDispatch.adoc[`findFixedDispatch`] 
| Dispatches a fixed&hyphen;size search to the best strategy for the range size&period;
| xref:folly/find_fixed_detail/findFixedLetTheCompilerDoIt.adoc[`findFixedLetTheCompilerDoIt`] 
| Searches a fixed&hyphen;size range with a plain scalar loop the compiler can unroll&period;
| xref:folly/find_fixed_detail/findSplitFirstRegister.adoc[`findSplitFirstRegister`] 
| Searches a fixed&hyphen;size range by splitting off a leading SIMD register&period;
| xref:folly/find_fixed_detail/firstTrue.adoc[`firstTrue`] 
| Returns the index of the first set element in a SIMD comparison register&period;
|===


=== Variables

[cols="1"]
|===
| Name
| xref:folly/find_fixed_detail/kMaxSimdRegister.adoc[`kMaxSimdRegister`] 
|===


== xref:folly/for_each_detail.adoc[folly::for&lowbar;each&lowbar;detail] namespace

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;

=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/for_each_detail/LoopControl.adoc[`LoopControl`] 
| Signals whether a for&lowbar;each callback wants to stop or keep iterating&period;
|===


== xref:folly/format_value.adoc[folly::format&lowbar;value] namespace

Utilities for all format value specializations&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/format_value/formatFormatter.adoc[`formatFormatter`] 
| Format a Formatter object recursively&period; Behaves just like formatString(fmt&period;str(), arg, cb)&semi; but avoids creating a temporary string if possible&period;
| xref:folly/format_value/formatNumber.adoc[`formatNumber`] 
| Format a number in &quot;val&quot;&semi; the first prefixLen characters form the prefix (sign, &quot;0x&quot; base prefix, etc) which must be left&hyphen;aligned if the alignment is Align&colon;&colon;PAD&lowbar;AFTER&lowbar;SIGN&period; Treats Align&colon;&colon;DEFAULT as Align&colon;&colon;LEFT&period; Ignores arg&period;precision, as that has a different meaning for numbers (not &quot;maximum field width&quot;)
| xref:folly/format_value/formatString.adoc[`formatString`] 
| Format a string in &quot;val&quot;, obeying appropriate alignment, padding, width, and precision&period; Treats Align&colon;&colon;DEFAULT as Align&colon;&colon;LEFT, and Align&colon;&colon;PAD&lowbar;AFTER&lowbar;SIGN as Align&colon;&colon;RIGHT&semi; use formatNumber for number&hyphen;specific formatting&period;
|===


== xref:folly/fs.adoc[folly::fs] namespace

Portable filesystem imports selecting the available `&lt;filesystem&gt;` backend&period;

=== Namespace Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/std_fs.adoc[`std&lowbar;fs`] 
| Alias for the selected standard filesystem namespace&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/unique_path_fn.adoc[`unique&lowbar;path&lowbar;fn`] 
| Function object that generates a unique path from a model&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/std_fs_unique_path_fn.adoc[`std&lowbar;fs&lowbar;unique&lowbar;path&lowbar;fn`] 
| Callable type that generates a unique path from a model&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/which_enum.adoc[`which&lowbar;enum`] 
| Identifies which standard filesystem implementation is in use&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/canonical_parent.adoc[`canonical&lowbar;parent`] 
| Canonicalize the parent path, leaving the filename (last component) unchanged&period; You may use this before creating a file instead of boost&colon;&colon;filesystem&colon;&colon;canonical, which requires that the entire path exists&period;
| xref:folly/fs/executable_path.adoc[`executable&lowbar;path`] 
| Get the path to the current executable&period;
| xref:folly/fs/lexically_normal.adoc[`lexically&lowbar;normal`] 
| Returns the lexically normal form of the given path&period;
| xref:folly/fs/remove_prefix.adoc[`remove&lowbar;prefix`] 
| If &quot;path&quot; starts with &quot;prefix&quot;, return &quot;path&quot; with &quot;prefix&quot; removed&period; Otherwise, throw filesystem&lowbar;error&period;
| xref:folly/fs/starts_with.adoc[`starts&lowbar;with`] 
| Check whether &quot;path&quot; starts with &quot;prefix&quot;&period; That is, if prefix has n path elements, then the first n elements of path must be the same as prefix&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/std_fs_unique_path.adoc[`std&lowbar;fs&lowbar;unique&lowbar;path`] 
| Callable that generates a unique path from a model&period;
| xref:folly/fs/which.adoc[`which`] 
| The filesystem implementation selected at compile time&period;
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/fs/absolute.adoc[`absolute`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;absolute`&period;
| xref:folly/fs/canonical.adoc[`canonical`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;canonical`&period;
| xref:folly/fs/copy.adoc[`copy`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;copy`&period;
| xref:folly/fs/copy_file.adoc[`copy&lowbar;file`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;copy&lowbar;file`&period;
| xref:folly/fs/copy_options.adoc[`copy&lowbar;options`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;copy&lowbar;options`&period;
| xref:folly/fs/copy_symlink.adoc[`copy&lowbar;symlink`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;copy&lowbar;symlink`&period;
| xref:folly/fs/create_directories.adoc[`create&lowbar;directories`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;create&lowbar;directories`&period;
| xref:folly/fs/create_directory.adoc[`create&lowbar;directory`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;create&lowbar;directory`&period;
| xref:folly/fs/create_directory_symlink.adoc[`create&lowbar;directory&lowbar;symlink`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;create&lowbar;directory&lowbar;symlink`&period;
| xref:folly/fs/create_hard_link.adoc[`create&lowbar;hard&lowbar;link`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;create&lowbar;hard&lowbar;link`&period;
| xref:folly/fs/create_symlink.adoc[`create&lowbar;symlink`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;create&lowbar;symlink`&period;
| xref:folly/fs/current_path.adoc[`current&lowbar;path`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;current&lowbar;path`&period;
| xref:folly/fs/directory_entry.adoc[`directory&lowbar;entry`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;directory&lowbar;entry`&period;
| xref:folly/fs/directory_iterator.adoc[`directory&lowbar;iterator`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;directory&lowbar;iterator`&period;
| xref:folly/fs/directory_options.adoc[`directory&lowbar;options`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;directory&lowbar;options`&period;
| xref:folly/fs/equivalent.adoc[`equivalent`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;equivalent`&period;
| xref:folly/fs/exists.adoc[`exists`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;exists`&period;
| xref:folly/fs/file_size.adoc[`file&lowbar;size`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;file&lowbar;size`&period;
| xref:folly/fs/file_status.adoc[`file&lowbar;status`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;file&lowbar;status`&period;
| xref:folly/fs/file_time_type.adoc[`file&lowbar;time&lowbar;type`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;file&lowbar;time&lowbar;type`&period;
| xref:folly/fs/file_type.adoc[`file&lowbar;type`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;file&lowbar;type`&period;
| xref:folly/fs/filesystem_error.adoc[`filesystem&lowbar;error`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;filesystem&lowbar;error`&period;
| xref:folly/fs/hard_link_count.adoc[`hard&lowbar;link&lowbar;count`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;hard&lowbar;link&lowbar;count`&period;
| xref:folly/fs/is_block_file.adoc[`is&lowbar;block&lowbar;file`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;block&lowbar;file`&period;
| xref:folly/fs/is_character_file.adoc[`is&lowbar;character&lowbar;file`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;character&lowbar;file`&period;
| xref:folly/fs/is_directory.adoc[`is&lowbar;directory`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;directory`&period;
| xref:folly/fs/is_empty.adoc[`is&lowbar;empty`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;empty`&period;
| xref:folly/fs/is_fifo.adoc[`is&lowbar;fifo`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;fifo`&period;
| xref:folly/fs/is_other.adoc[`is&lowbar;other`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;other`&period;
| xref:folly/fs/is_regular_file.adoc[`is&lowbar;regular&lowbar;file`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;regular&lowbar;file`&period;
| xref:folly/fs/is_socket.adoc[`is&lowbar;socket`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;socket`&period;
| xref:folly/fs/is_symlink.adoc[`is&lowbar;symlink`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;is&lowbar;symlink`&period;
| xref:folly/fs/last_write_time.adoc[`last&lowbar;write&lowbar;time`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;last&lowbar;write&lowbar;time`&period;
| xref:folly/fs/path.adoc[`path`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;path`&period;
| xref:folly/fs/perm_options.adoc[`perm&lowbar;options`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;perm&lowbar;options`&period;
| xref:folly/fs/permissions.adoc[`permissions`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;permissions`&period;
| xref:folly/fs/perms.adoc[`perms`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;perms`&period;
| xref:folly/fs/proximate.adoc[`proximate`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;proximate`&period;
| xref:folly/fs/read_symlink.adoc[`read&lowbar;symlink`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;read&lowbar;symlink`&period;
| xref:folly/fs/recursive_directory_iterator.adoc[`recursive&lowbar;directory&lowbar;iterator`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;recursive&lowbar;directory&lowbar;iterator`&period;
| xref:folly/fs/relative.adoc[`relative`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;relative`&period;
| xref:folly/fs/remove.adoc[`remove`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;remove`&period;
| xref:folly/fs/remove_all.adoc[`remove&lowbar;all`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;remove&lowbar;all`&period;
| xref:folly/fs/rename.adoc[`rename`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;rename`&period;
| xref:folly/fs/resize_file.adoc[`resize&lowbar;file`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;resize&lowbar;file`&period;
| xref:folly/fs/space.adoc[`space`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;space`&period;
| xref:folly/fs/space_info.adoc[`space&lowbar;info`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;space&lowbar;info`&period;
| xref:folly/fs/status.adoc[`status`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;status`&period;
| xref:folly/fs/status_known.adoc[`status&lowbar;known`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;status&lowbar;known`&period;
| xref:folly/fs/symlink_status.adoc[`symlink&lowbar;status`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;symlink&lowbar;status`&period;
| xref:folly/fs/temp_directory_path.adoc[`temp&lowbar;directory&lowbar;path`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;temp&lowbar;directory&lowbar;path`&period;
| xref:folly/fs/u8path.adoc[`u8path`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;u8path`&period;
| xref:folly/fs/weakly_canonical.adoc[`weakly&lowbar;canonical`] 
| Imported `std&colon;&colon;filesystem&colon;&colon;weakly&lowbar;canonical`&period;
|===


== xref:folly/futures.adoc[folly::futures] namespace

Futures&hyphen;based asynchronous programming primitives&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/futures/Barrier.adoc[`Barrier`] 
| A folly&colon;&colon;Future&hyphen;istic Barrier synchronization primitive&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/futures/retrying.adoc[`retrying`] 
| Retries a future&hyphen;factory according to a policy, returning a SemiFuture&period;
| xref:folly/futures/retryingPolicyBasic.adoc[`retryingPolicyBasic`] 
| Builds a retry policy that retries until a maximum number of attempts&period;
| xref:folly/futures/retryingPolicyCappedJitteredExponentialBackoff-0f2.adoc[`retryingPolicyCappedJitteredExponentialBackoff`] 
| `retryingPolicyCappedJitteredExponentialBackoff` overloads
| xref:folly/futures/retryingUnsafe.adoc[`retryingUnsafe`] 
| retrying and retryingUnsafe
|===


== xref:folly/gen.adoc[folly::gen] namespace

Lazy sequence generators and pipeline operators&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/gen/Cast.adoc[`Cast`] 
| Function object that constructs a `Dest` from a value&period;
| xref:folly/gen/ConstMemberFunction.adoc[`ConstMemberFunction`] 
| Function object that calls a const member function of a class&period;
| xref:folly/gen/ExprIsConst.adoc[`ExprIsConst`] 
| These exist because MSVC has problems with expression SFINAE in templates assignment and comparisons don&apos;t work properly without being pulled out of the template declaration
| xref:folly/gen/ExprIsMutable.adoc[`ExprIsMutable`] 
| SFINAE helper exposing whether `Constness` selects the mutable overload&period;
| xref:folly/gen/Field-01.adoc[`Field`] 
| Function object that accesses a data member of a class&period;
| xref:folly/gen/GenImpl-04.adoc[`GenImpl`] 
| CRTP base for sequence generators that yield `Value`&period;
| xref:folly/gen/Get-0e.adoc[`Get`] 
| Function object that extracts the nth element of a tuple&hyphen;like value&period;
| xref:folly/gen/Greater.adoc[`Greater`] 
| Function object that compares two values with `operator&gt;`&period;
| xref:folly/gen/Group.adoc[`Group`] 
| Groups the values of a sequence by a computed key&period;
| xref:folly/gen/Less.adoc[`Less`] 
| Function object that compares two values with `operator&lt;`&period;
| xref:folly/gen/MemberFunction.adoc[`MemberFunction`] 
| Function object that calls a non&hyphen;const member function of a class&period;
| xref:folly/gen/MixedNewlines.adoc[`MixedNewlines`] 
| EOL terms (&quot;r&quot;, &quot;n&quot;, or &quot;rn&quot;)&period;
| xref:folly/gen/Move.adoc[`Move`] 
| Function object that casts its argument to an rvalue reference&period;
| xref:folly/gen/Negate-07.adoc[`Negate`] 
| Class and helper function for negating a boolean Predicate
| xref:folly/gen/Operator-0c.adoc[`Operator`] 
| CRTP base for pipeline operators applied to generators&period;
| xref:folly/gen/StreamSplitter-05.adoc[`StreamSplitter`] 
| Outputs exactly the same bytes as the input stream, in different chunks&period; A chunk boundary occurs after each delimiter, or, if maxLength is non&hyphen;zero, after maxLength bytes, whichever comes first&period; Your callback can return false to stop consuming the stream at any time&period;
| xref:folly/gen/To-0a.adoc[`To`] 
| Function object that converts values to `Dest` via folly&colon;&colon;to&period;
| xref:folly/gen/TryTo.adoc[`TryTo`] 
| Function object that converts values to `Dest`, returning an Expected&period;
| xref:folly/gen/VirtualGen.adoc[`VirtualGen`] 
| Polymorphic wrapper
| xref:folly/gen/VirtualGenMoveOnly.adoc[`VirtualGenMoveOnly`] 
| Move&hyphen;only polymorphic wrapper for a generator yielding `Value`&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/gen/MemberType.adoc[`MemberType`] 
| Selects the const or non&hyphen;const overload of a member accessor&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/gen/all.adoc[`all`] 
| all() &hyphen; For determining whether all values in a sequence satisfy a predicate&period;
| xref:folly/gen/any.adoc[`any`] 
| any() &hyphen; For determining if any value in a sequence satisfies a predicate&period;
| xref:folly/gen/appendTo.adoc[`appendTo`] 
| Appends each value of a sequence to an existing collection&period;
| xref:folly/gen/as-0f.adoc[`as`] 
| `as` overloads
| xref:folly/gen/assert_type.adoc[`assert&lowbar;type`] 
| Asserts at compile time that the sequence yields the given value type&period;
| xref:folly/gen/byLine.adoc[`byLine`] 
| Generates the lines of an input stream, one std&colon;&colon;string at a time&period;
| xref:folly/gen/chunked-05.adoc[`chunked`] 
| `chunked` overloads
| xref:folly/gen/contains.adoc[`contains`] 
| Determines whether a sequence contains a given value&period;
| xref:folly/gen/distinctBy.adoc[`distinctBy`] 
| Keeps only the first value for each distinct selected key&period;
| xref:folly/gen/eachAs.adoc[`eachAs`] 
| Constructs a `Dest` from each value&period;
| xref:folly/gen/eachTo.adoc[`eachTo`] 
| Calls folly&colon;&colon;to on each value, converting it to `Dest`&period;
| xref:folly/gen/eachToPair-0e.adoc[`eachToPair`] 
| `eachToPair` overloads
| xref:folly/gen/eachToTuple-0b.adoc[`eachToTuple`] 
| `eachToTuple` overloads
| xref:folly/gen/eachTryTo.adoc[`eachTryTo`] 
| Calls folly&colon;&colon;tryTo on each value, mapping to an Expected of `Dest`&period;
| xref:folly/gen/empty.adoc[`empty`] 
| Produces an empty sequence of the given value type&period;
| xref:folly/gen/field-06.adoc[`field`] 
| Extracts a data member from each value&period;
| xref:folly/gen/filter.adoc[`filter`] 
| Keeps only values that satisfy the predicate&period;
| xref:folly/gen/foldl.adoc[`foldl`] 
| Left&hyphen;folds a sequence into a single value from an initial seed&period;
| xref:folly/gen/from-01.adoc[`from`] 
| `from` overloads
| xref:folly/gen/fromConst.adoc[`fromConst`] 
| Produces a sequence referencing the elements of a const container&period;
| xref:folly/gen/fromCopy.adoc[`fromCopy`] 
| Produces a sequence holding copies of the elements of a container&period;
| xref:folly/gen/fromFile-0e.adoc[`fromFile`] 
| `fromFile` overloads
| xref:folly/gen/generator.adoc[`generator`] 
| Wraps a source callable as a generator yielding `Value`&period;
| xref:folly/gen/get-00.adoc[`get`] 
| Extracts the nth element of each tuple&hyphen;like value&period;
| xref:folly/gen/groupBy.adoc[`groupBy`] 
| Groups all values by their selected key&period;
| xref:folly/gen/groupByAdjacent.adoc[`groupByAdjacent`] 
| Groups consecutive values that share the same selected key&period;
| xref:folly/gen/guard.adoc[`guard`] 
| Wraps a pipeline so exceptions of a given type are passed to a handler&period;
| xref:folly/gen/interleave.adoc[`interleave`] 
| Interleaves values from the source pipeline with those from `source2`&period;
| xref:folly/gen/just.adoc[`just`] 
| Produces a sequence containing a single value&period;
| xref:folly/gen/lines.adoc[`lines`] 
| Split by EOL (&quot;r&quot;, &quot;n&quot;, or &quot;rn&quot;)&period;
| xref:folly/gen/map.adoc[`map`] 
| Applies a function to each value, yielding the results&period;
| xref:folly/gen/mapOp.adoc[`mapOp`] 
| mapOp &hyphen; Given a generator of generators, maps the application of the given operator on to each inner gen&period; Especially useful in aggregating nested data structures&colon;
| xref:folly/gen/mapped.adoc[`mapped`] 
| Applies a function to each value, yielding the results&period;
| xref:folly/gen/maxBy.adoc[`maxBy`] 
| Finds the value with the maximum selected key&period;
| xref:folly/gen/member-04.adoc[`member`] 
| `member` overloads
| xref:folly/gen/minBy.adoc[`minBy`] 
| Finds the value with the minimum selected key&period;
| xref:folly/gen/negate-04.adoc[`negate`] 
| Creates a predicate that negates the result of `pred`&period;
| xref:folly/gen/orderBy.adoc[`orderBy`] 
| Orders values by their selected key using the given comparer&period;
| xref:folly/gen/orderByDescending.adoc[`orderByDescending`] 
| Orders values in descending order of their selected key&period;
| xref:folly/gen/parallel.adoc[`parallel`] 
| parallel &hyphen; A parallelization operator&period;
| xref:folly/gen/pmap.adoc[`pmap`] 
| Run `pred` in parallel in nThreads&period; Results are returned in the same order in which they were retrieved from the source generator (similar to map)&period;
| xref:folly/gen/range-09a.adoc[`range`] 
| `range` overloads
| xref:folly/gen/reduce.adoc[`reduce`] 
| Reduces a sequence to a single value using a binary reducer&period;
| xref:folly/gen/resplit.adoc[`resplit`] 
| Split the output from a generator into StringPiece &quot;lines&quot; delimited by the given delimiter&period; Delimters are NOT included in the output&period;
| xref:folly/gen/seq-03.adoc[`seq`] 
| `seq` overloads
| xref:folly/gen/split-0e1.adoc[`split`] 
| `split` overloads
| xref:folly/gen/streamSplitter-01.adoc[`streamSplitter`] 
| Creates a StreamSplitter, deducing the callback type&period;
| xref:folly/gen/sub.adoc[`sub`] 
| sub &hyphen; For sub&hyphen;summarization of a sequence&period;
| xref:folly/gen/takeWhile.adoc[`takeWhile`] 
| Yields values while the predicate holds, then stops&period;
| xref:folly/gen/toFile-0c.adoc[`toFile`] 
| `toFile` overloads
| xref:folly/gen/unsplit-0b.adoc[`unsplit`] 
| `unsplit` overloads
| xref:folly/gen/until.adoc[`until`] 
| Yields values until the predicate holds, then stops&period;
| xref:folly/gen/unwrapOr.adoc[`unwrapOr`] 
| Unwraps an optional&hyphen;like value, using a fallback when it is empty&period;
| xref:folly/gen/visit.adoc[`visit`] 
| Applies a visitor to each value, passing values through unchanged&period;
|===


== xref:folly/gflags.adoc[folly::gflags] namespace

Minimal stand&hyphen;in for the gflags namespace when gflags is unavailable&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/gflags/FlagSaver.adoc[`FlagSaver`] 
| No&hyphen;op replacement for the gflags command&hyphen;line flag saver&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/gflags/SetCommandLineOption.adoc[`SetCommandLineOption`] 
| Stub that ignores an attempt to set a command&hyphen;line flag&period;
|===


== xref:folly/hash-04.adoc[folly::hash] namespace

Hashing algorithms and helpers&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/farmhash.adoc[`farmhash`] 
| FarmHash hashing and fingerprinting functions imported from the bundled external implementation&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/SpookyHashV1.adoc[`SpookyHashV1`] 
| SpookyHash V1&colon; a 128&hyphen;bit noncryptographic hash function by Bob Jenkins&period;
| xref:folly/hash-04/SpookyHashV2.adoc[`SpookyHashV2`] 
| SpookyHash V2&colon; a 128&hyphen;bit noncryptographic hash function by Bob Jenkins&period;
| xref:folly/hash-04/StdHasher.adoc[`StdHasher`] 
| Hasher that forwards to std&colon;&colon;hash for each key type&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/commutative_hash_128_to_64.adoc[`commutative&lowbar;hash&lowbar;128&lowbar;to&lowbar;64`] 
| Order&hyphen;independent reduction of two 64&hyphen;bit hashes into one&period;
| xref:folly/hash-04/commutative_hash_combine.adoc[`commutative&lowbar;hash&lowbar;combine`] 
| Combine hashes of multiple items, order&hyphen;independently&period;
| xref:folly/hash-04/commutative_hash_combine_generic.adoc[`commutative&lowbar;hash&lowbar;combine&lowbar;generic`] 
| Combine hashes of multiple items, order&hyphen;independently&period;
| xref:folly/hash-04/commutative_hash_combine_range.adoc[`commutative&lowbar;hash&lowbar;combine&lowbar;range`] 
| Create a hash from multiple hashable objects, order&hyphen;independently&period;
| xref:folly/hash-04/commutative_hash_combine_range_generic.adoc[`commutative&lowbar;hash&lowbar;combine&lowbar;range&lowbar;generic`] 
| Create a hash from multiple hashable objects, order&hyphen;independently&period;
| xref:folly/hash-04/commutative_hash_combine_value_generic.adoc[`commutative&lowbar;hash&lowbar;combine&lowbar;value&lowbar;generic`] 
| Hash a value, and combine it with a seed&period; Commutative&period;
| xref:folly/hash-04/fnv32-02.adoc[`fnv32`] 
| Alias for fnv32&lowbar;BROKEN&period;
| xref:folly/hash-04/fnv32_BROKEN-06.adoc[`fnv32&lowbar;BROKEN`] 
| `fnv32&lowbar;BROKEN` overloads
| xref:folly/hash-04/fnv32_FIXED-03d.adoc[`fnv32&lowbar;FIXED`] 
| `fnv32&lowbar;FIXED` overloads
| xref:folly/hash-04/fnv32_append_byte.adoc[`fnv32&lowbar;append&lowbar;byte`] 
| Alias for fnv32&lowbar;append&lowbar;byte&lowbar;BROKEN&period;
| xref:folly/hash-04/fnv32_append_byte_BROKEN.adoc[`fnv32&lowbar;append&lowbar;byte&lowbar;BROKEN`] 
| Append byte to FNV hash&period;
| xref:folly/hash-04/fnv32_append_byte_FIXED.adoc[`fnv32&lowbar;append&lowbar;byte&lowbar;FIXED`] 
| Append byte to FNV hash&period;
| xref:folly/hash-04/fnv32_buf-0e.adoc[`fnv32&lowbar;buf`] 
| `fnv32&lowbar;buf` overloads
| xref:folly/hash-04/fnv32_buf_BROKEN-07.adoc[`fnv32&lowbar;buf&lowbar;BROKEN`] 
| `fnv32&lowbar;buf&lowbar;BROKEN` overloads
| xref:folly/hash-04/fnv32_buf_FIXED-05.adoc[`fnv32&lowbar;buf&lowbar;FIXED`] 
| `fnv32&lowbar;buf&lowbar;FIXED` overloads
| xref:folly/hash-04/fnv64-05c.adoc[`fnv64`] 
| Alias for fnv64&lowbar;BROKEN&period;
| xref:folly/hash-04/fnv64_BROKEN-0c.adoc[`fnv64&lowbar;BROKEN`] 
| `fnv64&lowbar;BROKEN` overloads
| xref:folly/hash-04/fnv64_FIXED-0c.adoc[`fnv64&lowbar;FIXED`] 
| `fnv64&lowbar;FIXED` overloads
| xref:folly/hash-04/fnv64_append_byte.adoc[`fnv64&lowbar;append&lowbar;byte`] 
| Alias for fnv64&lowbar;append&lowbar;byte&lowbar;BROKEN&period;
| xref:folly/hash-04/fnv64_append_byte_BROKEN.adoc[`fnv64&lowbar;append&lowbar;byte&lowbar;BROKEN`] 
| Append a byte to FNV hash&period;
| xref:folly/hash-04/fnv64_append_byte_FIXED.adoc[`fnv64&lowbar;append&lowbar;byte&lowbar;FIXED`] 
| Append a byte to FNV hash&period;
| xref:folly/hash-04/fnv64_buf-0d.adoc[`fnv64&lowbar;buf`] 
| `fnv64&lowbar;buf` overloads
| xref:folly/hash-04/fnv64_buf_BROKEN-0b.adoc[`fnv64&lowbar;buf&lowbar;BROKEN`] 
| `fnv64&lowbar;buf&lowbar;BROKEN` overloads
| xref:folly/hash-04/fnv64_buf_FIXED-09.adoc[`fnv64&lowbar;buf&lowbar;FIXED`] 
| `fnv64&lowbar;buf&lowbar;FIXED` overloads
| xref:folly/hash-04/fnva32.adoc[`fnva32`] 
| FNVA hash of a string&period;
| xref:folly/hash-04/fnva32_append_byte.adoc[`fnva32&lowbar;append&lowbar;byte`] 
| Append a byte to FNVA hash&period;
| xref:folly/hash-04/fnva32_buf-00.adoc[`fnva32&lowbar;buf`] 
| `fnva32&lowbar;buf` overloads
| xref:folly/hash-04/fnva64.adoc[`fnva64`] 
| FNVA hash of a string&period;
| xref:folly/hash-04/fnva64_append_byte.adoc[`fnva64&lowbar;append&lowbar;byte`] 
| Append a byte to FNVA hash&period;
| xref:folly/hash-04/fnva64_buf-0c.adoc[`fnva64&lowbar;buf`] 
| `fnva64&lowbar;buf` overloads
| xref:folly/hash-04/hash_128_to_64.adoc[`hash&lowbar;128&lowbar;to&lowbar;64`] 
| Reduce two 64&hyphen;bit hashes into one&period;
| xref:folly/hash-04/hash_combine.adoc[`hash&lowbar;combine`] 
| Combine hashes of multiple items, order&hyphen;dependently&period;
| xref:folly/hash-04/hash_combine_generic-0208.adoc[`hash&lowbar;combine&lowbar;generic`] 
| `hash&lowbar;combine&lowbar;generic` overloads
| xref:folly/hash-04/hash_range.adoc[`hash&lowbar;range`] 
| Combine hashes of items in the range &lsqb;first, last), order&hyphen;dependently&period;&rsqb;
| xref:folly/hash-04/hsieh_hash32.adoc[`hsieh&lowbar;hash32`] 
| hsieh hash a c&hyphen;str&period;
| xref:folly/hash-04/hsieh_hash32_buf.adoc[`hsieh&lowbar;hash32&lowbar;buf`] 
| hsieh hash a void&ast; byte&hyphen;range&period;
| xref:folly/hash-04/hsieh_hash32_buf_constexpr.adoc[`hsieh&lowbar;hash32&lowbar;buf&lowbar;constexpr`] 
| hsieh hash a byte&hyphen;range&period;
| xref:folly/hash-04/hsieh_hash32_str.adoc[`hsieh&lowbar;hash32&lowbar;str`] 
| hsieh hash a string&period;
| xref:folly/hash-04/jenkins_rev_mix32.adoc[`jenkins&lowbar;rev&lowbar;mix32`] 
| Robert Jenkins&apos; reversible 32 bit mix hash function&period;
| xref:folly/hash-04/jenkins_rev_unmix32.adoc[`jenkins&lowbar;rev&lowbar;unmix32`] 
| Inverse of jenkins&lowbar;rev&lowbar;mix32&period;
| xref:folly/hash-04/lowbias_mix32.adoc[`lowbias&lowbar;mix32`] 
| Low&hyphen;bias 32 bit mix function&period;
| xref:folly/hash-04/lowbias_unmix32.adoc[`lowbias&lowbar;unmix32`] 
| Inverse of lowbias&lowbar;mix32&period;
| xref:folly/hash-04/moremur_mix64.adoc[`moremur&lowbar;mix64`] 
| Pelle Evensen&apos;s moremur 64 bit mix function&period;
| xref:folly/hash-04/moremur_unmix64.adoc[`moremur&lowbar;unmix64`] 
| Inverse of moremur&lowbar;mix64&period;
| xref:folly/hash-04/murmurHash64.adoc[`murmurHash64`] 
| Implementation of MurmurHash2 hashing algorithm for 64&hyphen;bit platforms&period;
| xref:folly/hash-04/stdCompatibleHash.adoc[`stdCompatibleHash`] 
| Hash a string view compatibly with std&colon;&colon;hash, using a faster murmur&hyphen;based hash where available&period;
| xref:folly/hash-04/twang_32from64.adoc[`twang&lowbar;32from64`] 
| Thomas Wang downscaling hash function&period;
| xref:folly/hash-04/twang_mix64.adoc[`twang&lowbar;mix64`] 
| Thomas Wang 64 bit mix hash function&period;
| xref:folly/hash-04/twang_unmix64.adoc[`twang&lowbar;unmix64`] 
| Inverse of twang&lowbar;mix64&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/fnv32_hash_start.adoc[`fnv32&lowbar;hash&lowbar;start`] 
| FNV&hyphen;1 32&hyphen;bit offset&hyphen;basis seed, the starting value for 32&hyphen;bit FNV hashing&period;
| xref:folly/hash-04/fnv64_hash_start.adoc[`fnv64&lowbar;hash&lowbar;start`] 
| FNV&hyphen;1 64&hyphen;bit offset&hyphen;basis seed, the starting value for 64&hyphen;bit FNV hashing&period;
| xref:folly/hash-04/fnva32_hash_start.adoc[`fnva32&lowbar;hash&lowbar;start`] 
| FNV&hyphen;1a 32&hyphen;bit offset&hyphen;basis seed, the starting value for 32&hyphen;bit FNV&hyphen;1a hashing&period;
| xref:folly/hash-04/fnva64_hash_start.adoc[`fnva64&lowbar;hash&lowbar;start`] 
| FNV&hyphen;1a 64&hyphen;bit offset&hyphen;basis seed, the starting value for 64&hyphen;bit FNV&hyphen;1a hashing&period;
|===


=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/rapidhash.adoc[`rapidhash`] 
| Hash a byte buffer with rapidhash, `uint64&lowbar;t rapidhash(const char&ast; key, size&lowbar;t len)`&period;
| xref:folly/hash-04/rapidhashMicro.adoc[`rapidhashMicro`] 
| Hash a byte buffer with the rapidhashMicro variant, `uint64&lowbar;t rapidhashMicro(const char&ast; key, size&lowbar;t len)`&period;
| xref:folly/hash-04/rapidhashMicro_with_seed.adoc[`rapidhashMicro&lowbar;with&lowbar;seed`] 
| Hash a byte buffer with rapidhashMicro and an explicit seed, `uint64&lowbar;t rapidhashMicro&lowbar;with&lowbar;seed(const char&ast; key, size&lowbar;t len, uint64&lowbar;t seed)`&period;
| xref:folly/hash-04/rapidhashNano.adoc[`rapidhashNano`] 
| Hash a byte buffer with the rapidhashNano variant, `uint64&lowbar;t rapidhashNano(const char&ast; key, size&lowbar;t len)`&period;
| xref:folly/hash-04/rapidhashNano_with_seed.adoc[`rapidhashNano&lowbar;with&lowbar;seed`] 
| Hash a byte buffer with rapidhashNano and an explicit seed, `uint64&lowbar;t rapidhashNano&lowbar;with&lowbar;seed(const char&ast; key, size&lowbar;t len, uint64&lowbar;t seed)`&period;
| xref:folly/hash-04/rapidhash_with_seed.adoc[`rapidhash&lowbar;with&lowbar;seed`] 
| Hash a byte buffer with rapidhash and an explicit seed, `uint64&lowbar;t rapidhash&lowbar;with&lowbar;seed(const char&ast; key, size&lowbar;t len, uint64&lowbar;t seed)`&period;
|===


== xref:folly/hash-04/farmhash.adoc[folly::hash::farmhash] namespace

FarmHash hashing and fingerprinting functions imported from the bundled external implementation&period;

=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/hash-04/farmhash/Fingerprint32.adoc[`Fingerprint32`] 
| Fingerprint a byte buffer to a stable 32&hyphen;bit value, `uint32&lowbar;t Fingerprint32(char const&ast;, std&colon;&colon;size&lowbar;t)`&period;
| xref:folly/hash-04/farmhash/Fingerprint64.adoc[`Fingerprint64`] 
| Fingerprint a byte buffer to a stable 64&hyphen;bit value, `uint64&lowbar;t Fingerprint64(char const&ast;, std&colon;&colon;size&lowbar;t)`&period;
| xref:folly/hash-04/farmhash/Hash.adoc[`Hash`] 
| Hash a byte buffer to a `std&colon;&colon;size&lowbar;t`, `std&colon;&colon;size&lowbar;t Hash(char const&ast;, std&colon;&colon;size&lowbar;t)`&period;
| xref:folly/hash-04/farmhash/Hash32.adoc[`Hash32`] 
| Hash a byte buffer to a 32&hyphen;bit value, `uint32&lowbar;t Hash32(char const&ast;, std&colon;&colon;size&lowbar;t)`&period;
| xref:folly/hash-04/farmhash/Hash64.adoc[`Hash64`] 
| Hash a byte buffer to a 64&hyphen;bit value, `uint64&lowbar;t Hash64(char const&ast;, std&colon;&colon;size&lowbar;t)`&period;
|===


== xref:folly/invoke_detail.adoc[folly::invoke&lowbar;detail] namespace

Implementation details of the folly invocation traits&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/invoke_detail/conv_r_-09.adoc[`conv&lowbar;r&lowbar;`] 
| Tests return&hyphen;type convertibility, specialized on whether the target is void&period;
| xref:folly/invoke_detail/invoke_result-05.adoc[`invoke&lowbar;result`] 
| Holds the result type of invoking `F` with `A&period;&period;&period;`, or is empty if ill&hyphen;formed&period;
| xref:folly/invoke_detail/ok_one_.adoc[`ok&lowbar;one&lowbar;`] 
| Quoted metafunction enforcing that a type is complete, cv&hyphen;void, or unbounded&hyphen;array&period;
| xref:folly/invoke_detail/traits-06.adoc[`traits`] 
| Invocation traits for a callable type `F`&period;
| xref:folly/invoke_detail/traits_member_ptr.adoc[`traits&lowbar;member&lowbar;ptr`] 
| Invocation traits for a pointer&hyphen;to&hyphen;member `P`, via std&colon;&colon;mem&lowbar;fn&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/invoke_detail/invoke_result_t.adoc[`invoke&lowbar;result&lowbar;t`] 
| The result type of invoking `F` with `A&period;&period;&period;`&period;
| xref:folly/invoke_detail/is_nothrow.adoc[`is&lowbar;nothrow`] 
| Bool constant that is true when invoking `P` with `A&period;&period;&period;` is noexcept&period;
| xref:folly/invoke_detail/ok_.adoc[`ok&lowbar;`] 
| Yields `T` when every `A&period;&period;&period;` is complete, cv&hyphen;void, or unbounded&hyphen;array&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/invoke_detail/conv_r_v_.adoc[`conv&lowbar;r&lowbar;v&lowbar;`] 
| True if `FR` converts to `R`, honoring the noexcept requirement `NX`&period;
| xref:folly/invoke_detail/is_invocable_r_v-0a.adoc[`is&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if invoking `F` with `A&period;&period;&period;` yields a result convertible to `R`&period;
| xref:folly/invoke_detail/is_invocable_r_v-0d.adoc[`is&lowbar;invocable&lowbar;r&lowbar;v`] 
| Specialization testing return&hyphen;type convertibility when the invocation is well&hyphen;formed&period;
| xref:folly/invoke_detail/is_invocable_v-0f1.adoc[`is&lowbar;invocable&lowbar;v`] 
| True if `F` is invocable with `A&period;&period;&period;`&period;
| xref:folly/invoke_detail/is_invocable_v-0f6.adoc[`is&lowbar;invocable&lowbar;v`] 
| Specialization yielding true when the invocation is well&hyphen;formed&period;
| xref:folly/invoke_detail/is_nothrow_invocable_r_v-01.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v`] 
| True if a nothrow invocation of `F` yields a result convertible to `R`&period;
| xref:folly/invoke_detail/is_nothrow_invocable_r_v-06.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;r&lowbar;v`] 
| Specialization testing nothrow invocation and return convertibility when well&hyphen;formed&period;
| xref:folly/invoke_detail/is_nothrow_invocable_v-01.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;v`] 
| True if `F` is nothrow&hyphen;invocable with `A&period;&period;&period;`&period;
| xref:folly/invoke_detail/is_nothrow_invocable_v-02.adoc[`is&lowbar;nothrow&lowbar;invocable&lowbar;v`] 
| Specialization yielding the nothrow result when the invocation is well&hyphen;formed&period;
|===


== xref:folly/io.adoc[folly::io] namespace

Cursor and queue utilities for reading and writing IOBuf chains&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/io/Appender.adoc[`Appender`] 
| Append to the end of a buffer chain, growing the chain (by allocating new buffers) in increments of at least growth bytes every time&period; Won&apos;t grow (and push() and ensure() will throw) if growth &equals;&equals; 0&period;
| xref:folly/io/Cursor.adoc[`Cursor`] 
| Read&hyphen;only cursor over an IOBuf chain&period;
| xref:folly/io/CursorBase-048.adoc[`CursorBase`] 
| Base class implementing the shared cursor logic over an IOBuf chain&period;
| xref:folly/io/QueueAppender.adoc[`QueueAppender`] 
| Appender that writes to the end of an IOBufQueue&period;
| xref:folly/io/RWCursor.adoc[`RWCursor`] 
| Read&hyphen;write cursor over an IOBuf chain&period;
| xref:folly/io/ThinCursor.adoc[`ThinCursor`] 
| A register&hyphen;pass facade for a Cursor over an IOBuf chain&period;
| xref:folly/io/Writable-0e.adoc[`Writable`] 
| Mixin providing write operations for cursor types&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/io/RWPrivateCursor.adoc[`RWPrivateCursor`] 
| Read&hyphen;write cursor that assumes private access to the IOBuf chain&period;
| xref:folly/io/RWUnshareCursor.adoc[`RWUnshareCursor`] 
| Read&hyphen;write cursor that unshares (copy&hyphen;on&hyphen;write) buffers before writing&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/io/CloneOwnership.adoc[`CloneOwnership`] 
| Whether a clone may point at buffers that IOBuf does not own&period;
| xref:folly/io/CursorAccess.adoc[`CursorAccess`] 
| Selects whether a read&hyphen;write cursor unshares buffers before writing&period;
|===


== xref:folly/json.adoc[folly::json] namespace

JSON parsing and serialization utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/json/parse_error.adoc[`parse&lowbar;error`] 
| Error thrown when deserializing json (i&period;e&period; converting a string into json)&period;
| xref:folly/json/parse_location.adoc[`parse&lowbar;location`] 
| Source location of a parsed value (may be extended in the future to include offset, column, etc&period;)&period;
| xref:folly/json/parse_metadata.adoc[`parse&lowbar;metadata`] 
| Parse metadata describing where a value&apos;s key and value appear in the source text&period;
| xref:folly/json/parse_range.adoc[`parse&lowbar;range`] 
| Source range of a parsed value (may be extended in the future to include an end location)&period;
| xref:folly/json/print_error.adoc[`print&lowbar;error`] 
| Error thrown when serializing json (i&period;e&period; converting json into a string)&period;
| xref:folly/json/serialization_opts.adoc[`serialization&lowbar;opts`] 
| Options controlling how a dynamic is serialized to and parsed from JSON&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/json/metadata_map.adoc[`metadata&lowbar;map`] 
| Maps each parsed dynamic to its parse metadata&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/json/FloatFormat.adoc[`FloatFormat`] 
| Specifies how to format floating&hyphen;point values in serialized JSON output&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/json/buildExtraAsciiToEscapeBitmap.adoc[`buildExtraAsciiToEscapeBitmap`] 
| Create bitmap for serialization&lowbar;opts&period;extra&lowbar;ascii&lowbar;to&lowbar;escape&lowbar;bitmap&period;
| xref:folly/json/escapeString.adoc[`escapeString`] 
| Escape a string so that it is legal to print it in JSON text&period;
| xref:folly/json/serialize.adoc[`serialize`] 
| Serialize dynamic to json&hyphen;string, with options&period;
| xref:folly/json/stripComments.adoc[`stripComments`] 
| Strip all C99&hyphen;like comments (i&period;e&period; &sol;&sol; and &sol; &ast; &period;&period;&period; &ast; &sol;)
|===


== xref:folly/jsonschema.adoc[folly::jsonschema] namespace

JSON Schema (draft v4) validation utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/jsonschema/Validator.adoc[`Validator`] 
| Interface for a schema validator&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/jsonschema/makeSchemaValidator.adoc[`makeSchemaValidator`] 
| Makes a validator for schemas&period; You should probably check your schema with this before you use makeValidator()&period;
| xref:folly/jsonschema/makeValidator.adoc[`makeValidator`] 
| Make a validator that can be used to check various json&period; Thread&hyphen;safe&period;
|===


== xref:folly/libcpp_detail.adoc[folly::libcpp&lowbar;detail] namespace

Implementation details for libc&plus;&plus; bitset support&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/libcpp_detail/std_bit_reference_layout.adoc[`std&lowbar;bit&lowbar;reference&lowbar;layout`] 
| Memory layout mirroring libc&plus;&plus;&apos;s `std&colon;&colon;&lowbar;&lowbar;bit&lowbar;reference`&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/libcpp_detail/get_underlying_data_region.adoc[`get&lowbar;underlying&lowbar;data&lowbar;region`] 
| Return the content of the 64&hyphen;bit word, given an index&period;
| xref:folly/libcpp_detail/std_bitset_find_next.adoc[`std&lowbar;bitset&lowbar;find&lowbar;next`] 
| Return the index of the first set bit in a bitset at or after an index&period;
|===


== xref:folly/logging.adoc[folly::logging] namespace

Folly&apos;s logging library&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/logging/BridgeFromGoogleLogging.adoc[`BridgeFromGoogleLogging`] 
| Class to bridge GLOG to folly logging&period;
| xref:folly/logging/IntervalRateLimiter.adoc[`IntervalRateLimiter`] 
| Rate limiter allowing up to N events per fixed window of M milliseconds&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/logging/appendRawObjectInfo.adoc[`appendRawObjectInfo`] 
| Append raw information about an object to a string&period;
| xref:folly/logging/appendToString-00.adoc[`appendToString`] 
| `appendToString` overloads
| xref:folly/logging/objectToString.adoc[`objectToString`] 
| Convert an arbitrary object to a string for logging purposes&period;
|===


== xref:folly/memory.adoc[folly::memory] namespace

Memory management utilities&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/memory/makeIOBufArenaFactory.adoc[`makeIOBufArenaFactory`] 
| Builds an IOBuf factory backed by the given singleton allocator&period;
|===


=== Concepts

[cols="1,4"]
|===
| Name| Description
| xref:folly/memory/IOBufSingletonAllocator.adoc[`IOBufSingletonAllocator`] 
| Requirements for a singleton allocator usable with an IOBuf arena factory&period;
|===


== xref:folly/moveonly_.adoc[folly::moveonly&lowbar;] namespace

Internal namespace hosting the copy&sol;move control base types&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/moveonly_/Default.adoc[`Default`] 
| Empty base that permits both copy and move&period;
| xref:folly/moveonly_/MoveOnly.adoc[`MoveOnly`] 
| Disallow copy but not move in derived types&period; This is essentially boost&colon;&colon;noncopyable (the implementation is almost identical), except&colon; 1) It doesn&apos;t delete move constructor and move assignment&period; 2) It has public methods, enabling aggregate initialization&period;
| xref:folly/moveonly_/NonCopyableNonMovable.adoc[`NonCopyableNonMovable`] 
| Disallow copy and move for derived types&period; This is essentially boost&colon;&colon;noncopyable (the implementation is almost identical), except it has public methods, enabling aggregate initialization&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/moveonly_/EnableCopyMove.adoc[`EnableCopyMove`] 
| Base type selecting copy&sol;move capabilities from the given flags&period;
|===


== xref:folly/netops.adoc[folly::netops] namespace

Cross&hyphen;platform socket operation wrappers&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/netops/Dispatcher.adoc[`Dispatcher`] 
| Dispatcher for netops&colon;&colon; calls&period;
| xref:folly/netops/DispatcherContainer.adoc[`DispatcherContainer`] 
| Container for netops&colon;&colon;Dispatcher&period;
| xref:folly/netops/Msgheader.adoc[`Msgheader`] 
| A msghdr&sol;WSAMSG struct wrapper for cross&hyphen;platform use&period;
| xref:folly/netops/PollDescriptor.adoc[`PollDescriptor`] 
| Poll descriptor is intended to be byte&hyphen;for&hyphen;byte identical to pollfd, except that it is typed as containing a NetworkSocket for sane interactions&period;
| xref:folly/netops/sock_txtime.adoc[`sock&lowbar;txtime`] 
| 
| xref:folly/netops/tcp_zerocopy_receive.adoc[`tcp&lowbar;zerocopy&lowbar;receive`] 
| 
| xref:folly/netops/xdp_umem_reg.adoc[`xdp&lowbar;umem&lowbar;reg`] 
| 
| xref:folly/netops/xsk_tx_metadata.adoc[`xsk&lowbar;tx&lowbar;metadata`] 
| 
|===


=== Enums

[cols="1"]
|===
| Name
| xref:folly/netops/timestamping_flags.adoc[`timestamping&lowbar;flags`] 
| xref:folly/netops/tstamp_flags.adoc[`tstamp&lowbar;flags`] 
| xref:folly/netops/txtime_flags.adoc[`txtime&lowbar;flags`] 
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/netops/accept.adoc[`accept`] 
| Accepts a connection on a listening socket&period;
| xref:folly/netops/bind.adoc[`bind`] 
| Binds a socket to a local address&period;
| xref:folly/netops/close.adoc[`close`] 
| Closes a socket&period;
| xref:folly/netops/connect.adoc[`connect`] 
| Connects a socket to a remote address&period;
| xref:folly/netops/getpeername.adoc[`getpeername`] 
| Retrieves the address of the connected peer&period;
| xref:folly/netops/getsockname.adoc[`getsockname`] 
| Retrieves the local address bound to a socket&period;
| xref:folly/netops/getsockopt.adoc[`getsockopt`] 
| Retrieves a socket option&period;
| xref:folly/netops/inet_aton.adoc[`inet&lowbar;aton`] 
| Converts an IPv4 dotted&hyphen;decimal string to a network address&period;
| xref:folly/netops/listen.adoc[`listen`] 
| Marks a socket as accepting connections&period;
| xref:folly/netops/poll.adoc[`poll`] 
| Waits for events on a set of poll descriptors&period;
| xref:folly/netops/recv.adoc[`recv`] 
| Receives data from a connected socket&period;
| xref:folly/netops/recvfrom.adoc[`recvfrom`] 
| Receives data and records the source address&period;
| xref:folly/netops/recvmmsg.adoc[`recvmmsg`] 
| Receives multiple messages in a single call&period;
| xref:folly/netops/recvmsg.adoc[`recvmsg`] 
| Receives a message, including ancillary data&period;
| xref:folly/netops/send.adoc[`send`] 
| Sends data on a connected socket&period;
| xref:folly/netops/sendmmsg.adoc[`sendmmsg`] 
| Sends multiple messages in a single call&period;
| xref:folly/netops/sendmsg.adoc[`sendmsg`] 
| Sends a message, including ancillary data&period;
| xref:folly/netops/sendto.adoc[`sendto`] 
| Sends data to a specific destination address&period;
| xref:folly/netops/set_socket_blocking.adoc[`set&lowbar;socket&lowbar;blocking`] 
| Puts a socket into blocking mode&period;
| xref:folly/netops/set_socket_close_on_exec.adoc[`set&lowbar;socket&lowbar;close&lowbar;on&lowbar;exec`] 
| Sets the close&hyphen;on&hyphen;exec flag on a socket&period;
| xref:folly/netops/set_socket_non_blocking.adoc[`set&lowbar;socket&lowbar;non&lowbar;blocking`] 
| Puts a socket into non&hyphen;blocking mode&period;
| xref:folly/netops/setsockopt.adoc[`setsockopt`] 
| Sets a socket option&period;
| xref:folly/netops/shutdown.adoc[`shutdown`] 
| Shuts down part or all of a full&hyphen;duplex connection&period;
| xref:folly/netops/socket.adoc[`socket`] 
| Creates a socket&period;
| xref:folly/netops/socketpair.adoc[`socketpair`] 
| Creates a connected pair of sockets&period;
|===


== xref:folly/numbers.adoc[folly::numbers] namespace

numbers

=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/numbers/e.adoc[`e`] 
| e
| xref:folly/numbers/e_v.adoc[`e&lowbar;v`] 
| e&lowbar;v
| xref:folly/numbers/ln2.adoc[`ln2`] 
| ln2
| xref:folly/numbers/ln2_v.adoc[`ln2&lowbar;v`] 
| ln2&lowbar;v
|===


== xref:folly/observer.adoc[folly::observer] namespace

Folly&apos;s observer library&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/observer/AtomicObserver.adoc[`AtomicObserver`] 
| An AtomicObserver provides read&hyphen;optimized caching for an Observer using `std&colon;&colon;atomic`&period; Reading only requires atomic loads unless the cached value is stale&period; If the cache needs to be refreshed, a mutex is used to synchronize the update&period; This avoids creating a shared&lowbar;ptr for every read&period;
| xref:folly/observer/CallbackHandle.adoc[`CallbackHandle`] 
| Owns a callback subscription to an Observer&period;
| xref:folly/observer/CoreCachedObserver.adoc[`CoreCachedObserver`] 
| A read&hyphen;optimized observer that caches an observer&apos;s snapshot with core&hyphen;local sharing&period;
| xref:folly/observer/HazptrObserver.adoc[`HazptrObserver`] 
| HazptrObserver implements a read&hyphen;optimized Observer which caches an Observer&apos;s snapshot and protects access to it using hazptrs&period; The cached snapshot is kept up to date using a callback which fires when the original observer changes&period; This implementation incurs an additional allocation on updates making it less suitable for write&hyphen;heavy workloads&period;
| xref:folly/observer/ObservableTraits.adoc[`ObservableTraits`] 
| Default traits describing how to read from and subscribe to an observable&period;
| xref:folly/observer/Observer.adoc[`Observer`] 
| Observer &hyphen; a library which lets you create objects which track updates of their dependencies and get re&hyphen;computed when any of the dependencies changes&period;
| xref:folly/observer/ObserverCreator.adoc[`ObserverCreator`] 
| Creates an `Observer` from an observable using the given traits&period;
| xref:folly/observer/ObserverTraits-04.adoc[`ObserverTraits`] 
| Maps a value type to the observer type used to cache it&period;
| xref:folly/observer/ReadMostlyAtomicObserver.adoc[`ReadMostlyAtomicObserver`] 
| A ReadMostlyAtomicObserver guarantees that reading is exactly one relaxed atomic load and a read from a thread local bool&period; Like AtomicObserver, the value is cached using `std&colon;&colon;atomic`&period; However, there is no version check when reading which means that the cached value may be out&hyphen;of&hyphen;date with the Observer value&period; The cached value will be updated asynchronously in a background thread&period;
| xref:folly/observer/ReadMostlyTLObserver.adoc[`ReadMostlyTLObserver`] 
| A TLObserver that optimizes for getting a shared&lowbar;ptr&hyphen;like pointer to data&period;
| xref:folly/observer/SimpleObservable.adoc[`SimpleObservable`] 
| An observable whose value is set manually and read through an `Observer`&period;
| xref:folly/observer/Snapshot.adoc[`Snapshot`] 
| A stable view of an observed value at a point in time&period;
| xref:folly/observer/TLObserver.adoc[`TLObserver`] 
| A TLObserver provides read&hyphen;optimized caching for an Observer using thread&hyphen;local storage&period; This avoids creating a shared&lowbar;ptr for every read&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/observer/ObserverT.adoc[`ObserverT`] 
| Alias for the observer type selected by ObserverTraits&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/observer/makeAtomicObserver-0c.adoc[`makeAtomicObserver`] 
| `makeAtomicObserver` overloads
| xref:folly/observer/makeCoreCachedObserver-05.adoc[`makeCoreCachedObserver`] 
| `makeCoreCachedObserver` overloads
| xref:folly/observer/makeHazptrObserver-06.adoc[`makeHazptrObserver`] 
| `makeHazptrObserver` overloads
| xref:folly/observer/makeObserver-00.adoc[`makeObserver`] 
| `makeObserver` overloads
| xref:folly/observer/makeReadMostlyAtomicObserver-00.adoc[`makeReadMostlyAtomicObserver`] 
| `makeReadMostlyAtomicObserver` overloads
| xref:folly/observer/makeReadMostlyTLObserver-09.adoc[`makeReadMostlyTLObserver`] 
| `makeReadMostlyTLObserver` overloads
| xref:folly/observer/makeStaticObserver-09.adoc[`makeStaticObserver`] 
| `makeStaticObserver` overloads
| xref:folly/observer/makeTLObserver-04.adoc[`makeTLObserver`] 
| `makeTLObserver` overloads
| xref:folly/observer/makeValueObserver-0e.adoc[`makeValueObserver`] 
| `makeValueObserver` overloads
| xref:folly/observer/unwrap-02.adoc[`unwrap`] 
| `unwrap` overloads
| xref:folly/observer/unwrapValue-0e.adoc[`unwrapValue`] 
| `unwrapValue` overloads
| xref:folly/observer/withJitter.adoc[`withJitter`] 
| The returned Observer will proxy updates from the input observer but will delay the propagation of each update by some duration between 0 ms and lag &plus; jitter&period; In addition, if an update arrives while no preceding jittered updates are still in flight, then the delay applied to the latest update will be a uniformly random duration between lag &hyphen; jitter and lag &plus; jitter&period;
|===


== xref:folly/observer_detail.adoc[folly::observer&lowbar;detail] namespace

Implementation details&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/observer_detail/Core.adoc[`Core`] 
| Core stores the current version of the object held by Observer&period; It also keeps all dependencies and dependents of the Observer&period;
| xref:folly/observer_detail/GraphCycleDetector.adoc[`GraphCycleDetector`] 
| Tracks directed edges and rejects any that would introduce a cycle&period;
| xref:folly/observer_detail/NonObserver-0d.adoc[`NonObserver`] 
| Yields the decayed type unless `T` is an `Observer`, in which case it is empty&period;
| xref:folly/observer_detail/NonSharedPtr-0a.adoc[`NonSharedPtr`] 
| Yields the decayed type unless `T` is a `shared&lowbar;ptr`, in which case it is empty&period;
| xref:folly/observer_detail/Unwrap-09.adoc[`Unwrap`] 
| Removes an `Observer` wrapper from a type, if present&period;
| xref:folly/observer_detail/UnwrapObserver-03.adoc[`UnwrapObserver`] 
| Extracts the value type from an `Observer`&semi; empty for other types&period;
| xref:folly/observer_detail/UnwrapSharedPtr-07.adoc[`UnwrapSharedPtr`] 
| Extracts the element type from a `shared&lowbar;ptr`&semi; empty for other types&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/observer_detail/ResultOf.adoc[`ResultOf`] 
| The result of invoking `F`, with any `shared&lowbar;ptr` or `Observer` wrapper removed&period;
| xref:folly/observer_detail/ResultOfNoObserverUnwrap.adoc[`ResultOfNoObserverUnwrap`] 
| The result of invoking `F`, with any `shared&lowbar;ptr` wrapper removed&period;
| xref:folly/observer_detail/ResultOfUnwrapObserver.adoc[`ResultOfUnwrapObserver`] 
| The `Observer` value type produced by invoking `F`&period;
| xref:folly/observer_detail/ResultOfUnwrapSharedPtr.adoc[`ResultOfUnwrapSharedPtr`] 
| The `shared&lowbar;ptr` element type produced by invoking `F`&period;
|===


== xref:folly/padded.adoc[folly::padded] namespace

Utilities for storing data aligned on block (possibly cache&hyphen;line) boundaries, with optional padding&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/padded/Adaptor.adoc[`Adaptor`] 
| Adaptor around a STL sequence container&period;
| xref:folly/padded/Iterator.adoc[`Iterator`] 
| Wrapper around iterators to Node to return iterators to the underlying node elements&period;
| xref:folly/padded/Node.adoc[`Node`] 
| A Node is a fixed&hyphen;size container of as many objects of type T as would fit in a region of memory of size NS&period; The last NS % sizeof(T) bytes are ignored and uninitialized&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/padded/begin-0f0.adoc[`begin`] 
| `begin` overloads
| xref:folly/padded/cbegin.adoc[`cbegin`] 
| Given a container to Node, return iterators to the first element in the first Node &sol; one past the last element in the last Node&period; Note that the last node is assumed to be full&semi; if that&apos;s not the case, subtract from end() as appropriate&period;
| xref:folly/padded/cend.adoc[`cend`] 
| Returns a const element iterator one past the last element in the last Node&period;
| xref:folly/padded/end-05.adoc[`end`] 
| `end` overloads
|===


== xref:folly/pmr.adoc[folly::pmr] namespace

Aliases that use a polymorphic allocator&period;

=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/pmr/F14FastMap.adoc[`F14FastMap`] 
| F14FastMap specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14FastSet.adoc[`F14FastSet`] 
| F14FastSet specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14NodeMap.adoc[`F14NodeMap`] 
| F14NodeMap specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14NodeSet.adoc[`F14NodeSet`] 
| F14NodeSet specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14ValueMap.adoc[`F14ValueMap`] 
| F14ValueMap specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14ValueSet.adoc[`F14ValueSet`] 
| F14ValueSet specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14VectorMap.adoc[`F14VectorMap`] 
| F14VectorMap specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/F14VectorSet.adoc[`F14VectorSet`] 
| F14VectorSet specialized to use a std&colon;&colon;pmr polymorphic allocator&period;
| xref:folly/pmr/heap_vector_map.adoc[`heap&lowbar;vector&lowbar;map`] 
| A heap&lowbar;vector&lowbar;map that uses a polymorphic allocator&period;
| xref:folly/pmr/heap_vector_set.adoc[`heap&lowbar;vector&lowbar;set`] 
| A heap&lowbar;vector&lowbar;set that uses a polymorphic allocator&period;
| xref:folly/pmr/sorted_vector_map.adoc[`sorted&lowbar;vector&lowbar;map`] 
| A sorted&lowbar;vector&lowbar;map that uses a polymorphic allocator&period;
| xref:folly/pmr/sorted_vector_set.adoc[`sorted&lowbar;vector&lowbar;set`] 
| A sorted&lowbar;vector&lowbar;set that uses a polymorphic allocator&period;
| xref:folly/pmr/vector_bool.adoc[`vector&lowbar;bool`] 
| Alias for `vector&lowbar;bool` using a polymorphic allocator&period;
|===


== xref:folly/poly-07.adoc[folly::poly] namespace

Interfaces and helpers for the `Poly` type&hyphen;erasure utility&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/poly-07/IBooleanTestable.adoc[`IBooleanTestable`] 
| A `Poly` interface that can be used to make `Poly` objects contextually convertible to `bool` (`true` if and only if non&hyphen;empty)&period; It also gives `Poly` objects a unary logical negation operator&period;
| xref:folly/poly-07/IEqualityComparable.adoc[`IEqualityComparable`] 
| A `Poly` interface for types that are equality comparable&period;
| xref:folly/poly-07/IMoveOnly.adoc[`IMoveOnly`] 
| A `Poly` interface for types that are move&hyphen;only&period;
| xref:folly/poly-07/INullablePointer.adoc[`INullablePointer`] 
| A `Poly` interface that can be used to make Poly objects initializable from `nullptr` (to create an empty `Poly`) and equality comparable to `nullptr` (to test for emptiness)&period;
| xref:folly/poly-07/IRegular.adoc[`IRegular`] 
| A `Poly` interface for types that are copyable, movable, and equality comparable&period;
| xref:folly/poly-07/ISemiRegular.adoc[`ISemiRegular`] 
| A `Poly` interface for types that are copyable and movable&period;
| xref:folly/poly-07/IStrictlyOrderable.adoc[`IStrictlyOrderable`] 
| A `Poly` interface for types that are strictly orderable&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/poly-07/operator_eq-0a.adoc[`operator&equals;&equals;`] 
| Tests whether a `Poly` object is empty&period;
| xref:folly/poly-07/operator_not_eq-0e.adoc[`operator!&equals;`] 
| Tests whether a `Poly` object is non&hyphen;empty&period;
|===


== xref:folly/portability.adoc[folly::portability] namespace

Portability shims for platform&hyphen;specific system interfaces&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/portability/sockets.adoc[`sockets`] 
| Portable wrappers and imports for BSD socket functions&period;
| xref:folly/portability/stdlib.adoc[`stdlib`] 
| Portable wrappers and imports for C standard library routines&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/portability/internal_dirname.adoc[`internal&lowbar;dirname`] 
| Returns the directory portion of a path, without modifying the input&period;
|===


== xref:folly/portability/sockets.adoc[folly::portability::sockets] namespace

Portable wrappers and imports for BSD socket functions&period;

=== Using Declarations

[cols="1,4"]
|===
| Name| Description
| xref:folly/portability/sockets/accept.adoc[`accept`] 
| Imported global `accept`&period;
| xref:folly/portability/sockets/bind.adoc[`bind`] 
| Imported global `bind`&period;
| xref:folly/portability/sockets/connect.adoc[`connect`] 
| Imported global `connect`&period;
| xref:folly/portability/sockets/getpeername.adoc[`getpeername`] 
| Imported global `getpeername`&period;
| xref:folly/portability/sockets/getsockname.adoc[`getsockname`] 
| Imported global `getsockname`&period;
| xref:folly/portability/sockets/getsockopt.adoc[`getsockopt`] 
| Imported global `getsockopt`&period;
| xref:folly/portability/sockets/inet_ntop.adoc[`inet&lowbar;ntop`] 
| Imported global `inet&lowbar;ntop`&period;
| xref:folly/portability/sockets/listen.adoc[`listen`] 
| Imported global `listen`&period;
| xref:folly/portability/sockets/poll.adoc[`poll`] 
| Imported global `poll`&period;
| xref:folly/portability/sockets/recv.adoc[`recv`] 
| Imported global `recv`&period;
| xref:folly/portability/sockets/recvfrom.adoc[`recvfrom`] 
| Imported global `recvfrom`&period;
| xref:folly/portability/sockets/send.adoc[`send`] 
| Imported global `send`&period;
| xref:folly/portability/sockets/sendmsg.adoc[`sendmsg`] 
| Imported global `sendmsg`&period;
| xref:folly/portability/sockets/sendto.adoc[`sendto`] 
| Imported global `sendto`&period;
| xref:folly/portability/sockets/setsockopt.adoc[`setsockopt`] 
| Imported global `setsockopt`&period;
| xref:folly/portability/sockets/shutdown.adoc[`shutdown`] 
| Imported global `shutdown`&period;
| xref:folly/portability/sockets/socket.adoc[`socket`] 
| Imported global `socket`&period;
|===


== xref:folly/portability/stdlib.adoc[folly::portability::stdlib] namespace

Portable wrappers and imports for C standard library routines&period;

== xref:folly/recordio_helpers.adoc[folly::recordio&lowbar;helpers] namespace

Low&hyphen;level helpers exposing the RecordIO record format&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/recordio_helpers/RecordInfo.adoc[`RecordInfo`] 
| A record and the file id it was written with&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/recordio_helpers/findRecord-04.adoc[`findRecord`] 
| `findRecord` overloads
| xref:folly/recordio_helpers/headerSize.adoc[`headerSize`] 
| Header size&period;
| xref:folly/recordio_helpers/prependHeader.adoc[`prependHeader`] 
| Write a header in the buffer&period; We will prepend the header to the front of the chain&period; Do not write the buffer if empty (we don&apos;t allow empty records)&period; Returns the total length, including header (0 if empty) (same as buf&hyphen;&gt;computeChainDataLength(), but likely faster)
| xref:folly/recordio_helpers/validateRecord.adoc[`validateRecord`] 
| Check if there is a valid record at the beginning of range&period; This validates both record header and data and Returns the record data (not the header) if the record is valid, ByteRange() otherwise&period;
| xref:folly/recordio_helpers/validateRecordData.adoc[`validateRecordData`] 
| Check if there Record Data is valid (to be used after validating the header separately) Returns the record data (not the header) if the record data is valid, ByteRange() otherwise&period;
| xref:folly/recordio_helpers/validateRecordHeader.adoc[`validateRecordHeader`] 
| Check if the Record Header is valid at the beginning of range&period; Useful to check the validity of the header before building the entire record in IOBuf&period; If the record is from storage device (e&period;g&period; flash) then, it is better to make sure that the header is valid before reading the data from the storage device&period; Returns true if valid, false otherwise&period;
|===


== xref:folly/replaceable_detail.adoc[folly::replaceable&lowbar;detail] namespace

Implementation details for `Replaceable`&semi; not part of the public API&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/replaceable_detail/copy_assignment_mixin-0e.adoc[`copy&lowbar;assignment&lowbar;mixin`] 
| Mixin supplying the copy&hyphen;assignment operator for `Replaceable&lt;T&gt;` that matches the corresponding properties of `T`&period;
| xref:folly/replaceable_detail/copy_ctor_mixin-0c.adoc[`copy&lowbar;ctor&lowbar;mixin`] 
| Mixin supplying the copy constructor for `Replaceable&lt;T&gt;` that matches the copy&hyphen;constructibility of `T`&period;
| xref:folly/replaceable_detail/default_and_move_ctor_mixin-01.adoc[`default&lowbar;and&lowbar;move&lowbar;ctor&lowbar;mixin`] 
| Mixin supplying default and move constructors for `Replaceable&lt;T&gt;` that match the corresponding properties of `T`&period;
| xref:folly/replaceable_detail/dtor_mixin-06ea.adoc[`dtor&lowbar;mixin`] 
| Mixin supplying a destructor for `Replaceable&lt;T&gt;` that matches the destructibility of `T`&period;
| xref:folly/replaceable_detail/is_constructible_from_replaceable.adoc[`is&lowbar;constructible&lowbar;from&lowbar;replaceable`] 
| Trait that is true if `T` is constructible from any `Replaceable&lt;T&gt;` reference&period;
| xref:folly/replaceable_detail/is_convertible_from_replaceable.adoc[`is&lowbar;convertible&lowbar;from&lowbar;replaceable`] 
| Trait that is true if any `Replaceable&lt;T&gt;` reference is convertible to `T`&period;
| xref:folly/replaceable_detail/move_assignment_mixin-09.adoc[`move&lowbar;assignment&lowbar;mixin`] 
| Mixin supplying the move&hyphen;assignment operator for `Replaceable&lt;T&gt;` that matches the corresponding properties of `T`&period;
|===


== xref:folly/settings.adoc[folly::settings] namespace

Runtime configuration settings framework&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/settings/CommandLineParser.adoc[`CommandLineParser`] 
| Parses command line arguments into folly&colon;&colon;settings&period;
| xref:folly/settings/FrozenSettingProjects-06.adoc[`FrozenSettingProjects`] 
| An immutable snapshot of the set of frozen setting projects&period;
| xref:folly/settings/ISettingsAccessorProxy.adoc[`ISettingsAccessorProxy`] 
| Interface for applying string&hyphen;based setting changes to a snapshot&period;
| xref:folly/settings/SettingMetadata.adoc[`SettingMetadata`] 
| Static information about the setting definition
| xref:folly/settings/SettingValueAndMetadata.adoc[`SettingValueAndMetadata`] 
| Type containing the string representation of a setting as well as the static metadata associated with it&period; Used as the &quot;source&quot; in setting conversion&period;
| xref:folly/settings/SettingsAccessorProxy.adoc[`SettingsAccessorProxy`] 
| This class is a proxy for working with folly&colon;&colon;settings represented as strings&period; It can apply changes to these folly&colon;&colon;settings via snapshot provided by user&period; Changes are not going to be published by this class, it is callers resposibility to commit&sol;publish cahnges from snapshot into global state&period;
| xref:folly/settings/Snapshot.adoc[`Snapshot`] 
| Captures the current state of all setting values and allows updating multiple settings at once, with verification and rollback&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/settings/SetResult.adoc[`SetResult`] 
| Result of a setting update operation&colon; Unit on success or a SetErrorCode&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/settings/ArgParsingResult.adoc[`ArgParsingResult`] 
| Outcome of parsing command line arguments&period;
| xref:folly/settings/CommandLine.adoc[`CommandLine`] 
| Indicates whether a setting accepts overrides from the command line&period;
| xref:folly/settings/Mutability.adoc[`Mutability`] 
| Indicates whether a setting can change after initialization&period;
| xref:folly/settings/SetErrorCode.adoc[`SetErrorCode`] 
| Error codes for a failed setting update&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/settings/convertTo.adoc[`convertTo`] 
| Like parseTo in folly&sol;Conv&period;h, but the &quot;source&quot; is SettingValueAndMetadata instead of a StringPiece&period; Defaults to folly&colon;&colon;tryTo&lt;T&gt;(StringPiece) but can be overridden using ADL for user defined types&period;
| xref:folly/settings/freezeImmutables.adoc[`freezeImmutables`] 
| Freezes immutable settings &hyphen; preventing subsequent mutation attempts&period; It&apos;s up to the caller to call this function after settings have been initialized&period;
| xref:folly/settings/frozenSettingProjects-0b.adoc[`frozenSettingProjects`] 
| Returns a snapshot of the current set of frozen setting projects&period;
| xref:folly/settings/getAllSettingsMeta.adoc[`getAllSettingsMeta`] 
| Returns the metadata for all registered settings in the process&period;
| xref:folly/settings/getDefaultValue.adoc[`getDefaultValue`] 
| Returns the default value of a setting by name, if it exists and has type T&period;
| xref:folly/settings/getObserver.adoc[`getObserver`] 
| Gets a folly&colon;&colon;observer&colon;&colon;Observer&lt;T&gt; for a given setting&period; For example&colon; folly&colon;&colon;settings&colon;&colon;getObserver(FOLLY&lowbar;SETTING(project, retention))
| xref:folly/settings/getSettingsMeta.adoc[`getSettingsMeta`] 
| Returns the metadata for a setting by name, if it exists&period;
| xref:folly/settings/immutablesFrozen.adoc[`immutablesFrozen`] 
| Reports whether immutable settings for a project have been frozen&period;
| xref:folly/settings/parseCommandLineArguments.adoc[`parseCommandLineArguments`] 
| Main function to parse arguments folly&colon;&colon;settings&period; This function parses command line arguments into folly&colon;&colon;settings&period; It moves all positional, &hyphen;&hyphen;help, not recognized flags and their values to the end of the argv array&period; It stops parsing arguments after &apos;&hyphen;&hyphen;&apos; is encoutered&period;
| xref:folly/settings/printHelpIfNeeded.adoc[`printHelpIfNeeded`] 
| Outputs help message into stderr&period; May terminate program if error was encoutered during arguments parsing or exit is requested by caller&period;
| xref:folly/settings/to.adoc[`to`] 
| Converts a setting value and metadata to type T, throwing on error&period;
| xref:folly/settings/toString.adoc[`toString`] 
| Returns the string representation of a set error code&period;
| xref:folly/settings/tryTo.adoc[`tryTo`] 
| Conversion functions for converting a SettingValueAndMetadata to a setting type T&period; Implementation is similar to folly&sol;Conv and allows for customization using the convertTo function above&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/settings/kHelpFlag.adoc[`kHelpFlag`] 
| Name of the command line flag that requests the help message&period;
|===


== xref:folly/shared_mutex_detail.adoc[folly::shared&lowbar;mutex&lowbar;detail] namespace

Implementation details for SharedMutex&semi; not part of the public API&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/shared_mutex_detail/NopOwnershipTracker.adoc[`NopOwnershipTracker`] 
| Ownership tracker that records nothing&period;
| xref:folly/shared_mutex_detail/PolicySuppressTSAN.adoc[`PolicySuppressTSAN`] 
| Policy that suppresses ThreadSanitizer rwlock annotations&period;
| xref:folly/shared_mutex_detail/PolicyTracked.adoc[`PolicyTracked`] 
| Policy that enables tracking the id of the thread holding the lock&period;
| xref:folly/shared_mutex_detail/ThreadIdOwnershipTracker.adoc[`ThreadIdOwnershipTracker`] 
| Ownership tracker that records the id of the owning thread&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/shared_mutex_detail/annotationGuard.adoc[`annotationGuard`] 
| Returns a guard that gives permission for the current thread to annotate, and adjust the annotation bits in, the SharedMutex at ptr&period;
| xref:folly/shared_mutex_detail/getCurrentThreadInvoluntaryContextSwitchCount.adoc[`getCurrentThreadInvoluntaryContextSwitchCount`] 
| Returns the number of involuntary context switches for the current thread&period;
| xref:folly/shared_mutex_detail/getMaxDeferredReaders.adoc[`getMaxDeferredReaders`] 
| Returns the current maximum number of deferred readers&period;
| xref:folly/shared_mutex_detail/getMaxDeferredReadersSlow.adoc[`getMaxDeferredReadersSlow`] 
| Computes and caches the current maximum number of deferred readers&period;
| xref:folly/shared_mutex_detail/throwDeadlockWouldOccur.adoc[`throwDeadlockWouldOccur`]  [.small]#[noreturn]#
| Throws a system error indicating a deadlock would occur&period;
| xref:folly/shared_mutex_detail/throwOperationNotPermitted.adoc[`throwOperationNotPermitted`]  [.small]#[noreturn]#
| Throws a system error indicating the operation is not permitted&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/shared_mutex_detail/kMaxDeferredReadersAllocated.adoc[`kMaxDeferredReadersAllocated`] 
| Upper bound on the number of deferred reader slots that may be allocated&period;
|===


== xref:folly/simd.adoc[folly::simd] namespace

SIMD algorithms and utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/simd/composite_finder_first_of.adoc[`composite&lowbar;finder&lowbar;first&lowbar;of`] 
| composite&lowbar;finder
| xref:folly/simd/ignore_extrema.adoc[`ignore&lowbar;extrema`] 
| ignore(&lowbar;none&sol;&lowbar;extrema)
| xref:folly/simd/ignore_none.adoc[`ignore&lowbar;none`] 
| Tag type indicating that the whole register is used&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/simd/azmatch_vector_finder_first_not_of.adoc[`azmatch&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The SIMD azmatch&hyphen;based find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/azmatch_vector_finder_first_of.adoc[`azmatch&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| The SIMD azmatch&hyphen;based find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/basic_azmatch_vector_finder_first_not_of.adoc[`basic&lowbar;azmatch&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the SIMD azmatch&hyphen;based find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_azmatch_vector_finder_first_of.adoc[`basic&lowbar;azmatch&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the SIMD azmatch&hyphen;based find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_default_scalar_finder_first_not_of.adoc[`basic&lowbar;default&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the default scalar find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_default_scalar_finder_first_of.adoc[`basic&lowbar;default&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the default scalar find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_default_vector_finder_first_not_of.adoc[`basic&lowbar;default&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the SIMD&hyphen;accelerated default find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_default_vector_finder_first_of.adoc[`basic&lowbar;default&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the SIMD&hyphen;accelerated default find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_ltindex_scalar_finder_first_not_of.adoc[`basic&lowbar;ltindex&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the lookup&hyphen;table&hyphen;indexed scalar find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_ltindex_scalar_finder_first_of.adoc[`basic&lowbar;ltindex&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the lookup&hyphen;table&hyphen;indexed scalar find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_ltsparse_scalar_finder_first_not_of.adoc[`basic&lowbar;ltsparse&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the sparse lookup&hyphen;table scalar find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_ltsparse_scalar_finder_first_of.adoc[`basic&lowbar;ltsparse&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the sparse lookup&hyphen;table scalar find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_rngfind_vector_finder_first_of.adoc[`basic&lowbar;rngfind&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| Find&hyphen;first&hyphen;of finder that wraps folly&colon;&colon;Range&colon;&colon;find&lowbar;first&lowbar;of&period;
| xref:folly/simd/basic_shuffle_vector_finder_first_not_of.adoc[`basic&lowbar;shuffle&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| Alias for the SIMD shuffle&hyphen;based find&hyphen;first&hyphen;not&hyphen;of finder&period;
| xref:folly/simd/basic_shuffle_vector_finder_first_of.adoc[`basic&lowbar;shuffle&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the SIMD shuffle&hyphen;based find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/basic_stdfind_scalar_finder_first_of.adoc[`basic&lowbar;stdfind&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| Alias for the std&colon;&colon;find&lowbar;first&lowbar;of based scalar find&hyphen;first&hyphen;of finder&period;
| xref:folly/simd/default_scalar_finder_first_not_of.adoc[`default&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The default scalar find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/default_scalar_finder_first_of.adoc[`default&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| The default scalar find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/default_vector_finder_first_not_of.adoc[`default&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The SIMD&hyphen;accelerated default find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/default_vector_finder_first_of.adoc[`default&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| The SIMD&hyphen;accelerated default find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/ltindex_scalar_finder_first_not_of.adoc[`ltindex&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The lookup&hyphen;table&hyphen;indexed scalar find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/ltindex_scalar_finder_first_of.adoc[`ltindex&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| The lookup&hyphen;table&hyphen;indexed scalar find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/ltsparse_scalar_finder_first_not_of.adoc[`ltsparse&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The sparse lookup&hyphen;table scalar find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/ltsparse_scalar_finder_first_of.adoc[`ltsparse&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| The sparse lookup&hyphen;table scalar find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/rngfind_vector_finder_first_of.adoc[`rngfind&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| Range&hyphen;based find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/shuffle_vector_finder_first_not_of.adoc[`shuffle&lowbar;vector&lowbar;finder&lowbar;first&lowbar;not&lowbar;of`] 
| The SIMD shuffle&hyphen;based find&hyphen;first&hyphen;not&hyphen;of finder specialized for char&period;
| xref:folly/simd/shuffle_vector_finder_first_of.adoc[`shuffle&lowbar;vector&lowbar;finder&lowbar;first&lowbar;of`] 
| The SIMD shuffle&hyphen;based find&hyphen;first&hyphen;of finder specialized for char&period;
| xref:folly/simd/stdfind_scalar_finder_first_of.adoc[`stdfind&lowbar;scalar&lowbar;finder&lowbar;first&lowbar;of`] 
| The std&colon;&colon;find&lowbar;first&lowbar;of based scalar find&hyphen;first&hyphen;of finder specialized for char&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/simd/contains.adoc[`contains`] 
| Returns whether the range contains the given value&period;
| xref:folly/simd/movemask-07.adoc[`movemask`] 
| `movemask` overloads
|===


== xref:folly/small_vector_policy.adoc[folly::small&lowbar;vector&lowbar;policy] namespace

Policies that customize the behavior of folly&colon;&colon;small&lowbar;vector&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/small_vector_policy/merge.adoc[`merge`] 
| Combines several small&lowbar;vector policies into a single policy&period;
| xref:folly/small_vector_policy/policy_in_situ_only.adoc[`policy&lowbar;in&lowbar;situ&lowbar;only`] 
| Policy selecting whether a small&lowbar;vector may only store elements in situ&period;
| xref:folly/small_vector_policy/policy_size_type.adoc[`policy&lowbar;size&lowbar;type`] 
| Policy selecting the size&lowbar;type used by a small&lowbar;vector&period;
|===


== xref:folly/ssl.adoc[folly::ssl] namespace

SSL and TLS helpers built on OpenSSL&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/ssl_options_detail.adoc[`ssl&lowbar;options&lowbar;detail`] 
| Implementation details for the SSL options helpers&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/BasicTransportCertificate.adoc[`BasicTransportCertificate`] 
| In&hyphen;memory transport certificate holding an identity and an optional X509&period;
| xref:folly/ssl/ClientHelloInfo.adoc[`ClientHelloInfo`] 
| Parsed fields extracted from a TLS ClientHello message&period;
| xref:folly/ssl/DnsName.adoc[`DnsName`] 
| A DNS name subjectAltName entry&period;
| xref:folly/ssl/OpenSSLCertUtils.adoc[`OpenSSLCertUtils`] 
| Utilities for inspecting and encoding X509 certificates&period;
| xref:folly/ssl/OpenSSLHash.adoc[`OpenSSLHash`] 
| OpenSSL&hyphen;backed message digest and HMAC helpers&period;
| xref:folly/ssl/OpenSSLKeyUtils.adoc[`OpenSSLKeyUtils`] 
| Utilities for reading and encoding private keys with OpenSSL&period;
| xref:folly/ssl/OpenSSLUtils.adoc[`OpenSSLUtils`] 
| Helpers wrapping low&hyphen;level OpenSSL certificate, BIO, and session operations&period;
| xref:folly/ssl/PasswordCollector.adoc[`PasswordCollector`] 
| Collects passwords used to decrypt private keys&period;
| xref:folly/ssl/SSLOptions2021.adoc[`SSLOptions2021`] 
| SSLOptions2021 contains options that any new client or server from 2021 onwards should be using&period;
| xref:folly/ssl/SSLOptionsCompatibility.adoc[`SSLOptionsCompatibility`] 
| Recommended SSL options that stay compatible with older peers&period;
| xref:folly/ssl/SSLServerOptionsCompatibility.adoc[`SSLServerOptionsCompatibility`] 
| SSLServerOptionsCompatibility contains algorithms that are not recommended for modern servers, but are included to maintain comaptibility with very old clients&period;
| xref:folly/ssl/SSLSession.adoc[`SSLSession`] 
| An abstraction for SSL sessions&period;
| xref:folly/ssl/SSLSessionManager.adoc[`SSLSessionManager`] 
| A class that manages one SSL session&period;
| xref:folly/ssl/UriName.adoc[`UriName`] 
| A URI subjectAltName entry&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/BioDeleterFb.adoc[`BioDeleterFb`] 
| Deleter that frees a single BIO via BIO&lowbar;free&lowbar;fb&period;
| xref:folly/ssl/BioUniquePtrFb.adoc[`BioUniquePtrFb`] 
| Owning unique&lowbar;ptr alias for a single BIO freed via BIO&lowbar;free&lowbar;fb&period;
| xref:folly/ssl/EvpPkeySharedPtr.adoc[`EvpPkeySharedPtr`] 
| Shared&hyphen;ownership pointer to an EVP&lowbar;PKEY object&period;
| xref:folly/ssl/GeneralName.adoc[`GeneralName`] 
| A subjectAltName entry&colon; a DNS name, a URI, or an IP address&period;
| xref:folly/ssl/SSLCommonOptions.adoc[`SSLCommonOptions`] 
| Default option set for clients and general use&period;
| xref:folly/ssl/SSLServerOptions.adoc[`SSLServerOptions`] 
| Default option set for servers&period;
| xref:folly/ssl/X509VerifyParam.adoc[`X509VerifyParam`] 
| Owning unique&lowbar;ptr alias for an X509&lowbar;VERIFY&lowbar;PARAM object&period;
| xref:folly/ssl/X509VerifyParamDeleter.adoc[`X509VerifyParamDeleter`] 
| Deleter that frees an X509&lowbar;VERIFY&lowbar;PARAM object&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/HashAlgorithm.adoc[`HashAlgorithm`] 
| TLS signature&hyphen;scheme hash algorithm codes (IANA tls&hyphen;parameters)&period;
| xref:folly/ssl/NameType.adoc[`NameType`] 
| TLS server&hyphen;name entry type&period;
| xref:folly/ssl/SignatureAlgorithm.adoc[`SignatureAlgorithm`] 
| TLS signature&hyphen;scheme signature algorithm codes (IANA tls&hyphen;parameters)&period;
| xref:folly/ssl/TLSExtension.adoc[`TLSExtension`] 
| TLS extension type codes, per the IANA tls&hyphen;extensiontype&hyphen;values registry&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/BIO_free_fb.adoc[`BIO&lowbar;free&lowbar;fb`] 
| Frees a single BIO, asserting that the underlying BIO&lowbar;free succeeds&period;
| xref:folly/ssl/setCipherSuites-02.adoc[`setCipherSuites`] 
| `setCipherSuites` overloads
| xref:folly/ssl/setGroups.adoc[`setGroups`] 
| Set the groups of ctx to that in TSSLOptions, and print any runtime error it catches&period;
| xref:folly/ssl/setSignatureAlgorithms.adoc[`setSignatureAlgorithms`] 
| Set the signature algorithm list of ctx to that in TSSLOptions, and print any runtime errors it catche&period;
| xref:folly/ssl/operator_lshift.adoc[`operator&lt;&lt;`] 
| Writes a password collector&apos;s description to an output stream&period;
|===


== xref:folly/ssl/ssl_options_detail.adoc[folly::ssl::ssl&lowbar;options&lowbar;detail] namespace

Implementation details for the SSL options helpers&period;

=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/ssl/ssl_options_detail/logDfatal.adoc[`logDfatal`] 
| Logs an exception at DFATAL severity&period;
|===


== xref:folly/stable_radix_sort_detail.adoc[folly::stable&lowbar;radix&lowbar;sort&lowbar;detail] namespace

Implementation details for the stable radix sort&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/stable_radix_sort_detail/DefaultProjection.adoc[`DefaultProjection`] 
| Default projection that handles common types&period;
| xref:folly/stable_radix_sort_detail/TransformingProjection.adoc[`TransformingProjection`] 
| Projection wrapper that applies type&hyphen;appropriate transformation&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/stable_radix_sort_detail/extractRadixDigit.adoc[`extractRadixDigit`] 
| Extract the radix digit at the given pass index from a key&period; Pass 0 extracts the least significant digit&period;
| xref:folly/stable_radix_sort_detail/insertionSort.adoc[`insertionSort`] 
| Stable insertion sort for small inputs&period; O(n&circ;2) but fast for small n due to low overhead&period;
| xref:folly/stable_radix_sort_detail/stableRadixSort.adoc[`stableRadixSort`] 
| Wrapper that handles buffer allocation and fallback to std&colon;&colon;stable&lowbar;sort&period;
| xref:folly/stable_radix_sort_detail/stableRadixSortImpl.adoc[`stableRadixSortImpl`] 
| Core LSD radix sort implementation with alternating buffers&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/stable_radix_sort_detail/kRadixBits.adoc[`kRadixBits`] 
| Number of bits processed per radix pass&period;
| xref:folly/stable_radix_sort_detail/kRadixBuckets.adoc[`kRadixBuckets`] 
| Number of counting&hyphen;sort buckets per pass (2&circ;kRadixBits)&period;
| xref:folly/stable_radix_sort_detail/kRadixMask.adoc[`kRadixMask`] 
| Mask selecting the low kRadixBits of a digit&period;
| xref:folly/stable_radix_sort_detail/kRadixPasses.adoc[`kRadixPasses`] 
| Number of radix passes needed to sort a key of the given type&period;
| xref:folly/stable_radix_sort_detail/kRadixSortThreshold.adoc[`kRadixSortThreshold`] 
| Size threshold below which we fall back to insertion sort&period;
|===


== xref:folly/stable_radix_sort_keys.adoc[folly::stable&lowbar;radix&lowbar;sort&lowbar;keys] namespace

Stable LSD (Least Significant Digit) Radix Sort

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/stable_radix_sort_keys/FloatKey.adoc[`FloatKey`] 
| FloatKey &hyphen; Converts IEEE 754 floats&sol;doubles to sortable unsigned integers&period;
| xref:folly/stable_radix_sort_keys/IdentityKey.adoc[`IdentityKey`] 
| IdentityKey &hyphen; Returns the value unchanged (for unsigned integers)&period;
| xref:folly/stable_radix_sort_keys/IntegralKey.adoc[`IntegralKey`] 
| IntegralKey &hyphen; Handles signed&sol;unsigned integers for radix sort&period;
|===


== xref:folly/symbolizer.adoc[folly::symbolizer] namespace

Stack trace capture and symbolization utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/symbolizer/AddressFormatter.adoc[`AddressFormatter`] 
| Format one address in the way it&apos;s usually printed by SymbolizePrinter&period; Async&hyphen;signal&hyphen;safe&period;
| xref:folly/symbolizer/ElfFile.adoc[`ElfFile`] 
| A memory&hyphen;mapped ELF object file&period;
| xref:folly/symbolizer/FDSymbolizePrinter.adoc[`FDSymbolizePrinter`] 
| Print a list of symbolized addresses to a file descriptor&period; Ignores errors&period; Async&hyphen;signal&hyphen;safe&period;
| xref:folly/symbolizer/FILESymbolizePrinter.adoc[`FILESymbolizePrinter`] 
| Print a list of symbolized addresses to a FILE&ast;&period; Ignores errors&period; Not reentrant&period; Do not use from signal handling code&period;
| xref:folly/symbolizer/FrameArray.adoc[`FrameArray`] 
| A fixed&hyphen;capacity array of captured addresses and their symbolized frames&period;
| xref:folly/symbolizer/LineReader.adoc[`LineReader`] 
| Async&hyphen;signal&hyphen;safe line reader&period;
| xref:folly/symbolizer/LocationInfo.adoc[`LocationInfo`] 
| Contains location info like file name, line number, etc&period;
| xref:folly/symbolizer/OStreamSymbolizePrinter.adoc[`OStreamSymbolizePrinter`] 
| Print a list of symbolized addresses to a stream&period; Not reentrant&period; Do not use from signal handling code&period;
| xref:folly/symbolizer/Path.adoc[`Path`] 
| Represent a file path as a collection of three parts (base directory, subdirectory, and file)&period;
| xref:folly/symbolizer/SafeStackTracePrinter.adoc[`SafeStackTracePrinter`] 
| Use this class to print a stack trace from a signal handler, or other place where you shouldn&apos;t allocate memory on the heap, and fsync()ing your file descriptor is more important than performance&period;
| xref:folly/symbolizer/StringSymbolizePrinter.adoc[`StringSymbolizePrinter`] 
| Print a list of symbolized addresses to a std&colon;&colon;string&period; Not reentrant&period; Do not use from signal handling code&period;
| xref:folly/symbolizer/SymbolCacheBase.adoc[`SymbolCacheBase`] 
| A cache of symbolized frames, keyed by instruction address&period;
| xref:folly/symbolizer/SymbolizePrinter.adoc[`SymbolizePrinter`] 
| Print a list of symbolized addresses&period; Base class&period;
| xref:folly/symbolizer/SymbolizedFrame.adoc[`SymbolizedFrame`] 
| Frame information&colon; symbol name and location&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/symbolizer/CachedSymbolizedFrames.adoc[`CachedSymbolizedFrames`] 
| Symbolized frames for a single address&colon; the stacked inline calls, if any, followed by the non&hyphen;inlined call&period; Most addresses have no inlined frames, so optimize for the single&hyphen;entry case&period;
| xref:folly/symbolizer/SignalCallback.adoc[`SignalCallback`] 
| Add a callback to be run when receiving a fatal signal&period; They will also be called by LOG(FATAL) and abort() (as those raise SIGABRT internally)&period;
|===


=== Enums

[cols="1,4"]
|===
| Name| Description
| xref:folly/symbolizer/LocationInfoMode.adoc[`LocationInfoMode`] 
| How aggressively to resolve source location information&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/symbolizer/addFatalSignalCallback.adoc[`addFatalSignalCallback`] 
| Register a callback to be run when a fatal signal is received&period;
| xref:folly/symbolizer/fatalSignalReceived.adoc[`fatalSignalReceived`] 
| True if a fatal signal was received (i&period;e&period; the process is crashing)&period;
| xref:folly/symbolizer/getAsyncStackTraceSafe-0a.adoc[`getAsyncStackTraceSafe`] 
| `getAsyncStackTraceSafe` overloads
| xref:folly/symbolizer/getAsyncStackTraceStr.adoc[`getAsyncStackTraceStr`] 
| Async stack trace as a string&semi; empty when symbolization is unavailable&period;
| xref:folly/symbolizer/getSharedSymbolCache.adoc[`getSharedSymbolCache`] 
| The process&hyphen;wide cache for `mode`&period;
| xref:folly/symbolizer/getStackTrace-00.adoc[`getStackTrace`] 
| `getStackTrace` overloads
| xref:folly/symbolizer/getStackTraceHeap-0e.adoc[`getStackTraceHeap`] 
| `getStackTraceHeap` overloads
| xref:folly/symbolizer/getStackTraceSafe-0c.adoc[`getStackTraceSafe`] 
| `getStackTraceSafe` overloads
| xref:folly/symbolizer/getStackTraceStr-00.adoc[`getStackTraceStr`] 
| `getStackTraceStr` overloads
| xref:folly/symbolizer/getSuspendedStackTraces.adoc[`getSuspendedStackTraces`] 
| Async stack traces for suspended coroutines&semi; empty when unavailable&period;
| xref:folly/symbolizer/installFatalSignalCallbacks.adoc[`installFatalSignalCallbacks`] 
| Install the fatal signal callbacks&semi; fatal signals will call these callbacks in the order in which they were added&period;
| xref:folly/symbolizer/installFatalSignalHandler.adoc[`installFatalSignalHandler`] 
| Install handler for fatal signals&period; The list of signals being handled is in SignalHandler&period;cpp&period;
| xref:folly/symbolizer/makeGenerationalSymbolCache.adoc[`makeGenerationalSymbolCache`] 
| A cache of roughly `capacity` entries, backed by a folly&colon;&colon;GenerationalCacheMap&colon; lookups are lock&hyphen;free, and an address that stops appearing in stack traces is eventually evicted in favour of one that does&period;
| xref:folly/symbolizer/makeLruSymbolCache.adoc[`makeLruSymbolCache`] 
| An LRU cache of `capacity` entries, backed by a Synchronized EvictingCacheMap&period;
| xref:folly/symbolizer/makeNullSymbolCache.adoc[`makeNullSymbolCache`] 
| A cache that stores nothing&period;
| xref:folly/symbolizer/operator_lshift.adoc[`operator&lt;&lt;`] 
| Write a Path to an output stream&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/symbolizer/kAllFatalSignals.adoc[`kAllFatalSignals`] 
| Bitmask of all fatal signals handled by the symbolizer signal handler&period;
|===


== xref:folly/test.adoc[folly::test] namespace

Testing utilities&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/test/CaptureFD.adoc[`CaptureFD`] 
| Temporarily capture a file descriptor by redirecting it into a file&period; You can consume its entire output thus far via read(), incrementally via readIncremental(), or via callback using chunk&lowbar;cob&period; Great for testing logging (see also glog&ast;Pattern())&period;
| xref:folly/test/ChangeToTempDir.adoc[`ChangeToTempDir`] 
| Changes into a temporary directory, and deletes it with all its contents upon destruction, also changing back to the original working directory&period;
| xref:folly/test/EnvVarSaver.adoc[`EnvVarSaver`] 
| RAII class allowing scoped changes to the process environment&period; The environment state at the time of its construction is restored at the time of its destruction&period;
| xref:folly/test/TemporaryDirectory.adoc[`TemporaryDirectory`] 
| Temporary directory&period;
| xref:folly/test/TemporaryFile.adoc[`TemporaryFile`] 
| Temporary file&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/test/find_resource.adoc[`find&lowbar;resource`] 
| Finds the file path of a resource which was built alongside a test binary&period;
| xref:folly/test/glogErrOrWarnPattern.adoc[`glogErrOrWarnPattern`] 
| PCRE pattern matching a glog error&hyphen;level or warning&hyphen;level log line&period;
| xref:folly/test/glogErrorPattern.adoc[`glogErrorPattern`] 
| Use these patterns together with CaptureFD and EXPECT&lowbar;PCRE&lowbar;MATCH() to test for the presence (or absence) of log lines at a particular level&colon;
| xref:folly/test/glogWarningPattern.adoc[`glogWarningPattern`] 
| PCRE pattern matching a glog warning&hyphen;level log line&period;
| xref:folly/test/msvcSuppressAbortOnInvalidParams.adoc[`msvcSuppressAbortOnInvalidParams`] 
| Invokes a function while suppressing the Windows CRT abort on invalid parameters&period;
|===


== xref:folly/threadlocal_detail.adoc[folly::threadlocal&lowbar;detail] namespace

Implementation details&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/threadlocal_detail/ElementWrapper.adoc[`ElementWrapper`] 
| POD wrapper around an element (a void&ast;) and an associated deleter&period; This must be POD, as we memset() it to 0 and memcpy() it around&period;
| xref:folly/threadlocal_detail/FakeUniqueInstance.adoc[`FakeUniqueInstance`] 
| No&hyphen;op stand&hyphen;in for UniqueInstance used when the tag is void&period;
| xref:folly/threadlocal_detail/SharedPtrDeleter.adoc[`SharedPtrDeleter`] 
| Deleter that owns a shared&lowbar;ptr and disposes it on thread&hyphen;local destruction&period;
| xref:folly/threadlocal_detail/StaticMeta.adoc[`StaticMeta`] 
| Held in a singleton to track our global instances&period; We have one of these per &quot;Tag&quot;, by default one for the whole system (Tag&equals;void)&period;
| xref:folly/threadlocal_detail/StaticMetaBase.adoc[`StaticMetaBase`] 
| Non&hyphen;templated base holding the shared thread&hyphen;local bookkeeping state&period;
| xref:folly/threadlocal_detail/ThreadEntry.adoc[`ThreadEntry`] 
| Per&hyphen;thread entry&period; Each thread using a StaticMeta object has one&period; This is written from the owning thread only (under the lock), read from the owning thread (no lock necessary), and read from other threads (under the lock)&period;
| xref:folly/threadlocal_detail/ThreadEntryList.adoc[`ThreadEntryList`] 
| Intrusive list of ThreadEntry objects for a single thread&period;
| xref:folly/threadlocal_detail/ThreadEntrySet.adoc[`ThreadEntrySet`] 
| ThreadEntrySet is used to track all ThreadEntry that have a valid ElementWrapper for a particular TL id&period; The class provides no internal locking and caller must ensure safety of any access&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/threadlocal_detail/ElementDisposeInfo.adoc[`ElementDisposeInfo`] 
| Cache the ptr &plus; deleter info in ThreadEntrySet too&period; This allows accessAllThreads() to get to the per thread ptr without holding the StaticMeta&apos;s lock&lowbar;&period; Eventually, the deleter info will be moved to the ThreadEntrySet alone, leaving only the ptr in the ElementWrapper&period; For now, the ElementDisposeInfo tracked in ThreadEntrySet is the same as ElementWrapper&period;
|===


=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:folly/threadlocal_detail/kEntryIDInvalid.adoc[`kEntryIDInvalid`] 
| Sentinel entry id representing an unallocated thread&hyphen;local slot&period;
|===


== xref:folly/traits_detail.adoc[folly::traits&lowbar;detail] namespace

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;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail/type_pack_element_indexed_type.adoc[`type&lowbar;pack&lowbar;element&lowbar;indexed&lowbar;type`] 
| A helper pairing an index with the type at that position&period;
| xref:folly/traits_detail/type_pack_element_set-0d.adoc[`type&lowbar;pack&lowbar;element&lowbar;set`] 
| A helper collecting a type pack as a set of indexed types&period;
| xref:folly/traits_detail/type_pack_element_test.adoc[`type&lowbar;pack&lowbar;element&lowbar;test`] 
| A helper that recovers the type stored at a given index&period;
| xref:folly/traits_detail/type_t_-0a.adoc[`type&lowbar;t&lowbar;`] 
| A helper that exposes its first type argument, ignoring the rest&period;
| xref:folly/traits_detail/uint_bits_t_-0a.adoc[`uint&lowbar;bits&lowbar;t&lowbar;`] 
| A helper mapping a bit width to the unsigned integer type of that width&period;
| xref:folly/traits_detail/value_list_traits_-00.adoc[`value&lowbar;list&lowbar;traits&lowbar;`] 
| A helper exposing the size and elements of a value list&period;
| xref:folly/traits_detail/value_pack_constant.adoc[`value&lowbar;pack&lowbar;constant`] 
| A helper wrapping a single value as a type carrying that value&period;
|===


=== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail/type_pack_element_fallback.adoc[`type&lowbar;pack&lowbar;element&lowbar;fallback`] 
| A fallback implementation of type&lowbar;pack&lowbar;element&lowbar;t without the builtin&period;
| xref:folly/traits_detail/type_pack_element_set_t.adoc[`type&lowbar;pack&lowbar;element&lowbar;set&lowbar;t`] 
| An alias building the indexed&hyphen;type set for the pack T&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail/type_list_element_.adoc[`type&lowbar;list&lowbar;element&lowbar;`] 
| Deduces the type identity of the Ith element of a type list&period;
| xref:folly/traits_detail/type_list_size_.adoc[`type&lowbar;list&lowbar;size&lowbar;`] 
| Deduces the size of a type list&period;
|===


== xref:folly/traits_detail_IsEqualityComparable.adoc[folly::traits&lowbar;detail&lowbar;IsEqualityComparable] namespace

Implementation namespace for the IsEqualityComparable trait&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail_IsEqualityComparable/IsEqualityComparable.adoc[`IsEqualityComparable`] 
| A trait to test whether values of T and U can be compared with operator&equals;&equals;&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail_IsEqualityComparable/operator_eq.adoc[`operator&equals;&equals;`] 
| A fallback operator used to detect the absence of a real operator&equals;&equals;&period;
|===


== xref:folly/traits_detail_IsLessThanComparable.adoc[folly::traits&lowbar;detail&lowbar;IsLessThanComparable] namespace

Implementation namespace for the IsLessThanComparable trait&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail_IsLessThanComparable/IsLessThanComparable.adoc[`IsLessThanComparable`] 
| A trait to test whether values of T and U can be compared with operator&lt;&period;
|===


=== Functions

[cols="1,4"]
|===
| Name| Description
| xref:folly/traits_detail_IsLessThanComparable/operator_lt.adoc[`operator&lt;`] 
| A fallback operator used to detect the absence of a real operator&lt;&period;
|===


== xref:ranges.adoc[ranges] namespace

The range&hyphen;v3 library namespace&period;

=== Variables

[cols="1,4"]
|===
| Name| Description
| xref:ranges/enable_view-0f.adoc[`enable&lowbar;view`] 
| Trait template that marks a type as a range&hyphen;v3 view&period;
| xref:ranges/enable_view-0c.adoc[`enable&lowbar;view`] 
| Marks folly&colon;&colon;Range as satisfying the range&hyphen;v3 view concept&period;
|===


== xref:std.adoc[std] namespace

Standard library specializations of std&colon;&colon;hash for Folly and standard types&period;

=== Namespaces

[cols="1,4"]
|===
| Name| Description
| xref:std/pmr.adoc[`pmr`] 
| Standard library namespace&period;
|===


=== Types

[cols="1,4"]
|===
| Name| Description
| xref:std/coroutine_traits-0f.adoc[`coroutine&lowbar;traits&lt;folly::coro::safe&lowbar;task&lt;ArgSafety, T&gt;, Args&period;&period;&period;&gt;`] 
| Coroutine traits selecting the promise type for a `safe&lowbar;task` coroutine&period;
| xref:std/equal_to-02.adoc[`equal&lowbar;to&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;equal&lowbar;to` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/greater-09.adoc[`greater&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;greater` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/greater_equal-0f.adoc[`greater&lowbar;equal&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;greater&lowbar;equal` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/hash-0d5.adoc[`hash&lt;folly::IPAddress&gt;`] 
| Hash support for folly&colon;&colon;IPAddress&period;
| xref:std/hash-000.adoc[`hash&lt;folly::IPAddressV4&gt;`] 
| Hash support for `folly&colon;&colon;IPAddressV4`&period;
| xref:std/hash-09.adoc[`hash&lt;folly::IPAddressV6&gt;`] 
| Hash specialization enabling `IPAddressV6` as a key in unordered containers&period;
| xref:std/hash-0a6.adoc[`hash&lt;folly::MacAddress&gt;`] 
| Specialization of std&colon;&colon;hash for folly&colon;&colon;MacAddress&period;
| xref:std/hash-0c0.adoc[`hash&lt;folly::NetworkSocket&gt;`] 
| Hash specialization for folly&colon;&colon;NetworkSocket&period;
| xref:std/hash-030.adoc[`hash&lt;folly::RegexMatchCacheKey&gt;`] 
| std&colon;&colon;hash specialization for folly&colon;&colon;RegexMatchCacheKey&period;
| xref:std/hash-0f.adoc[`hash&lt;folly::RequestToken&gt;`] 
| Hash specialization for folly&colon;&colon;RequestToken&period;
| xref:std/hash-0c7.adoc[`hash&lt;folly::SocketAddress&gt;`] 
| Specialization of std&colon;&colon;hash for folly&colon;&colon;SocketAddress&period;
| xref:std/hash-04.adoc[`hash&lt;folly::AsyncSocket::WriteRequestTag&gt;`] 
| Hash specialization for AsyncSocket&colon;&colon;WriteRequestTag&period;
| xref:std/hash-0ec.adoc[`hash&lt;folly::dynamic&gt;`] 
| Standard library hash specialization for folly&colon;&colon;dynamic&period;
| xref:std/hash-07.adoc[`hash&lt;T&gt;`] 
| Hash support so strong types can be keys in unordered containers&period;
| xref:std/hash-05b.adoc[`hash&lt;folly::enable&lowbar;std&lowbar;hash&lowbar;helper&lt;folly::Optional&lt;T&gt;, remove&lowbar;const&lowbar;t&lt;T&gt;&gt;&gt;`] 
| Hash specialization enabling folly&colon;&colon;Optional in unordered containers&period;
| xref:std/hash-0e9.adoc[`hash&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;hash` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/hash-0c6.adoc[`hash&lt;std::tuple&lt;Ts&period;&period;&period;&gt;&gt;`] 
| std&colon;&colon;hash specialization for std&colon;&colon;tuple&period;
| xref:std/hash-026d6.adoc[`hash&lt;folly::unique&lowbar;hash&lowbar;key&lt;Size&gt;&gt;`] 
| std&colon;&colon;hash specialization for folly&colon;&colon;unique&lowbar;hash&lowbar;key&period;
| xref:std/hash-0d7.adoc[`hash&lt;folly::unique&lowbar;hash&lowbar;key&lowbar;with&lt;Algo&gt;&gt;`] 
| std&colon;&colon;hash specialization for folly&colon;&colon;unique&lowbar;hash&lowbar;key&lowbar;with&period;
| xref:std/hash-08.adoc[`hash&lt;folly::basic&lowbar;cstring&lowbar;view&lt;Char, Traits&gt;&gt;`] 
| Hash specialization for basic&lowbar;cstring&lowbar;view, matching string&lowbar;view hashing&period;
| xref:std/hash-051.adoc[`hash&lt;folly::indirect&lt;T, Alloc&gt;&gt;`] 
| Hash specialization for `folly&colon;&colon;indirect`&period;
| xref:std/hash-0c3.adoc[`hash&lt;folly::not&lowbar;null&lt;PtrT, NullHandlerT&gt;&gt;`] 
| Hashing&colon; &hyphen; Forwards to underlying PtrT&period;
| xref:std/hash-055.adoc[`hash&lt;std::pair&lt;T1, T2&gt;&gt;`] 
| std&colon;&colon;hash specialization for std&colon;&colon;pair&period;
| xref:std/hash-026d3.adoc[`hash&lt;folly::small&lowbar;vector&lt;T, M, P&gt;&gt;`] 
| Hash specialization for folly&colon;&colon;small&lowbar;vector&period;
| xref:std/is_error_code_enum.adoc[`is&lowbar;error&lowbar;code&lowbar;enum`] 
| Marks folly&colon;&colon;cli&lowbar;apply&lowbar;args&lowbar;files&lowbar;errc as an error&hyphen;code enum&period;
| xref:std/less-07.adoc[`less&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;less` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/less_equal-0e.adoc[`less&lowbar;equal&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;less&lowbar;equal` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/not_equal_to-06.adoc[`not&lowbar;equal&lowbar;to&lt;folly::propagate&lowbar;const&lt;Pointer&gt;&gt;`] 
| `std&colon;&colon;not&lowbar;equal&lowbar;to` specialization for `folly&colon;&colon;propagate&lowbar;const`&period;
| xref:std/shared_lock-0b.adoc[`shared&lowbar;lock&lt;folly::SharedMutexImpl&lt;ReaderPriority, Tag&lowbar;, Atom, Policy&gt;&gt;`] 
| std&colon;&colon;shared&lowbar;lock specialization for folly&colon;&colon;SharedMutexImpl&period;
| xref:std/tuple_element-02.adoc[`tuple&lowbar;element&lt;I, &sol;&ast; implementation-defined &ast;&sol;&gt;`] 
| Type of the I&hyphen;th element of a lite&lowbar;tuple&period;
| xref:std/tuple_size.adoc[`tuple&lowbar;size`] 
| Number of elements in a lite&lowbar;tuple&period;
|===


== xref:std/pmr.adoc[std::pmr] namespace

Standard library namespace&period;

=== Types

[cols="1,4"]
|===
| Name| Description
| xref:std/pmr/memory_resource-05.adoc[`memory&lowbar;resource`] 
| Abstract interface for polymorphic memory resources&period;
|===



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