SYMBOL INDEX (13153 symbols across 1315 files)

FILE: build/fbcode_builder/CMake/fb_py_test_main.py
  class get_cpu_instr_counter (line 42) | class get_cpu_instr_counter:
    method read (line 43) | def read(self):
  class TestStatus (line 52) | class TestStatus:
  class PathMatcher (line 62) | class PathMatcher:
    method __init__ (line 63) | def __init__(self, include_patterns, omit_patterns):
    method omit (line 67) | def omit(self, path):
    method include (line 78) | def include(self, path):
  class DebugWipeFinder (line 82) | class DebugWipeFinder(PathFinder):
    method __init__ (line 88) | def __init__(self, matcher):
    method find_spec (line 91) | def find_spec(self, fullname, path=None, target=None):
  function optimize_for_coverage (line 128) | def optimize_for_coverage(cov, include_patterns, omit_patterns):
  class TeeStream (line 138) | class TeeStream:
    method __init__ (line 139) | def __init__(self, *streams):
    method write (line 142) | def write(self, data):
    method flush (line 146) | def flush(self):
    method isatty (line 150) | def isatty(self):
  class CallbackStream (line 154) | class CallbackStream:
    method __init__ (line 155) | def __init__(self, callback, bytes_callback=None, orig=None):
    method write (line 170) | def write(self, data):
    method flush (line 173) | def flush(self):
    method isatty (line 176) | def isatty(self):
    method fileno (line 179) | def fileno(self):
  class BuckTestResult (line 183) | class BuckTestResult(unittest.TextTestResult):
    method __init__ (line 191) | def __init__(
    method getResults (line 203) | def getResults(self):
    method startTest (line 206) | def startTest(self, test):
    method _find_next_test (line 227) | def _find_next_test(self, suite):
    method stopTest (line 245) | def stopTest(self, test):
    method stopTestRun (line 282) | def stopTestRun(self):
    method _withTest (line 288) | def _withTest(self, test):
    method _setStatus (line 293) | def _setStatus(self, test, status, message=None, stacktrace=None):
    method setStatus (line 302) | def setStatus(self, test, status, message=None, stacktrace=None):
    method setException (line 314) | def setException(self, test, status, excinfo):
    method addSuccess (line 323) | def addSuccess(self, test):
    method addError (line 327) | def addError(self, test, err):
    method addFailure (line 331) | def addFailure(self, test, err):
    method addSkip (line 335) | def addSkip(self, test, reason):
    method addExpectedFailure (line 339) | def addExpectedFailure(self, test, err):
    method addUnexpectedSuccess (line 343) | def addUnexpectedSuccess(self, test):
    method addStdout (line 347) | def addStdout(self, val):
    method addStdoutBytes (line 353) | def addStdoutBytes(self, val):
    method addStderr (line 357) | def addStderr(self, val):
    method addStderrBytes (line 363) | def addStderrBytes(self, val):
  class BuckTestRunner (line 368) | class BuckTestRunner(unittest.TextTestRunner):
    method __init__ (line 369) | def __init__(self, main_program, suite, show_output=True, **kwargs):
    method _makeResult (line 375) | def _makeResult(self):
  function _format_test_name (line 386) | def _format_test_name(test_class, attrname):
  class StderrLogHandler (line 390) | class StderrLogHandler(logging.StreamHandler):
    method __init__ (line 401) | def __init__(self):
    method stream (line 405) | def stream(self):
  class RegexTestLoader (line 409) | class RegexTestLoader(unittest.TestLoader):
    method __init__ (line 410) | def __init__(self, regex=None):
    method getTestCaseNames (line 414) | def getTestCaseNames(self, testCaseClass):
  class Loader (line 431) | class Loader:
    method __init__ (line 435) | def __init__(self, modules, regex=None):
    method load_all (line 439) | def load_all(self):
    method load_args (line 449) | def load_args(self, args):
  class MainProgram (line 486) | class MainProgram:
    method __init__ (line 495) | def __init__(self, argv):
    method init_option_parser (line 500) | def init_option_parser(self):
    method parse_options (line 580) | def parse_options(self, argv):
    method setup_logging (line 592) | def setup_logging(self):
    method create_loader (line 629) | def create_loader(self):
    method load_tests (line 634) | def load_tests(self):
    method get_tests (line 651) | def get_tests(self, test_suite):
    method run (line 662) | def run(self):
    method run_tests (line 680) | def run_tests(self, test_suite):
    method get_abbr_impl (line 704) | def get_abbr_impl(self):
    method start_coverage (line 718) | def start_coverage(self):
    method get_coverage (line 743) | def get_coverage(self):
    method convert_to_diff_cov_str (line 780) | def convert_to_diff_cov_str(self, analysis):
  function main (line 800) | def main(argv):

FILE: build/fbcode_builder/CMake/fb_py_win_main.c
  function locate_py_main (line 13) | int locate_py_main(int argc, wchar_t** argv) {
  function wmain (line 47) | int wmain() {

FILE: build/fbcode_builder/CMake/make_fbpy_archive.py
  class UsageError (line 19) | class UsageError(Exception):
    method __init__ (line 20) | def __init__(self, message):
    method __str__ (line 23) | def __str__(self):
  class BadManifestError (line 27) | class BadManifestError(UsageError):
    method __init__ (line 28) | def __init__(self, path, line_num, message):
  function parse_manifest (line 41) | def parse_manifest(manifest, path_map):
  function populate_install_tree (line 93) | def populate_install_tree(inst_dir, path_map):
  function build_pex (line 127) | def build_pex(args, path_map):
  function build_zipapp (line 157) | def build_zipapp(args, path_map):
  function create_main_module (line 177) | def create_main_module(args, inst_dir, path_map):
  function build_install_dir (line 198) | def build_install_dir(args, path_map):
  function ensure_directory (line 213) | def ensure_directory(path):
  function install_library (line 221) | def install_library(args, path_map):
  function parse_manifests (line 242) | def parse_manifests(args):
  function check_main_module (line 258) | def check_main_module(args, path_map):
  function main (line 303) | def main():

FILE: build/fbcode_builder/getdeps.py
  class UsageError (line 46) | class UsageError(Exception):
  class ValidateManifest (line 60) | class ValidateManifest(SubCmd):
    method run (line 61) | def run(self, args):
    method setup_parser (line 70) | def setup_parser(self, parser):
  class ShowHostType (line 75) | class ShowHostType(SubCmd):
    method run (line 76) | def run(self, args):
  class ProjectCmdBase (line 82) | class ProjectCmdBase(SubCmd):
    method run (line 83) | def run(self, args):
    method process_project_dir_arguments (line 120) | def process_project_dir_arguments(self, args, loader):
    method setup_parser (line 161) | def setup_parser(self, parser):
    method setup_project_cmd_parser (line 220) | def setup_project_cmd_parser(self, parser):
    method create_builder (line 223) | def create_builder(self, loader, manifest):
    method check_built (line 239) | def check_built(self, loader, manifest):
  class CachedProject (line 246) | class CachedProject:
    method __init__ (line 250) | def __init__(self, cache, loader, m):
    method is_cacheable (line 269) | def is_cacheable(self):
    method was_cached (line 273) | def was_cached(self):
    method download (line 277) | def download(self):
    method upload (line 302) | def upload(self):
  class FetchCmd (line 322) | class FetchCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 323) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 338) | def run_project_cmd(self, args, loader, manifest):
  class InstallSysDepsCmd (line 371) | class InstallSysDepsCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 372) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 409) | def run_project_cmd(self, args, loader, manifest):
  class ListDepsCmd (line 491) | class ListDepsCmd(ProjectCmdBase):
    method run_project_cmd (line 492) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 497) | def setup_project_cmd_parser(self, parser):
  function clean_dirs (line 507) | def clean_dirs(opts):
  class CleanCmd (line 516) | class CleanCmd(SubCmd):
    method run (line 517) | def run(self, args):
  class ShowScratchDirCmd (line 523) | class ShowScratchDirCmd(SubCmd):
    method run (line 524) | def run(self, args):
  class ShowBuildDirCmd (line 530) | class ShowBuildDirCmd(ProjectCmdBase):
    method run_project_cmd (line 531) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 541) | def setup_project_cmd_parser(self, parser):
  class ShowInstDirCmd (line 551) | class ShowInstDirCmd(ProjectCmdBase):
    method run_project_cmd (line 552) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 568) | def setup_project_cmd_parser(self, parser):
  class QueryPathsCmd (line 578) | class QueryPathsCmd(ProjectCmdBase):
    method run_project_cmd (line 579) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 600) | def setup_project_cmd_parser(self, parser):
  class ShowSourceDirCmd (line 610) | class ShowSourceDirCmd(ProjectCmdBase):
    method run_project_cmd (line 611) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 621) | def setup_project_cmd_parser(self, parser):
  class BuildCmd (line 631) | class BuildCmd(ProjectCmdBase):
    method run_project_cmd (line 632) | def run_project_cmd(self, args, loader, manifest):
    method compute_dep_change_status (line 757) | def compute_dep_change_status(self, m, built_marker, loader):
    method compute_source_change_status (line 793) | def compute_source_change_status(
    method setup_project_cmd_parser (line 834) | def setup_project_cmd_parser(self, parser):
  class FixupDeps (line 897) | class FixupDeps(ProjectCmdBase):
    method run_project_cmd (line 898) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 924) | def setup_project_cmd_parser(self, parser):
  class TestCmd (line 938) | class TestCmd(ProjectCmdBase):
    method run_project_cmd (line 939) | def run_project_cmd(self, args, loader, manifest):
    method setup_project_cmd_parser (line 953) | def setup_project_cmd_parser(self, parser):
  class DebugCmd (line 982) | class DebugCmd(ProjectCmdBase):
    method run_project_cmd (line 983) | def run_project_cmd(self, args, loader, manifest):
  class EnvCmd (line 991) | class EnvCmd(ProjectCmdBase):
    method setup_project_cmd_parser (line 992) | def setup_project_cmd_parser(self, parser):
    method run_project_cmd (line 1002) | def run_project_cmd(self, args, loader, manifest):
  class GenerateGitHubActionsCmd (line 1009) | class GenerateGitHubActionsCmd(ProjectCmdBase):
    method run_project_cmd (line 1021) | def run_project_cmd(self, args, loader, manifest):
    method get_run_on (line 1033) | def get_run_on(self, args):
    method write_job_for_platform (line 1066) | def write_job_for_platform(self, platform, args):  # noqa: C901
    method setup_project_cmd_parser (line 1415) | def setup_project_cmd_parser(self, parser):
  function get_arg_var_name (line 1486) | def get_arg_var_name(args):
  function parse_args (line 1494) | def parse_args():
  function main (line 1627) | def main():

FILE: build/fbcode_builder/getdeps/builder.py
  class BuilderBase (line 38) | class BuilderBase:
    method __init__ (line 39) | def __init__(
    method _get_cmd_prefix (line 79) | def _get_cmd_prefix(self) -> list[str]:
    method _check_cmd (line 101) | def _check_cmd(self, cmd: list[str], **kwargs: object) -> None:
    method _run_cmd (line 110) | def _run_cmd(
    method _reconfigure (line 143) | def _reconfigure(self, reconfigure: bool) -> bool:
    method _apply_patchfile (line 150) | def _apply_patchfile(self) -> None:
    method prepare (line 185) | def prepare(self, reconfigure: bool) -> None:
    method debug (line 191) | def debug(self, reconfigure: bool) -> None:
    method printenv (line 201) | def printenv(self, reconfigure: bool) -> None:
    method build (line 224) | def build(self, reconfigure: bool) -> None:
    method _job_weight_mib (line 254) | def _job_weight_mib(self) -> int:
    method num_jobs (line 273) | def num_jobs(self) -> int:
    method memory_limit_preexec_fn (line 277) | def memory_limit_preexec_fn(self) -> Callable[[], None] | None:
    method run_tests (line 285) | def run_tests(
    method _prepare (line 299) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 305) | def _build(self, reconfigure: bool) -> None:
    method _compute_env (line 312) | def _compute_env(self, env: Env | None = None) -> Env:
    method get_dev_run_script_path (line 325) | def get_dev_run_script_path(self) -> str:
    method get_dev_run_extra_path_dirs (line 329) | def get_dev_run_extra_path_dirs(
  class MakeBuilder (line 341) | class MakeBuilder(BuilderBase):
    method __init__ (line 342) | def __init__(
    method _make_binary (line 371) | def _make_binary(self) -> str | None:
    method _get_prefix (line 374) | def _get_prefix(self) -> list[str]:
    method _build (line 377) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 406) | def run_tests(
  class CMakeBootStrapBuilder (line 447) | class CMakeBootStrapBuilder(MakeBuilder):
    method _build (line 448) | def _build(self, reconfigure: bool) -> None:
  class AutoconfBuilder (line 459) | class AutoconfBuilder(BuilderBase):
    method __init__ (line 460) | def __init__(
    method _make_binary (line 493) | def _make_binary(self) -> str | None:
    method _build (line 496) | def _build(self, reconfigure: bool) -> None:
  class Iproute2Builder (line 540) | class Iproute2Builder(BuilderBase):
    method __init__ (line 545) | def __init__(
    method _build (line 567) | def _build(self, reconfigure: bool) -> None:
  class MesonBuilder (line 585) | class MesonBuilder(BuilderBase):
    method __init__ (line 588) | def __init__(
    method _build (line 610) | def _build(self, reconfigure: bool) -> None:
  class CMakeBuilder (line 644) | class CMakeBuilder(BuilderBase):
    method __init__ (line 757) | def __init__(
    method _invalidate_cache (line 801) | def _invalidate_cache(self) -> None:
    method _needs_reconfigure (line 813) | def _needs_reconfigure(self) -> bool:
    method _write_build_script (line 820) | def _write_build_script(self, **kwargs: object) -> None:
    method _compute_cmake_define_args (line 856) | def _compute_cmake_define_args(self, env: Env) -> list[str]:
    method _run_include_rewriter (line 924) | def _run_include_rewriter(self) -> None:
    method _build (line 941) | def _build(self, reconfigure: bool) -> None:
    method _build_targets (line 1005) | def _build_targets(self, targets: Sequence[str]) -> None:
    method _get_missing_test_executables (line 1044) | def _get_missing_test_executables(
    method run_tests (line 1082) | def run_tests(
  class NinjaBootstrap (line 1345) | class NinjaBootstrap(BuilderBase):
    method __init__ (line 1346) | def __init__(
    method _build (line 1368) | def _build(self, reconfigure: bool) -> None:
  class OpenSSLBuilder (line 1381) | class OpenSSLBuilder(BuilderBase):
    method __init__ (line 1382) | def __init__(
    method _build (line 1404) | def _build(self, reconfigure: bool) -> None:
  class Boost (line 1469) | class Boost(BuilderBase):
    method __init__ (line 1470) | def __init__(
    method _build (line 1499) | def _build(self, reconfigure: bool) -> None:
  class NopBuilder (line 1554) | class NopBuilder(BuilderBase):
    method __init__ (line 1555) | def __init__(
    method build (line 1569) | def build(self, reconfigure: bool) -> None:
  class SetupPyBuilder (line 1609) | class SetupPyBuilder(BuilderBase):
    method _build (line 1610) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 1640) | def run_tests(
  class SqliteBuilder (line 1667) | class SqliteBuilder(BuilderBase):
    method __init__ (line 1668) | def __init__(
    method _build (line 1690) | def _build(self, reconfigure: bool) -> None:

FILE: build/fbcode_builder/getdeps/buildopts.py
  function detect_project (line 34) | def detect_project(path: str) -> tuple[str | None, str | None]:
  class BuildOptions (line 53) | class BuildOptions:
    method __init__ (line 54) | def __init__(
    method manifests_dir (line 196) | def manifests_dir(self) -> str:
    method is_darwin (line 199) | def is_darwin(self) -> bool:
    method is_windows (line 202) | def is_windows(self) -> bool:
    method is_arm (line 205) | def is_arm(self) -> bool:
    method get_vcvars_path (line 208) | def get_vcvars_path(self) -> str | None:
    method is_linux (line 211) | def is_linux(self) -> bool:
    method is_freebsd (line 214) | def is_freebsd(self) -> bool:
    method get_num_jobs (line 217) | def get_num_jobs(self, job_weight: int) -> int:
    method get_context_generator (line 228) | def get_context_generator(
    method compute_env_for_install_dirs (line 251) | def compute_env_for_install_dirs(
    method add_homebrew_package_to_env (line 389) | def add_homebrew_package_to_env(self, package: str, env: Env) -> bool:
    method add_prefix_to_env (line 397) | def add_prefix_to_env(
  function list_win32_subst_letters (line 529) | def list_win32_subst_letters() -> dict[str, str]:
  function find_existing_win32_subst_for_path (line 545) | def find_existing_win32_subst_for_path(
  function find_unused_drive_letter (line 556) | def find_unused_drive_letter() -> str | None:
  function map_subst_path (line 580) | def map_subst_path(path: str) -> str:
  function _check_host_type (line 611) | def _check_host_type(args: argparse.Namespace, host_type: HostType | Non...
  function setup_build_options (line 623) | def setup_build_options(

FILE: build/fbcode_builder/getdeps/cache.py
  class ArtifactCache (line 11) | class ArtifactCache:
    method download_to_file (line 17) | def download_to_file(self, name: str, dest_file_name: str) -> bool:
    method upload_from_file (line 28) | def upload_from_file(self, name: str, source_file_name: str) -> None:
  function create_cache (line 38) | def create_cache() -> ArtifactCache | None:

FILE: build/fbcode_builder/getdeps/cargo.py
  class CargoBuilder (line 25) | class CargoBuilder(BuilderBase):
    method __init__ (line 26) | def __init__(
    method run_cargo (line 61) | def run_cargo(
    method build_source_dir (line 80) | def build_source_dir(self) -> str:
    method workspace_dir (line 83) | def workspace_dir(self) -> str:
    method manifest_dir (line 86) | def manifest_dir(self, manifest: str) -> str:
    method recreate_dir (line 89) | def recreate_dir(self, src: str, dst: str) -> None:
    method recreate_linked_dir (line 97) | def recreate_linked_dir(self, src: str, dst: str) -> None:
    method cargo_config_file (line 105) | def cargo_config_file(self) -> str:
    method _create_cargo_config (line 112) | def _create_cargo_config(self) -> dict[str, dict[str, str]]:
    method _prepare (line 178) | def _prepare(self, reconfigure: bool) -> None:
    method _build (line 187) | def _build(self, reconfigure: bool) -> None:
    method run_tests (line 223) | def run_tests(
    method _patchup_workspace (line 256) | def _patchup_workspace(self, dep_to_git: dict[str, dict[str, str]]) ->...
    method _resolve_config (line 325) | def _resolve_config(
    method _resolve_dep_to_git (line 360) | def _resolve_dep_to_git(self) -> dict[str, dict[str, str]]:
    method _resolve_dep_to_crates (line 448) | def _resolve_dep_to_crates(
    method _extract_crates_used (line 492) | def _extract_crates_used(
    method _resolve_crate_to_path (line 521) | def _resolve_crate_to_path(

FILE: build/fbcode_builder/getdeps/copytree.py
  function containing_repo_type (line 23) | def containing_repo_type(path: str) -> tuple[str | None, str | None]:
  function find_eden_root (line 36) | def find_eden_root(dirpath: str) -> str | None:
  function prefetch_dir_if_eden (line 55) | def prefetch_dir_if_eden(dirpath: str) -> None:
  function simple_copytree (line 73) | def simple_copytree(src_dir: str, dest_dir: str, symlinks: bool = False)...
  function _remove_readonly_and_try_again (line 106) | def _remove_readonly_and_try_again(
  function rmtree_more (line 134) | def rmtree_more(path: str) -> None:

FILE: build/fbcode_builder/getdeps/dyndeps.py
  function copyfile (line 29) | def copyfile(src: str, dest: str) -> None:
  class DepBase (line 34) | class DepBase:
    method __init__ (line 35) | def __init__(
    method list_dynamic_deps (line 53) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method interesting_dep (line 56) | def interesting_dep(self, d: str) -> bool:
    method process_deps (line 64) | def process_deps(
    method find_all_dependencies (line 97) | def find_all_dependencies(self, build_dir: str) -> list[str]:
    method munge_in_place (line 114) | def munge_in_place(self, objfile: str, final_lib_dir: str) -> None:
    method rewrite_dep (line 142) | def rewrite_dep(
    method resolve_loader_path (line 152) | def resolve_loader_path(self, dep: str) -> str | None:
    method list_objs_in_dir (line 163) | def list_objs_in_dir(
    method is_objfile (line 180) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 183) | def strip_debug_info(self, objfile: str) -> None:
    method check_call_verbose (line 188) | def check_call_verbose(self, args: list[str]) -> None:
  class WinDeps (line 193) | class WinDeps(DepBase):
    method __init__ (line 194) | def __init__(
    method find_dumpbin (line 204) | def find_dumpbin(self) -> str:
    method list_dynamic_deps (line 239) | def list_dynamic_deps(self, exe: str) -> list[str]:
    method rewrite_dep (line 254) | def rewrite_dep(
    method interesting_dep (line 282) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 289) | def is_objfile(self, objfile: str) -> bool:
    method emit_dev_run_script (line 296) | def emit_dev_run_script(self, script_path: str, dep_dirs: list[str]) -...
    method compute_dependency_paths (line 312) | def compute_dependency_paths(self, build_dir: str) -> list[str]:
    method compute_dependency_paths_fast (line 328) | def compute_dependency_paths_fast(self, build_dir: str) -> list[str]:
    method read_custom_dep_dirs (line 344) | def read_custom_dep_dirs(self, build_dir: str) -> set[str]:
    method _get_dev_run_script_contents (line 364) | def _get_dev_run_script_contents(self, path_dirs: list[str]) -> str:
  class ElfDeps (line 382) | class ElfDeps(DepBase):
    method __init__ (line 383) | def __init__(
    method list_dynamic_deps (line 409) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 420) | def rewrite_dep(
    method is_objfile (line 436) | def is_objfile(self, objfile: str) -> bool:
    method strip_debug_info (line 444) | def strip_debug_info(self, objfile: str) -> None:
  class MachDeps (line 452) | class MachDeps(DepBase):
    method interesting_dep (line 453) | def interesting_dep(self, d: str) -> bool:
    method is_objfile (line 458) | def is_objfile(self, objfile: str) -> bool:
    method list_dynamic_deps (line 470) | def list_dynamic_deps(self, objfile: str) -> list[str]:
    method rewrite_dep (line 489) | def rewrite_dep(
  function create_dyn_dep_munger (line 514) | def create_dyn_dep_munger(

FILE: build/fbcode_builder/getdeps/envfuncs.py
  class Env (line 16) | class Env:
    method __init__ (line 17) | def __init__(self, src: Mapping[str, str] | None = None) -> None:
    method update (line 24) | def update(self, src: Mapping[str, str]) -> None:
    method copy (line 28) | def copy(self) -> Env:
    method _key (line 31) | def _key(self, key: str) -> str | None:
    method get (line 60) | def get(self, key: str, defval: str | None = None) -> str | None:
    method __getitem__ (line 66) | def __getitem__(self, key: str) -> str:
    method unset (line 72) | def unset(self, key: str) -> None:
    method __delitem__ (line 80) | def __delitem__(self, key: str) -> None:
    method __repr__ (line 83) | def __repr__(self) -> str:
    method set (line 86) | def set(self, key: str, value: str) -> None:
    method __setitem__ (line 107) | def __setitem__(self, key: str, value: str) -> None:
    method __iter__ (line 110) | def __iter__(self) -> Iterator[str]:
    method __len__ (line 113) | def __len__(self) -> int:
    method keys (line 116) | def keys(self) -> KeysView[str]:
    method values (line 119) | def values(self) -> ValuesView[str]:
    method items (line 122) | def items(self) -> ItemsView[str, str]:
  function add_path_entry (line 126) | def add_path_entry(
  function add_flag (line 145) | def add_flag(env: Env, name: str, flag: str, append: bool = True) -> None:
  function tpx_path (line 162) | def tpx_path() -> str:
  function path_search (line 166) | def path_search(
  function _perform_path_search (line 191) | def _perform_path_search(path: str, exename: str) -> str | None:

FILE: build/fbcode_builder/getdeps/errors.py
  class TransientFailure (line 9) | class TransientFailure(Exception):
  class ManifestNotFound (line 17) | class ManifestNotFound(Exception):
    method __init__ (line 18) | def __init__(self, manifest_name: str) -> None:

FILE: build/fbcode_builder/getdeps/expr.py
  function parse_expr (line 15) | def parse_expr(expr_text: str, valid_variables: set[str]) -> ExprNode:
  class ExprNode (line 44) | class ExprNode:
    method eval (line 45) | def eval(self, ctx: dict[str, str | None]) -> bool:
  class TrueExpr (line 49) | class TrueExpr(ExprNode):
    method eval (line 50) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 53) | def __str__(self) -> str:
  class NotExpr (line 57) | class NotExpr(ExprNode):
    method __init__ (line 58) | def __init__(self, node: ExprNode) -> None:
    method eval (line 61) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 64) | def __str__(self) -> str:
  class AllExpr (line 68) | class AllExpr(ExprNode):
    method __init__ (line 69) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 72) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 78) | def __str__(self) -> str:
  class AnyExpr (line 85) | class AnyExpr(ExprNode):
    method __init__ (line 86) | def __init__(self, nodes: list[ExprNode]) -> None:
    method eval (line 89) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 95) | def __str__(self) -> str:
  class EqualExpr (line 102) | class EqualExpr(ExprNode):
    method __init__ (line 103) | def __init__(self, key: str, value: str) -> None:
    method eval (line 107) | def eval(self, ctx: dict[str, str | None]) -> bool:
    method __str__ (line 110) | def __str__(self) -> str:
  class Parser (line 114) | class Parser:
    method __init__ (line 115) | def __init__(self, text: str, valid_variables: set[str]) -> None:
    method parse (line 120) | def parse(self) -> ExprNode:
    method top (line 129) | def top(self) -> ExprNode:
    method ident (line 158) | def ident(self) -> str:
    method parse_not (line 164) | def parse_not(self) -> NotExpr:
    method parse_any (line 172) | def parse_any(self) -> AnyExpr:
    method parse_all (line 183) | def parse_all(self) -> AllExpr:

FILE: build/fbcode_builder/getdeps/fetcher.py
  function file_name_is_cmake_file (line 42) | def file_name_is_cmake_file(file_name: str) -> bool:
  class ChangeStatus (line 52) | class ChangeStatus:
    method __init__ (line 65) | def __init__(self, all_changed: bool = False) -> None:
    method record_change (line 76) | def record_change(self, file_name: str) -> None:
    method sources_changed (line 96) | def sources_changed(self) -> bool:
    method build_changed (line 103) | def build_changed(self) -> bool:
  class Fetcher (line 111) | class Fetcher(ABC):
    method update (line 117) | def update(self) -> ChangeStatus:
    method clean (line 126) | def clean(self) -> None:
    method hash (line 132) | def hash(self) -> str:
    method get_src_dir (line 146) | def get_src_dir(self) -> str:
  class LocalDirFetcher (line 152) | class LocalDirFetcher:
    method __init__ (line 159) | def __init__(self, path: str) -> None:
    method update (line 162) | def update(self) -> ChangeStatus:
    method hash (line 165) | def hash(self) -> str:
    method get_src_dir (line 168) | def get_src_dir(self) -> str:
    method clean (line 171) | def clean(self) -> None:
  class SystemPackageFetcher (line 175) | class SystemPackageFetcher:
    method __init__ (line 176) | def __init__(
    method packages_are_installed (line 188) | def packages_are_installed(self) -> bool:
    method update (line 224) | def update(self) -> ChangeStatus:
    method hash (line 228) | def hash(self) -> str:
    method get_src_dir (line 234) | def get_src_dir(self) -> None:
  class PreinstalledNopFetcher (line 238) | class PreinstalledNopFetcher(SystemPackageFetcher):
    method __init__ (line 239) | def __init__(self) -> None:
  class GitFetcher (line 243) | class GitFetcher(Fetcher):
    method __init__ (line 246) | def __init__(
    method _update (line 291) | def _update(self) -> ChangeStatus:
    method update (line 320) | def update(self) -> ChangeStatus:
    method _clone (line 326) | def _clone(self) -> None:
    method clean (line 347) | def clean(self) -> None:
    method hash (line 351) | def hash(self) -> str:
    method get_src_dir (line 354) | def get_src_dir(self) -> str:
  function does_file_need_update (line 358) | def does_file_need_update(
  function copy_if_different (line 392) | def copy_if_different(src_name: str, dest_name: str) -> bool:
  function filter_strip_marker (line 417) | def filter_strip_marker(dest_name: str, marker: str) -> None:
  function list_files_under_dir_newer_than_timestamp (line 442) | def list_files_under_dir_newer_than_timestamp(
  class ShipitPathMap (line 453) | class ShipitPathMap:
    method __init__ (line 454) | def __init__(self) -> None:
    method add_mapping (line 460) | def add_mapping(self, fbsource_dir: str, target_dir: str) -> None:
    method add_exclusion (line 468) | def add_exclusion(self, pattern: str) -> None:
    method _minimize_roots (line 472) | def _minimize_roots(self) -> None:
    method _sort_mapping (line 490) | def _sort_mapping(self) -> None:
    method _map_name (line 493) | def _map_name(self, norm_name: str, dest_root: str) -> str | None:
    method mirror (line 520) | def mirror(self, fbsource_root: str, dest_root: str) -> ChangeStatus:
  class FbsourceRepoData (line 594) | class FbsourceRepoData(NamedTuple):
  function get_fbsource_repo_data (line 602) | def get_fbsource_repo_data(build_options: BuildOptions) -> FbsourceRepoD...
  function is_public_commit (line 636) | def is_public_commit(build_options: BuildOptions) -> bool:  # noqa: C901
  class SimpleShipitTransformerFetcher (line 727) | class SimpleShipitTransformerFetcher(Fetcher):
    method __init__ (line 728) | def __init__(
    method clean (line 741) | def clean(self) -> None:
    method update (line 745) | def update(self) -> ChangeStatus:
    method hash (line 765) | def hash(self) -> str:
    method get_src_dir (line 771) | def get_src_dir(self) -> str:
  class SubFetcher (line 775) | class SubFetcher(Fetcher):
    method __init__ (line 778) | def __init__(self, base: Fetcher, subs: list[tuple[Fetcher, str]]) -> ...
    method update (line 782) | def update(self) -> ChangeStatus:
    method clean (line 794) | def clean(self) -> None:
    method hash (line 799) | def hash(self) -> str:
    method get_src_dir (line 805) | def get_src_dir(self) -> str:
  class ShipitTransformerFetcher (line 809) | class ShipitTransformerFetcher(Fetcher):
    method _shipit_paths (line 811) | def _shipit_paths(cls, build_options: BuildOptions) -> list[str]:
    method __init__ (line 824) | def __init__(
    method update (line 839) | def update(self) -> ChangeStatus:
    method clean (line 845) | def clean(self) -> None:
    method available (line 850) | def available(cls, build_options: BuildOptions) -> bool:
    method run_shipit (line 856) | def run_shipit(self) -> None:
    method hash (line 900) | def hash(self) -> str:
    method get_src_dir (line 904) | def get_src_dir(self) -> str:
  function download_url_to_file_with_progress (line 908) | def download_url_to_file_with_progress(url: str, file_name: str) -> None:
  class ArchiveFetcher (line 1011) | class ArchiveFetcher(Fetcher):
    method __init__ (line 1012) | def __init__(
    method _verify_hash (line 1034) | def _verify_hash(self) -> None:
    method _download_dir (line 1049) | def _download_dir(self) -> str:
    method _download (line 1056) | def _download(self) -> None:
    method clean (line 1074) | def clean(self) -> None:
    method update (line 1078) | def update(self) -> ChangeStatus:
    method hash (line 1148) | def hash(self) -> str:
    method get_src_dir (line 1151) | def get_src_dir(self) -> str:
  function homebrew_package_prefix (line 1155) | def homebrew_package_prefix(package: str) -> str | None:

FILE: build/fbcode_builder/getdeps/include_rewriter.py
  class IncludePathRewriter (line 27) | class IncludePathRewriter:
    method __init__ (line 43) | def __init__(self, mappings: list[tuple[str, str]], verbose: bool = Fa...
    method rewrite_file (line 65) | def rewrite_file(self, file_path: Path, dry_run: bool = False) -> bool:
    method process_directory (line 128) | def process_directory(self, source_dir: Path, dry_run: bool = False) -...
  function rewrite_includes_from_manifest (line 175) | def rewrite_includes_from_manifest(

FILE: build/fbcode_builder/getdeps/load.py
  class Loader (line 26) | class Loader:
    method _list_manifests (line 29) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _load_manifest (line 39) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 42) | def load_project(
    method load_all (line 55) | def load_all(self, build_opts: BuildOptions) -> dict[str, ManifestPars...
  class ResourceLoader (line 69) | class ResourceLoader(Loader):
    method __init__ (line 70) | def __init__(self, namespace: str, manifests_dir: str) -> None:
    method _list_manifests (line 74) | def _list_manifests(self, build_opts: BuildOptions) -> Iterator[str]:
    method _find_manifest (line 89) | def _find_manifest(self, project_name: str) -> str:
    method _load_manifest (line 97) | def _load_manifest(self, path: str) -> ManifestParser:
    method load_project (line 103) | def load_project(
  function patch_loader (line 114) | def patch_loader(namespace: str, manifests_dir: str = "manifests") -> None:
  function load_project (line 119) | def load_project(build_opts: BuildOptions, project_name: str) -> Manifes...
  function load_all_manifests (line 125) | def load_all_manifests(build_opts: BuildOptions) -> dict[str, ManifestPa...
  class ManifestLoader (line 129) | class ManifestLoader:
    method __init__ (line 137) | def __init__(
    method load_manifest (line 155) | def load_manifest(self, name: str) -> ManifestParser:
    method load_all_manifests (line 162) | def load_all_manifests(self) -> dict[str, ManifestParser]:
    method dependencies_of (line 177) | def dependencies_of(self, manifest: ManifestParser) -> list[ManifestPa...
    method manifests_in_dependency_order (line 185) | def manifests_in_dependency_order(
    method set_project_src_dir (line 263) | def set_project_src_dir(self, project_name: str, path: str) -> None:
    method set_project_build_dir (line 266) | def set_project_build_dir(self, project_name: str, path: str) -> None:
    method set_project_install_dir (line 269) | def set_project_install_dir(self, project_name: str, path: str) -> None:
    method set_project_install_prefix (line 272) | def set_project_install_prefix(self, project_name: str, path: str) -> ...
    method create_fetcher (line 275) | def create_fetcher(
    method get_project_hash (line 285) | def get_project_hash(self, manifest: ManifestParser) -> str:
    method _compute_project_hash (line 292) | def _compute_project_hash(self, manifest: ManifestParser) -> str:
    method _get_project_dir_name (line 368) | def _get_project_dir_name(self, manifest: ManifestParser) -> str:
    method get_project_install_dir (line 375) | def get_project_install_dir(self, manifest: ManifestParser) -> str:
    method get_project_build_dir (line 383) | def get_project_build_dir(self, manifest: ManifestParser) -> str:
    method get_project_install_prefix (line 391) | def get_project_install_prefix(self, manifest: ManifestParser) -> str ...
    method get_project_install_dir_respecting_install_prefix (line 394) | def get_project_install_dir_respecting_install_prefix(

FILE: build/fbcode_builder/getdeps/manifest.py
  function parse_conditional_section_name (line 166) | def parse_conditional_section_name(name: str, section_def: str) -> ExprN...
  function validate_allowed_fields (line 171) | def validate_allowed_fields(
  function validate_allow_values (line 192) | def validate_allow_values(
  function validate_section (line 208) | def validate_section(
  class ManifestParser (line 243) | class ManifestParser:
    method __init__ (line 244) | def __init__(self, file_name: str, fp: str | typing.IO[str] | None = N...
    method get (line 299) | def get(
    method get_dependencies (line 327) | def get_dependencies(self, ctx: ManifestContext) -> list[str]:
    method get_section_as_args (line 345) | def get_section_as_args(
    method get_section_as_ordered_pairs (line 377) | def get_section_as_ordered_pairs(
    method get_section_as_dict (line 403) | def get_section_as_dict(
    method update_hash (line 425) | def update_hash(self, hasher: hashlib._Hash, ctx: ManifestContext) -> ...
    method is_first_party_project (line 451) | def is_first_party_project(self) -> bool:
    method get_required_system_packages (line 455) | def get_required_system_packages(
    method _is_satisfied_by_preinstalled_environment (line 466) | def _is_satisfied_by_preinstalled_environment(self, ctx: ManifestConte...
    method get_repo_url (line 483) | def get_repo_url(self, ctx: ManifestContext) -> str | None:
    method _create_fetcher (line 486) | def _create_fetcher(
    method create_fetcher (line 574) | def create_fetcher(
    method get_builder_name (line 594) | def get_builder_name(self, ctx: ManifestContext) -> str:
    method create_builder (line 600) | def create_builder(  # noqa:C901
    method create_prepare_builders (line 817) | def create_prepare_builders(
    method create_cargo_builder (line 844) | def create_cargo_builder(
  class ManifestContext (line 876) | class ManifestContext:
    method __init__ (line 893) | def __init__(self, ctx_dict: dict[str, str | None]) -> None:
    method get (line 897) | def get(self, key: str) -> str | None:
    method set (line 900) | def set(self, key: str, value: str | None) -> None:
    method copy (line 904) | def copy(self) -> ManifestContext:
    method __str__ (line 907) | def __str__(self) -> str:
  class ContextGenerator (line 914) | class ContextGenerator:
    method __init__ (line 920) | def __init__(self, default_ctx: dict[str, str | None]) -> None:
    method set_value_for_project (line 924) | def set_value_for_project(
    method set_value_for_all_projects (line 933) | def set_value_for_all_projects(self, key: str, value: str | None) -> N...
    method get_context (line 938) | def get_context(self, project_name: str) -> ManifestContext:

FILE: build/fbcode_builder/getdeps/platform.py
  function is_windows (line 16) | def is_windows() -> bool:
  function get_linux_type (line 22) | def get_linux_type() -> tuple[str | None, str | None, str | None]:
  function _get_available_ram_linux (line 59) | def _get_available_ram_linux() -> int:
  function _get_available_ram_macos (line 90) | def _get_available_ram_macos() -> int:
  function _get_available_ram_windows (line 117) | def _get_available_ram_windows() -> int:
  function _get_available_ram_freebsd (line 148) | def _get_available_ram_freebsd() -> int:
  function get_available_ram (line 174) | def get_available_ram() -> int:
  function is_current_host_arm (line 192) | def is_current_host_arm() -> bool:
  class HostType (line 201) | class HostType:
    method __init__ (line 202) | def __init__(
    method is_windows (line 242) | def is_windows(self) -> bool:
    method is_arm (line 252) | def is_arm(self) -> bool:
    method is_darwin (line 255) | def is_darwin(self) -> bool:
    method is_linux (line 258) | def is_linux(self) -> bool:
    method is_freebsd (line 261) | def is_freebsd(self) -> bool:
    method as_tuple_string (line 264) | def as_tuple_string(self) -> str:
    method get_package_manager (line 271) | def get_package_manager(self) -> str | None:
    method from_tuple_string (line 287) | def from_tuple_string(s: str) -> HostType:
    method __eq__ (line 291) | def __eq__(self, b: object) -> bool:

FILE: build/fbcode_builder/getdeps/py_wheel_builder.py
  class PythonWheelBuilder (line 99) | class PythonWheelBuilder(BuilderBase):
    method _build (line 109) | def _build(self, reconfigure: bool) -> None:
    method _run_cmake_build (line 178) | def _run_cmake_build(self, reconfigure: bool) -> None:
    method _write_cmakelists (line 195) | def _write_cmakelists(
    method _write_cmake_config_template (line 222) | def _write_cmake_config_template(self) -> None:
    method _add_sources (line 229) | def _add_sources(
    method _parse_wheel_name (line 244) | def _parse_wheel_name(self) -> WheelNameInfo:
    method _read_wheel_metadata (line 281) | def _read_wheel_metadata(self, wheel_name: WheelNameInfo) -> email.mes...
  function _to_cmake_path (line 287) | def _to_cmake_path(path: str) -> str:

FILE: build/fbcode_builder/getdeps/runcmd.py
  class RunCommandError (line 21) | class RunCommandError(Exception):
  function make_memory_limit_preexec_fn (line 25) | def make_memory_limit_preexec_fn(
  function _print_env_diff (line 72) | def _print_env_diff(env: Env, log_fn: Callable[[str], None]) -> None:
  function check_cmd (line 94) | def check_cmd(
  function run_cmd (line 107) | def run_cmd(
  function _run_cmd (line 145) | def _run_cmd(
  function _pipe_output (line 218) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...
  function _pipe_output (line 244) | def _pipe_output(p: subprocess.Popen[bytes], log_fn: Callable[[str], Non...

FILE: build/fbcode_builder/getdeps/subcmd.py
  class SubCmd (line 14) | class SubCmd:
    method run (line 18) | def run(self, args: argparse.Namespace) -> int:
    method setup_parser (line 22) | def setup_parser(self, parser: argparse.ArgumentParser) -> None:
  function add_subcommands (line 31) | def add_subcommands(
  function cmd (line 49) | def cmd(

FILE: build/fbcode_builder/getdeps/test/expr_test.py
  class ExprTest (line 14) | class ExprTest(unittest.TestCase):
    method test_equal (line 15) | def test_equal(self) -> None:
    method test_not_equal (line 22) | def test_not_equal(self) -> None:
    method test_bad_not (line 28) | def test_bad_not(self) -> None:
    method test_bad_variable (line 33) | def test_bad_variable(self) -> None:
    method test_all (line 38) | def test_all(self) -> None:
    method test_any (line 45) | def test_any(self) -> None:

FILE: build/fbcode_builder/getdeps/test/manifest_test.py
  class ManifestTest (line 16) | class ManifestTest(unittest.TestCase):
    method test_missing_section (line 17) | def test_missing_section(self) -> None:
    method test_missing_name (line 23) | def test_missing_name(self) -> None:
    method test_minimal (line 35) | def test_minimal(self) -> None:
    method test_minimal_with_fbsource_path (line 46) | def test_minimal_with_fbsource_path(self) -> None:
    method test_unknown_field (line 58) | def test_unknown_field(self) -> None:
    method test_invalid_section_name (line 75) | def test_invalid_section_name(self) -> None:
    method test_value_in_dependencies_section (line 90) | def test_value_in_dependencies_section(self) -> None:
    method test_invalid_conditional_section_name (line 110) | def test_invalid_conditional_section_name(self) -> None:
    method test_section_as_args (line 129) | def test_section_as_args(self) -> None:
    method test_section_as_dict (line 169) | def test_section_as_dict(self) -> None:
    method test_parse_common_manifests (line 207) | def test_parse_common_manifests(self) -> None:
    method test_mismatch_name (line 213) | def test_mismatch_name(self) -> None:
    method test_duplicate_manifest (line 226) | def test_duplicate_manifest(self) -> None:
    method assertRaisesRegex (line 235) | def assertRaisesRegex(self, *args, **kwargs):

FILE: build/fbcode_builder/getdeps/test/platform_test.py
  class PlatformTest (line 14) | class PlatformTest(unittest.TestCase):
    method test_create (line 15) | def test_create(self) -> None:
    method test_rendering_of_none (line 23) | def test_rendering_of_none(self) -> None:
    method test_is_methods (line 27) | def test_is_methods(self) -> None:

FILE: build/fbcode_builder/getdeps/test/retry_test.py
  class RetryTest (line 18) | class RetryTest(unittest.TestCase):
    method _get_build_opts (line 19) | def _get_build_opts(self) -> BuildOptions:
    method _get_manifest (line 24) | def _get_manifest(self) -> ManifestParser:
    method _get_archive_fetcher (line 29) | def _get_archive_fetcher(self) -> ArchiveFetcher:
    method test_no_retries (line 41) | def test_no_retries(
    method test_retries (line 77) | def test_retries(
    method test_all_retries (line 124) | def test_all_retries(

FILE: build/fbcode_builder/getdeps/test/scratch_test.py
  class Win32SubstTest (line 14) | class Win32SubstTest(unittest.TestCase):
    method test_no_existing_subst (line 15) | def test_no_existing_subst(self) -> None:
    method test_exact_match_returns_drive_path (line 29) | def test_exact_match_returns_drive_path(self) -> None:
    method test_multiple_exact_matches_returns_arbitrary_drive_path (line 45) | def test_multiple_exact_matches_returns_arbitrary_drive_path(self) -> ...
    method test_drive_letter_is_case_insensitive (line 58) | def test_drive_letter_is_case_insensitive(self) -> None:
    method test_path_components_are_case_insensitive (line 67) | def test_path_components_are_case_insensitive(self) -> None:

FILE: build/fbcode_builder/getdeps/test/strip_marker_test.py
  class ManifestStripMarkerTest (line 17) | class ManifestStripMarkerTest(unittest.TestCase):
    method test_default_strip_marker (line 18) | def test_default_strip_marker(self) -> None:
    method test_custom_strip_marker (line 28) | def test_custom_strip_marker(self) -> None:
  class FilterStripMarkerTest (line 40) | class FilterStripMarkerTest(unittest.TestCase):
    method _write_temp (line 41) | def _write_temp(self, content: str) -> str:
    method _read (line 48) | def _read(self, path: str) -> str:
    method test_single_line_removal (line 52) | def test_single_line_removal(self) -> None:
    method test_block_removal (line 60) | def test_block_removal(self) -> None:
    method test_no_marker_present_no_change (line 76) | def test_no_marker_present_no_change(self) -> None:
    method test_custom_marker_single_line (line 85) | def test_custom_marker_single_line(self) -> None:
    method test_custom_marker_block (line 94) | def test_custom_marker_block(self) -> None:
    method test_custom_marker_ignores_default (line 109) | def test_custom_marker_ignores_default(self) -> None:
    method test_mixed_single_and_block (line 119) | def test_mixed_single_and_block(self) -> None:
    method test_marker_with_regex_metacharacters (line 136) | def test_marker_with_regex_metacharacters(self) -> None:
    method test_binary_file_skipped (line 147) | def test_binary_file_skipped(self) -> None:

FILE: folly/AtomicHashArray-inl.h
  function namespace (line 28) | namespace folly {
  type typename (line 209) | typedef
  function try (line 377) | try {
  function aha_ (line 494) | aha_(nullptr) {}
  function explicit (line 506) | explicit aha_iterator(ContT* array, size_t offset)
  function advancePastEmpty (line 514) | void advancePastEmpty() {
  function increment (line 525) | void increment() {
  function equal (line 530) | bool equal(const aha_iterator& o) const {

FILE: folly/AtomicHashArray.h
  function namespace (line 39) | namespace folly {

FILE: folly/AtomicHashMap-inl.h
  function namespace (line 26) | namespace folly {
  function ahm_ (line 577) | ahm_(nullptr) {}
  function increment (line 606) | void increment() {
  function equal (line 612) | bool equal(const ahm_iterator& other) const {
  function checkAdvanceToNextSubmap (line 628) | void checkAdvanceToNextSubmap() {

FILE: folly/AtomicHashMap.h
  function namespace (line 92) | namespace folly {
  function iterator (line 367) | iterator begin() {
  function const_iterator (line 373) | const_iterator begin() const {
  function value_type (line 415) | inline const value_type& idxToRec(uint32_t idx) const {
  type SimpleRetT (line 433) | struct SimpleRetT {
  function tryLockMap (line 460) | inline bool tryLockMap(unsigned int idx) {

FILE: folly/AtomicIntrusiveLinkedList.h
  function T (line 40) | T* next{nullptr};
  function AtomicIntrusiveLinkedList (line 68) | AtomicIntrusiveLinkedList spliceAll() { return std::move(*this); }
  function T (line 95) | T* unsafeHead() const { return head_.load(std::memory_order_acquire); }
  function insertHead (line 110) | bool insertHead(T* t) {
  function T (line 178) | static T*& next(T* t) { return (t->*HookMember).next; }
  function T (line 182) | static T* reverse(T* head) {

FILE: folly/AtomicLinkedList.h
  function namespace (line 22) | namespace folly {
  type Wrapper (line 119) | struct Wrapper {

FILE: folly/AtomicUnorderedMap.h
  function namespace (line 37) | namespace folly {
  function guardSlot (line 274) | auto guardSlot = folly::makeGuard([&] {
  function guardKey (line 279) | auto guardKey = folly::makeGuard([&] { addr->first.~Key(); }
  function guardMapped (line 281) | auto guardMapped = folly::makeGuard([&] { addr->second.~Value(); }
  function const_iterator (line 326) | const_iterator find(const Key& key) const {
  function const_iterator (line 330) | const_iterator cbegin() const {
  type IndexType (line 343) | enum : IndexType {
  function IndexType (line 347) | enum BucketState : IndexType {
  function stateUpdate (line 386) | void stateUpdate(BucketState before, BucketState after) {
  function value_type (line 391) | value_type* keyValue() {
  function value_type (line 396) | const value_type* keyValue() const {
  function IndexType (line 415) | IndexType keyToSlotIdx(const Key& key) const {
  function IndexType (line 424) | IndexType find(const Key& key, IndexType slot) const {
  function IndexType (line 437) | IndexType allocateNear(IndexType start) {
  function IndexType (line 453) | IndexType allocationAttempt(IndexType start, IndexType tries) const {
  function zeroFillSlots (line 468) | void zeroFillSlots() {
  function explicit (line 508) | explicit MutableAtom(const T& init) : data(init) {}
  function explicit (line 517) | explicit MutableData(const T& init) : data(init) {}

FILE: folly/Benchmark.cpp
  type folly (line 218) | namespace folly {
    type detail (line 219) | namespace detail {
      function string (line 494) | string readableTime(double n, unsigned int decimals) {
      function PerfScoped (line 1215) | PerfScoped BenchmarkingStateBase::doSetUpPerfScoped(
      function PerfScoped (line 1220) | PerfScoped BenchmarkingStateBase::setUpPerfScoped() const {
      function runBenchmarksWithResults (line 1252) | std::vector<BenchmarkResult> runBenchmarksWithResults() {
      function benchmarkResultsToString (line 1256) | std::string benchmarkResultsToString(
    function BENCHMARK (line 242) | BENCHMARK(FB_FOLLY_GLOBAL_BENCHMARK_BASELINE) {
    function runBenchmarkGetNSPerIteration (line 258) | static std::pair<double, UserCounters> runBenchmarkGetNSPerIteration(
    function runBenchmarkGetNSPerIterationEstimate (line 325) | static std::pair<double, UserCounters> runBenchmarkGetNSPerIterationEs...
    function runProfilingGetNSPerIteration (line 414) | static std::pair<double, UserCounters> runProfilingGetNSPerIteration(
    type ScaleInfo (line 436) | struct ScaleInfo {
    function string (line 477) | static string humanReadable(
    type detail (line 493) | namespace detail {
      function string (line 494) | string readableTime(double n, unsigned int decimals) {
      function PerfScoped (line 1215) | PerfScoped BenchmarkingStateBase::doSetUpPerfScoped(
      function PerfScoped (line 1220) | PerfScoped BenchmarkingStateBase::setUpPerfScoped() const {
      function runBenchmarksWithResults (line 1252) | std::vector<BenchmarkResult> runBenchmarksWithResults() {
      function benchmarkResultsToString (line 1256) | std::string benchmarkResultsToString(
    function string (line 499) | static string metricReadable(double n, unsigned int decimals) {
    function headerContents (line 508) | std::string headerContents(std::string_view file, size_t columns) {
    class BenchmarkResultsPrinter (line 527) | class BenchmarkResultsPrinter {
      method BenchmarkResultsPrinter (line 529) | explicit BenchmarkResultsPrinter(
      method separator (line 544) | void separator(char pad) { line(string(columns_, pad)); }
      method header (line 546) | void header(std::string_view file) {
      method print (line 557) | void print(
      method isBaselineSet (line 657) | bool isBaselineSet() {
      method line (line 661) | void line(std::string_view s) { *os_ << indent_ << s << std::endl; }
    function printBenchmarkResultsAsJson (line 673) | static void printBenchmarkResultsAsJson(
    function benchmarkResultsToDynamic (line 683) | void benchmarkResultsToDynamic(
    function benchmarkResultsFromDynamic (line 705) | void benchmarkResultsFromDynamic(
    function resultKey (line 716) | static pair<StringPiece, StringPiece> resultKey(
    function printResultComparison (line 721) | void printResultComparison(
    function checkRunMode (line 790) | void checkRunMode() {
    type BenchmarksToRun (line 801) | struct BenchmarksToRun {
    function addSeparator (line 808) | void addSeparator(BenchmarksToRun& res) {
    function BenchmarksToRun (line 819) | BenchmarksToRun selectBenchmarksToRun(
    function maybeRunWarmUpIteration (line 870) | void maybeRunWarmUpIteration(const BenchmarksToRun& toRun) {
    class ShouldDrawLineTracker (line 892) | class ShouldDrawLineTracker {
      method ShouldDrawLineTracker (line 894) | explicit ShouldDrawLineTracker(const std::vector<size_t>& separators...
    function runAdaptiveMode (line 917) | auto runAdaptiveMode(
    function userSetGflag (line 946) | bool userSetGflag([[maybe_unused]] const char* name) {
    function validateFlagCombinations (line 957) | void validateFlagCombinations() {
    function resolveSliceUsec (line 1017) | int64_t resolveSliceUsec() {
    function resultsFromFile (line 1138) | std::vector<detail::BenchmarkResult> resultsFromFile(
    function writeResultsToFile (line 1149) | bool writeResultsToFile(
    type detail (line 1159) | namespace detail {
      function string (line 494) | string readableTime(double n, unsigned int decimals) {
      function PerfScoped (line 1215) | PerfScoped BenchmarkingStateBase::doSetUpPerfScoped(
      function PerfScoped (line 1220) | PerfScoped BenchmarkingStateBase::setUpPerfScoped() const {
      function runBenchmarksWithResults (line 1252) | std::vector<BenchmarkResult> runBenchmarksWithResults() {
      function benchmarkResultsToString (line 1256) | std::string benchmarkResultsToString(
    function runBenchmarks (line 1283) | void runBenchmarks() {

FILE: folly/Benchmark.h
  function namespace (line 50) | namespace folly {
  function class (line 219) | class BenchmarkingStateBase {
  function addBenchmarkImpl (line 359) | inline void addBenchmarkImpl(
  function high_resolution_clock (line 370) | struct BenchmarkSuspender
  type dynamic (line 393) | struct dynamic

FILE: folly/BenchmarkUtil.cpp
  type folly (line 35) | namespace folly {
    type detail (line 37) | namespace detail {
      function bm_llc_size_fallback (line 39) | size_t bm_llc_size_fallback() {
    function bm_llc_size (line 120) | size_t bm_llc_size() {
    function bm_llc_evict (line 126) | void bm_llc_evict(size_t value) {

FILE: folly/BenchmarkUtil.h
  function namespace (line 22) | namespace folly {
  function namespace (line 47) | namespace detail {

FILE: folly/CancellationToken-inl.h
  function namespace (line 26) | namespace folly {
  function swap (line 169) | inline void CancellationToken::swap(CancellationToken& other) noexcept {
  function CancellationToken (line 173) | inline CancellationToken::CancellationToken(
  function CancellationSource (line 190) | inline CancellationSource::CancellationSource(
  function CancellationSource (line 198) | inline CancellationSource::CancellationSource(
  function CancellationSource (line 217) | inline CancellationSource CancellationSource::invalid() noexcept {
  function CancellationToken (line 229) | inline CancellationToken CancellationSource::getToken() const noexcept {
  function swap (line 243) | inline void CancellationSource::swap(CancellationSource& other) noexcept {
  function CancellationSource (line 247) | inline CancellationSource::CancellationSource(
  function invokeCallback (line 295) | inline void CancellationCallback::invokeCallback() noexcept {
  function namespace (line 300) | namespace detail {

FILE: folly/CancellationToken.cpp
  type folly (line 30) | namespace folly {
    type detail (line 31) | namespace detail {
      function allocAndConstructMergingState (line 300) | auto allocAndConstructMergingState(size_t n, Args&&... ctorArgs) {
      function CancellationStateTokenPtr (line 320) | CancellationStateTokenPtr MergingCancellationState::createCopy(
      function CancellationStateTokenPtr (line 324) | CancellationStateTokenPtr MergingCancellationState::createMove(
      function CancellationStateTokenPtr (line 328) | CancellationStateTokenPtr MergingCancellationState::createCopyMove(

FILE: folly/CancellationToken.h
  type cancellation_token_merge_fn (line 32) | struct cancellation_token_merge_fn
  function namespace (line 34) | namespace detail {
  function requestCancellation (line 223) | bool requestCancellation() const noexcept;

FILE: folly/Chrono.h
  function namespace (line 28) | namespace folly {
  type coarse_system_clock (line 96) | struct coarse_system_clock {
  function std (line 120) | static std::time_t to_time_t(const time_point& t) noexcept {
  function time_point (line 125) | static time_point from_time_t(std::time_t t) noexcept {

FILE: folly/ClockGettimeWrappers.cpp
  type folly (line 31) | namespace folly {
    type chrono (line 32) | namespace chrono {
      function clock_gettime_ns_fallback (line 34) | static int64_t clock_gettime_ns_fallback(clockid_t clock) {
      type VdsoInitializer (line 58) | struct VdsoInitializer {
        method VdsoInitializer (line 59) | VdsoInitializer() {

FILE: folly/ClockGettimeWrappers.h
  function namespace (line 23) | namespace folly {

FILE: folly/ConcurrentBitSet.h
  function namespace (line 27) | namespace folly {

FILE: folly/ConcurrentLazy.h
  function namespace (line 25) | namespace folly {

FILE: folly/ConcurrentSkipList-inl.h
  function namespace (line 37) | namespace folly {

FILE: folly/ConcurrentSkipList.h
  function namespace (line 134) | namespace folly {
  function less (line 218) | static bool less(const value_type& data, const NodeType* node) {
  function findInsertionPoint (line 222) | static int findInsertionPoint(
  function incrementSize (line 255) | size_t incrementSize(int delta) {
  function NodeType (line 260) | NodeType* find(const value_type& data) {
  function remove (line 360) | bool remove(const value_type& data) {
  function value_type (line 402) | const value_type* first() const {
  function value_type (line 407) | const value_type* last() const {
  function okToDelete (line 423) | static bool okToDelete(NodeType* candidate, int layer) {
  function findInsertionPointGetMaxLayer (line 430) | int findInsertionPointGetMaxLayer(
  function NodeType (line 496) | NodeType* lower_bound(const value_type& data) const {
  function growHeight (line 504) | void growHeight(int height) {
  function recycle (line 529) | void recycle(NodeType* node) { recycler_.add(node); }
  function explicit (line 556) | explicit Accessor(std::shared_ptr<ConcurrentSkipList> skip_list)
  function explicit (line 565) | explicit Accessor(ConcurrentSkipList* skip_list) : sl_(skip_list) {
  function size_type (line 589) | size_type max_size() const { return std::numeric_limits<size_type>::max(...
  function const_iterator (line 595) | const_iterator find(const key_type& value) const {
  function size_type (line 598) | size_type count(const key_type& data) const { return contains(data); }
  function iterator (line 600) | iterator begin() const {
  function erase (line 616) | size_t erase(const key_type& data) { return remove(data); }
  function iterator (line 618) | iterator lower_bound(const key_type& data) const {
  function key_type (line 635) | const key_type* first() const { return sl_->first(); }
  function key_type (line 636) | const key_type* last() const { return sl_->last(); }
  function pop_back (line 643) | bool pop_back() {
  function SkipListType (line 653) | SkipListType* skiplist() const { return sl_; }
  function contains (line 659) | bool contains(const key_type& data) const { return sl_->find(data); }
  function add (line 660) | bool add(const key_type& data) { return sl_->addOrGetData(data).second; }
  function remove (line 661) | bool remove(const key_type& data) { return sl_->remove(data); }
  function increment (line 704) | void increment() { node_ = node_->next(); }
  function equal (line 705) | bool equal(const csl_iterator& other) const { return node_ == other.node...
  function accessor_ (line 729) | Skipper(const Accessor& accessor) : accessor_(accessor) { init(); }
  function init (line 731) | void init() {
  function value_type (line 772) | const value_type& data() const {
  function to (line 793) | bool to(const value_type& data) {

FILE: folly/ConstexprMath.h
  function namespace (line 30) | namespace folly {

FILE: folly/ConstructorCallbackList.h
  function namespace (line 30) | namespace folly {

FILE: folly/Conv.cpp
  type folly (line 26) | namespace folly {
    type detail (line 27) | namespace detail {
      type MaxString (line 56) | struct MaxString {
      type ErrorString (line 218) | struct ErrorString {
      function tolower_ascii (line 268) | inline char tolower_ascii(char in) {
      function bool_str_cmp (line 272) | inline bool bool_str_cmp(const char** b, size_t len, const char* val...
      function str_to_bool (line 291) | Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
      function str_to_floating_fast_float_from_chars (line 365) | Expected<Tgt, ConversionCode> str_to_floating_fast_float_from_chars(
      function str_to_floating (line 406) | Expected<Tgt, ConversionCode> str_to_floating(StringPiece* src) noex...
      class SignedValueHandler (line 422) | class SignedValueHandler
      class SignedValueHandler<T, true> (line 425) | class SignedValueHandler<T, true> {
        method ConversionCode (line 427) | ConversionCode init(const char*& b) {
        method ConversionCode (line 440) | ConversionCode overflow() {
        method finalize (line 447) | Expected<T, ConversionCode> finalize(U value) {
      class SignedValueHandler<T, false> (line 476) | class SignedValueHandler<T, false> {
        method ConversionCode (line 478) | ConversionCode init(const char*&) { return ConversionCode::SUCCESS; }
        method ConversionCode (line 480) | ConversionCode overflow() { return ConversionCode::POSITIVE_OVERFL...
        method finalize (line 482) | Expected<T, ConversionCode> finalize(T value) { return value; }
      function digits_to (line 495) | inline Expected<Tgt, ConversionCode> digits_to(
      function str_to_integral (line 633) | Expected<Tgt, ConversionCode> str_to_integral(StringPiece* src) noex...
    function ConversionError (line 715) | ConversionError makeConversionError(ConversionCode code, StringPiece i...

FILE: folly/Conv.h
  function namespace (line 148) | namespace folly {
  function estimateSpaceNeeded (line 464) | inline size_t estimateSpaceNeeded(std::nullptr_t /* value */) {
  function DtoaMode (line 654) | enum class DtoaMode {
  function namespace (line 861) | namespace detail {
  function one (line 916) | static void one(const T& v, Tgt* result) {
  function call (line 923) | void call(const T&... v) {
  function one (line 934) | static void one(const Delimiter& d, const T& v, Tgt* result) {
  function call (line 944) | void call(const Delimiter& d, const T&... v) {
  function typename (line 1519) | typename std::underlying_type<T>::type tmp{}
  function namespace (line 1532) | namespace detail {
  type CheckTrailingSpace (line 1575) | struct CheckTrailingSpace {
  function Tgt (line 1651) | Tgt result{}
  function Tgt (line 1685) | Tgt result{}
  function Error (line 1693) | Error e) { return makeConversionError(e, *src); }

FILE: folly/CpuId.h
  function namespace (line 25) | namespace folly {

FILE: folly/DefaultKeepAliveExecutor.h
  function namespace (line 27) | namespace folly {
  function class (line 50) | class WeakRefExecutor : public virtual Executor {}
  function joinAndResetKeepAlive (line 59) | void joinAndResetKeepAlive() {
  type ControlBlock (line 69) | struct ControlBlock {
  function add (line 81) | void add(Func f) override {
  function addWithPriority (line 87) | void addWithPriority(Func f, int8_t priority) override {
  function keepAliveAcquire (line 101) | bool keepAliveAcquire() noexcept override {
  function keepAliveRelease (line 109) | void keepAliveRelease() noexcept override {
  function keepAliveAcquire (line 143) | bool keepAliveAcquire() noexcept override {
  function keepAliveRelease (line 151) | void keepAliveRelease() noexcept override {

FILE: folly/Demangle.cpp
  type poison (line 69) | struct poison {}
  function FOLLY_POP_WARNING (line 74) | FOLLY_POP_WARNING
  function call_rust_demangle_callback (line 91) | int call_rust_demangle_callback(
  type folly (line 128) | namespace folly {
    function demangle_build_has_cxxabi (line 130) | bool demangle_build_has_cxxabi() noexcept {
    function demangle_build_has_liberty (line 133) | bool demangle_build_has_liberty() noexcept {
    function demangleStringCallback (line 142) | void demangleStringCallback(const char* str, size_t size, void* p) {
    function fbstring (line 149) | fbstring demangle(const char* name) {
    type DemangleBuf (line 204) | struct DemangleBuf {
    function demangleBufCallback (line 210) | void demangleBufCallback(const char* str, size_t size, void* p) {
    function demangle (line 221) | size_t demangle(const char* name, char* out, size_t outSize) {

FILE: folly/Demangle.h
  function namespace (line 22) | namespace folly {

FILE: folly/DiscriminatedPtr.h
  function namespace (line 40) | namespace folly {
  function clear (line 143) | void clear() { data_ = 0; }
  function set (line 207) | void set(void* p, uint16_t v) {

FILE: folly/Exception.h
  function namespace (line 31) | namespace folly {
  function throwSystemErrorExplicit (line 73) | [[noreturn]] inline void throwSystemErrorExplicit(int err, const char* m...
  function throwSystemErrorExplicit (line 78) | [[noreturn]] void throwSystemErrorExplicit(int err, Args&&... args) {
  function throwSystemError (line 84) | [[noreturn]] void throwSystemError(Args&&... args) {

FILE: folly/ExceptionString.cpp
  type folly (line 25) | namespace folly {
    function fbstring (line 29) | fbstring exception_string_type(std::type_info const* ti) {
    function fbstring (line 39) | fbstring exceptionStr(std::exception const& e) {
    function fbstring (line 44) | fbstring exceptionStr(std::exception_ptr const& ep) {

FILE: folly/ExceptionString.h
  function namespace (line 23) | namespace folly {

FILE: folly/ExceptionWrapper-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/ExceptionWrapper.cpp
  type folly (line 21) | namespace folly {
    function fbstring (line 31) | fbstring exceptionStr(exception_wrapper const& ew) {

FILE: folly/ExceptionWrapper.h
  function class (line 99) | class exception_wrapper final {
  function swap (line 384) | inline void swap(exception_wrapper& a, exception_wrapper& b) noexcept {
  function exception_wrapper (line 402) | inline exception_wrapper current_exception_wrapper() noexcept {
  function fbstring (line 409) | struct fmt::formatter<folly::exception_wrapper> : formatter<folly::fbstr...

FILE: folly/Executor.cpp
  type folly (line 27) | namespace folly {
    function getExecutorBlockingContext (line 53) | Optional<ExecutorBlockingContext> getExecutorBlockingContext() noexcept {

FILE: folly/Executor.h
  function namespace (line 29) | namespace folly {
  function ExecutorT (line 140) | ExecutorT* get() const {
  function invokeCatchingExns (line 232) | static void invokeCatchingExns(char const* p, F f) noexcept {
  function isKeepAliveDummy (line 245) | bool isKeepAliveDummy(const KeepAlive<ExecutorT>& keepAlive) {
  function keepAliveAcquire (line 249) | static bool keepAliveAcquire(Executor* executor) {
  function keepAliveRelease (line 252) | static void keepAliveRelease(Executor* executor) {
  type ExecutorBlockingContext (line 341) | struct ExecutorBlockingContext {
  type ExecutorBlockingList (line 351) | struct ExecutorBlockingList {
  function class (line 359) | class ExecutorBlockingGuard {

FILE: folly/Expected.h
  function namespace (line 54) | namespace folly {
  function namespace (line 214) | namespace expected_detail {
  type EmptyTag (line 277) | struct EmptyTag {}
  type ValueTag (line 278) | struct ValueTag {}
  type ErrorTag (line 279) | struct ErrorTag {}
  function Which (line 280) | enum class Which : unsigned char { eEmpty, eValue, eError };
  function Value (line 354) | const Value&& value() const&& { return std::move(value_); }
  function noexcept (line 439) | noexcept(Noexcept) {
  function noexcept (line 461) | noexcept(Noexcept) {
  function Base (line 499) | Base{ErrorTag{}
  function clear (line 506) | void clear() noexcept {
  function isSelfAssign (line 548) | bool isSelfAssign(const ExpectedStorage* that) const { return this == th...
  function isSelfAssign (line 549) | constexpr bool isSelfAssign(const void*) const { return false; }
  function explicit (line 584) | explicit constexpr ExpectedStorage(EmptyTag) noexcept
  function namespace (line 631) | namespace expected_detail_ExpectedHelper {
  type UnexpectedTag (line 836) | struct UnexpectedTag {}
  function expected_detail (line 843) | inline expected_detail::UnexpectedTag unexpected(
  function namespace (line 848) | namespace expected_detail {
  type expected_detail (line 951) | struct expected_detail
  type MakeBadExpectedAccess (line 958) | struct MakeBadExpectedAccess {
  function noexcept (line 985) | noexcept(noexcept(B{})) : Base{}
  function noexcept (line 1054) | noexcept(
  function swap (line 1132) | void swap(Expected& that) noexcept(
  function hasValue (line 1176) | constexpr bool hasValue() const noexcept {
  function Value (line 1186) | const Value& value() const& {
  function explicit (line 1243) | explicit constexpr operator bool() const noexcept { return hasValue(); }
  function explicit (line 1411) | explicit Expected(EmptyTag tag) noexcept : Base{tag}
  function requireValueMove (line 1436) | void requireValueMove() { return requireValueMove(*this); }
  function unhandled_exception (line 1628) | [[noreturn]] void unhandled_exception() {
  function return_void (line 1654) | void return_void() { this->value_->emplace(Value{}); }
  function explicit (line 1668) | explicit UnexpectedAwaitable(Unexpected<Error> o) : o_(std::move(o)) {}
  function std (line 1670) | constexpr std::false_type await_ready() const noexcept { return {}; }
  function explicit (line 1688) | explicit ExpectedAwaitable(Expected<Value, Error> o) : o_(std::move(o)) {}
  function Value (line 1691) | Value await_resume() { return std::move(o_.value()); }
  function await_suspend (line 1695) | void

FILE: folly/FBString.h
  function FOLLY_PUSH_WARNING (line 50) | FOLLY_PUSH_WARNING
  function swap (line 328) | void swap(fbstring_core& rhs) {
  function Char (line 335) | const Char* data() const { return c_str(); }
  function Char (line 337) | Char* data() { return c_str(); }
  function Char (line 339) | Char* mutableData() {
  function Char (line 352) | const Char* c_str() const {
  function shrink (line 359) | void shrink(const size_t delta) {
  function FOLLY_NOINLINE (line 370) | FOLLY_NOINLINE
  function push_back (line 396) | void push_back(Char c) { *expandNoinit(1, /* expGrowth = */ true) = c; }
  function size (line 398) | size_t size() const {
  function reset (line 463) | void reset() { setSmallSize(0); }
  function FOLLY_NOINLINE (line 465) | FOLLY_NOINLINE void destroyMediumLarge() noexcept {
  type RefCounted (line 475) | struct RefCounted {
  function refs (line 489) | static size_t refs(Char* p) {
  function incrementRefs (line 493) | static void incrementRefs(Char* p) {
  function decrementRefs (line 497) | static void decrementRefs(Char* p) {
  function RefCounted (line 506) | static RefCounted* create(size_t* size) {
  function RefCounted (line 522) | static RefCounted* create(const Char* data, size_t* size) {
  function RefCounted (line 531) | static RefCounted* reallocate(
  type category_type (line 559) | typedef uint8_t category_type;
  function category_type (line 561) | enum class Category : category_type {
  function setSmallSize (line 615) | void setSmallSize(size_t s) {
  function backend_ (line 926) | dummy_fbstring_core(const dummy_fbstring_core& another)
  function Char (line 930) | const Char* data() const { return backend_.data(); }
  function Char (line 931) | Char* mutableData() { return const_cast<Char*>(backend_.data()); }
  function shrink (line 932) | void shrink(size_t delta) {
  function Char (line 936) | Char* expandNoinit(size_t delta) {
  function push_back (line 941) | void push_back(Char c) { backend_.push_back(c); }
  function reserve (line 947) | void reserve(size_t minCapacity) { backend_.reserve(minCapacity); }
  function enforce (line 969) | void enforce(bool condition, Args&&... args) {
  function explicit (line 984) | explicit Invariant(const basic_fbstring& s) noexcept : s_(s) {
  type typename (line 996) | typedef typename traits_type::char_type value_type;
  type A (line 997) | typedef A allocator_type;
  type typename (line 998) | typedef typename std::allocator_traits<A>::size_type size_type;
  type typename (line 999) | typedef typename std::allocator_traits<A>::difference_type difference_type;
  type typename (line 1001) | typedef typename std::allocator_traits<A>::value_type& reference;
  type typename (line 1002) | typedef typename std::allocator_traits<A>::value_type const& const_refer...
  type typename (line 1003) | typedef typename std::allocator_traits<A>::pointer pointer;
  type typename (line 1004) | typedef typename std::allocator_traits<A>::const_pointer const_pointer;
  type E (line 1006) | typedef E* iterator;
  type E (line 1007) | typedef const E* const_iterator;
  type std (line 1008) | typedef std::reverse_iterator<iterator> reverse_iterator;
  type std (line 1009) | typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  type std (line 1012) | typedef std::true_type IsRelocatable;
  type string_view_ctor (line 1034) | struct string_view_ctor {}
  function FOLLY_NOINLINE (line 1035) | FOLLY_NOINLINE basic_fbstring(
  function explicit (line 1057) | explicit basic_fbstring(const A&) noexcept {}
  function store_ (line 1059) | basic_fbstring(const basic_fbstring& str) : store_(str.store_) {}
  function FOLLY_NOINLINE (line 1078) | FOLLY_NOINLINE
  function FOLLY_NOINLINE (line 1082) | FOLLY_NOINLINE
  function FOLLY_NOINLINE (line 1086) | FOLLY_NOINLINE
  function FOLLY_NOINLINE (line 1104) | FOLLY_NOINLINE
  function FOLLY_NOINLINE (line 1114) | FOLLY_NOINLINE
  function operator (line 1180) | operator string_view_type() const noexcept { return {data(), size()}; }
  function iterator (line 1189) | iterator end() { return store_.mutableData() + store_.size(); }
  function reverse_iterator (line 1195) | reverse_iterator rbegin() { return reverse_iterator(end()); }
  function reverse_iterator (line 1203) | reverse_iterator rend() { return reverse_iterator(begin()); }
  function pop_back (line 1225) | void pop_back() {
  function size_type (line 1235) | size_type max_size() const { return std::numeric_limits<size_type>::max(...
  function shrink_to_fit (line 1257) | void shrink_to_fit() {
  function clear (line 1265) | void clear() { resize(0); }
  function const_reference (line 1270) | const_reference operator[](size_type pos) const { return *(begin() + pos...
  function reference (line 1272) | reference operator[](size_type pos) { return *(begin() + pos); }
  function const_reference (line 1274) | const_reference at(size_type n) const {
  function reference (line 1279) | reference at(size_type n) {
  function push_back (line 1338) | void push_back(const value_type c) { // primitive
  function iterator (line 1398) | iterator insert(const_iterator p, const value_type c) {
  function iterator (line 1448) | iterator insert(const_iterator p, std::initializer_list<value_type> il) {
  function iterator (line 1462) | iterator erase(iterator position) {
  function iterator (line 1469) | iterator erase(iterator first, iterator last) {
  function swap (line 1601) | void swap(basic_fbstring& rhs) { store_.swap(rhs.store_); }
  function value_type (line 1603) | const value_type* c_str() const { return store_.c_str(); }
  function value_type (line 1605) | const value_type* data() const { return c_str(); }
  function value_type (line 1607) | value_type* data() { return store_.data(); }
  function size_type (line 1626) | size_type rfind(const basic_fbstring& str, size_type pos = npos) const {
  function size_type (line 1632) | size_type rfind(const value_type* s, size_type pos = npos) const {
  function size_type (line 1636) | size_type rfind(value_type c, size_type pos = npos) const {
  function size_type (line 1655) | size_type find_last_of(
  function size_type (line 1662) | size_type find_last_of(const value_type* s, size_type pos = npos) const {
  function size_type (line 1666) | size_type find_last_of(value_type c, size_type pos = npos) const {
  function size_type (line 1686) | size_type find_last_not_of(
  function size_type (line 1694) | size_type find_last_not_of(const value_type* s, size_type pos = npos) co...
  function size_type (line 1698) | size_type find_last_not_of(value_type c, size_type pos = npos) const {
  function compare (line 1716) | int compare(const basic_fbstring& str) const {
  function compare (line 1721) | int compare(size_type pos1, size_type n1, const basic_fbstring& str) con...
  function compare (line 1725) | int compare(size_type pos1, size_type n1, const value_type* s) const {
  function compare (line 1729) | int compare(
  function compare (line 1738) | int compare(
  function compare (line 1750) | int compare(const value_type* s) const {
  type typename (line 2426) | typedef typename basic_fbstring<E, T, A, S>::size_type size_type;
  type typename (line 2427) | typedef typename basic_fbstring<E, T, A, S>::traits_type traits_type;
  type std (line 2714) | typedef std::ostreambuf_iterator<
  type streamsize (line 2733) | typedef decltype(os.precision()) streamsize;
  type basic_fbstring (line 2828) | typedef basic_fbstring<char> fbstring;
  function std (line 2841) | inline const std::string& toStdString(const std::string& s) {
  function std (line 2847) | inline std::string&& toStdString(std::string&& s) {
  function namespace (line 2870) | namespace std {
  function namespace (line 2883) | namespace folly {
  type fmt (line 2892) | struct fmt

FILE: folly/File.cpp
  type folly (line 31) | namespace folly {
    function File (line 61) | File& File::operator=(File&& other) {
    function File (line 76) | File File::temporary() {
    function swap (line 104) | void swap(File& a, File& b) noexcept {
    function File (line 108) | File File::dup() const {
    function File (line 119) | File File::dupCloseOnExec() const {

FILE: folly/File.h
  function namespace (line 37) | namespace folly {

FILE: folly/FileUtil.cpp
  type folly (line 32) | namespace folly {
    function openNoInt (line 39) | int openNoInt(const char* name, int flags, mode_t mode) {
    function filterCloseReturn (line 58) | static int filterCloseReturn(int r) {
    function closeNoInt (line 74) | int closeNoInt(int fd) {
    function closeNoInt (line 78) | int closeNoInt(NetworkSocket fd) {
    function fsyncNoInt (line 82) | int fsyncNoInt(int fd) {
    function dupNoInt (line 86) | int dupNoInt(int fd) {
    function dup2NoInt (line 90) | int dup2NoInt(int oldFd, int newFd) {
    function fdatasyncNoInt (line 94) | int fdatasyncNoInt(int fd) {
    function ftruncateNoInt (line 104) | int ftruncateNoInt(int fd, off_t len) {
    function truncateNoInt (line 108) | int truncateNoInt(const char* path, off_t len) {
    function flockNoInt (line 112) | int flockNoInt(int fd, int operation) {
    function shutdownNoInt (line 116) | int shutdownNoInt(NetworkSocket fd, int how) {
    function readNoInt (line 120) | ssize_t readNoInt(int fd, void* buf, size_t count) {
    function preadNoInt (line 124) | ssize_t preadNoInt(int fd, void* buf, size_t count, off_t offset) {
    function readvNoInt (line 128) | ssize_t readvNoInt(int fd, const iovec* iov, int count) {
    function preadvNoInt (line 132) | ssize_t preadvNoInt(int fd, const iovec* iov, int count, off_t offset) {
    function writeNoInt (line 136) | ssize_t writeNoInt(int fd, const void* buf, size_t count) {
    function pwriteNoInt (line 140) | ssize_t pwriteNoInt(int fd, const void* buf, size_t count, off_t offse...
    function writevNoInt (line 144) | ssize_t writevNoInt(int fd, const iovec* iov, int count) {
    function pwritevNoInt (line 148) | ssize_t pwritevNoInt(int fd, const iovec* iov, int count, off_t offset) {
    function readFull (line 152) | ssize_t readFull(int fd, void* buf, size_t count) {
    function preadFull (line 156) | ssize_t preadFull(int fd, void* buf, size_t count, off_t offset) {
    function writeFull (line 160) | ssize_t writeFull(int fd, const void* buf, size_t count) {
    function pwriteFull (line 164) | ssize_t pwriteFull(int fd, const void* buf, size_t count, off_t offset) {
    function readvFull (line 169) | ssize_t readvFull(int fd, iovec* iov, int count) {
    function preadvFull (line 173) | ssize_t preadvFull(int fd, iovec* iov, int count, off_t offset) {
    function writevFull (line 177) | ssize_t writevFull(int fd, iovec* iov, int count) {
    function pwritevFull (line 181) | ssize_t pwritevFull(int fd, iovec* iov, int count, off_t offset) {
    function readvFull (line 192) | ssize_t readvFull(int fd, iovec* iov, int count) {
    function preadvFull (line 196) | ssize_t preadvFull(int fd, iovec* iov, int count, off_t offset) {
    function writevFull (line 200) | ssize_t writevFull(int fd, iovec* iov, int count) {
    function pwritevFull (line 204) | ssize_t pwritevFull(int fd, iovec* iov, int count, off_t offset) {
    function WriteFileAtomicOptions (line 209) | WriteFileAtomicOptions& WriteFileAtomicOptions::setPermissions(
    function WriteFileAtomicOptions (line 215) | WriteFileAtomicOptions& WriteFileAtomicOptions::setSyncType(
    function WriteFileAtomicOptions (line 221) | WriteFileAtomicOptions& WriteFileAtomicOptions::setTemporaryDirectory(
    function throwIfWriteFileAtomicFailed (line 228) | void throwIfWriteFileAtomicFailed(
    function writeFileAtomicNoThrowImpl (line 243) | int writeFileAtomicNoThrowImpl(
  function writeFileAtomicNoThrow (line 303) | int writeFileAtomicNoThrow(
  function writeFileAtomicNoThrow (line 318) | int writeFileAtomicNoThrow(
  function writeFileAtomic (line 326) | void writeFileAtomic(
  function writeFileAtomic (line 342) | void writeFileAtomic(
  function writeFileAtomic (line 351) | void writeFileAtomic(
  function writeFileAtomic (line 359) | void writeFileAtomic(
  function iovec (line 370) | iovec getIOVecFor(ByteRange byteRange) {

FILE: folly/FileUtil.h
  function namespace (line 33) | namespace folly {
  type class (line 229) | enum class
  function mode_t (line 238) | mode_t permissions{0644};

FILE: folly/Fingerprint.cpp
  type folly (line 24) | namespace folly {
    type detail (line 25) | namespace detail {
      type FingerprintTablePoly (line 41) | struct FingerprintTablePoly
      type FingerprintTablePoly<63> (line 43) | struct FingerprintTablePoly<63> {
      type FingerprintTablePoly<95> (line 47) | struct FingerprintTablePoly<95> {
      type FingerprintTablePoly<127> (line 51) | struct FingerprintTablePoly<127> {
      function copy_table (line 56) | constexpr auto copy_table(D const (&table)[S0], std::index_sequence<...
      function copy_table (line 61) | constexpr auto copy_table(D const (&table)[S0]) {
      function copy_table (line 66) | constexpr auto copy_table(
      function copy_table (line 72) | constexpr auto copy_table(D const (&table)[S0][S1]) {
      function copy_table (line 77) | constexpr auto copy_table(
      function copy_table (line 83) | constexpr auto copy_table(D const (&table)[S0][S1][S2]) {
      function make_poly_table (line 88) | constexpr poly_table<Deg> make_poly_table() {

FILE: folly/Fingerprint.h
  function namespace (line 49) | namespace folly {
  function fingerprint64 (line 190) | inline uint64_t fingerprint64(StringPiece str) {
  function fingerprint96 (line 201) | inline void fingerprint96(StringPiece str, uint64_t* msb, uint32_t* lsb) {
  function fingerprint128 (line 213) | inline void fingerprint128(StringPiece str, uint64_t* msb, uint64_t* lsb) {

FILE: folly/FixedString.h
  function namespace (line 39) | namespace folly {
  function BasicFixedString (line 911) | constexpr BasicFixedString& assign(
  function swap (line 925) | constexpr void swap(BasicFixedString& that) noexcept {
  function Char (line 938) | constexpr Char* data() noexcept { return data_; }
  function Char (line 943) | constexpr const Char* data() const noexcept { return data_; }
  function Char (line 948) | constexpr const Char* c_str() const noexcept { return data_; }
  function Char (line 953) | constexpr Char* begin() noexcept { return data_; }
  function Char (line 958) | constexpr const Char* begin() const noexcept { return data_; }
  function Char (line 963) | constexpr const Char* cbegin() const noexcept { return begin(); }
  function Char (line 968) | constexpr Char* end() noexcept { return data_ + size_; }
  function Char (line 973) | constexpr const Char* end() const noexcept { return data_ + size_; }
  function Char (line 978) | constexpr const Char* cend() const noexcept { return end(); }
  function reverse_iterator (line 984) | constexpr reverse_iterator rbegin() noexcept {
  function BasicFixedString (line 1165) | constexpr BasicFixedString& append(std::size_t count, Char ch) noexcept(
  function BasicFixedString (line 1228) | constexpr BasicFixedString& append(const Char* that) noexcept(false) {
  function BasicFixedString (line 1241) | constexpr BasicFixedString& append(
  function noexcept (line 1353) | noexcept(false) {
  function BasicFixedString (line 1362) | constexpr BasicFixedString& erase() noexcept {
  function BasicFixedString (line 1377) | constexpr BasicFixedString& erase(
  function BasicFixedString (line 1418) | constexpr BasicFixedString cerase(
  function noexcept (line 1447) | const noexcept(false) {
  function compare (line 1478) | constexpr int compare(const Char* that) const noexcept {
  function compare (line 1485) | constexpr int compare(Range<const Char*> that) const noexcept {
  function compare (line 1494) | constexpr int compare(
  function compare (line 1503) | constexpr int compare(
  function compare (line 1525) | constexpr int compare(
  function compare (line 1540) | constexpr int compare(
  function BasicFixedString (line 1556) | constexpr BasicFixedString substr(std::size_t pos) const noexcept(false) {
  function BasicFixedString (line 1564) | constexpr BasicFixedString substr(std::size_t pos, std::size_t count) const
  function BasicFixedString (line 1626) | constexpr BasicFixedString& replace(
  function BasicFixedString (line 1641) | constexpr BasicFixedString& replace(
  function BasicFixedString (line 1664) | constexpr BasicFixedString& replace(
  function BasicFixedString (line 1687) | constexpr BasicFixedString& replace(
  function BasicFixedString (line 1701) | constexpr BasicFixedString& replace(
  function BasicFixedString (line 1718) | constexpr BasicFixedString& replace(
  function noexcept (line 1841) | const
  function copy (line 1928) | constexpr std::size_t copy(Char* dest, std::size_t count) const noexcept {
  function copy (line 1939) | constexpr std::size_t copy(
  function resize (line 1955) | constexpr void resize(std::size_t count) noexcept(false) {
  function resize (line 1964) | constexpr void resize(std::size_t count, Char ch) noexcept(false) {
  function find (line 1983) | size_t find(
  function find (line 1995) | size_t find(
  function find (line 2007) | constexpr std::size_t find(const Char* that) const noexcept {
  function find (line 2017) | constexpr std::size_t find(const Char* that, std::size_t pos) const
  function find (line 2033) | constexpr std::size_t find(
  function find (line 2045) | constexpr std::size_t find(Char ch) const noexcept { return find(ch, 0u); }
  function find (line 2053) | constexpr std::size_t find(Char ch, std::size_t pos) const noexcept(fals...
  function rfind (line 2066) | size_t rfind(
  function rfind (line 2077) | size_t rfind(
  function rfind (line 2096) | constexpr std::size_t rfind(const Char* that) const noexcept {
  function rfind (line 2105) | constexpr std::size_t rfind(const Char* that, std::size_t pos) const
  function rfind (line 2121) | constexpr std::size_t rfind(
  function rfind (line 2139) | constexpr std::size_t rfind(Char ch) const noexcept {
  function rfind (line 2149) | constexpr std::size_t rfind(Char ch, std::size_t pos) const noexcept(fal...
  function swap (line 2872) | constexpr void swap(
  function namespace (line 2877) | inline namespace literals {

FILE: folly/FmtUtility.cpp
  type folly (line 23) | namespace folly {

FILE: folly/FmtUtility.h
  function namespace (line 23) | namespace folly {
  function fmt_make_format_args_from_map_fn (line 44) | inline constexpr fmt_make_format_args_from_map_fn
  type fmt_vformat_mangle_name_fn (line 52) | struct fmt_vformat_mangle_name_fn {
  function fmt_vformat_mangle_name_fn (line 56) | inline constexpr fmt_vformat_mangle_name_fn fmt_vformat_mangle_name{}
  type fmt_vformat_mangle_format_string_fn (line 64) | struct fmt_vformat_mangle_format_string_fn {
  function fmt_vformat_mangle_format_string_fn (line 77) | inline constexpr fmt_vformat_mangle_format_string_fn

FILE: folly/FollyMemcpy.cpp
  type folly (line 20) | namespace folly {

FILE: folly/FollyMemcpy.h
  function namespace (line 19) | namespace folly {

FILE: folly/FollyMemset.cpp
  type folly (line 21) | namespace folly {

FILE: folly/FollyMemset.h
  function namespace (line 21) | namespace folly {

FILE: folly/Format-inl.h
  function namespace (line 44) | namespace detail {
  function namespace (line 318) | namespace format_value {
  type typename (line 474) | typedef typename std::make_unsigned<T>::type UT;
  function namespace (line 881) | namespace detail {
  function namespace (line 953) | namespace detail {

FILE: folly/Format.cpp
  type folly (line 27) | namespace folly {
    type detail (line 28) | namespace detail {
      type format_table_align_make_item (line 31) | struct format_table_align_make_item {
      type format_table_conv_make_item (line 48) | struct format_table_conv_make_item {
        type make_item (line 50) | struct make_item {
          method alpha (line 52) | constexpr char alpha(std::size_t ord) const {
      type format_table_sign_make_item (line 66) | struct format_table_sign_make_item {
      function insertThousandsGroupingUnsafe (line 392) | void insertThousandsGroupingUnsafe(char* start_buffer, char** end_bu...
    type detail (line 391) | namespace detail {
      type format_table_align_make_item (line 31) | struct format_table_align_make_item {
      type format_table_conv_make_item (line 48) | struct format_table_conv_make_item {
        type make_item (line 50) | struct make_item {
          method alpha (line 52) | constexpr char alpha(std::size_t ord) const {
      type format_table_sign_make_item (line 66) | struct format_table_sign_make_item {
      function insertThousandsGroupingUnsafe (line 392) | void insertThousandsGroupingUnsafe(char* start_buffer, char** end_bu...

FILE: folly/Format.h
  function class (line 65) | class FormatterTag {}
  type BaseFormatterBase (line 67) | struct BaseFormatterBase {
  function explicit (line 88) | explicit BaseFormatterTuple(std::in_place_t, A&&... a)
  function const (line 95) | void operator()(StringPiece s) const { str.append(s.data(), s.size()); }
  function formatCheckIndex (line 98) | inline void formatCheckIndex(size_t i, const FormatArg& arg, size_t max) {
  function getSizeArgAt (line 173) | int getSizeArgAt(std::false_type) const {
  function getSizeArg (line 181) | void getSizeArg(int* out) const {
  function doFormatArg (line 235) | void doFormatArg(
  function namespace (line 252) | namespace detail {
  function writer (line 270) | auto writer = detail::FormatterOstreamInsertionWriterFn<out_t>{out};
  function namespace (line 327) | namespace detail {
  function namespace (line 361) | namespace format_value {
  function namespace (line 418) | namespace detail {

FILE: folly/FormatArg.h
  function namespace (line 28) | namespace folly {
  type class (line 76) | enum class
  type class (line 116) | enum class
  function Sign (line 129) | enum class Sign : uint8_t {

FILE: folly/FormatTraits.h
  function namespace (line 22) | namespace folly {

FILE: folly/Function.h
  function namespace (line 218) | namespace folly {
  type DispatchBig (line 577) | struct DispatchBig {
  type Dispatch (line 603) | struct Dispatch
  type Dispatch (line 605) | struct Dispatch
  type Dispatch (line 607) | struct Dispatch
  type Dispatch (line 609) | struct Dispatch
  function mutable (line 646) | mutable Data data_{unsafe_default_initialized};
  function namespace (line 1006) | namespace detail {
  function Call (line 1084) | Call call_{&FunctionRef::uninitCall};

FILE: folly/GroupVarint.cpp
  type folly (line 22) | namespace folly {
    type detail (line 42) | namespace detail {
      type group_varint_table_base_make_item (line 44) | struct group_varint_table_base_make_item {
        method get_d (line 45) | constexpr std::size_t get_d(std::size_t index, std::size_t j) const {
        method get_offset (line 48) | constexpr std::size_t get_offset(std::size_t index, std::size_t j)...
      type group_varint_table_length_make_item (line 60) | struct group_varint_table_length_make_item : group_varint_table_base...
      type group_varint_table_sse_mask_make_item (line 106) | struct group_varint_table_sse_mask_make_item
        method partial_item (line 108) | constexpr auto partial_item(
        method item_impl (line 116) | constexpr auto item_impl(std::size_t d, std::size_t offset) const {
        method item (line 127) | constexpr auto item(std::size_t index, std::size_t j) const {

FILE: folly/GroupVarint.h
  function namespace (line 45) | namespace folly {
  function namespace (line 52) | namespace folly {
  function namespace (line 58) | namespace folly {

FILE: folly/IPAddress.cpp
  type folly (line 34) | namespace folly {
    function hash_value (line 37) | size_t hash_value(const IPAddress& addr) {
    function ostream (line 40) | ostream& operator<<(ostream& os, const IPAddress& addr) {
    function toAppend (line 44) | void toAppend(IPAddress addr, string* result) {
    function toAppend (line 47) | void toAppend(IPAddress addr, fbstring* result) {
    function IPAddressV4 (line 56) | IPAddressV4 IPAddress::createIPv4(const IPAddress& addr) {
    function IPAddressV6 (line 65) | IPAddressV6 IPAddress::createIPv6(const IPAddress& addr) {
    function splitIpSlashCidr (line 75) | auto splitIpSlashCidr(StringPiece ipSlashCidr) {
    function CIDRNetwork (line 84) | CIDRNetwork IPAddress::createNetwork(
    function IPAddress (line 185) | IPAddress IPAddress::fromBinary(ByteRange bytes) {
    function IPAddress (line 210) | IPAddress IPAddress::fromLong(uint32_t src) {
    function IPAddress (line 213) | IPAddress IPAddress::fromLongHBO(uint32_t src) {
    function IPAddress (line 295) | IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) noexcept {
    function IPAddress (line 302) | IPAddress& IPAddress::operator=(const IPAddressV6& ipv6_addr) noexcept {
    function CIDRNetwork (line 455) | CIDRNetwork IPAddress::longestCommonPrefix(

FILE: folly/IPAddress.h
  function namespace (line 44) | namespace folly {
  function IPAddressV6 (line 295) | const IPAddressV6& asV6() const {
  function bitCount (line 414) | size_t bitCount() const {
  function getNthLSBit (line 441) | bool getNthLSBit(size_t bitIndex) const {
  function getNthLSByte (line 449) | uint8_t getNthLSByte(size_t byteIndex) const {
  function isLoopback (line 474) | bool isLoopback() const {
  function isNonroutable (line 499) | bool isNonroutable() const {
  function IPAddress (line 528) | IPAddress mask(uint8_t numBits) const {
  function toFullyQualifiedAppend (line 556) | void toFullyQualifiedAppend(std::string& out) const {
  function version (line 563) | uint8_t version() const {
  function namespace (line 662) | namespace std {

FILE: folly/IPAddressException.h
  type class (line 39) | enum class
  function CIDRNetworkError (line 48) | enum class CIDRNetworkError {

FILE: folly/IPAddressV4.cpp
  type folly (line 33) | namespace folly {
    function hash_value (line 36) | size_t hash_value(const IPAddressV4& addr) {
    function ostream (line 39) | ostream& operator<<(ostream& os, const IPAddressV4& addr) {
    function toAppend (line 43) | void toAppend(IPAddressV4 addr, string* result) {
    function toAppend (line 46) | void toAppend(IPAddressV4 addr, fbstring* result) {
    function IPAddressV4 (line 55) | IPAddressV4 IPAddressV4::fromLong(uint32_t src) {
    function IPAddressV4 (line 61) | IPAddressV4 IPAddressV4::fromLongHBO(uint32_t src) {
    type in_addr (line 101) | struct in_addr
    function IPAddressV4 (line 111) | IPAddressV4 IPAddressV4::fromBinary(ByteRange bytes) {
    function IPAddressV4 (line 142) | IPAddressV4 IPAddressV4::fromInverseArpaName(const std::string& arpana...
    function IPAddressV6 (line 157) | IPAddressV6 IPAddressV4::createIPv6() const {
    function IPAddressV6 (line 166) | IPAddressV6 IPAddressV4::getIPv6For6To4() const {
    function string (line 175) | string IPAddressV4::toJson() const {
    function IPAddressV4 (line 246) | IPAddressV4 IPAddressV4::mask(size_t numBits) const {
    function string (line 258) | string IPAddressV4::str() const {
    function string (line 268) | string IPAddressV4::toInverseArpaName() const {
    function ByteArray4 (line 290) | ByteArray4 IPAddressV4::fetchMask(size_t numBits) {
    function CIDRNetworkV4 (line 301) | CIDRNetworkV4 IPAddressV4::longestCommonPrefix(

FILE: folly/IPAddressV4.h
  function namespace (line 40) | namespace folly {
  function inSubnet (line 222) | bool inSubnet(const IPAddressV4& subnet, uint8_t cidr) const {
  function isLoopback (line 240) | bool isLoopback() const;
  function sockaddr_in (line 315) | sockaddr_in toSockAddr() const {
  function byteCount (line 373) | static size_t byteCount() { return 4; }
  function getNthMSBit (line 379) | bool getNthMSBit(size_t bitIndex) const {
  function getNthLSBit (line 393) | bool getNthLSBit(size_t bitIndex) const {
  function getNthLSByte (line 401) | uint8_t getNthLSByte(size_t byteIndex) const {
  function explicit (line 418) | explicit AddressStorage(const ByteArray4 bytes) : bytes_(bytes) {}
  function explicit (line 419) | explicit AddressStorage(const in_addr addr) : inAddr_(addr) {}
  function namespace (line 490) | namespace std {

FILE: folly/IPAddressV6.cpp
  type folly (line 48) | namespace folly {
    function hash_value (line 55) | size_t hash_value(const IPAddressV6& addr) {
    function ostream (line 58) | ostream& operator<<(ostream& os, const IPAddressV6& addr) {
    function toAppend (line 62) | void toAppend(IPAddressV6 addr, string* result) {
    function toAppend (line 65) | void toAppend(IPAddressV6 addr, fbstring* result) {
    type addrinfo (line 103) | struct addrinfo
    type addrinfo (line 104) | struct addrinfo
    type sockaddr_in6 (line 113) | struct sockaddr_in6
    type sockaddr_in6 (line 114) | struct sockaddr_in6
    function IPAddressV6 (line 177) | IPAddressV6 IPAddressV6::fromBinary(ByteRange bytes) {
    function IPAddressV6 (line 209) | IPAddressV6 IPAddressV6::fromInverseArpaName(const std::string& arpana...
    function IPAddressV4 (line 239) | IPAddressV4 IPAddressV6::createIPv4() const {
    function unpack (line 248) | static inline uint16_t unpack(uint8_t lobyte, uint8_t hibyte) {
    function unpackInto (line 254) | static inline void unpackInto(
    function IPAddressV4 (line 264) | IPAddressV4 IPAddressV6::getIPv4For6To4() const {
    function string (line 318) | string IPAddressV6::toJson() const {
    function IPAddressV6 (line 409) | IPAddressV6 IPAddressV6::getSolicitedNodeAddress() const {
    function IPAddressV6 (line 436) | IPAddressV6 IPAddressV6::mask(size_t numBits) const {
    function string (line 447) | string IPAddressV6::str() const {
    function string (line 476) | string IPAddressV6::toFullyQualified() const {
    function string (line 486) | string IPAddressV6::toInverseArpaName() const {
    function ByteArray16 (line 512) | ByteArray16 IPAddressV6::fetchMask(size_t numBits) {
    function CIDRNetworkV6 (line 532) | CIDRNetworkV6 IPAddressV6::longestCommonPrefix(

FILE: folly/IPAddressV6.h
  function namespace (line 44) | namespace folly {
  function scope_ (line 589) | uint16_t scope_{0};
  function namespace (line 620) | namespace std {

FILE: folly/Indestructible.h
  type factory_constructor_t (line 60) | struct factory_constructor_t {
  function factory_constructor_t (line 64) | constexpr factory_constructor_t factory_constructor{}
  function noexcept (line 118) | constexpr Indestructible(std::initializer_list<U> il, Args... args) noex...

FILE: folly/IndexedMemPool.h
  function namespace (line 37) | namespace detail {
  function eagerRecycle (line 47) | static constexpr bool eagerRecycle() {
  function initialize (line 55) | static void initialize(T* ptr) {
  function cleanup (line 63) | static void cleanup(T* ptr) {
  function onRecycle (line 83) | static void onRecycle(T* ptr) {
  function maxIndexForCapacity (line 181) | static constexpr uint32_t maxIndexForCapacity(uint32_t capacity) {
  function capacityForMaxIndex (line 190) | static constexpr uint32_t capacityForMaxIndex(uint32_t maxIndex) {
  function capacity (line 234) | uint32_t capacity() { return capacityForMaxIndex(actualCapacity_); }
  function recycleIndex (line 273) | void recycleIndex(uint32_t idx) {
  function T (line 282) | const T& operator[](uint32_t idx) const { return *(slot(idx).elemPtr()); }
  function locateElem (line 286) | uint32_t locateElem(const T* elem) const {
  function isAllocated (line 303) | bool isAllocated(uint32_t idx) const {
  type Slot (line 310) | struct Slot {
  function withSize (line 322) | struct TaggedPtr {
  function namespace (line 528) | namespace detail {

FILE: folly/Lazy.h
  function namespace (line 25) | namespace folly {

FILE: folly/MPMCPipeline.h
  function namespace (line 26) | namespace folly {

FILE: folly/MPMCQueue.h
  function namespace (line 33) | namespace folly {
  function initQueue (line 161) | void initQueue(size_t queueCapacity) {
  type ClosedArray (line 242) | struct ClosedArray {
  function Slot (line 244) | Slot* slots_{nullptr};
  function explicit (line 255) | explicit MPMCQueue(
  function blockingReadWithTicket (line 381) | void blockingReadWithTicket(uint64_t& ticket, T& elem) noexcept {
  function initQueue (line 409) | void initQueue(const size_t cap, const size_t mult) {
  function tryObtainReadyPushTicket (line 423) | bool tryObtainReadyPushTicket(
  function tryObtainPromisedPushTicket (line 466) | bool tryObtainPromisedPushTicket(
  function tryObtainReadyPopTicket (line 503) | bool tryObtainReadyPopTicket(
  function tryObtainPromisedPopTicket (line 531) | bool tryObtainPromisedPopTicket(
  function getOffset (line 578) | uint64_t getOffset(const uint64_t state) const noexcept {
  function getNumClosed (line 582) | int getNumClosed(const uint64_t state) const noexcept {
  function tryExpand (line 590) | bool tryExpand(const uint64_t state, const size_t cap) noexcept {
  function trySeqlockReadSection (line 635) | bool trySeqlockReadSection(
  function maybeUpdateFromClosed (line 654) | bool maybeUpdateFromClosed(
  function namespace (line 680) | namespace detail {
  function blockingRead (line 952) | void blockingRead(T& elem) noexcept {
  function blockingReadWithTicket (line 958) | void blockingReadWithTicket(uint64_t& ticket, T& elem) noexcept {
  function read (line 973) | bool read(T& elem) noexcept {
  function readAndGetTicket (line 979) | bool readAndGetTicket(uint64_t& ticket, T& elem) noexcept {
  function readIfNotEmpty (line 1017) | bool readIfNotEmpty(T& elem) noexcept {
  function computeStride (line 1116) | static int computeStride(size_t capacity) noexcept {
  function idx (line 1137) | size_t idx(uint64_t ticket, size_t cap, int stride) noexcept {
  function turn (line 1143) | uint32_t turn(uint64_t ticket, size_t cap) noexcept {
  function tryObtainReadyPushTicket (line 1151) | bool tryObtainReadyPushTicket(
  function tryObtainPromisedPushTicket (line 1217) | bool tryObtainPromisedPushTicket(
  function tryObtainReadyPopTicket (line 1243) | bool tryObtainReadyPopTicket(
  function tryObtainPromisedPopTicket (line 1305) | bool tryObtainPromisedPopTicket(
  function dequeueWithTicketBase (line 1349) | void dequeueWithTicketBase(
  function enqueue (line 1386) | void enqueue(
  function mayEnqueue (line 1409) | bool mayEnqueue(const uint32_t turn) const noexcept {
  function dequeue (line 1413) | void dequeue(
  function mayDequeue (line 1436) | bool mayDequeue(const uint32_t turn) const noexcept {
  function T (line 1447) | T* ptr() noexcept { return static_cast<T*>(static_cast<void*>(&contents_...
  function destroyContents (line 1449) | void destroyContents() noexcept {
  function enqueueImpl (line 1457) | void enqueueImpl(
  function dequeueImpl (line 1468) | void dequeueImpl(

FILE: folly/MacAddress.cpp
  type folly (line 30) | namespace folly {
    function MacAddress (line 40) | MacAddress MacAddress::createMulticast(IPAddressV6 v6addr) {
    function string (line 51) | string MacAddress::toString() const {

FILE: folly/MacAddress.h
  function namespace (line 27) | namespace folly {
  function MacAddress (line 84) | static MacAddress fromBinary(ByteRange value) {
  function MacAddress (line 99) | static MacAddress fromNBO(uint64_t value) { return MacAddress(value); }
  function MacAddress (line 110) | static MacAddress fromHBO(uint64_t value) {
  function parse (line 162) | void parse(StringPiece str) { setFromString(str); }
  function getByte (line 230) | inline uint64_t getByte(size_t index) const { return bytes_[index + 2]; }
  function packedBytes (line 232) | uint64_t packedBytes() const {

FILE: folly/Math.h
  function namespace (line 30) | namespace folly {

FILE: folly/MaybeManagedPtr.h
  function namespace (line 21) | namespace folly {

FILE: folly/Memory.h
  function namespace (line 44) | namespace folly {
  function aligned_free (line 109) | inline void aligned_free(void* aligned_ptr) {
  function aligned_free (line 119) | inline void aligned_free(void* aligned_ptr) {
  function aligned_free (line 129) | inline void aligned_free(void* aligned_ptr) {
  function namespace (line 135) | namespace detail {
  type static_function_deleter (line 302) | struct static_function_deleter {
  function namespace (line 369) | namespace detail {
  function T (line 449) | const T*>>>
  function namespace (line 518) | namespace detail {
  function erased_unique_ptr (line 562) | inline erased_unique_ptr empty_erased_unique_ptr() {
  function noexcept (line 580) | constexpr SysAllocator() = default;
  function T (line 587) | T* allocate(size_t count) {
  function deallocate (line 594) | void deallocate(T* p, size_t count) { sizedFree(p, count * sizeof(T)); }
  function class (line 600) | class DefaultAlign {
  function deallocate (line 696) | void deallocate(T* p, size_t /* count */) { aligned_free(p); }
  function explicit (line 735) | explicit CxxAllocatorAdaptor() {}
  function explicit (line 737) | constexpr explicit CxxAllocatorAdaptor(Inner& ref) : inner_(&ref) {}
  function deallocate (line 762) | void deallocate(T* p, std::size_t n) {
  function explicit (line 807) | explicit allocator_delete(const allocator_type& alloc)
  function explicit (line 810) | explicit allocator_delete(allocator_type&& alloc)
  function const (line 819) | void operator()(pointer p) const {
  function DeferCondDeallocate (line 853) | DeferCondDeallocate handler{constructed, copy, p};
  type SysBufferDeleter (line 860) | struct SysBufferDeleter {
  function SysBufferUniquePtr (line 865) | inline SysBufferUniquePtr allocate_sys_buffer(std::size_t size) {
  function namespace (line 890) | namespace detail {

FILE: folly/MicroLock.cpp
  type folly (line 23) | namespace folly {

FILE: folly/MicroLock.h
  function namespace (line 28) | namespace folly {

FILE: folly/MoveWrapper.h
  function explicit (line 42) | explicit MoveWrapper(T&& t) : value(std::move(t)) {}
  function value (line 45) | MoveWrapper(const MoveWrapper& other) : value(std::move(other.value)) {}

FILE: folly/ObserverContainer.h
  function namespace (line 35) | namespace folly {

FILE: folly/OperationCancelled.h
  function namespace (line 21) | namespace folly {

FILE: folly/Optional.h
  function namespace (line 76) | namespace folly {
  function noexcept (line 167) | OptionalCopyBase(const OptionalCopyBase& src) noexcept(
  function _secret (line 218) | enum class _secret { _token };
  function None (line 226) | constexpr None none{None::_secret::_token};
  function Value (line 471) | constexpr const Value& value() const& {
  type detail (line 546) | struct detail
  function namespace (line 763) | namespace folly {

FILE: folly/Overload.h
  function namespace (line 39) | namespace folly {
  function const (line 89) | struct type {
  function const (line 114) | struct type {
  type type (line 134) | struct type {
  function const (line 155) | struct type {
  type type (line 175) | struct type {
  function const (line 196) | struct type {
  function noexcept (line 215) | const noexcept -> T& {
  function noexcept (line 218) | const noexcept -> const T& {
  function noexcept (line 221) | const noexcept -> T&& {
  function noexcept (line 224) | const noexcept -> const T&& {
  function explicit (line 241) | explicit constexpr Overload(Case c, Cases... cs)
  function explicit (line 250) | explicit constexpr Overload(Case c) : Case(std::move(c)) {}
  function namespace (line 273) | namespace overload_detail {
  function f (line 308) | auto f = [&](auto&& v) -> R {

FILE: folly/PackedSyncPtr.h
  function namespace (line 61) | namespace folly {

FILE: folly/Padded.h
  function namespace (line 46) | namespace folly {
  function const_iterator (line 316) | const_iterator cend() const {
  function iterator (line 325) | iterator begin() { return iterator(c_.begin()); }
  function iterator (line 326) | iterator end() {
  function swap (line 333) | void swap(Adaptor& other) {
  function push_back (line 374) | void push_back(value_type x) { emplace_back(std::move(x)); }
  function pop_back (line 376) | void pop_back() {
  function clear (line 384) | void clear() {
  function reserve (line 389) | void reserve(size_type n) {
  function value_type (line 396) | const value_type& operator[](size_type idx) const {
  function padToFullNode (line 422) | void padToFullNode(const value_type& padValue) {
  function Node (line 444) | static Node fullNode(const value_type& value) {

FILE: folly/Poly-inl.h
  function namespace (line 17) | namespace folly {

FILE: folly/Poly.h
  function namespace (line 43) | namespace folly {
  type NoneSuch (line 411) | struct NoneSuch {}
  function noexcept (line 418) | const noexcept { return *this; }
  function Data (line 420) | Data* _data_() noexcept { return PolyAccess::data(*this); }
  function Data (line 421) | Data const* _data_() const noexcept { return PolyAccess::data(*this); }
  function Data (line 498) | Data* _data_() noexcept { return PolyAccess::data(*this); }
  function Data (line 499) | Data const* _data_() const noexcept { return PolyAccess::data(*this); }
  function RefType (line 501) | static constexpr RefType refType() noexcept;

FILE: folly/PolyException.h
  function namespace (line 24) | namespace folly {

FILE: folly/Portability.h
  function namespace (line 141) | namespace folly {
  function namespace (line 152) | namespace folly {
  function namespace (line 286) | namespace folly {
  function namespace (line 295) | namespace folly {
  function namespace (line 304) | namespace folly {
  function namespace (line 319) | namespace folly {
  function namespace (line 443) | namespace folly {
  function namespace (line 480) | namespace folly {

FILE: folly/ProducerConsumerQueue.h
  function namespace (line 29) | namespace folly {
  function sizeGuess (line 157) | size_t sizeGuess() const {

FILE: folly/Random-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/Random.cpp
  type folly (line 44) | namespace folly {
    function readRandomDevice (line 48) | void readRandomDevice(void* data, size_t size) {
    class BufferedRandomDevice (line 91) | class BufferedRandomDevice {
      method notifyNewGlobalEpoch (line 95) | static void notifyNewGlobalEpoch() { ++globalEpoch_; }
      method get (line 99) | void get(void* data, size_t size) {
      method remaining (line 111) | inline size_t remaining() const {
    type RandomTag (line 124) | struct RandomTag {}
    type Wrapper (line 178) | struct Wrapper {

FILE: folly/Random.h
  function namespace (line 38) | namespace folly {
  function rand64 (line 314) | static uint64_t rand64(uint64_t max) {
  function rand64 (line 322) | uint64_t rand64(uint64_t max, RNG&& rng) {
  function rand64 (line 329) | static uint64_t rand64(uint64_t min, uint64_t max) {
  function rand64 (line 337) | uint64_t rand64(uint64_t min, uint64_t max, RNG&& rng) {
  function oneIn (line 347) | static bool oneIn(uint32_t n) { return oneIn(n, ThreadLocalPRNG()); }
  function oneIn64 (line 352) | static bool oneIn64(uint64_t n) { return oneIn64(n, ThreadLocalPRNG()); }
  function oneIn (line 358) | bool oneIn(uint32_t n, RNG&& rng) {
  function oneIn64 (line 366) | bool oneIn64(uint64_t n, RNG&& rng) {
  function randBool (line 376) | static bool randBool(double p) { return randBool(p, ThreadLocalPRNG()); }
  function randBool (line 382) | bool randBool(double p, RNG&& rng) {
  function randDouble01 (line 389) | static double randDouble01() { return randDouble01(ThreadLocalPRNG()); }
  function randDouble (line 409) | static double randDouble(double min, double max) {
  function randDouble (line 417) | double randDouble(double min, double max, RNG&& rng) {
  function randomNumberSeed (line 431) | inline uint32_t randomNumberSeed() {

FILE: folly/Range.h
  function namespace (line 135) | namespace detail {
  function char8_t (line 162) | struct IsCharPointer<const char8_t*> {
  type IsUnsignedCharPointer (line 172) | struct IsUnsignedCharPointer
  type IsUnsignedCharPointer (line 177) | struct IsUnsignedCharPointer
  type range_traits_char_ (line 207) | struct range_traits_char_ {
  type range_traits_byte_ (line 211) | struct range_traits_byte_ {
  function compare (line 216) | static constexpr int compare(
  type range_traits_fbck_ (line 222) | struct range_traits_fbck_ {
  function compare (line 227) | static constexpr int compare(
  function Range (line 372) | Range(const Range& other, size_type first, size_type length = npos)
  function clear (line 579) | void clear() {
  function assign (line 587) | void assign(Iter start, Iter end) {
  function reset (line 595) | void reset(Iter start, size_type size) {
  function size_type (line 610) | constexpr size_type walk_size() const {
  function reference (line 620) | reference front() {
  function reference (line 624) | reference back() {
  type NotStringView (line 654) | struct NotStringView {}
  type StringViewTypeChar (line 655) | struct StringViewTypeChar {
  type StringViewTypeNone (line 659) | struct StringViewTypeNone {
  function Range (line 1175) | Range split_step(const value_type& delimiter) {
  function Range (line 1184) | Range split_step(Range delimiter) {
  function namespace (line 1418) | namespace detail {
  function namespace (line 1545) | namespace detail {
  type AsciiCaseSensitive (line 1564) | struct AsciiCaseSensitive {
  function if (line 1573) | struct AsciiCaseInsensitive {
  function qfind (line 1632) | inline size_t qfind(
  function rfind (line 1644) | inline size_t rfind(
  function qfind_first_of (line 1662) | inline size_t qfind_first_of(
  function qfind_first_of (line 1669) | inline size_t qfind_first_of(
  function const (line 1685) | size_t operator()(folly::Range<T*> r) const {
  function namespace (line 1704) | inline namespace literals {
  function namespace (line 1739) | namespace fmt {
  function namespace (line 1769) | namespace ranges {
  function namespace (line 1777) | namespace ranges {

FILE: folly/Replaceable.h
  function namespace (line 122) | namespace folly {
  function explicit (line 196) | inline explicit default_and_move_ctor_mixin(int) {}
  function noexcept (line 206) | inline default_and_move_ctor_mixin(
  function explicit (line 237) | inline explicit default_and_move_ctor_mixin(int) {}
  function noexcept (line 244) | inline default_and_move_ctor_mixin(
  function explicit (line 257) | inline explicit default_and_move_ctor_mixin(int) {}
  type copy_ctor_mixin (line 298) | struct copy_ctor_mixin
  function noexcept (line 314) | inline copy_ctor_mixin(copy_ctor_mixin const& other) noexcept(
  function explicit (line 453) | explicit Replaceable(

FILE: folly/ScopeGuard.h
  function namespace (line 92) | namespace detail {

FILE: folly/SharedMutex.cpp
  type folly (line 25) | namespace folly {
    class SharedMutexImpl<true> (line 27) | class SharedMutexImpl<true>
    class SharedMutexImpl<false> (line 28) | class SharedMutexImpl<false>
    type shared_mutex_detail (line 30) | namespace shared_mutex_detail {
      function annotationGuard (line 31) | std::unique_lock<std::mutex> annotationGuard(void* ptr) {
      function getMaxDeferredReadersSlow (line 46) | uint32_t getMaxDeferredReadersSlow(relaxed_atomic<uint32_t>& cache) {
      function getCurrentThreadInvoluntaryContextSwitchCount (line 57) | long getCurrentThreadInvoluntaryContextSwitchCount() {
      function throwOperationNotPermitted (line 70) | [[noreturn]] void throwOperationNotPermitted() {
      function throwDeadlockWouldOccur (line 75) | [[noreturn]] void throwDeadlockWouldOccur() {

FILE: folly/SharedMutex.h
  function namespace (line 240) | namespace folly {
  type SharedMutexPolicyDefault (line 258) | struct SharedMutexPolicyDefault {
  function namespace (line 265) | namespace shared_mutex_detail {
  function namespace (line 1602) | namespace shared_mutex_detail {
  function namespace (line 1614) | namespace std {

FILE: folly/Singleton-inl.h
  function namespace (line 17) | namespace folly {

FILE: folly/Singleton.cpp
  type folly (line 51) | namespace folly {
    type detail (line 54) | namespace detail {
      function singletonWarnDoubleRegistrationAndAbort (line 89) | [[noreturn]] void singletonWarnDoubleRegistrationAndAbort(
      function singletonWarnLeakyDoubleRegistrationAndAbort (line 101) | [[noreturn]] void singletonWarnLeakyDoubleRegistrationAndAbort(
      function singletonWarnLeakyInstantiatingNotRegisteredAndAbort (line 113) | [[noreturn]] void singletonWarnLeakyInstantiatingNotRegisteredAndAbort(
      function singletonWarnRegisterMockEarlyAndAbort (line 120) | [[noreturn]] void singletonWarnRegisterMockEarlyAndAbort(
      function singletonWarnDestroyInstanceLeak (line 127) | void singletonWarnDestroyInstanceLeak(
      function singletonWarnCreateCircularDependencyAndAbort (line 140) | [[noreturn]] void singletonWarnCreateCircularDependencyAndAbort(
      function singletonWarnCreateUnregisteredAndAbort (line 145) | [[noreturn]] void singletonWarnCreateUnregisteredAndAbort(
      function singletonWarnCreateBeforeRegistrationCompleteAndAbort (line 152) | [[noreturn]] void singletonWarnCreateBeforeRegistrationCompleteAndAb...
      function singletonPrintDestructionStackTrace (line 166) | void singletonPrintDestructionStackTrace(const TypeDescriptor& type) {
      function singletonThrowNullCreator (line 173) | [[noreturn]] void singletonThrowNullCreator(const std::type_info& ty...
      function singletonThrowGetInvokedAfterDestruction (line 181) | [[noreturn]] void singletonThrowGetInvokedAfterDestruction(
    type detail (line 78) | namespace detail {
      function singletonWarnDoubleRegistrationAndAbort (line 89) | [[noreturn]] void singletonWarnDoubleRegistrationAndAbort(
      function singletonWarnLeakyDoubleRegistrationAndAbort (line 101) | [[noreturn]] void singletonWarnLeakyDoubleRegistrationAndAbort(
      function singletonWarnLeakyInstantiatingNotRegisteredAndAbort (line 113) | [[noreturn]] void singletonWarnLeakyInstantiatingNotRegisteredAndAbort(
      function singletonWarnRegisterMockEarlyAndAbort (line 120) | [[noreturn]] void singletonWarnRegisterMockEarlyAndAbort(
      function singletonWarnDestroyInstanceLeak (line 127) | void singletonWarnDestroyInstanceLeak(
      function singletonWarnCreateCircularDependencyAndAbort (line 140) | [[noreturn]] void singletonWarnCreateCircularDependencyAndAbort(
      function singletonWarnCreateUnregisteredAndAbort (line 145) | [[noreturn]] void singletonWarnCreateUnregisteredAndAbort(
      function singletonWarnCreateBeforeRegistrationCompleteAndAbort (line 152) | [[noreturn]] void singletonWarnCreateBeforeRegistrationCompleteAndAb...
      function singletonPrintDestructionStackTrace (line 166) | void singletonPrintDestructionStackTrace(const TypeDescriptor& type) {
      function singletonThrowNullCreator (line 173) | [[noreturn]] void singletonThrowNullCreator(const std::type_info& ty...
      function singletonThrowGetInvokedAfterDestruction (line 181) | [[noreturn]] void singletonThrowGetInvokedAfterDestruction(
    type FatalHelper (line 193) | struct FatalHelper {
    function fireShutdownSignalHelper (line 472) | [[noreturn]] void fireShutdownSignalHelper(sigval_t sigval) {
    type sigevent (line 488) | struct sigevent
    type itimerspec (line 496) | struct itimerspec

FILE: folly/Singleton.h
  function namespace (line 172) | namespace folly {
  function explicit (line 833) | explicit LeakySingleton(CreateFunc createFunc) {
  function T (line 842) | static T& get() { return instance(); }
  function make_mock (line 848) | static void make_mock(CreateFunc createFunc) {
  type class (line 863) | enum class
  type Entry (line 865) | struct Entry {
  function Entry (line 877) | static Entry& entryInstance() { return detail::createGlobal<Entry, Tag>(...
  function T (line 879) | static T& instance() {
  function createInstance (line 888) | static void createInstance() {

FILE: folly/SingletonThreadLocal.cpp
  type folly (line 19) | namespace folly {
    type detail (line 21) | namespace detail {
      function FOLLY_NOINLINE (line 23) | FOLLY_NOINLINE SingletonThreadLocalState::Tracking::Tracking() noexc...
      function FOLLY_NOINLINE (line 25) | FOLLY_NOINLINE SingletonThreadLocalState::Tracking::~Tracking() {
      function FOLLY_NOINLINE (line 31) | FOLLY_NOINLINE void SingletonThreadLocalState::LocalLifetime::destroy(
      function FOLLY_NOINLINE (line 44) | FOLLY_NOINLINE void SingletonThreadLocalState::LocalLifetime::track(

FILE: folly/SingletonThreadLocal.h
  function namespace (line 32) | namespace folly {
  function LocalLifetime (line 128) | struct LocalLifetime : State::LocalLifetime {
  function FOLLY_ALWAYS_INLINE (line 134) | FOLLY_ALWAYS_INLINE static WrapperTL& getWrapperTL() {
  function FOLLY_NOINLINE (line 139) | FOLLY_NOINLINE static Wrapper& getWrapper() { return *getWrapperTL(); }
  function LocalCache (line 151) | static LocalCache& getLocalCache() {
  function T (line 166) | static T* try_get() {
  function class (line 180) | class Accessor {
  function Accessor (line 224) | static Accessor accessAllThreads() {

FILE: folly/SocketAddress.cpp
  type ScopedAddrInfo (line 46) | struct ScopedAddrInfo {
    method ScopedAddrInfo (line 47) | explicit ScopedAddrInfo(struct addrinfo* addrinfo) : info(addrinfo) {}
    type addrinfo (line 50) | struct addrinfo
  type HostAndPort (line 64) | struct HostAndPort {
    method HostAndPort (line 65) | HostAndPort(const char* str, bool hostRequired)
  type GetAddrInfoError (line 107) | struct GetAddrInfoError {
    method GetAddrInfoError (line 111) | explicit GetAddrInfoError(int errorCode) {
    method GetAddrInfoError (line 119) | explicit GetAddrInfoError(int errorCode) : error(gai_strerror(errorCod...
  type folly (line 125) | namespace folly {
    type sockaddr (line 202) | struct sockaddr
    type sockaddr (line 221) | struct sockaddr
    type sockaddr_un (line 256) | struct sockaddr_un
    type sockaddr (line 275) | struct sockaddr
    type sockaddr (line 310) | struct sockaddr
    type sockaddr (line 313) | struct sockaddr
    type sockaddr_in (line 320) | struct sockaddr_in
    type sockaddr_in (line 325) | struct sockaddr_in
    type sockaddr_in6 (line 327) | struct sockaddr_in6
    type sockaddr_in6 (line 332) | struct sockaddr_in6
    type sockaddr_un (line 335) | struct sockaddr_un
    type sockaddr_vm (line 338) | struct sockaddr_vm
    type sockaddr_in (line 347) | struct sockaddr_in
    type sockaddr_in6 (line 352) | struct sockaddr_in6
    type sockaddr_un (line 358) | struct sockaddr_un
    type sockaddr_un (line 360) | struct sockaddr_un
    type sockaddr_un (line 376) | struct sockaddr_un
    type sockaddr_un (line 378) | struct sockaddr_un
    type sockaddr_vm (line 383) | struct sockaddr_vm
    function socklen_t (line 397) | socklen_t SocketAddress::getActualSize() const {
    type addrinfo (line 716) | struct addrinfo
    type addrinfo (line 725) | struct addrinfo
    type addrinfo (line 727) | struct addrinfo
    type addrinfo (line 733) | struct addrinfo
    type addrinfo (line 747) | struct addrinfo
    type addrinfo (line 751) | struct addrinfo
    type addrinfo (line 754) | struct addrinfo
    type sockaddr (line 767) | struct sockaddr
    type sockaddr_un (line 812) | struct sockaddr_un
    type sockaddr_un (line 829) | struct sockaddr_un
    type sockaddr_un (line 832) | struct sockaddr_un
    function hash_value (line 904) | size_t hash_value(const SocketAddress& address) {

FILE: folly/SocketAddress.h
  function namespace (line 37) | namespace folly {
  function isPrivateAddress (line 138) | bool isPrivateAddress() const;
  function setFromIpPort (line 193) | void setFromIpPort(const std::string& ip, uint16_t port) {
  function setFromLocalPort (line 233) | void setFromLocalPort(const std::string& port) {
  function setFromLocalIpPort (line 256) | void setFromLocalIpPort(const std::string& addressAndPort) {
  function setFromIpPort (line 277) | void setFromIpPort(const std::string& addressAndPort) {
  function setFromHostPort (line 299) | void setFromHostPort(const std::string& hostAndPort) {
  type sockaddr (line 319) | struct sockaddr
  type sockaddr (line 334) | struct sockaddr
  function setFromPath (line 348) | void setFromPath(const char* path, size_t length) {
  type ExternalUnixAddr (line 746) | struct ExternalUnixAddr {
  type sockaddr_un (line 755) | struct sockaddr_un
  function ExternalUnixAddr (line 760) | ExternalUnixAddr(const ExternalUnixAddr& other) : ExternalUnixAddr() {
  function holdsUnix (line 779) | struct IPAddr {
  type addrinfo (line 814) | struct addrinfo
  type addrinfo (line 815) | struct addrinfo
  type addrinfo (line 816) | struct addrinfo
  type addrinfo (line 817) | struct addrinfo
  type sockaddr (line 820) | struct sockaddr
  function namespace (line 846) | namespace std {

FILE: folly/SpinLock.h
  function namespace (line 40) | namespace folly {

FILE: folly/String-inl.h
  function namespace (line 29) | namespace folly {
  function namespace (line 157) | namespace detail {
  function namespace (line 258) | namespace detail {
  function prepareDelim (line 378) | inline char prepareDelim(char c) {
  function toOrIgnore (line 387) | inline void toOrIgnore(StringPiece, decltype(std::ignore)&) {}
  function ConversionCode (line 435) | inline ConversionCode convertError(ConversionCode code) {
  function split (line 566) | bool>::type
  function namespace (line 572) | namespace detail {
  function namespace (line 766) | namespace detail {

FILE: folly/String.cpp
  type folly (line 33) | namespace folly {
    type detail (line 41) | namespace detail {
      type string_table_c_escape_make_item (line 43) | struct string_table_c_escape_make_item {
      type string_table_c_unescape_make_item (line 59) | struct string_table_c_unescape_make_item {
      type string_table_hex_make_item (line 81) | struct string_table_hex_make_item {
      type string_table_uri_escape_make_item (line 93) | struct string_table_uri_escape_make_item {
      function hexDumpLine (line 683) | size_t hexDumpLine(
      function delimCountTokensImpl (line 790) | size_t delimCountTokensImpl(DelimT delim, StringPiece sp, bool ignor...
      function delimCountTokens (line 828) | size_t delimCountTokens(char delim, StringPiece sp, bool ignoreEmpty) {
      function delimCountTokens (line 832) | size_t delimCountTokens(StringPiece delim, StringPiece sp, bool igno...
    function is_oddspace (line 127) | static inline bool is_oddspace(char c) {
    function StringPiece (line 131) | StringPiece ltrimWhitespace(StringPiece sp) {
    function StringPiece (line 149) | StringPiece rtrimWhitespace(StringPiece sp) {
    function stringAppendfImplHelper (line 169) | int stringAppendfImplHelper(
    function stringAppendfImpl (line 178) | void stringAppendfImpl(std::string& output, const char* format, va_lis...
    function stringPrintf (line 221) | std::string stringPrintf(const char* format, ...) {
    function stringVPrintf (line 230) | std::string stringVPrintf(const char* format, va_list ap) {
    function stringPrintf (line 253) | void stringPrintf(std::string* output, const char* format, ...) {
    function stringVPrintf (line 262) | void stringVPrintf(std::string* output, const char* format, va_list ap) {
    type PrettySuffix (line 269) | struct PrettySuffix {
    function prettyPrint (line 396) | std::string prettyPrint(double val, PrettyType type, bool addSpace) {
    function prettyToDouble (line 426) | double prettyToDouble(
    function prettyToDouble (line 462) | double prettyToDouble(folly::StringPiece prettyString, const PrettyTyp...
    function hexDump (line 468) | std::string hexDump(const void* ptr, size_t size) {
    function invoke_strerror_r (line 485) | [[maybe_unused]] static std::string invoke_strerror_r(
    function invoke_strerror_r (line 499) | [[maybe_unused]] static std::string invoke_strerror_r(
    function errnoStr (line 508) | std::string errnoStr(int err) {
    function toLowerAscii8 (line 542) | void toLowerAscii8(char& c) {
    function toLowerAscii32 (line 600) | void toLowerAscii32(uint32_t& c) {
    function toLowerAscii64 (line 620) | void toLowerAscii64(uint64_t& c) {
    function toLowerAscii (line 634) | void toLowerAscii(char* str, size_t length) {
    type detail (line 681) | namespace detail {
      type string_table_c_escape_make_item (line 43) | struct string_table_c_escape_make_item {
      type string_table_c_unescape_make_item (line 59) | struct string_table_c_unescape_make_item {
      type string_table_hex_make_item (line 81) | struct string_table_hex_make_item {
      type string_table_uri_escape_make_item (line 93) | struct string_table_uri_escape_make_item {
      function hexDumpLine (line 683) | size_t hexDumpLine(
      function delimCountTokensImpl (line 790) | size_t delimCountTokensImpl(DelimT delim, StringPiece sp, bool ignor...
      function delimCountTokens (line 828) | size_t delimCountTokens(char delim, StringPiece sp, bool ignoreEmpty) {
      function delimCountTokens (line 832) | size_t delimCountTokens(StringPiece delim, StringPiece sp, bool igno...
    function stripLeftMargin (line 737) | std::string stripLeftMargin(std::string s) {
    type detail (line 786) | namespace detail {
      type string_table_c_escape_make_item (line 43) | struct string_table_c_escape_make_item {
      type string_table_c_unescape_make_item (line 59) | struct string_table_c_unescape_make_item {
      type string_table_hex_make_item (line 81) | struct string_table_hex_make_item {
      type string_table_uri_escape_make_item (line 93) | struct string_table_uri_escape_make_item {
      function hexDumpLine (line 683) | size_t hexDumpLine(
      function delimCountTokensImpl (line 790) | size_t delimCountTokensImpl(DelimT delim, StringPiece sp, bool ignor...
      function delimCountTokens (line 828) | size_t delimCountTokens(char delim, StringPiece sp, bool ignoreEmpty) {
      function delimCountTokens (line 832) | size_t delimCountTokens(StringPiece delim, StringPiece sp, bool igno...

FILE: folly/String.h
  function namespace (line 48) | namespace folly {
  function toLowerAscii (line 846) | inline void toLowerAscii(MutableStringPiece str) {
  function toLowerAscii (line 850) | inline void toLowerAscii(std::string& str) {
  function hasSpaceOrCntrlSymbols (line 858) | inline bool hasSpaceOrCntrlSymbols(folly::StringPiece s) {
  type format_string_for_each_named_arg_fn (line 862) | struct format_string_for_each_named_arg_fn {
  function format_string_for_each_named_arg_fn (line 907) | inline constexpr format_string_for_each_named_arg_fn

FILE: folly/Subprocess.cpp
  type detail (line 83) | namespace detail {
    function Ret (line 129) | static Ret subprocess_libc_load(
    type subprocess_libc (line 174) | struct subprocess_libc {
      method subprocess_libc_init (line 180) | static void subprocess_libc_init() {
    type Scratch (line 199) | struct Scratch {
      method Scratch (line 204) | explicit Scratch(Options const& options)
    type AttrWithMeta (line 215) | struct AttrWithMeta {
    function SpawnRawArgs (line 253) | explicit SpawnRawArgs(Scratch const& scratch, Options const& options)
    function ProcessReturnCode (line 284) | ProcessReturnCode ProcessReturnCode::make(int status) {
    function ProcessReturnCode (line 297) | ProcessReturnCode& ProcessReturnCode::operator=(
    function toSubprocessSpawnErrorMessage (line 371) | static inline std::string toSubprocessSpawnErrorMessage(
    function cloneStrings (line 388) | std::unique_ptr<const char*[]> cloneStrings(const std::vector<std::str...
    function checkStatus (line 398) | void checkStatus(ProcessReturnCode returnCode) {
    function Subprocess (line 494) | Subprocess Subprocess::fromExistingProcess(pid_t pid) {
    type Subprocess::ChildErrorInfo (line 537) | struct Subprocess::ChildErrorInfo {
    function FOLLY_DETAIL_SUBPROCESS_RAW (line 542) | [[noreturn]]
  function FOLLY_DETAIL_SUBPROCESS_RAW (line 720) | FOLLY_DETAIL_SUBPROCESS_RAW
  function FOLLY_POP_WARNING (line 756) | FOLLY_POP_WARNING
  function FOLLY_DETAIL_SUBPROCESS_RAW (line 768) | FOLLY_DETAIL_SUBPROCESS_RAW
  function FOLLY_DETAIL_SUBPROCESS_RAW (line 807) | FOLLY_DETAIL_SUBPROCESS_RAW
  function FOLLY_DETAIL_SUBPROCESS_RAW (line 1043) | FOLLY_DETAIL_SUBPROCESS_RAW
  function ProcessReturnCode (line 1069) | ProcessReturnCode Subprocess::poll(struct rusage* ru) {
  function ProcessReturnCode (line 1095) | ProcessReturnCode Subprocess::wait() {
  function ProcessReturnCode (line 1114) | ProcessReturnCode Subprocess::waitAndGetRusage(struct rusage* ru) {
  function ProcessReturnCode (line 1138) | ProcessReturnCode Subprocess::waitTimeout(TimeoutDuration timeout) {
  function ProcessReturnCode (line 1182) | ProcessReturnCode Subprocess::waitOrTerminateOrKill(
  function ProcessReturnCode (line 1195) | ProcessReturnCode Subprocess::terminateOrKill(TimeoutDuration sigtermTim...
  function pid_t (line 1220) | pid_t Subprocess::pid() const {
  function ByteRange (line 1226) | ByteRange queueFront(const IOBufQueue& queue) {
  function handleWrite (line 1235) | bool handleWrite(int fd, IOBufQueue& queue) {
  function handleRead (line 1252) | bool handleRead(int fd, IOBufQueue& queue) {
  function discardRead (line 1267) | bool discardRead(int fd) {
  class Initializer (line 1463) | class Initializer {
    method Initializer (line 1465) | Initializer() {

FILE: folly/Subprocess.h
  function namespace (line 127) | namespace folly {
  function T (line 540) | T value{}
  function processGroupLeader_ (line 551) | bool processGroupLeader_{false};

FILE: folly/Synchronized.h
  type class (line 82) | enum class
  function SynchronizedMutexMethod (line 92) | enum class SynchronizedMutexMethod { Lock, TryLock };
  function LockedPtr (line 201) | LockedPtr wlock() { return LockedPtr(static_cast<Subclass*>(this)); }
  function TryWLockedPtr (line 217) | TryWLockedPtr tryWLock() {
  function RLockedPtr (line 232) | RLockedPtr rlock() { return RLockedPtr(static_cast<Subclass*>(this)); }
  function TryRLockedPtr (line 248) | TryRLockedPtr tryRLock() {
  function UpgradeLockedPtr (line 407) | UpgradeLockedPtr ulock() {
  function TryUpgradeLockedPtr (line 425) | TryUpgradeLockedPtr tryULock() {
  function LockedPtr (line 526) | LockedPtr lock() { return LockedPtr(static_cast<Subclass*>(this)); }
  function TryLockedPtr (line 549) | TryLockedPtr tryLock() { return TryLockedPtr{static_cast<Subclass*>(this...
  function nxMoveCtor (line 647) | static constexpr bool nxMoveCtor{
  function guard (line 779) | auto guard = LockedPtr{this};
  function guard (line 790) | auto guard = LockedPtr{this};
  function LockedPtr (line 808) | LockedPtr contextualLock() { return LockedPtr(this); }
  function LockedPtr (line 845) | LockedPtr timedAcquire(unsigned int milliseconds) {
  function ConstLockedPtr (line 857) | ConstLockedPtr timedAcquire(unsigned int milliseconds) const {
  function guard1 (line 875) | auto guard1 = LockedPtr{this};
  type Simulacrum (line 984) | struct Simulacrum {
  function LockedPtr (line 1028) | [[deprecated("use explicit lock(), wlock(), or rlock() instead")]] Locke...
  function ConstLockedPtr (line 1041) | [[deprecated(
  function namespace (line 1051) | namespace detail {

FILE: folly/SynchronizedPtr.h
  function namespace (line 33) | namespace folly {

FILE: folly/ThreadCachedInt.h
  function namespace (line 28) | namespace folly {

FILE: folly/ThreadLocal.h
  function namespace (line 62) | namespace folly {
  function incrementToValid (line 326) | void incrementToValid() {
  function decrementToValid (line 331) | void decrementToValid() {
  function release (line 429) | void release() {

FILE: folly/TimeoutQueue.cpp
  type folly (line 23) | namespace folly {

FILE: folly/TimeoutQueue.h
  function namespace (line 36) | namespace folly {

FILE: folly/TokenBucket.h
  function namespace (line 29) | namespace folly {
  function balance (line 115) | double balance(
  function timeWhenBucket (line 174) | double timeWhenBucket(double rate, double target) {
  function returnTokens (line 183) | void returnTokens(double tokensToReturn, double rate) {
  function compare_exchange_weak_relaxed (line 207) | static bool compare_exchange_weak_relaxed(
  function defaultClockNow (line 299) | static double defaultClockNow() noexcept {
  function consume (line 320) | bool consume(
  function consumeOrDrain (line 356) | double consumeOrDrain(
  function returnTokens (line 380) | void returnTokens(double tokensToReturn, double rate) {
  function consumeWithBorrowAndWait (line 438) | bool consumeWithBorrowAndWait(
  function available (line 459) | double available(
  function balance (line 471) | double balance(
  function defaultClockNow (line 525) | static double defaultClockNow() noexcept(noexcept(Impl::defaultClockNow(...
  function setCapacity (line 562) | void setCapacity(double tokens, double nowInSeconds) noexcept {
  function consume (line 580) | bool consume(double toConsume, double nowInSeconds = defaultClockNow()) {
  function consumeOrDrain (line 597) | double consumeOrDrain(
  function returnTokens (line 607) | void returnTokens(double tokensToReturn) {
  function consumeWithBorrowAndWait (line 624) | bool consumeWithBorrowAndWait(
  function available (line 637) | double available(double nowInSeconds = defaultClockNow()) const noexcept {
  function balance (line 646) | double balance(double nowInSeconds = defaultClockNow()) const noexcept {

FILE: folly/Traits.h
  function namespace (line 29) | namespace folly {
  function namespace (line 269) | namespace detail {
  function namespace (line 340) | namespace detail {
  function namespace (line 555) | namespace detail {
  function namespace (line 631) | namespace detail {
  function namespace (line 669) | namespace fallback {
  function namespace (line 740) | namespace traits_detail {
  type Ignore (line 761) | struct Ignore {
  function namespace (line 774) | namespace traits_detail_IsEqualityComparable {
  function namespace (line 787) | namespace traits_detail_IsLessThanComparable {
  function namespace (line 826) | namespace detail {
  function size (line 873) | static constexpr std::size_t size() { return sizeof...(Bs); }
  function namespace (line 886) | namespace detail {
  function namespace (line 903) | namespace detail {
  function namespace (line 1002) | namespace folly {
  function FOLLY_ASSUME_FBVECTOR_COMPATIBLE_1 (line 1106) | FOLLY_ASSUME_FBVECTOR_COMPATIBLE_2(std::unique_ptr)
  function namespace (line 1315) | namespace traits_detail {
  function namespace (line 1353) | namespace detail {

FILE: folly/Try-inl.h
  function namespace (line 26) | namespace folly {
  function tryEmplace (line 302) | void tryEmplace(Try<void>& t) noexcept {
  function namespace (line 334) | namespace try_detail {

FILE: folly/Try.cpp
  type folly (line 19) | namespace folly {
    class Try<Unit> (line 21) | class Try<Unit>

FILE: folly/Try.h
  function namespace (line 33) | namespace folly {
  function T (line 264) | const T* operator->() const { return &value(); }
  function exception_wrapper (line 305) | const exception_wrapper& exception() const& {
  function explicit (line 413) | explicit Try(exception_wrapper e) noexcept
  function emplace (line 441) | void emplace() noexcept {
  function throwIfFailed (line 470) | inline void throwIfFailed() const;
  function exception_wrapper (line 503) | const exception_wrapper& exception() const& {
  function exception_wrapper (line 510) | const exception_wrapper&& exception() const&& {

FILE: folly/UTF8String.h
  function namespace (line 25) | namespace folly {

FILE: folly/Unicode.cpp
  type folly (line 23) | namespace folly {
    function unicode_code_point_utf8 (line 25) | unicode_code_point_utf8 unicode_code_point_to_utf8(char32_t const cp) {
    function appendCodePointToUtf8 (line 61) | void appendCodePointToUtf8(char32_t const cp, std::string& out) {
    function codePointToUtf8 (line 66) | std::string codePointToUtf8(char32_t const cp) {
    function utf8ToCodePoint (line 72) | char32_t utf8ToCodePoint(

FILE: folly/Unicode.h
  function namespace (line 28) | namespace folly {

FILE: folly/Unit.h
  function namespace (line 21) | namespace folly {
  function Unit (line 41) | constexpr Unit unit{}
  function void (line 48) | struct lift_unit<void> {
  function Unit (line 59) | struct drop_unit<Unit> {

FILE: folly/Uri-inl.h
  function namespace (line 27) | namespace folly {
  function namespace (line 84) | namespace std {
  function Uri (line 95) | struct equal_to<folly::Uri> {

FILE: folly/Uri.cpp
  type folly (line 24) | namespace folly {
    function submatch (line 28) | std::string submatch(const boost::cmatch& m, int idx) {

FILE: folly/Uri.h
  function namespace (line 26) | namespace folly {

FILE: folly/Utility.h
  function namespace (line 52) | namespace detail {
  type initlist_construct_t (line 172) | struct initlist_construct_t {}
  function initlist_construct_t (line 173) | constexpr initlist_construct_t initlist_construct{}
  type sorted_unique_t (line 196) | struct sorted_unique_t {}
  function sorted_unique_t (line 197) | constexpr sorted_unique_t sorted_unique{}
  type sorted_equivalent_t (line 219) | struct sorted_equivalent_t {}
  function sorted_equivalent_t (line 220) | constexpr sorted_equivalent_t sorted_equivalent{}
  type identity_fn (line 247) | struct identity_fn {
  function identity_fn (line 254) | inline constexpr identity_fn identity{}
  function size (line 262) | struct literal_c_str {
  function C (line 300) | constexpr C const* c_str() const noexcept { return buffer; }
  function explicit (line 305) | explicit operator String() const //
  function namespace (line 328) | namespace detail {
  function namespace (line 386) | namespace moveonly_ {
  type variadic_noop_fn (line 440) | struct variadic_noop_fn {
  type unsafe_default_initialized_cv (line 495) | struct unsafe_default_initialized_cv {
  function unsafe_default_initialized_cv (line 526) | inline constexpr unsafe_default_initialized_cv unsafe_default_initialized{}
  type to_bool_fn (line 536) | struct to_bool_fn {
  function to_bool_fn (line 547) | inline constexpr to_bool_fn to_bool{}
  type to_signed_fn (line 549) | struct to_signed_fn {
  function to_signed_fn (line 561) | inline constexpr to_signed_fn to_signed{}
  type to_unsigned_fn (line 563) | struct to_unsigned_fn {
  function to_unsigned_fn (line 571) | inline constexpr to_unsigned_fn to_unsigned{}
  function namespace (line 573) | namespace detail {
  type to_narrow_fn (line 623) | struct to_narrow_fn {
  function to_narrow_fn (line 630) | inline constexpr to_narrow_fn to_narrow{}
  type to_integral_fn (line 673) | struct to_integral_fn {
  function to_integral_fn (line 680) | inline constexpr to_integral_fn to_integral{}
  type to_floating_point_fn (line 725) | struct to_floating_point_fn {
  function to_floating_point_fn (line 732) | inline constexpr to_floating_point_fn to_floating_point{}
  type to_underlying_fn (line 734) | struct to_underlying_fn {
  function to_underlying_fn (line 741) | inline constexpr to_underlying_fn to_underlying{}
  function namespace (line 743) | namespace detail {

FILE: folly/Varint.h
  function namespace (line 27) | namespace folly {

FILE: folly/algorithm/BinaryHeap.h
  function namespace (line 24) | namespace folly {

FILE: folly/algorithm/StableRadixSort.h
  function namespace (line 31) | namespace folly {

FILE: folly/algorithm/simd/Contains.cpp
  type folly::simd::detail (line 23) | namespace folly::simd::detail {
    function containsU8 (line 25) | bool containsU8(
    function containsU16 (line 29) | bool containsU16(
    function containsU32 (line 33) | bool containsU32(
    function containsU64 (line 38) | bool containsU64(

FILE: folly/algorithm/simd/Contains.h
  function namespace (line 24) | namespace folly::simd {

FILE: folly/algorithm/simd/FindFixed.h
  function namespace (line 41) | namespace folly {

FILE: folly/algorithm/simd/Ignore.h
  function namespace (line 23) | namespace folly::simd {

FILE: folly/algorithm/simd/detail/ContainsImpl.h
  function namespace (line 29) | namespace folly::simd::detail {

FILE: folly/algorithm/simd/detail/SimdAnyOf.h
  function namespace (line 23) | namespace folly {

FILE: folly/algorithm/simd/detail/SimdForEach.h
  function namespace (line 29) | namespace folly {
  function const (line 127) | size_t unrolling>
  function ignore_extrema (line 186) | ignore_extrema ignore{static_cast<int>(f - af), 0};

FILE: folly/algorithm/simd/detail/SimdPlatform.h
  function FOLLY_ERASE (line 231) | FOLLY_ERASE
  function FOLLY_ERASE (line 236) | FOLLY_ERASE
  function FOLLY_ERASE (line 242) | FOLLY_ERASE
  function FOLLY_ERASE (line 311) | FOLLY_ERASE
  function FOLLY_ERASE (line 316) | FOLLY_ERASE
  function FOLLY_ERASE (line 322) | FOLLY_ERASE

FILE: folly/algorithm/simd/detail/Traits.h
  type AsSimdFriendlyUintFn (line 99) | struct AsSimdFriendlyUintFn {

FILE: folly/algorithm/simd/detail/UnrollUtils.h
  function namespace (line 25) | namespace folly::simd::detail {

FILE: folly/algorithm/simd/detail/test/SimdAnyOfTest.cpp
  type folly (line 28) | namespace folly {
    type simd::detail (line 29) | namespace simd::detail {
      function anySpacesTestForPlatformUnrolling (line 32) | void anySpacesTestForPlatformUnrolling(
      function anySpacesTestForPlatform (line 43) | void anySpacesTestForPlatform(
      function anySpacesTest (line 55) | void anySpacesTest(folly::StringPiece sChars, bool expected) {
      function TEST (line 77) | TEST(SimdAnyOfSimple, Basic) {
      function TEST (line 88) | TEST(SimdAnyOfSimple, Ignore) {
      function TEST (line 98) | TEST(SimdAnyOfSimple, BigChunk) {

FILE: folly/algorithm/simd/detail/test/SimdForEachTest.cpp
  type folly (line 23) | namespace folly {
    type simd::detail (line 24) | namespace simd::detail {
      type TestDelegate (line 29) | struct TestDelegate {
        method step (line 33) | bool step(char* s, ignore_extrema ignore, N unroll_i) const {
        method step (line 55) | bool step(char* s, ignore_none, N unroll_i) const {
        method unrolledStep (line 68) | bool unrolledStep(std::array<char*, unroll> unrolled) {
      function run (line 80) | std::string run(int offset, int len, int stopAt) {
      function runAllUnrolls (line 91) | std::string runAllUnrolls(int offset, int len, int stopAt) {
      function TEST (line 99) | TEST(SimdForEachAligningTest, Tails) {
      function TEST (line 131) | TEST(SimdForEachAligningTest, Large) {
      function TEST (line 163) | TEST(SimdForEachAligningTest, Stops) {
      function TEST (line 184) | TEST(SimdForEachAligningTest, UnrollIndexes) {

FILE: folly/algorithm/simd/detail/test/TraitsTest.cpp
  type folly::simd::detail (line 26) | namespace folly::simd::detail {
    type SimdTraitsTest (line 28) | struct SimdTraitsTest : testing::Test {}
    type simd_friendly_equivalent_scalar_test (line 30) | namespace simd_friendly_equivalent_scalar_test {
      type SomeInt (line 76) | enum SomeInt : std::int16_t {}
      type SomeIntClass (line 77) | enum class SomeIntClass : std::uint32_t {}
      type sfinae_call (line 103) | struct sfinae_call {
      type NotSimdFriendly (line 112) | struct NotSimdFriendly {}
    type as_simd_friendly_type_test (line 117) | namespace as_simd_friendly_type_test {
    type as_simd_friendly_uint_type_test (line 153) | namespace as_simd_friendly_uint_type_test {
    function TEST_F (line 196) | TEST_F(SimdTraitsTest, AsSimdFriendly) {
    function TEST_F (line 213) | TEST_F(SimdTraitsTest, AsSimdFriendlyUint) {

FILE: folly/algorithm/simd/detail/test/UnrollUtilsTest.cpp
  type folly::simd::detail (line 23) | namespace folly::simd::detail {
    function TEST (line 25) | TEST(UnrollUtilsTest, ArrayMap) {
    function reduceValues (line 42) | constexpr int reduceValues() {
    function TEST (line 47) | TEST(UnrollUtilsTest, ArrayReduce) {
    type UnrollUntilTestOp (line 55) | struct UnrollUntilTestOp {
    function unrollUntilTest (line 72) | constexpr bool unrollUntilTest() {
    function TEST (line 80) | TEST(UnrollUtilsTest, UnrollUntil) {

FILE: folly/algorithm/simd/find_first_of.h
  function namespace (line 48) | namespace folly::simd {
  function prep (line 190) | void prep(SparseByteSet& set) const noexcept {
  function match (line 196) | bool match(value_type const c, SparseByteSet const& set) const noexcept {
  function T (line 336) | constexpr T exchange(T& obj, U&& val) noexcept {
  function shuffle (line 342) | static constexpr shuffle make_shuffle(view const alphabet) noexcept {
  type meta (line 449) | struct meta {
  function T (line 460) | constexpr T exchange(T& obj, U&& val) noexcept {
  function next_segment (line 466) | static constexpr size_t next_segment(
  function meta (line 485) | static constexpr meta make_meta(view alphabet) noexcept {

FILE: folly/algorithm/simd/find_first_of_extra.h
  function namespace (line 27) | namespace folly::simd {

FILE: folly/algorithm/simd/test/ContainsTest.cpp
  type ContainsTest (line 94) | struct ContainsTest : ::testing::Test {}
  type ContainsTestSpeicalCases (line 96) | struct ContainsTestSpeicalCases : ::testing::Test {}
  type folly::simd (line 110) | namespace folly::simd {
  function testSimdContainsVerify (line 117) | void testSimdContainsVerify(folly::span<T> haystack, T needle, bool expe...
  function TYPED_TEST (line 136) | TYPED_TEST(ContainsTest, Basic) {
  function TEST_F (line 156) | TEST_F(ContainsTestSpeicalCases, Pointers) {
  function TEST_F (line 163) | TEST_F(ContainsTestSpeicalCases, AsanShouldDetectInvalidRange) {

FILE: folly/algorithm/simd/test/FindFixedBenchmark.cpp
  type folly (line 30) | namespace folly {
    function stdFindBenchmark (line 44) | void stdFindBenchmark(unsigned n) {
    function follyFindFixedBenchmark (line 55) | void follyFindFixedBenchmark(unsigned n) {
    function registerBenchmark (line 67) | void registerBenchmark(T, IndexConstant<N>) {
    function drawLine (line 90) | void drawLine() {
    function registerAllBenchmarks (line 94) | void registerAllBenchmarks() {
  function main (line 122) | int main(int argc, char** argv) {

FILE: folly/algorithm/simd/test/FindFixedTest.cpp
  function allTestsForN (line 36) | void allTestsForN(std::span<T, N> buf) {
  function allTestsForImpl (line 59) | void allTestsForImpl(std::span<T> buf, std::index_sequence<idx...>) {
  function allTestsFor (line 64) | void allTestsFor() {
  function TEST (line 80) | TEST(FindFixed, Basic) {
  function TEST (line 98) | TEST(FindFixed, Interfaces) {
  function TEST (line 129) | TEST(FollyFindFixed, SfianeFriendlyUnsupportedTypes) {

FILE: folly/algorithm/simd/test/MovemaskTest.cpp
  type folly (line 34) | namespace folly {
    function Reg (line 39) | Reg loadReg(const std::array<T, N>& arr) {
    function safeShift (line 45) | std::uint64_t safeShift(std::uint64_t what, std::uint32_t shift) {
    function allOneTrueTests (line 55) | void allOneTrueTests() {
    function TEST (line 109) | TEST(Movemask, Sse2Example) {
    function TEST (line 165) | TEST(Movemask, Sse2) {
    function TEST (line 174) | TEST(Movemask, Avx2) {
    function TEST (line 187) | TEST(Movemask, AARCH64) {

FILE: folly/algorithm/simd/test/find_first_of_bench.cpp
  function FOLLY_KEEP (line 38) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 45) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 52) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 59) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 67) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 75) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 83) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 91) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 101) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 108) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 115) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 122) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 130) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 138) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 148) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 156) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 164) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 172) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 181) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 190) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 200) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 210) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 222) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 230) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 238) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 246) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 256) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 266) | FOLLY_KEEP size_t
  function make_string (line 280) | static std::string make_string(std::string_view alphabet, size_t run) {
  function FOLLY_NOINLINE (line 290) | FOLLY_NOINLINE static void do_find_first_op_of(
  function find_first_of_json_str (line 302) | static void find_first_of_json_str(size_t iters, size_t run) {
  function find_first_not_of_json_ws (line 316) | static void find_first_not_of_json_ws(size_t iters, size_t run) {
  function find_first_of_json_str_stdfind_scalar (line 328) | void find_first_of_json_str_stdfind_scalar(size_t iters, size_t run) {
  function find_first_of_json_str_default_scalar (line 333) | void find_first_of_json_str_default_scalar(size_t iters, size_t run) {
  function find_first_of_json_str_ltindex_scalar (line 338) | void find_first_of_json_str_ltindex_scalar(size_t iters, size_t run) {
  function find_first_of_json_str_ltsparse_scalar (line 343) | void find_first_of_json_str_ltsparse_scalar(size_t iters, size_t run) {
  function find_first_of_json_str_stdfind_vector (line 349) | void find_first_of_json_str_stdfind_vector(size_t iters, size_t run) {
  function find_first_of_json_str_rngfind_vector (line 355) | void find_first_of_json_str_rngfind_vector(size_t iters, size_t run) {
  function find_first_of_json_str_default_vector (line 360) | void find_first_of_json_str_default_vector(size_t iters, size_t run) {
  function find_first_of_json_str_shuffle_vector (line 367) | void find_first_of_json_str_shuffle_vector(size_t iters, size_t run) {
  function find_first_of_json_str_azmatch_vector (line 374) | void find_first_of_json_str_azmatch_vector(size_t iters, size_t run) {
  function find_first_not_of_json_ws_default_scalar (line 381) | void find_first_not_of_json_ws_default_scalar(size_t iters, size_t run) {
  function find_first_not_of_json_ws_ltindex_scalar (line 386) | void find_first_not_of_json_ws_ltindex_scalar(size_t iters, size_t run) {
  function find_first_not_of_json_ws_ltsparse_scalar (line 391) | void find_first_not_of_json_ws_ltsparse_scalar(size_t iters, size_t run) {
  function find_first_not_of_json_ws_default_vector (line 396) | void find_first_not_of_json_ws_default_vector(size_t iters, size_t run) {
  function find_first_not_of_json_ws_shuffle_vector (line 403) | void find_first_not_of_json_ws_shuffle_vector(size_t iters, size_t run) {
  function find_first_not_of_json_ws_azmatch_vector (line 410) | void find_first_not_of_json_ws_azmatch_vector(size_t iters, size_t run) {
  function main (line 762) | int main(int argc, char** argv) {

FILE: folly/algorithm/simd/test/find_first_of_test.cpp
  function quote (line 29) | static auto quote(std::string_view sv) {
  type FindFirstOpOfTest (line 34) | struct FindFirstOpOfTest : testing::TestWithParam<Param> {
    method finder_type (line 39) | static constexpr finder_type make_finder(std::string_view const alphab...
    method make_from (line 45) | auto make_from(std::string_view const in, size_t const len) {
  type FindFirstOfTest (line 55) | struct FindFirstOfTest : FindFirstOpOfTest<Param> {
  function TYPED_TEST_P (line 62) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha) {
  function TYPED_TEST_P (line 73) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc) {
  function TYPED_TEST_P (line 85) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc2) {
  function TYPED_TEST_P (line 97) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc2n) {
  function TYPED_TEST_P (line 110) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc_edge) {
  function TYPED_TEST_P (line 122) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc2_edge) {
  function TYPED_TEST_P (line 134) | TYPED_TEST_P(FindFirstOfTest, json_str_stress_loalpha_with_esc2n_edge) {
  type find_first_of_impls (line 160) | struct find_first_of_impls {
  type FindFirstNotOfTest (line 198) | struct FindFirstNotOfTest : FindFirstOpOfTest<Param> {
    method make_json_spaces (line 209) | auto make_json_spaces(size_t const len) { //
  function TYPED_TEST_P (line 217) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_whitespace) {
  function TYPED_TEST_P (line 228) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_spaces) {
  function TYPED_TEST_P (line 241) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_spaces_then_text) {
  function TYPED_TEST_P (line 255) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_spaces_then_nulls) {
  function TYPED_TEST_P (line 269) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_spaces_then_his) {
  function TYPED_TEST_P (line 283) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_wspaces) {
  function TYPED_TEST_P (line 296) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_wspaces_then_text) {
  function TYPED_TEST_P (line 310) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_wspaces_then_nulls) {
  function TYPED_TEST_P (line 324) | TYPED_TEST_P(FindFirstNotOfTest, json_ws_stress_wspaces_then_his) {
  function TYPED_TEST_P (line 338) | TYPED_TEST_P(FindFirstNotOfTest, loweq_stress) {
  function TYPED_TEST_P (line 352) | TYPED_TEST_P(FindFirstNotOfTest, weird_stress) {
  type find_first_not_of_impls (line 383) | struct find_first_not_of_impls {

FILE: folly/algorithm/test/BinaryHeapTest.cpp
  function TEST (line 25) | TEST(BinaryHeap, DownHeap) {

FILE: folly/algorithm/test/StableRadixSortBenchmark.cpp
  function generateData (line 39) | std::span<const T> generateData(size_t n) {
  function benchmarkStdSort (line 56) | void benchmarkStdSort(size_t n) {
  function benchmarkRadixSort (line 64) | void benchmarkRadixSort(size_t n) {
  function benchmarkSpreadsort (line 72) | void benchmarkSpreadsort(size_t n) {
  function benchmarkPdqsort (line 84) | void benchmarkPdqsort(size_t n) {
  function benchmarkDoubleDetailRadixSort (line 91) | void benchmarkDoubleDetailRadixSort(size_t n) {
  function main (line 136) | int main(int argc, char** argv) {

FILE: folly/algorithm/test/StableRadixSortTest.cpp
  type folly (line 27) | namespace folly {
    type Item (line 31) | struct Item {
      method friend (line 35) | [[maybe_unused]] friend bool operator==(const Item&, const Item&) = ...
    function augmented_less (line 41) | bool augmented_less(const T& a, const T& b) {
    function augmented_greater (line 57) | bool augmented_greater(const T& a, const T& b) {
    function validate (line 63) | void validate(std::vector<T> v) {
    function validate (line 71) | void validate(std::vector<T> v, Proj proj) {
    function validateDescending (line 82) | void validateDescending(std::vector<T> v) {
    function validateDescending (line 90) | void validateDescending(std::vector<T> v, Proj proj) {
    class StableRadixSortTest (line 101) | class StableRadixSortTest : public ::testing::Test {
    function TEST_F (line 110) | TEST_F(StableRadixSortTest, EmptyRange) {
    function TEST_F (line 114) | TEST_F(StableRadixSortTest, SingleElement) {
    function TEST_F (line 118) | TEST_F(StableRadixSortTest, TwoElements) {
    function TEST_F (line 122) | TEST_F(StableRadixSortTest, AlreadySorted) {
    function TEST_F (line 126) | TEST_F(StableRadixSortTest, ReverseSorted) {
    function TEST_F (line 130) | TEST_F(StableRadixSortTest, AllEqual) {
    function TEST_F (line 138) | TEST_F(StableRadixSortTest, Uint32Random) {
    function TEST_F (line 147) | TEST_F(StableRadixSortTest, Uint64Random) {
    function TEST_F (line 156) | TEST_F(StableRadixSortTest, Uint16Random) {
    function TEST_F (line 165) | TEST_F(StableRadixSortTest, Uint8Random) {
    function TEST_F (line 178) | TEST_F(StableRadixSortTest, Int32Random) {
    function TEST_F (line 187) | TEST_F(StableRadixSortTest, Int64Random) {
    function TEST_F (line 196) | TEST_F(StableRadixSortTest, Int32NegativeValues) {
    function TEST_F (line 200) | TEST_F(StableRadixSortTest, Int64Extremes) {
    function TEST_F (line 217) | TEST_F(StableRadixSortTest, DoubleRandom) {
    function TEST_F (line 226) | TEST_F(StableRadixSortTest, FloatRandom) {
    function TEST_F (line 235) | TEST_F(StableRadixSortTest, DoubleSpecialValues) {
    function TEST_F (line 251) | TEST_F(StableRadixSortTest, DoubleNegativeNumbers) {
    function TEST_F (line 255) | TEST_F(StableRadixSortTest, NegativeZeroPositiveZeroEquality) {
    function TEST_F (line 276) | TEST_F(StableRadixSortTest, NegativeZeroPositiveZeroEqualityFloat) {
    function TEST_F (line 305) | TEST_F(StableRadixSortTest, Uint64Descending) {
    function TEST_F (line 314) | TEST_F(StableRadixSortTest, Int64Descending) {
    function TEST_F (line 323) | TEST_F(StableRadixSortTest, DoubleDescending) {
    function TEST_F (line 336) | TEST_F(StableRadixSortTest, KeyExtractorDouble) {
    function TEST_F (line 347) | TEST_F(StableRadixSortTest, KeyExtractorDescending) {
    function TEST_F (line 360) | TEST_F(StableRadixSortTest, KeyExtractorInteger) {
    function TEST_F (line 383) | TEST_F(StableRadixSortTest, StabilityPreserved) {
    function TEST_F (line 397) | TEST_F(StableRadixSortTest, StabilityWithMultipleGroups) {
    function TEST_F (line 412) | TEST_F(StableRadixSortTest, MatchesStableSort) {
    function TEST_F (line 421) | TEST_F(StableRadixSortTest, MatchesStableSortDescending) {
    function TEST_F (line 434) | TEST_F(StableRadixSortTest, LargeInput) {
    function TEST_F (line 444) | TEST_F(StableRadixSortTest, LargeInputDouble) {
    function TEST_F (line 458) | TEST_F(StableRadixSortTest, SmallInputFallback) {
    function TEST_F (line 466) | TEST_F(StableRadixSortTest, FloatKeyCorrectness) {
    function TEST_F (line 483) | TEST_F(StableRadixSortTest, IntegralKeyCorrectness) {

FILE: folly/base64.h
  function namespace (line 31) | namespace folly {

FILE: folly/channels/Channel-fwd.h
  function namespace (line 23) | namespace folly {

FILE: folly/channels/Channel-inl.h
  function namespace (line 24) | namespace folly {

FILE: folly/channels/Channel.h
  function namespace (line 22) | namespace folly {
  function close (line 102) | void close() && {
  function close (line 112) | void close(exception_wrapper exception) && {
  function isReceiverCancelled (line 123) | bool isReceiverCancelled() {
  type NextSemiAwaitable (line 178) | struct NextSemiAwaitable
  function cancel (line 260) | void cancel() && {

FILE: folly/channels/ChannelCallbackHandle.h
  function namespace (line 23) | namespace folly {

FILE: folly/channels/ChannelProcessor-inl.h
  function namespace (line 27) | namespace folly {

FILE: folly/channels/ChannelProcessor.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/ConsumeChannel-inl.h
  function namespace (line 29) | namespace folly {

FILE: folly/channels/ConsumeChannel.h
  function namespace (line 26) | namespace folly {

FILE: folly/channels/FanoutChannel-inl.h
  function namespace (line 25) | namespace folly {
  function namespace (line 94) | namespace detail {
  function closeSubscribers (line 198) | void closeSubscribers(CloseResult closeResult) override {
  function destroyHandle (line 210) | void destroyHandle(CloseResult closeResult) override {
  function anySubscribers (line 218) | bool anySubscribers() override {
  function ContextType (line 222) | ContextType getContext() override { return state_.rlock()->context; }
  function canceled (line 238) | void canceled(ChannelBridgeBase*) override {
  function processAllAvailableValues (line 255) | void processAllAvailableValues(
  function processReceiverCancelled (line 310) | void processReceiverCancelled(
  function processHandleDestroyed (line 327) | void processHandleDestroyed(WLockedStatePtr& state, CloseResult closeRes...
  function maybeDelete (line 345) | void maybeDelete(WLockedStatePtr& state) {

FILE: folly/channels/FanoutChannel.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/FanoutSender-inl.h
  function namespace (line 24) | namespace folly {

FILE: folly/channels/FanoutSender.h
  function namespace (line 23) | namespace folly {

FILE: folly/channels/MaxConcurrentRateLimiter.cpp
  type folly (line 19) | namespace folly {
    type channels (line 20) | namespace channels {
      class MaxConcurrentRateLimiter::Token (line 22) | class MaxConcurrentRateLimiter::Token : public RateLimiter::Token {
        method Token (line 24) | explicit Token(
        method Token (line 28) | Token(Token&&) = default;
        method Token (line 29) | Token& operator=(Token&&) = default;
        method Token (line 30) | Token(const Token&) = delete;
        method Token (line 31) | Token& operator=(const Token&) = delete;

FILE: folly/channels/MaxConcurrentRateLimiter.h
  function namespace (line 24) | namespace folly {

FILE: folly/channels/Merge-inl.h
  function namespace (line 24) | namespace folly {
  function processSenderCancelled (line 249) | void processSenderCancelled() {

FILE: folly/channels/Merge.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/MergeChannel-inl.h
  function namespace (line 25) | namespace folly {
  function namespace (line 87) | namespace detail {
  function destroyHandle (line 257) | void destroyHandle(CloseResult closeResult) {
  function consume (line 266) | void consume(ChannelBridgeBase* bridge) override {
  function canceled (line 288) | void canceled(ChannelBridgeBase* bridge) override {
  function processReceiverCancelled (line 377) | void processReceiverCancelled(
  function processSenderCancelled (line 406) | void processSenderCancelled(WLockedStatePtr& state) {

FILE: folly/channels/MergeChannel.h
  function namespace (line 23) | namespace folly {

FILE: folly/channels/MultiplexChannel-inl.h
  function namespace (line 26) | namespace folly {
  function processor_ (line 84) | processor_(processor) {}
  function namespace (line 143) | namespace detail {

FILE: folly/channels/MultiplexChannel.h
  function namespace (line 28) | namespace folly {

FILE: folly/channels/OnClosedException.h
  function namespace (line 21) | namespace folly {

FILE: folly/channels/Producer-inl.h
  function namespace (line 26) | namespace folly {
  function namespace (line 116) | namespace detail {

FILE: folly/channels/Producer.h
  function namespace (line 23) | namespace folly {

FILE: folly/channels/ProxyChannel-inl.h
  function namespace (line 22) | namespace folly {
  function namespace (line 75) | namespace detail {

FILE: folly/channels/ProxyChannel.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/RateLimiter.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/Transform-inl.h
  function namespace (line 25) | namespace folly {
  function initialize (line 353) | void initialize(InitializeArg initializeArg) {

FILE: folly/channels/Transform.h
  function namespace (line 24) | namespace folly {

FILE: folly/channels/detail/AtomicQueue.h
  function namespace (line 27) | namespace folly {

FILE: folly/channels/detail/ChannelBridge.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/detail/IntrusivePtr.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/detail/MultiplexerTraits.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/detail/PointerVariant.h
  function namespace (line 22) | namespace folly {

FILE: folly/channels/detail/Utility.h
  function namespace (line 29) | namespace folly {

FILE: folly/channels/detail/test/AtomicQueueTest.cpp
  type folly (line 23) | namespace folly {
    type channels (line 24) | namespace channels {
      type detail (line 25) | namespace detail {
        function TEST (line 31) | TEST(AtomicQueueTest, Basic) {
        function TEST (line 100) | TEST(AtomicQueueTest, Canceled) {
        function TEST (line 126) | TEST(AtomicQueueTest, Stress) {

FILE: folly/channels/detail/test/PointerVariantTest.cpp
  type folly (line 20) | namespace folly {
    type channels (line 21) | namespace channels {
      type detail (line 22) | namespace detail {
        function TEST (line 26) | TEST(PointerVariantTest, Basic) {
        function TEST (line 48) | TEST(PointerVariantTest, GetIncorrecttype) {

FILE: folly/channels/test/ChannelProcessorTest.cpp
  type folly (line 21) | namespace folly {
    type channels (line 22) | namespace channels {
      type MockCallback (line 26) | struct MockCallback {
      class ChannelProcessorFixture (line 30) | class ChannelProcessorFixture : public Test {
        method ChannelProcessorFixture (line 32) | ChannelProcessorFixture()
      function TEST_F (line 40) | TEST_F(ChannelProcessorFixture, SimpleChannel_ReceiveValues) {
      function TEST_F (line 62) | TEST_F(ChannelProcessorFixture, SimpleChannel_ThrowOnClosedException) {
      function TEST_F (line 89) | TEST_F(
      function TEST_F (line 117) | TEST_F(ChannelProcessorFixture, SimpleChannel_ThrowOtherException_De...
      function TEST_F (line 149) | TEST_F(ChannelProcessorFixture, SimpleChannel_RemoveChannel) {
      function TEST_F (line 192) | TEST_F(
      function TEST_F (line 241) | TEST_F(
      function TEST_F (line 262) | TEST_F(
      function TEST_F (line 283) | TEST_F(
      function TEST_F (line 318) | TEST_F(

FILE: folly/channels/test/ChannelTest.cpp
  type folly (line 23) | namespace folly {
    type channels (line 24) | namespace channels {
      class ChannelFixture (line 28) | class ChannelFixture
        method ChannelFixture (line 33) | ChannelFixture() : ChannelConsumerBase(GetParam()) {}
        method getExecutor (line 43) | folly::Executor::KeepAlive<folly::SequencedExecutor> getExecutor()...
        method onNext (line 47) | void onNext(Try<int> result) override { onNext_(std::move(result)); }
      function TEST_P (line 53) | TEST_P(ChannelFixture, SingleWriteBeforeNext_ThenCancelled) {
      function TEST_P (line 71) | TEST_P(ChannelFixture, SingleWriteAfterNext_ThenCancelled) {
      function TEST_P (line 91) | TEST_P(ChannelFixture, MultipleWrites_ThenStopConsumingByReturningFa...
      function TEST_P (line 112) | TEST_P(
      function TEST_P (line 135) | TEST_P(ChannelFixture, Close_NoException_BeforeSubscribe) {
      function TEST_P (line 146) | TEST_P(ChannelFixture, Close_NoException_AfterSubscribeAndWrite) {
      function TEST_P (line 159) | TEST_P(ChannelFixture, Close_DueToDestruction_BeforeSubscribe) {
      function TEST_P (line 172) | TEST_P(ChannelFixture, Close_DueToDestruction_AfterSubscribeAndWrite) {
      function TEST_P (line 188) | TEST_P(ChannelFixture, Close_Exception_BeforeSubscribe) {
      function TEST_P (line 199) | TEST_P(ChannelFixture, Close_Exception_AfterSubscribeAndWrite) {
      function TEST_P (line 212) | TEST_P(ChannelFixture, CancellationRespected) {
      function TEST (line 230) | TEST(Channel, CancelNextWithoutClose) {
      class ChannelFixtureStress (line 278) | class ChannelFixtureStress
        method ChannelFixtureStress (line 282) | ChannelFixtureStress()
      function TEST_P (line 300) | TEST_P(ChannelFixtureStress, Close_NoException) {
      function TEST_P (line 312) | TEST_P(ChannelFixtureStress, Close_Exception) {
      function TEST_P (line 324) | TEST_P(ChannelFixtureStress, Cancelled) {
      function TEST_P (line 338) | TEST_P(ChannelFixtureStress, Close_NoException_ThenCancelledImmediat...
      function TEST_P (line 353) | TEST_P(ChannelFixtureStress, Cancelled_ThenClosedImmediately_NoExcep...

FILE: folly/channels/test/ChannelTestUtil.h
  type class (line 69) | enum class
  function startConsuming (line 92) | void startConsuming(Receiver<TValue> receiver) {
  function callbackHandle (line 130) | auto callbackHandle = consumeChannelWithCallback(
  function CloseType (line 155) | enum class CloseType { NoException, Exception, Cancelled };

FILE: folly/channels/test/FanoutChannelTest.cpp
  type folly (line 25) | namespace folly {
    type channels (line 26) | namespace channels {
      class FanoutChannelFixture (line 30) | class FanoutChannelFixture : public Test {
        method FanoutChannelFixture (line 32) | FanoutChannelFixture() {}
        method processValues (line 40) | std::pair<ChannelCallbackHandle, Callback<T>*> processValues(
        method createCallback (line 55) | StrictMock<MockNextCallback<std::string>> createCallback() {
      function TEST_F (line 62) | TEST_F(FanoutChannelFixture, ReceiveValue_FanoutBroadcastsValues) {
      function TEST_F (line 122) | TEST_F(FanoutChannelFixture, InputClosed_AllOutputReceiversClose) {
      function TEST_F (line 148) | TEST_F(FanoutChannelFixture, InputThrows_AllOutputReceiversGetExcept...
      function TEST_F (line 174) | TEST_F(FanoutChannelFixture, ReceiversCancelled) {
      function TEST_F (line 215) | TEST_F(FanoutChannelFixture, SubscribersClosed) {
      function TEST_F (line 254) | TEST_F(FanoutChannelFixture, VectorBool) {
      class FanoutChannelFixtureStress (line 289) | class FanoutChannelFixtureStress : public Test {
        method FanoutChannelFixtureStress (line 291) | FanoutChannelFixtureStress()
        method makeProducer (line 295) | static std::unique_ptr<StressTestProducer<int>> makeProducer() {
        method makeConsumer (line 301) | static std::unique_ptr<StressTestConsumer<int>> makeConsumer() {
        method sleepFor (line 313) | static void sleepFor(std::chrono::milliseconds duration) {
      function TEST_F (line 325) | TEST_F(FanoutChannelFixtureStress, HandleClosed) {
      function TEST_F (line 353) | TEST_F(FanoutChannelFixtureStress, InputChannelClosed) {

FILE: folly/channels/test/FanoutSenderTest.cpp
  type folly (line 25) | namespace folly {
    type channels (line 26) | namespace channels {
      class FanoutSenderFixture (line 30) | class FanoutSenderFixture : public Test {
        method FanoutSenderFixture (line 32) | FanoutSenderFixture() {}
        method processValues (line 36) | std::pair<ChannelCallbackHandle, TCallback*> processValues(
        method createCallback (line 51) | StrictMock<MockNextCallback<std::string>> createCallback() {
      function TEST_F (line 58) | TEST_F(FanoutSenderFixture, WriteValue_FanoutBroadcastsValues) {
      function TEST_F (line 98) | TEST_F(FanoutSenderFixture, InputThrows_AllOutputReceiversGetExcepti...
      function TEST_F (line 130) | TEST_F(FanoutSenderFixture, ReceiversCancelled) {
      function TEST_F (line 174) | TEST_F(FanoutSenderFixture, ReceiverCancelled_DelayedCancellationCal...
      function TEST_F (line 207) | TEST_F(FanoutSenderFixture, Close_DelayedCancellationCallback) {
      function TEST_F (line 233) | TEST_F(FanoutSenderFixture, NumSubscribers) {

FILE: folly/channels/test/MaxConcurrentRateLimiterTest.cpp
  type folly (line 25) | namespace folly {
    type channels (line 26) | namespace channels {
      class MaxConcurrentRateLimiterTest (line 28) | class MaxConcurrentRateLimiterTest : public Test {
        method MaxConcurrentRateLimiterTest (line 30) | MaxConcurrentRateLimiterTest() {
      function TEST_F (line 40) | TEST_F(MaxConcurrentRateLimiterTest, Basic) {
      function TEST_F (line 51) | TEST_F(MaxConcurrentRateLimiterTest, UnderQuota) {
      function TEST_F (line 64) | TEST_F(MaxConcurrentRateLimiterTest, OverQuota) {

FILE: folly/channels/test/MergeChannelTest.cpp
  type folly (line 26) | namespace folly {
    type channels (line 27) | namespace channels {
      function isMatch (line 33) | bool isMatch(
      class MergeChannelFixture (line 108) | class MergeChannelFixture : public Test {
        method MergeChannelFixture (line 110) | MergeChannelFixture() {}
        method ChannelCallbackHandle (line 116) | ChannelCallbackHandle processValues(
      function TEST_F (line 139) | TEST_F(MergeChannelFixture, ReceiveValues_ReturnMergedValues) {
      function TEST_F (line 180) | TEST_F(
      function TEST_F (line 222) | TEST_F(
      function TEST_F (line 267) | TEST_F(MergeChannelFixture, ReceiveValues_RemoveReceiver) {
      function TEST_F (line 302) | TEST_F(MergeChannelFixture, ReceiveValues_RemoveReceiver_AfterClose) {
      function TEST_F (line 338) | TEST_F(MergeChannelFixture, OneInputClosed_ContinuesMerging) {
      function TEST_F (line 383) | TEST_F(MergeChannelFixture, OneInputThrows_ContinuesMerging) {
      function TEST_F (line 426) | TEST_F(MergeChannelFixture, Cancelled) {
      type ProducedValue (line 467) | struct ProducedValue {
      class MergeChannelFixtureStress (line 472) | class MergeChannelFixtureStress : public Test {
        method MergeChannelFixtureStress (line 474) | MergeChannelFixtureStress()
        method makeProducer (line 478) | static std::unique_ptr<StressTestProducer<ProducedValue>> makeProd...
        method makeConsumer (line 484) | static std::unique_ptr<
        method sleepFor (line 499) | static void sleepFor(std::chrono::milliseconds duration) {
      function TEST_F (line 512) | TEST_F(MergeChannelFixtureStress, HandleClosed) {
      function TEST_F (line 538) | TEST_F(MergeChannelFixtureStress, Cancelled) {
      function TEST_F (line 564) | TEST_F(MergeChannelFixtureStress, Cancelled_ThenHandleClosedImmediat...
      function TEST_F (line 593) | TEST_F(MergeChannelFixtureStress, HandleClosed_ThenCancelledImmediat...

FILE: folly/channels/test/MergeTest.cpp
  type folly (line 25) | namespace folly {
    type channels (line 26) | namespace channels {
      class MergeFixture (line 30) | class MergeFixture : public Test {
        method ChannelCallbackHandle (line 34) | ChannelCallbackHandle processValues(Receiver<int> receiver) {
      function TEST_F (line 48) | TEST_F(MergeFixture, ReceiveValues_ReturnMergedValues) {
      function TEST_F (line 83) | TEST_F(MergeFixture, OneInputClosed_WaitForAllInputsToClose_Continue...
      function TEST_F (line 116) | TEST_F(MergeFixture, OneInputClosed_DoNotWaitForAllInputsToClose_Sto...
      function TEST_F (line 151) | TEST_F(MergeFixture, OneInputThrows_OutputClosedWithException) {
      function TEST_F (line 181) | TEST_F(MergeFixture, CancelledAfterStart) {
      function TEST_F (line 216) | TEST_F(MergeFixture, CancelledBeforeStart) {
      type ProducedValue (line 237) | struct ProducedValue {
      class MergeFixtureStress (line 242) | class MergeFixtureStress : public Test {
        method MergeFixtureStress (line 244) | MergeFixtureStress()
        method makeProducer (line 248) | static std::unique_ptr<StressTestProducer<ProducedValue>> makeProd...
        method makeConsumer (line 254) | static std::unique_ptr<StressTestConsumer<ProducedValue>> makeCons...
      function TEST_F (line 269) | TEST_F(MergeFixtureStress, Close_NoException) {
      function TEST_F (line 290) | TEST_F(MergeFixtureStress, Close_Exception) {
      function TEST_F (line 317) | TEST_F(MergeFixtureStress, Cancelled) {
      function TEST_F (line 337) | TEST_F(MergeFixtureStress, Close_NoException_ThenCancelledImmediatel...
      function TEST_F (line 362) | TEST_F(MergeFixtureStress, Cancelled_ThenClosedImmediately_NoExcepti...

FILE: folly/channels/test/MultiplexChannelTest.cpp
  type folly (line 27) | namespace folly {
    type channels (line 28) | namespace channels {
      class MultiplexChannelFixture (line 33) | class MultiplexChannelFixture : public Test {
        method MultiplexChannelFixture (line 35) | MultiplexChannelFixture() {}
        method processValues (line 43) | std::pair<ChannelCallbackHandle, Callback<T>*> processValues(
      type TestInputValue (line 63) | struct TestInputValue {
      type TestContext (line 67) | struct TestContext {
      type TestSubscriptionArg (line 71) | struct TestSubscriptionArg {
      type TestMultiplexer (line 78) | struct TestMultiplexer {
        method TestMultiplexer (line 80) | TestMultiplexer(
        method getExecutor (line 85) | folly::Executor::KeepAlive<folly::SequencedExecutor> getExecutor() {
        method onNewSubscription (line 89) | folly::coro::Task<std::vector<int>> onNewSubscription(
        method onInputValue (line 104) | folly::coro::Task<void> onInputValue(
        method getRateLimiter (line 120) | std::shared_ptr<RateLimiter> getRateLimiter() { return rateLimiter...
      function TEST_F (line 127) | TEST_F(MultiplexChannelFixture, ReceiveValues_MultiplexesValues) {
      function TEST_F (line 181) | TEST_F(MultiplexChannelFixture, InputThrows_AllOutputReceiversGetExc...
      function TEST_F (line 212) | TEST_F(MultiplexChannelFixture, ClearUnusedSubscriptions) {
      function TEST_F (line 284) | TEST_F(MultiplexChannelFixture, OnNewSubscriptionThrows_OutputReceiv...
      function TEST_F (line 319) | TEST_F(MultiplexChannelFixture, HandleDestroyed) {
      function TEST_F (line 343) | TEST_F(MultiplexChannelFixture, Subscribe_WithRateLimiter) {
      class MultiplexChannelFixtureStress (line 388) | class MultiplexChannelFixtureStress : public Test {
        method MultiplexChannelFixtureStress (line 390) | MultiplexChannelFixtureStress()
        method makeProducer (line 395) | static std::unique_ptr<StressTestProducer<int>> makeProducer() {
        method makeConsumer (line 401) | static std::unique_ptr<StressTestConsumer<int>> makeConsumer(int r...
        method sleepFor (line 415) | static void sleepFor(std::chrono::milliseconds duration) {
      type NoContext (line 427) | struct NoContext {}
      type NoSubscriptionArg (line 428) | struct NoSubscriptionArg {}
      type TestMultiplexerStress (line 430) | struct TestMultiplexerStress {
        method TestMultiplexerStress (line 432) | explicit TestMultiplexerStress(
        method getExecutor (line 436) | folly::Executor::KeepAlive<folly::SequencedExecutor> getExecutor() {
        method getRateLimiter (line 440) | std::shared_ptr<RateLimiter> getRateLimiter() {
        method onNewSubscription (line 444) | folly::coro::Task<std::vector<int>> onNewSubscription(
        method onInputValue (line 449) | folly::coro::Task<void> onInputValue(
      function TEST_F (line 462) | TEST_F(MultiplexChannelFixtureStress, HandleClosed) {
      function TEST_F (line 494) | TEST_F(MultiplexChannelFixtureStress, InputChannelClosed) {

FILE: folly/channels/test/ProducerTest.cpp
  type folly (line 23) | namespace folly {
    type channels (line 24) | namespace channels {
      class ProducerFixture (line 28) | class ProducerFixture : public Test {
        method ProducerFixture (line 30) | ProducerFixture() {}
        method ChannelCallbackHandle (line 34) | ChannelCallbackHandle processValues(Receiver<int> receiver) {
      function TEST_F (line 48) | TEST_F(ProducerFixture, Write_ThenCloseWithoutException) {
      function TEST_F (line 70) | TEST_F(ProducerFixture, Write_ThenCloseWithException) {
      function TEST_F (line 92) | TEST_F(ProducerFixture, KeepAliveExists_DelaysDestruction) {
      function TEST_F (line 136) | TEST_F(

FILE: folly/channels/test/ProxyChannelTest.cpp
  type folly (line 23) | namespace folly {
    type channels (line 24) | namespace channels {
      class ProxyChannelFixture (line 28) | class ProxyChannelFixture : public Test {
        method ChannelCallbackHandle (line 32) | ChannelCallbackHandle processValues(Receiver<int> receiver) {
      function TEST_F (line 46) | TEST_F(ProxyChannelFixture, ReceiveValues) {
      function TEST_F (line 70) | TEST_F(ProxyChannelFixture, InputSenderClosedWithException) {
      function TEST_F (line 95) | TEST_F(ProxyChannelFixture, ReplaceInputReceiver_BeforeFirstReceiver...
      function TEST_F (line 135) | TEST_F(ProxyChannelFixture, ReplaceInputReceiver_AfterFirstReceiverC...
      function TEST_F (line 162) | TEST_F(ProxyChannelFixture, ReplaceInputReceiver_AfterFirstReceiverR...
      function TEST_F (line 199) | TEST_F(
      function TEST_F (line 225) | TEST_F(

FILE: folly/channels/test/TransformTest.cpp
  type folly (line 30) | namespace folly {
    type channels (line 31) | namespace channels {
      class TransformFixture (line 36) | class TransformFixture : public Test {
        method TransformFixture (line 38) | TransformFixture() {}
        method ChannelCallbackHandle (line 42) | ChannelCallbackHandle processValues(Receiver<std::string> receiver) {
      class SimpleTransformFixture (line 56) | class SimpleTransformFixture : public TransformFixture {}
      function TEST_F (line 58) | TEST_F(SimpleTransformFixture, ReceiveValue_ReturnTransformedValue) {
      function TEST_F (line 89) | TEST_F(SimpleTransformFixture, ReceiveValue_Close) {
      function TEST_F (line 118) | TEST_F(SimpleTransformFixture, ReceiveValue_Throw_InCoroutine) {
      function TEST_F (line 147) | TEST_F(SimpleTransformFixture, ReceiveValue_Throw_InNonCoroutine) {
      function TEST_F (line 179) | TEST_F(SimpleTransformFixture, ReceiveClosed_Close) {
      function TEST_F (line 205) | TEST_F(SimpleTransformFixture, ReceiveClosed_Throw) {
      function TEST_F (line 232) | TEST_F(SimpleTransformFixture, ReceiveException_Close) {
      function TEST_F (line 260) | TEST_F(SimpleTransformFixture, ReceiveException_Throw) {
      function TEST_F (line 286) | TEST_F(SimpleTransformFixture, Cancelled) {
      function TEST_F (line 311) | TEST_F(SimpleTransformFixture, Chained) {
      function TEST_F (line 343) | TEST_F(SimpleTransformFixture, MultipleTransformsWithRateLimiter) {
      class TransformFixtureStress (line 418) | class TransformFixtureStress : public Test {
        method TransformFixtureStress (line 420) | TransformFixtureStress()
      function TEST_F (line 439) | TEST_F(TransformFixtureStress, Close) {
      function TEST_F (line 457) | TEST_F(TransformFixtureStress, Cancel) {
      function TEST_F (line 475) | TEST_F(TransformFixtureStress, Close_ThenCancelImmediately) {
      function TEST_F (line 497) | TEST_F(TransformFixtureStress, Cancel_ThenCloseImmediately) {
      class ResumableTransformFixture (line 519) | class ResumableTransformFixture : public TransformFixture {}
      function TEST_F (line 521) | TEST_F(
      function TEST_F (line 560) | TEST_F(
      function TEST_F (line 599) | TEST_F(
      function TEST_F (line 633) | TEST_F(
      function TEST_F (line 685) | TEST_F(
      function TEST_F (line 719) | TEST_F(
      function TEST_F (line 767) | TEST_F(ResumableTransformFixture, TransformThrows_NoReinitialization...
      function TEST_F (line 804) | TEST_F(ResumableTransformFixture, MultipleResumableTransformsWithRat...
      class ResumableTransformFixtureStress (line 912) | class ResumableTransformFixtureStress : public Test {
        method ResumableTransformFixtureStress (line 914) | ResumableTransformFixtureStress()
        method makeProducer (line 926) | std::unique_ptr<StressTestProducer<int>> makeProducer() {
        method setProducer (line 932) | void setProducer(std::unique_ptr<StressTestProducer<int>> producer) {
        method waitForProducer (line 937) | void waitForProducer() {
        method stopProducing (line 943) | void stopProducing() { (*producer_.wlock())->stopProducing(); }
      function TEST_F (line 953) | TEST_F(ResumableTransformFixtureStress, Close) {
      function TEST_F (line 995) | TEST_F(ResumableTransformFixtureStress, CancelDuringReinitialization) {

FILE: folly/chrono/Clock.h
  function namespace (line 28) | namespace folly::chrono {

FILE: folly/chrono/Conv.h
  function namespace (line 40) | namespace folly {
  function maxValue (line 193) | constexpr auto maxValue = std::numeric_limits<time_t>::max() / Numerator;
  type IntermediateTimeRep (line 228) | struct IntermediateTimeRep {}
  function maxInput (line 273) | constexpr auto maxInput =
  function minInput (line 278) | constexpr auto minInput =
  function intermediate (line 283) | auto intermediate = IntermediateType{
  function ConversionCode (line 304) | ConversionCode check(Seconds seconds, Subseconds subseconds) {
  type CheckOverflowToDuration (line 364) | struct CheckOverflowToDuration
  function ConversionCode (line 370) | ConversionCode check(
  type timespec (line 664) | struct timespec
  type timeval (line 683) | struct timeval

FILE: folly/chrono/Hardware.h
  function hardware_timestamp (line 41) | inline std::uint64_t hardware_timestamp() {
  function hardware_timestamp_measurement_stop (line 118) | inline std::uint64_t hardware_timestamp_measurement_stop() noexcept {

FILE: folly/chrono/test/ClockTest.cpp
  function TEST (line 24) | TEST(ClockTest, SteadyClockSanity) {
  function TEST (line 44) | TEST(ClockTest, SystemClockSanity) {

FILE: folly/chrono/test/ConvTest.cpp
  function createTimePoint (line 35) | typename Clock::time_point createTimePoint(const Duration& d) {
  function TEST (line 41) | TEST(Conv, timespecToStdChrono) {
  function TEST (line 152) | TEST(Conv, timespecToStdChronoOverflow) {
  function TEST (line 285) | TEST(Conv, timevalToStdChrono) {
  function TEST (line 338) | TEST(Conv, stdChronoToTimespec) {
  function TEST (line 397) | TEST(Conv, stdChronoToTimespecOverflow) {
  function TEST (line 439) | TEST(Conv, stdChronoToTimeval) {
  function TEST (line 601) | TEST(Conv, stdChronoToTimevalOverflow) {

FILE: folly/cli/Args.cpp
  type folly (line 31) | namespace folly {
    function cli_args_strings_to_c_strings (line 33) | std::vector<char const*> cli_args_strings_to_c_strings(
    class cli_apply_args_files_error_category (line 45) | class cli_apply_args_files_error_category : public std::error_category {
      method message (line 48) | std::string message(int ev) const override {
    function make_error_code (line 60) | std::error_code make_error_code(cli_apply_args_files_errc errc) {
    type cli_parsed_arg (line 67) | struct cli_parsed_arg {
    type cli_parse_error (line 79) | struct cli_parse_error {
    type cli_parse_result (line 91) | struct cli_parse_result {
    function cli_is_space (line 99) | constexpr bool cli_is_space(char c) noexcept {
    function cli_parse_result (line 117) | cli_parse_result cli_parse_args_from_content(std::string_view content) {
    function cli_read_file (line 424) | std::pair<std::string, std::error_code> cli_read_file(
    type cli_arg_item (line 435) | struct cli_arg_item {
    function cli_process_single_arg (line 456) | cli_apply_args_files_receiver::control cli_process_single_arg(
    function cli_process_file_args (line 579) | void cli_process_file_args(
    function cli_apply_args_files (line 610) | void cli_apply_args_files(
    class cli_throwing_receiver (line 636) | class cli_throwing_receiver : public cli_apply_args_files_receiver {
      method cli_throwing_receiver (line 638) | explicit cli_throwing_receiver(std::vector<std::string>& result)
      method control (line 641) | control on_term(std::string arg, location /*loc*/) override {
      method on_term_error (line 661) | void on_term_error(
      method found (line 675) | found on_file_found(cstring_view /*file*/, location /*loc*/) override {
      method control (line 679) | control on_file_error(
      method on_file_enter (line 685) | void on_file_enter(std::string file, location /*loc*/) override {
      method on_file_leave (line 690) | void on_file_leave() override {
      method cycle (line 697) | cycle on_file_cycle(
    function cli_apply_args_files (line 713) | std::vector<std::string> cli_apply_args_files(
    function cli_apply_args_files (line 721) | std::vector<std::string> cli_apply_args_files(
    function cli_apply_args_files (line 732) | std::vector<std::string> cli_apply_args_files(
    function cli_apply_args_files (line 738) | std::vector<std::string> cli_apply_args_files(
    function cli_apply_args_files (line 744) | std::vector<std::string> cli_apply_args_files(int argc, char* const* a...

FILE: folly/cli/Args.h
  type class (line 36) | enum class
  type class (line 41) | enum class
  function cycle (line 47) | enum class cycle {
  function namespace (line 152) | namespace std {
  function namespace (line 157) | namespace folly {

FILE: folly/cli/NestedCommandLineApp.cpp
  type folly (line 30) | namespace folly {
    function guessProgramName (line 35) | std::string guessProgramName() {

FILE: folly/cli/NestedCommandLineApp.h
  function namespace (line 27) | namespace folly {
  function addCallback (line 188) | void addCallback(InitFunction callback) {

FILE: folly/cli/ProgramOptions.cpp
  type folly (line 35) | namespace folly {
    class GFlagInfo (line 49) | class GFlagInfo {
      method GFlagInfo (line 51) | explicit GFlagInfo(folly::gflags::CommandLineFlagInfo info)
      method set (line 54) | void set(const T& value) {
      method T (line 68) | T get() const {
    class GFlagValueSemanticBase (line 82) | class GFlagValueSemanticBase : public po::value_semantic {
      method GFlagValueSemanticBase (line 84) | explicit GFlagValueSemanticBase(std::shared_ptr<GFlagInfo<T>> info)
      method name (line 87) | std::string name() const override { return "arg"; }
      method adjacent_tokens_only (line 89) | bool adjacent_tokens_only() const override { return false; }
      method is_composing (line 91) | bool is_composing() const override { return false; }
      method is_required (line 92) | bool is_required() const override { return false; }
      method notify (line 94) | void notify(const boost::any& /* valueStore */) const override {}
      method apply_default (line 95) | bool apply_default(boost::any& valueStore) const override {
      method transform (line 113) | virtual void transform(T& /* val */) const {}
    class GFlagValueSemantic (line 136) | class GFlagValueSemantic : public GFlagValueSemanticBase<T> {
      method GFlagValueSemantic (line 138) | explicit GFlagValueSemantic(std::shared_ptr<GFlagInfo<T>> info)
      method min_tokens (line 141) | unsigned min_tokens() const override { return 1; }
      method max_tokens (line 142) | unsigned max_tokens() const override { return 1; }
      method T (line 144) | T parseValue(const std::vector<std::string>& tokens) const override {
    class BoolGFlagValueSemantic (line 150) | class BoolGFlagValueSemantic : public GFlagValueSemanticBase<bool> {
      method BoolGFlagValueSemantic (line 152) | explicit BoolGFlagValueSemantic(std::shared_ptr<GFlagInfo<bool>> info)
      method min_tokens (line 155) | unsigned min_tokens() const override { return 0; }
      method max_tokens (line 156) | unsigned max_tokens() const override { return 0; }
      method parseValue (line 158) | bool parseValue(const std::vector<std::string>& tokens) const overri...
    class NegativeBoolGFlagValueSemantic (line 164) | class NegativeBoolGFlagValueSemantic : public BoolGFlagValueSemantic {
      method NegativeBoolGFlagValueSemantic (line 166) | explicit NegativeBoolGFlagValueSemantic(std::shared_ptr<GFlagInfo<bo...
      method transform (line 170) | void transform(bool& val) const override { val = !val; }
    function addGFlag (line 183) | void addGFlag(
    function getGFlags (line 254) | po::options_description getGFlags(ProgramOptionsStyle style) {
    function NestedCommandLineParseResult (line 292) | NestedCommandLineParseResult doParseNestedCommandLine(
    function NestedCommandLineParseResult (line 328) | NestedCommandLineParseResult parseNestedCommandLine(
    function NestedCommandLineParseResult (line 337) | NestedCommandLineParseResult parseNestedCommandLine(

FILE: folly/cli/ProgramOptions.h
  function namespace (line 24) | namespace folly {

FILE: folly/cli/test/ArgsTest.cpp
  class ArgsTest (line 36) | class ArgsTest : public ::testing::Test {
    type Entry (line 41) | struct Entry {
      type Type (line 42) | enum Type {
    class TestReceiver (line 113) | class TestReceiver : public cli_apply_args_files_receiver {
      method control (line 120) | control on_term(std::string arg, location loc) override {
      method on_term_error (line 135) | void on_term_error(
      method found (line 146) | found on_file_found(cstring_view file, location loc) override {
      method control (line 157) | control on_file_error(
      method on_file_enter (line 169) | void on_file_enter(std::string file, location loc) override {
      method on_file_leave (line 179) | void on_file_leave() override {
      method cycle (line 187) | cycle on_file_cycle(
      method set_stop_string (line 201) | void set_stop_string(std::string const& str) { stop_string = str; }
    method write_file (line 205) | void write_file(const std::string& filename, const std::string& conten...
    method temp_dir (line 214) | std::filesystem::path temp_dir() const {
    method location (line 219) | static location idx(size_t idx_val) {
    method Entry (line 224) | Entry entry_term(size_t depth, const std::string& value, location loc ...
      type Type (line 42) | enum Type {
    method Entry (line 230) | Entry entry_file_found(
      type Type (line 42) | enum Type {
    method Entry (line 237) | Entry entry_file_enter(
      type Type (line 42) | enum Type {
    method Entry (line 244) | Entry entry_file_leave(size_t depth) {
      type Type (line 42) | enum Type {
    method Entry (line 249) | Entry entry_file_error(
      type Type (line 42) | enum Type {
    method Entry (line 259) | Entry entry_file_error_no_such_file(
      type Type (line 42) | enum Type {
    method Entry (line 265) | Entry entry_file_error_is_a_directory(
      type Type (line 42) | enum Type {
    method Entry (line 271) | Entry entry_file_error_max_depth(
      type Type (line 42) | enum Type {
    method Entry (line 280) | Entry entry_term_error(
      type Type (line 42) | enum Type {
    method Entry (line 290) | Entry entry_file_cycle(
      type Type (line 42) | enum Type {
  function TEST_F (line 306) | TEST_F(ArgsTest, BasicArguments) {
  function TEST_F (line 336) | TEST_F(ArgsTest, SimpleArgsFile) {
  function TEST_F (line 383) | TEST_F(ArgsTest, QuotedArguments) {
  function TEST_F (line 432) | TEST_F(ArgsTest, EscapeSequences) {
  function TEST_F (line 481) | TEST_F(ArgsTest, CommentLines) {
  function TEST_F (line 529) | TEST_F(ArgsTest, EmptyFile) {
  function TEST_F (line 561) | TEST_F(ArgsTest, NestedArgsFiles) {
  function TEST_F (line 623) | TEST_F(ArgsTest, MultipleArgsFiles) {
  function TEST_F (line 683) | TEST_F(ArgsTest, ArgumentStartingWithAt) {
  function TEST_F (line 711) | TEST_F(ArgsTest, NonExistentFile) {
  function TEST_F (line 735) | TEST_F(ArgsTest, ComplexRealWorldExample) {
  function TEST_F (line 849) | TEST_F(ArgsTest, TabsAndSpaces) {
  function TEST_F (line 898) | TEST_F(ArgsTest, EscapesOutsideQuotes) {
  function TEST_F (line 947) | TEST_F(ArgsTest, EmptyInputVector) {
  function TEST_F (line 957) | TEST_F(ArgsTest, PositionTracking) {
  function TEST_F (line 984) | TEST_F(ArgsTest, FileErrorPosition) {
  function TEST_F (line 1014) | TEST_F(ArgsTest, MissingFileAtTopLevel) {
  function TEST_F (line 1041) | TEST_F(ArgsTest, MissingFileInNestedArgsFile) {
  function TEST_F (line 1091) | TEST_F(ArgsTest, MultipleMissingFilesAtSameLevel) {
  function TEST_F (line 1124) | TEST_F(ArgsTest, MissingFileInDeeplyNestedStructure) {
  function TEST_F (line 1196) | TEST_F(ArgsTest, MixOfValidAndMissingFiles) {
  function TEST_F (line 1258) | TEST_F(ArgsTest, MissingFileWithSpecialCharactersInName) {
  function TEST_F (line 1286) | TEST_F(ArgsTest, TopLevelArgumentsNotProcessedForQuotes) {
  function TEST_F (line 1320) | TEST_F(ArgsTest, ArgsFileArgumentsProcessedForQuotes) {
  function TEST_F (line 1374) | TEST_F(ArgsTest, StopStringInTopLevelArgs) {
  function TEST_F (line 1410) | TEST_F(ArgsTest, StopStringInArgsFile) {
  function TEST_F (line 1455) | TEST_F(ArgsTest, StopStringInNestedArgsFile) {
  function TEST_F (line 1523) | TEST_F(ArgsTest, MixedQuotesInSingleToken) {
  function TEST_F (line 1565) | TEST_F(ArgsTest, UnclosedSingleQuoteCallsOnTermError) {
  function TEST_F (line 1613) | TEST_F(ArgsTest, UnclosedDoubleQuoteCallsOnTermError) {
  function TEST_F (line 1661) | TEST_F(ArgsTest, UnclosedQuoteInNestedFileContinuesParent) {
  function TEST_F (line 1730) | TEST_F(ArgsTest, SingleQuotesAreLiteral) {
  function TEST_F (line 1756) | TEST_F(ArgsTest, EscapedHash) {
  function TEST_F (line 1781) | TEST_F(ArgsTest, EscapedHashInDoubleQuotes) {
  function TEST_F (line 1806) | TEST_F(ArgsTest, UnknownEscapeCallsOnTermError) {
  function TEST_F (line 1848) | TEST_F(ArgsTest, DoubleAtEscapeAtTopLevel) {
  function TEST_F (line 1883) | TEST_F(ArgsTest, DoubleAtEscapeInArgsFile) {
  function TEST_F (line 1936) | TEST_F(ArgsTest, AtInsideQuotesNotArgsFile) {
  function TEST_F (line 1964) | TEST_F(ArgsTest, AtOutsideQuotesThenQuotedFilename) {
  function TEST_F (line 1992) | TEST_F(ArgsTest, DoubleAtInsideQuotesNotEscaped) {
  function TEST_F (line 2018) | TEST_F(ArgsTest, DoubleAtOutsideQuotesThenQuotedContent) {
  function TEST_F (line 2044) | TEST_F(ArgsTest, QuotedAtThenUnquoted) {
  function TEST_F (line 2069) | TEST_F(ArgsTest, BareAtInArgsFileTriggersFileError) {
  function TEST_F (line 2121) | TEST_F(ArgsTest, DirectCyclicalReference) {
  function TEST_F (line 2179) | TEST_F(ArgsTest, IndirectCyclicalReference) {
  function TEST_F (line 2263) | TEST_F(ArgsTest, LongCyclicalChain) {
  function TEST_F (line 2363) | TEST_F(ArgsTest, SameFileReferencedTwiceNotCyclical) {
  function TEST_F (line 2456) | TEST_F(ArgsTest, SimpleOverloadBasicArguments) {
  function TEST_F (line 2477) | TEST_F(ArgsTest, SimpleOverloadArgsFileExpansion) {
  function TEST_F (line 2502) | TEST_F(ArgsTest, SimpleOverloadNestedArgsFiles) {
  function TEST_F (line 2530) | TEST_F(ArgsTest, SimpleOverloadDoubleAtEscape) {
  function TEST_F (line 2549) | TEST_F(ArgsTest, SimpleOverloadThrowsOnMissingFile) {
  function TEST_F (line 2560) | TEST_F(ArgsTest, SimpleOverloadThrowsOnUnclosedQuote) {
  function TEST_F (line 2575) | TEST_F(ArgsTest, SimpleOverloadThrowsOnUnknownEscape) {
  function TEST_F (line 2590) | TEST_F(ArgsTest, SimpleOverloadErrorMessageContainsFilename) {
  function TEST_F (line 2611) | TEST_F(ArgsTest, SimpleOverloadErrorMessageContainsLineCol) {
  function TEST_F (line 2635) | TEST_F(ArgsTest, SimpleOverloadThrowsOnCircularReference) {
  function TEST_F (line 2650) | TEST_F(ArgsTest, SimpleOverloadCircularErrorMessage) {
  function TEST_F (line 2673) | TEST_F(ArgsTest, OptionsMaxDepthZeroSkipsAllFiles) {
  function TEST_F (line 2712) | TEST_F(ArgsTest, OptionsMaxDepthOneAllowsTopLevelFiles) {
  function TEST_F (line 2768) | TEST_F(ArgsTest, OptionsMaxDepthTwoAllowsTwoLevels) {
  function TEST_F (line 2800) | TEST_F(ArgsTest, OptionsDefaultMaxDepthAllowsDeepNesting) {
  function TEST_F (line 2835) | TEST_F(ArgsTest, SimpleOverloadRespectsDefaultMaxDepth) {

FILE: folly/cli/test/NestedCommandLineAppExample.cpp
  class InputError (line 31) | class InputError : public std::runtime_error {
    method InputError (line 33) | explicit InputError(const std::string& msg) : std::runtime_error(msg) {}
  class OutputError (line 36) | class OutputError : public std::runtime_error {
    method OutputError (line 38) | explicit OutputError(const std::string& msg) : std::runtime_error(msg) {}
  class Concatenator (line 41) | class Concatenator {
    method Concatenator (line 43) | explicit Concatenator(const po::variables_map& options)
  function throwOutputError (line 55) | [[noreturn]] void throwOutputError() {
  function throwInputError (line 59) | [[noreturn]] void throwInputError() {
  function runCat (line 103) | void runCat(
  function runEcho (line 137) | void runEcho(
  function main (line 160) | int main(int argc, char* argv[]) {

FILE: folly/cli/test/NestedCommandLineAppTest.cpp
  type folly (line 29) | namespace folly {
    type test (line 30) | namespace test {
      function getHelperPath (line 34) | std::string getHelperPath() {
      function callHelper (line 49) | std::string callHelper(
      function TEST (line 77) | TEST(ProgramOptionsTest, Errors) {
      function TEST (line 84) | TEST(ProgramOptionsTest, Help) {
      function TEST (line 108) | TEST(ProgramOptionsTest, DevFull) {
      function TEST (line 114) | TEST(ProgramOptionsTest, CutArguments) {
      function TEST (line 139) | TEST(ProgramOptionsTest, Success) {
      function TEST (line 170) | TEST(ProgramOptionsTest, Aliases) {
      function TEST (line 182) | TEST(ProgramOptionsTest, PositionalArgsSuccess) {
      function TEST (line 233) | TEST(ProgramOptionsTest, BuiltinCommand) {
      function TEST (line 242) | TEST(ProgramOptionsTest, ParseCallbacks) {
      function TEST (line 262) | TEST(ProgramOptionsTest, ParseMissingRequiredOption) {
      function TEST (line 278) | TEST(ProgramOptionsTest, ConflictingFlags) {

FILE: folly/cli/test/NestedCommandLineAppTestHelper.cpp
  function init (line 27) | void init(
  function foo (line 34) | void foo(
  function qux (line 45) | void qux(
  function main (line 58) | int main(int argc, char* argv[]) {

FILE: folly/cli/test/ProgramOptionsTest.cpp
  type folly (line 26) | namespace folly {
    type test (line 27) | namespace test {
      function getHelperPath (line 31) | std::string getHelperPath() {
      function callHelper (line 46) | std::string callHelper(
      function TEST (line 76) | TEST(ProgramOptionsTest, GFlagsStyleDefaultValues) {
      function TEST (line 85) | TEST(ProgramOptionsTest, GFlagsStyleFlagsSet) {
      function TEST (line 103) | TEST(ProgramOptionsTest, GFlagsStyleBoolFlagsNegation) {
      function TEST (line 117) | TEST(ProgramOptionsTest, GNUStyleDefaultValues) {
      function TEST (line 126) | TEST(ProgramOptionsTest, GNUStyleFlagsSet) {
      function TEST (line 144) | TEST(ProgramOptionsTest, GNUStyleBoolFlagsNegation) {
      function TEST (line 158) | TEST(ProgramOptionsTest, GNUStyleSubCommand) {
      function TEST (line 183) | TEST(ProgramOptionsTest, GNUStyleSubCommandUnrecognizedOptionFirst) {

FILE: folly/cli/test/ProgramOptionsTestHelper.cpp
  function print (line 33) | void print(const po::variables_map& vm, const std::string& name) {
  function main (line 39) | int main(int argc, char* argv[]) {

FILE: folly/codec/Uuid.h
  function namespace (line 31) | namespace folly {

FILE: folly/codec/hex.h
  function namespace (line 26) | namespace folly {
  function hex_decoded_digit_is_valid (line 57) | constexpr bool hex_decoded_digit_is_valid(uint8_t const v) {
  function hex_is_digit_table (line 62) | constexpr bool hex_is_digit_table(char const h) {
  function hex_decode_digit_table (line 70) | constexpr uint8_t hex_decode_digit_table(char const h) {
  function hex_is_digit_flavor_x86_64 (line 77) | constexpr bool hex_is_digit_flavor_x86_64(char const h) {
  function hex_decode_digit_raw_flavor_x86_64 (line 87) | constexpr uint8_t hex_decode_digit_raw_flavor_x86_64(char const h) {
  function hex_decode_digit_flavor_x86_64 (line 94) | constexpr uint8_t hex_decode_digit_flavor_x86_64(char const h) {
  function hex_is_digit_flavor_aarch64 (line 104) | constexpr bool hex_is_digit_flavor_aarch64(char const h) {
  function hex_decode_digit_raw_flavor_aarch64 (line 113) | constexpr uint8_t hex_decode_digit_raw_flavor_aarch64(char const h) {
  function hex_decode_digit_flavor_aarch64 (line 122) | constexpr uint8_t hex_decode_digit_flavor_aarch64(char const h) {
  function hex_is_digit (line 132) | constexpr bool hex_is_digit(char const h) {
  function hex_decode_digit_raw (line 144) | constexpr uint8_t hex_decode_digit_raw(char const h) {
  function hex_decode_digit (line 154) | constexpr uint8_t hex_decode_digit(char const h) {

FILE: folly/codec/test/UuidBenchmark.cpp
  function generateRandomGuid (line 27) | static std::string generateRandomGuid() {
  function folly_uuid_parse_benchmark (line 37) | inline void folly_uuid_parse_benchmark(size_t n) {
  function BENCHMARK (line 54) | BENCHMARK(uuid_parse_folly_avx2, n) {
  function BENCHMARK (line 60) | BENCHMARK(uuid_parse_folly_ssse3, n) {
  function BENCHMARK (line 65) | BENCHMARK(uuid_parse_folly_scalar, n) {
  function BENCHMARK (line 69) | BENCHMARK(uuid_parse_folly, n) {
  function BENCHMARK (line 74) | BENCHMARK(uuid_parse_glibc, n) {
  function BENCHMARK (line 89) | BENCHMARK(uuid_parse_boost, n) {
  function main (line 105) | int main(int argc, char** argv) {

FILE: folly/codec/test/UuidTest.cpp
  type UuidParseTestParam (line 28) | struct UuidParseTestParam {
    method UuidParseTestParam (line 34) | UuidParseTestParam(ParseFuncType f, std::string n)
  class UuidParseTest (line 39) | class UuidParseTest : public ::testing::TestWithParam<UuidParseTestParam> {
    method parse (line 41) | auto parse(std::string& output, const std::string& input) {
  function TEST_P (line 47) | TEST_P(UuidParseTest, ValidUuid) {
  function TEST_P (line 64) | TEST_P(UuidParseTest, InvalidUuidTooShort) {
  function TEST_P (line 72) | TEST_P(UuidParseTest, InvalidUuidTooLong) {
  function TEST_P (line 80) | TEST_P(UuidParseTest, InvalidUuidWrongDashes) {
  function TEST_P (line 89) | TEST_P(UuidParseTest, InvalidUuidInvalidCharacters) {
  function getUuidParseTestParams (line 129) | static std::vector<UuidParseTestParam> getUuidParseTestParams() {
  function generateRandomGuid (line 163) | static std::string generateRandomGuid() {
  class UuidParseComparisonTest (line 180) | class UuidParseComparisonTest
  function TEST_P (line 183) | TEST_P(UuidParseComparisonTest, CompareToScalar) {
  function getSimdParseFunctions (line 202) | static std::vector<UuidParseTestParam> getSimdParseFunctions() {

FILE: folly/codec/test/hex_test.cpp
  function FOLLY_KEEP (line 26) | FOLLY_KEEP bool check_folly_hex_is_digit_table(char h) {
  function FOLLY_KEEP (line 30) | FOLLY_KEEP bool check_folly_hex_is_digit_flavor_aarch64(char h) {
  function FOLLY_KEEP (line 34) | FOLLY_KEEP bool check_folly_hex_is_digit_flavor_x86_64(char h) {
  function FOLLY_KEEP (line 38) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 43) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 48) | FOLLY_KEEP uint8_t check_folly_hex_decode_digit_table(char h) {
  function FOLLY_KEEP (line 52) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 57) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 62) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 71) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 80) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 89) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 98) | FOLLY_KEEP uint8_t
  function FOLLY_KEEP (line 107) | FOLLY_KEEP uint8_t
  type HexTest (line 116) | struct HexTest : testing::Test {}
  function TEST_F (line 118) | TEST_F(HexTest, hex_decode_digit_lower_all) {
  function TEST_F (line 129) | TEST_F(HexTest, hex_decode_digit_upper_all) {
  function TEST_F (line 140) | TEST_F(HexTest, hex_decode_digit_full) {

FILE: folly/compression/Compression.cpp
  type folly (line 69) | namespace folly {
    type compression (line 70) | namespace compression {
      function addOutputBuffer (line 327) | static std::unique_ptr<IOBuf> addOutputBuffer(
      function computeBufferLength (line 379) | static uint64_t computeBufferLength(
      class NoCompressionCodec (line 440) | class NoCompressionCodec final : public Codec {
      function encodeVarintToIOBuf (line 492) | void encodeVarintToIOBuf(uint64_t val, folly::IOBuf* out) {
      function decodeVarintFromCursor (line 497) | inline uint64_t decodeVarintFromCursor(folly::io::Cursor& cursor) {
      function lz4_stream_t_deleter (line 523) | void lz4_stream_t_deleter(LZ4_stream_t* ctx) {
      function lz4_streamhc_t_deleter (line 527) | void lz4_streamhc_t_deleter(LZ4_streamHC_t* ctx) {
      class LZ4Codec (line 535) | class LZ4Codec final : public Codec {
        method encodeSize (line 545) | bool encodeSize() const { return type() == CodecType::LZ4_VARINT_S...
      function lz4ConvertLevel (line 569) | int lz4ConvertLevel(int level) {
      class LZ4FrameCodec (line 704) | class LZ4FrameCodec final : public Codec {
      function lz4FrameThrowOnError (line 755) | size_t lz4FrameThrowOnError(size_t code) {
      function lz4fConvertLevel (line 774) | int lz4fConvertLevel(int level) {
      class IOBufSnappySource (line 918) | class IOBufSnappySource final : public snappy::Source {
      class SnappyCodec (line 949) | class SnappyCodec final : public Codec {
      class LZMA2StreamCodec (line 1056) | class LZMA2StreamCodec final : public StreamCodec {
        method encodeSize (line 1072) | bool encodeSize() const { return type() == CodecType::LZMA2_VARINT...
      function lzma_ret (line 1212) | lzma_ret lzmaThrowOnError(lzma_ret const rc) {
      function FOLLY_POP_WARNING (line 1232) | FOLLY_POP_WARNING
    function zstdConvertLevel (line 1396) | int zstdConvertLevel(int level) {
    function zstdFastConvertLevel (line 1414) | int zstdFastConvertLevel(int level) {
    function getZstdCodec (line 1430) | std::unique_ptr<Codec> getZstdCodec(int level, CodecType type) {
    function getZstdStreamCodec (line 1435) | std::unique_ptr<StreamCodec> getZstdStreamCodec(int level, CodecType t...
    function getZstdFastCodec (line 1440) | std::unique_ptr<Codec> getZstdFastCodec(int level, CodecType type) {
    function getZstdFastStreamCodec (line 1445) | std::unique_ptr<StreamCodec> getZstdFastStreamCodec(int level, CodecTy...
    class Bzip2StreamCodec (line 1454) | class Bzip2StreamCodec final : public StreamCodec {
    function bz_stream (line 1541) | bz_stream createBzStream() {
    function bzCheck (line 1552) | int bzCheck(int const rc) {
    function bzip2TranslateFlush (line 1591) | int bzip2TranslateFlush(StreamCodec::FlushOp flushOp) {
    function getZlibOptions (line 1701) | zlib::Options getZlibOptions(CodecType type) {
    function getZlibCodec (line 1708) | std::unique_ptr<Codec> getZlibCodec(int level, CodecType type) {
    function getZlibStreamCodec (line 1712) | std::unique_ptr<StreamCodec> getZlibStreamCodec(int level, CodecType t...
    class AutomaticCodec (line 1721) | class AutomaticCodec final : public Codec {
      method doMaxCompressedLength (line 1738) | uint64_t doMaxCompressedLength(uint64_t) const override {
      method doCompress (line 1742) | std::unique_ptr<IOBuf> doCompress(const IOBuf*) override {
    type Factory (line 1937) | struct Factory {
    function Factory (line 2010) | Factory const& getFactory(CodecType type) {
    function hasCodec (line 2020) | bool hasCodec(CodecType type) {
    function getCodec (line 2024) | std::unique_ptr<Codec> getCodec(CodecType type, int level) {
    function hasStreamCodec (line 2035) | bool hasStreamCodec(CodecType type) {
    function getStreamCodec (line 2039) | std::unique_ptr<StreamCodec> getStreamCodec(CodecType type, int level) {
    function getAutoUncompressionCodec (line 2050) | std::unique_ptr<Codec> getAutoUncompressionCodec(

FILE: folly/compression/Compression.h
  type class (line 36) | enum class
  function class (line 130) | class Codec {

FILE: folly/compression/CompressionContextPool.h
  function namespace (line 53) | namespace folly {
  function Ref (line 207) | Ref create() {
  type SyncState (line 222) | struct SyncState {

FILE: folly/compression/CompressionContextPoolSingletons.cpp
  type folly (line 69) | namespace folly {
    type compression (line 70) | namespace compression {
      type contexts (line 71) | namespace contexts {
        type ZSTD_cctx_pool_singleton (line 78) | struct ZSTD_cctx_pool_singleton : ZSTD_CCtx_Pool {
          method ZSTD_cctx_pool_singleton (line 79) | constexpr ZSTD_cctx_pool_singleton()
        type ZSTD_dctx_pool_singleton (line 82) | struct ZSTD_dctx_pool_singleton : ZSTD_DCtx_Pool {
          method ZSTD_dctx_pool_singleton (line 83) | constexpr ZSTD_dctx_pool_singleton()
        function huge_page_free (line 104) | void huge_page_free(void*, void* address) {
        function ZSTD_CCtx (line 123) | ZSTD_CCtx* ZSTD_CCtx_Creator::operator()() const noexcept {
        function ZSTD_DCtx (line 127) | ZSTD_DCtx* ZSTD_DCtx_Creator::operator()() const noexcept {
        function getZSTD_CCtx (line 185) | ZSTD_CCtx_Pool::Ref getZSTD_CCtx() {
        function getZSTD_DCtx (line 189) | ZSTD_DCtx_Pool::Ref getZSTD_DCtx() {
        function getNULL_ZSTD_CCtx (line 193) | ZSTD_CCtx_Pool::Ref getNULL_ZSTD_CCtx() {
        function getNULL_ZSTD_DCtx (line 197) | ZSTD_DCtx_Pool::Ref getNULL_ZSTD_DCtx() {
        function ZSTD_CCtx_Pool (line 201) | ZSTD_CCtx_Pool& zstd_cctx_pool() {
        function ZSTD_DCtx_Pool (line 205) | ZSTD_DCtx_Pool& zstd_dctx_pool() {
        function get_zstd_cctx_created_count (line 209) | size_t get_zstd_cctx_created_count() {
        function get_zstd_dctx_created_count (line 213) | size_t get_zstd_dctx_created_count() {

FILE: folly/compression/CompressionContextPoolSingletons.h
  function namespace (line 38) | namespace folly {

FILE: folly/compression/CompressionCoreLocalContextPool.h
  function namespace (line 22) | namespace folly {

FILE: folly/compression/Instructions.h
  function namespace (line 32) | namespace folly {

FILE: folly/compression/QuotientMultiSet-inl.h
  function namespace (line 30) | namespace folly {
  function FOLLY_ALWAYS_INLINE (line 68) | FOLLY_ALWAYS_INLINE uint64_t maxValue(uint32_t nbits) {
  function Block (line 102) | static const Block* get(const char* data) {
  function BlockPtr (line 106) | static BlockPtr make(size_t remainderBits) {
  function blockSize (line 117) | static uint64_t blockSize(size_t remainderBits) {
  function FOLLY_ALWAYS_INLINE (line 121) | FOLLY_ALWAYS_INLINE bool isOccupied(size_t offsetInBlock) const {
  function FOLLY_ALWAYS_INLINE (line 125) | FOLLY_ALWAYS_INLINE bool isRunend(size_t offsetInBlock) const {
  function FOLLY_ALWAYS_INLINE (line 129) | FOLLY_ALWAYS_INLINE uint64_t getRemainder(
  function setOccupied (line 138) | void setOccupied(size_t offsetInBlock) {
  function setRunend (line 142) | void setRunend(size_t offsetInBlock) {
  function setRemainder (line 146) | void setRemainder(
  function qms_ (line 291) | qms_(qms) {}
  function qr (line 326) | const auto qr =

FILE: folly/compression/QuotientMultiSet.cpp
  type folly (line 25) | namespace folly {

FILE: folly/compression/QuotientMultiSet.h
  function namespace (line 33) | namespace folly {
  function class (line 241) | class QuotientMultiSetBuilder final {

FILE: folly/compression/Select64.cpp
  type folly (line 26) | namespace folly {
    type detail (line 27) | namespace detail {
      function selectInByte (line 31) | constexpr std::uint8_t selectInByte(std::size_t i, std::size_t j) {
      function makeSelectInByteNestedArray (line 42) | constexpr auto makeSelectInByteNestedArray(
      function makeSelectInByteArray (line 48) | constexpr auto makeSelectInByteArray(Is is, std::index_sequence<J......

FILE: folly/compression/Select64.h
  function namespace (line 26) | namespace folly {

FILE: folly/compression/Utils.h
  function namespace (line 29) | namespace folly {

FILE: folly/compression/Zlib.cpp
  type folly (line 32) | namespace folly {
    type compression (line 33) | namespace compression {
      type zlib (line 34) | namespace zlib {
        function isValidStrategy (line 38) | bool isValidStrategy(int strategy) {
        function getWindowBits (line 51) | int getWindowBits(Options::Format format, int windowSize) {
        function CodecType (line 66) | CodecType getCodecType(Options options) {
        class ZlibStreamCodec (line 77) | class ZlibStreamCodec final : public StreamCodec {
        function inBounds (line 195) | bool inBounds(int value, int low, int high) {
        function zlibConvertLevel (line 199) | int zlibConvertLevel(int level) {
        function zlibTranslateFlush (line 316) | int zlibTranslateFlush(StreamCodec::FlushOp flush) {
        function zlibThrowOnError (line 329) | int zlibThrowOnError(int rc) {
    function Options (line 421) | Options defaultGzipOptions() {
    function Options (line 425) | Options defaultZlibOptions() {
    function getCodec (line 429) | std::unique_ptr<Codec> getCodec(Options options, int level) {
    function getStreamCodec (line 433) | std::unique_ptr<StreamCodec> getStreamCodec(Options options, int level) {

FILE: folly/compression/Zlib.h
  function namespace (line 29) | namespace folly {

FILE: folly/compression/Zstd.cpp
  type folly (line 39) | namespace folly {
    type compression (line 40) | namespace compression {
      type zstd (line 41) | namespace zstd {
        function zstdThrowIfError (line 44) | size_t zstdThrowIfError(size_t rc) {
        function ZSTD_EndDirective (line 52) | ZSTD_EndDirective zstdTranslateFlush(StreamCodec::FlushOp flush) {
        class ZSTDStreamCodec (line 65) | class ZSTDStreamCodec final : public StreamCodec {
        function CodecType (line 108) | CodecType codecType(Options const& options) {
    function getCodec (line 236) | std::unique_ptr<Codec> getCodec(Options options) {
    function getStreamCodec (line 240) | std::unique_ptr<StreamCodec> getStreamCodec(Options options) {

FILE: folly/compression/Zstd.h
  function namespace (line 32) | namespace folly {

FILE: folly/compression/elias_fano/BitVectorCoding.h
  function namespace (line 34) | namespace folly {
  type BitVectorEncoder (line 174) | struct BitVectorEncoder
  function reset (line 262) | void reset() {
  function next (line 270) | bool next() {
  function skip (line 287) | bool skip(SizeType n) {
  function ValueType (line 399) | ValueType value() const {
  function jumpTo (line 409) | bool jumpTo(ValueType v) {
  function setDone (line 414) | bool setDone() {
  function setValue (line 424) | bool setValue(size_t inner) {
  function reposition (line 429) | void reposition(size_t dest) {

FILE: folly/compression/elias_fano/CodingDetail.h
  function namespace (line 25) | namespace folly {

FILE: folly/compression/elias_fano/EliasFanoCoding.h
  function namespace (line 42) | namespace folly {
  function MutableCompressedList (line 188) | const MutableCompressedList& finish() {
  function writeBits56 (line 211) | static void writeBits56(
  function Layout (line 266) | static Layout fromInternalSizes(
  function namespace (line 354) | namespace detail {
  function FOLLY_ALWAYS_INLINE (line 624) | FOLLY_ALWAYS_INLINE bool setValue(size_t inner) {
  function FOLLY_ALWAYS_INLINE (line 629) | FOLLY_ALWAYS_INLINE bool setDone() {
  function FOLLY_ALWAYS_INLINE (line 636) | FOLLY_ALWAYS_INLINE void reposition(size_t dest) {
  function reset (line 700) | void reset() { upper_.reset(); }
  function previous (line 702) | bool previous() {
  function next (line 710) | bool next() {
  function skip (line 722) | bool skip(SizeType n) {
  function jump (line 800) | bool jump(SizeType n) {
  function ValueType (line 843) | ValueType previousValue() const {
  function ValueType (line 856) | ValueType value() const {
  function rebase (line 911) | auto rebase = [&](const uint8_t* ptr) { return buf + (ptr - origBase); }

FILE: folly/compression/elias_fano/test/BitVectorCodingTest.cpp
  class BitVectorCodingTest (line 32) | class BitVectorCodingTest : public ::testing::Test {
    method doTestEmpty (line 34) | void doTestEmpty() {
    method doTestAll (line 41) | void doTestAll() {
  function TEST_F (line 50) | TEST_F(BitVectorCodingTest, Empty) {
  function TEST_F (line 54) | TEST_F(BitVectorCodingTest, Simple) {
  function TEST_F (line 58) | TEST_F(BitVectorCodingTest, SkipPointers) {
  function TEST_F (line 62) | TEST_F(BitVectorCodingTest, ForwardPointers) {
  function TEST_F (line 66) | TEST_F(BitVectorCodingTest, SkipForwardPointers) {
  type bm (line 70) | namespace bm {
    function init (line 82) | void init() {
    function free (line 96) | void free() {
  function BENCHMARK (line 102) | BENCHMARK(Next, iters) {
  function Skip_ForwardQ128 (line 109) | size_t Skip_ForwardQ128(size_t iters, size_t logAvgSkip) {
  function BENCHMARK (line 125) | BENCHMARK(Jump_ForwardQ128, iters) {
  function SkipTo_SkipQ128 (line 134) | size_t SkipTo_SkipQ128(size_t iters, size_t logAvgSkip) {
  function BENCHMARK (line 150) | BENCHMARK(JumpTo_SkipQ128, iters) {
  function BENCHMARK (line 159) | BENCHMARK(Encode_10) {
  function BENCHMARK (line 165) | BENCHMARK(Encode) {

FILE: folly/compression/elias_fano/test/EliasFanoCodingTest.cpp
  function slowDefaultNumLowerBits (line 34) | uint8_t slowDefaultNumLowerBits(size_t upperBound, size_t size) {
  function TEST (line 44) | TEST(EliasFanoCoding, defaultNumLowerBits) {
  class EliasFanoCodingTest (line 86) | class EliasFanoCodingTest : public ::testing::Test {
    method doTestEmpty (line 88) | void doTestEmpty() {
    method doTest (line 100) | void doTest() {
    method doTestAll (line 130) | void doTestAll() {
    method doTestDense (line 140) | void doTestDense() {
    method doTestDenseAll (line 160) | void doTestDenseAll() {
  function TEST_F (line 166) | TEST_F(EliasFanoCodingTest, Empty) {
  function TEST_F (line 170) | TEST_F(EliasFanoCodingTest, Simple32Bit) {
  function TEST_F (line 173) | TEST_F(EliasFanoCodingTest, Simple64Bit) {
  function TEST_F (line 176) | TEST_F(EliasFanoCodingTest, SimpleDense) {
  function TEST_F (line 180) | TEST_F(EliasFanoCodingTest, SkipPointers32Bit) {
  function TEST_F (line 183) | TEST_F(EliasFanoCodingTest, SkipPointers64Bit) {
  function TEST_F (line 186) | TEST_F(EliasFanoCodingTest, SkipPointersDense) {
  function TEST_F (line 190) | TEST_F(EliasFanoCodingTest, ForwardPointers32Bit) {
  function TEST_F (line 193) | TEST_F(EliasFanoCodingTest, ForwardPointers64Bit) {
  function TEST_F (line 196) | TEST_F(EliasFanoCodingTest, ForwardPointersDense) {
  function TEST_F (line 200) | TEST_F(EliasFanoCodingTest, SkipForwardPointers32Bit) {
  function TEST_F (line 203) | TEST_F(EliasFanoCodingTest, SkipForwardPointers64Bit) {
  function TEST_F (line 206) | TEST_F(EliasFanoCodingTest, SkipForwardPointersDense) {
  function TEST_F (line 210) | TEST_F(EliasFanoCodingTest, BugLargeGapInUpperBits) { // t16274876
  function TEST (line 234) | TEST(CopyCompressedList, BasicCopy) {
  function TEST (line 253) | TEST(CopyCompressedList, BasicCopyUpperFirst) {
  function TEST (line 272) | TEST(CopyCompressedList, CopyIsIndependent) {
  function TEST (line 291) | TEST(CopyCompressedList, CopyPreservesMetadata) {
  type bm (line 310) | namespace bm {
    function init (line 324) | void init() {
    function free (line 345) | void free() {
  function BENCHMARK (line 351) | BENCHMARK(Next, iters) {
  function Skip_ForwardQ128 (line 358) | size_t Skip_ForwardQ128(size_t iters, size_t logAvgSkip) {
  function BENCHMARK (line 374) | BENCHMARK(Jump_ForwardQ128, iters) {
  function SkipTo_SkipQ128 (line 383) | size_t SkipTo_SkipQ128(size_t iters, size_t logAvgSkip) {
  function BENCHMARK (line 399) | BENCHMARK(JumpTo_SkipQ128, iters) {
  function BENCHMARK (line 408) | BENCHMARK(Encode_10) {
  function BENCHMARK (line 414) | BENCHMARK(Encode) {
  function BENCHMARK (line 422) | BENCHMARK(defaultNumLowerBits, iters) {
  function BENCHMARK (line 435) | BENCHMARK(slowDefaultNumLowerBits, iters) {

FILE: folly/compression/test/CodingTestUtils.cpp
  type folly (line 28) | namespace folly {
    type compression (line 29) | namespace compression {
      function instructionsOverride (line 31) | folly::Optional<instructions::Type> instructionsOverride() {

FILE: folly/compression/test/CodingTestUtils.h
  function namespace (line 35) | namespace folly {
  function std (line 81) | inline std::vector<uint64_t> loadList(const std::string& filename) {

FILE: folly/compression/test/CompressionContextPoolBenchmark.cpp
  class Foo (line 30) | class alignas(folly::hardware_destructive_interference_size) Foo {
    method use (line 32) | void use() { used_ = true; }
    method reset (line 34) | void reset() { used_ = false; }
  type FooCreator (line 40) | struct FooCreator {
    method Foo (line 41) | Foo* operator()() const { return new Foo(); }
  type FooDeleter (line 44) | struct FooDeleter {
  type FooResetter (line 48) | struct FooResetter {
  type FooSizeof (line 52) | struct FooSizeof {
  type FooCallback (line 56) | struct FooCallback {
  function multithreadedBench (line 81) | size_t multithreadedBench(size_t iters, size_t numThreads, Pool& pool) {
  function main (line 312) | int main(int argc, char** argv) {

FILE: folly/compression/test/CompressionContextPoolTest.cpp
  type folly (line 25) | namespace folly {
    type compression (line 26) | namespace compression {
      class Foo (line 34) | class alignas(4) Foo {
        method use (line 36) | void use() {
        method reset (line 41) | void reset() { used_ = false; }
      type FooCreator (line 47) | struct FooCreator {
        method Foo (line 48) | Foo* operator()() const {
      type BadFooCreator (line 54) | struct BadFooCreator {
        method Foo (line 55) | Foo* operator()() const {
      type FooDeleter (line 61) | struct FooDeleter {
      type FooResetter (line 68) | struct FooResetter {
      type FooSizeof (line 72) | struct FooSizeof {
      type FooCallback (line 76) | struct FooCallback {
      class CompressionContextPoolTest (line 97) | class CompressionContextPoolTest : public testing::Test {
        method SetUp (line 99) | void SetUp() override { pool_ = std::make_unique<Pool>(); }
        method TearDown (line 101) | void TearDown() override { pool_.reset(); }
      function TEST_F (line 106) | TEST_F(CompressionContextPoolTest, testGet) {
      function TEST_F (line 112) | TEST_F(CompressionContextPoolTest, testSame) {
      function TEST_F (line 125) | TEST_F(CompressionContextPoolTest, testFree) {
      function TEST_F (line 139) | TEST_F(CompressionContextPoolTest, testDifferent) {
      function TEST_F (line 149) | TEST_F(CompressionContextPoolTest, testLifo) {
      function TEST_F (line 185) | TEST_F(CompressionContextPoolTest, testExplicitCreatorDeleter) {
      function TEST_F (line 191) | TEST_F(CompressionContextPoolTest, testMultithread) {
      function TEST_F (line 215) | TEST_F(CompressionContextPoolTest, testBadCreate) {
      function TEST_F (line 220) | TEST_F(CompressionContextPoolTest, testReset) {
      function TEST_F (line 234) | TEST_F(CompressionContextPoolTest, testFlush) {
      type FooIncrementCallback (line 241) | struct FooIncrementCallback {
      function TEST_F (line 257) | TEST_F(CompressionContextPoolTest, testCallback) {
      function TEST_F (line 265) | TEST_F(CompressionContextPoolTest, testBytesUsed) {
      class CompressionCoreLocalContextPoolTest (line 283) | class CompressionCoreLocalContextPoolTest : public testing::Test {
        method SetUp (line 293) | void SetUp() override { pool_ = std::make_unique<Pool>(); }
        method TearDown (line 295) | void TearDown() override { pool_.reset(); }
      function TEST_F (line 300) | TEST_F(CompressionCoreLocalContextPoolTest, testGet) {
      function TEST_F (line 305) | TEST_F(CompressionCoreLocalContextPoolTest, testSame) {
      function TEST_F (line 317) | TEST_F(CompressionCoreLocalContextPoolTest, testDifferent) {
      function TEST_F (line 323) | TEST_F(CompressionCoreLocalContextPoolTest, testSwap) {
      function TEST_F (line 343) | TEST_F(CompressionCoreLocalContextPoolTest, testFlush) {
      function TEST_F (line 350) | TEST_F(CompressionCoreLocalContextPoolTest, testMultithread) {
      function TEST_F (line 371) | TEST_F(CompressionCoreLocalContextPoolTest, testReset) {
      function TEST_F (line 397) | TEST_F(CompressionCoreLocalContextPoolTest, testSetSize) {
      function TEST_F (line 404) | TEST_F(CompressionCoreLocalContextPoolTest, testGetZeroStripes) {
      function TEST_F (line 410) | TEST_F(CompressionCoreLocalContextPoolTest, testBytesUsed) {
      function TEST (line 428) | TEST(CompressionContextPoolSingletonsTest, testSingletons) {
      function TEST (line 433) | TEST(CompressionContextPoolSingletonsTest, testSingletonsNull) {

FILE: folly/compression/test/CompressionTest.cpp
  type folly (line 45) | namespace folly {
    type compression (line 46) | namespace compression {
      type test (line 47) | namespace test {
        class DataHolder (line 49) | class DataHolder {
          method DataHolder (line 51) | DataHolder(const DataHolder&) = delete;
          method DataHolder (line 52) | DataHolder& operator=(const DataHolder&) = delete;
        function ByteRange (line 78) | ByteRange DataHolder::data(size_t size) const {
        function hashIOBuf (line 83) | uint64_t hashIOBuf(const IOBuf* buf) {
        class RandomDataHolder (line 91) | class RandomDataHolder : public DataHolder {
        class ConstantDataHolder (line 122) | class ConstantDataHolder : public DataHolder {
        function supportedCodecs (line 136) | static std::vector<CodecType> supportedCodecs(std::vector<CodecTyp...
        function availableCodecs (line 146) | static std::vector<CodecType> availableCodecs() {
        function availableStreamCodecs (line 159) | static std::vector<CodecType> availableStreamCodecs() {
        function TEST (line 172) | TEST(CompressionTestNeedsUncompressedLength, Simple) {
        class CompressionTest (line 199) | class CompressionTest
          method SetUp (line 202) | void SetUp() override {
        function TEST_P (line 288) | TEST_P(CompressionTest, RandomData) {
        function TEST_P (line 292) | TEST_P(CompressionTest, ConstantData) {
        function TEST_P (line 296) | TEST_P(CompressionTest, RandomDataString) {
        function TEST_P (line 300) | TEST_P(CompressionTest, ConstantDataString) {
        class CompressionVarintTest (line 312) | class CompressionVarintTest
          method SetUp (line 315) | void SetUp() override {
        function oneBasedMsbPos (line 327) | inline uint64_t oneBasedMsbPos(uint64_t number) {
        function TEST_P (line 353) | TEST_P(CompressionVarintTest, RandomData) {
        function TEST_P (line 357) | TEST_P(CompressionVarintTest, ConstantData) {
        function TEST (line 371) | TEST(LZMATest, UncompressBadVarint) {
        class CompressionCorruptionTest (line 383) | class CompressionCorruptionTest : public testing::TestWithParam<Co...
          method SetUp (line 385) | void SetUp() override { codec_ = getCodec(GetParam()); }
        function TEST_P (line 439) | TEST_P(CompressionCorruptionTest, RandomData) {
        function TEST_P (line 443) | TEST_P(CompressionCorruptionTest, ConstantData) {
        function codecHasFlush (line 462) | static bool codecHasFlush(CodecType type) {
        class StreamingUnitTest (line 466) | class StreamingUnitTest : public testing::TestWithParam<CodecType> {
          method SetUp (line 468) | void SetUp() override { codec_ = getStreamCodec(GetParam()); }
          method hasFlush (line 470) | bool hasFlush() const { return codecHasFlush(GetParam()); }
        function TEST (line 475) | TEST(StreamingUnitTest, needsDataLength) {
        function TEST_P (line 495) | TEST_P(StreamingUnitTest, maxCompressedLength) {
        function TEST_P (line 501) | TEST_P(StreamingUnitTest, getUncompressedLength) {
        function TEST_P (line 533) | TEST_P(StreamingUnitTest, emptyData) {
        function TEST_P (line 602) | TEST_P(StreamingUnitTest, noForwardProgress) {
        function TEST_P (line 665) | TEST_P(StreamingUnitTest, stateTransitions) {
        class StreamingCompressionTest (line 788) | class StreamingCompressionTest
          method hasFlush (line 791) | bool hasFlush() const { return codecHasFlush(std::get<2>(GetPara...
          method SetUp (line 793) | void SetUp() override {
        function compressSome (line 826) | static std::unique_ptr<IOBuf> compressSome(
        function uncompressSome (line 858) | static std::pair<bool, std::unique_ptr<IOBuf>> uncompressSome(
        function TEST_P (line 895) | TEST_P(StreamingCompressionTest, resetStream) {
        function TEST_P (line 920) | TEST_P(StreamingCompressionTest, compressStream) {
        function TEST_P (line 961) | TEST_P(StreamingCompressionTest, uncompressStream) {
        function TEST_P (line 997) | TEST_P(StreamingCompressionTest, testFlush) {
        function TEST_P (line 1048) | TEST_P(StreamingCompressionTest, testFlushNone) {
        class AutomaticCodecTest (line 1076) | class AutomaticCodecTest : public testing::TestWithParam<CodecType> {
          method SetUp (line 1078) | void SetUp() override {
          method getTerminalCodec (line 1092) | std::unique_ptr<Codec> getTerminalCodec() {
        function TEST_P (line 1131) | TEST_P(AutomaticCodecTest, RandomData) {
        function TEST_P (line 1135) | TEST_P(AutomaticCodecTest, ConstantData) {
        function TEST_P (line 1139) | TEST_P(AutomaticCodecTest, ValidPrefixes) {
        function TEST_P (line 1152) | TEST_P(AutomaticCodecTest, NeedsUncompressedLength) {
        function TEST_P (line 1158) | TEST_P(AutomaticCodecTest, maxUncompressedLength) {
        function TEST_P (line 1162) | TEST_P(AutomaticCodecTest, DefaultCodec) {
        class CustomCodec (line 1182) | class CustomCodec : public Codec {
          method create (line 1184) | static std::unique_ptr<Codec> create(std::string prefix, CodecTy...
          method CustomCodec (line 1187) | explicit CustomCodec(std::string prefix, CodecType type)
          method validPrefixes (line 1193) | std::vector<std::string> validPrefixes() const override { return...
          method doMaxCompressedLength (line 1195) | uint64_t doMaxCompressedLength(uint64_t uncompressedLength) cons...
          method canUncompress (line 1199) | bool canUncompress(const IOBuf* data, Optional<uint64_t>) const ...
          method doCompress (line 1207) | std::unique_ptr<IOBuf> doCompress(const IOBuf* data) override {
          method doUncompress (line 1214) | std::unique_ptr<IOBuf> doUncompress(
        function TEST_P (line 1227) | TEST_P(AutomaticCodecTest, CustomCodec) {
        function TEST_P (line 1257) | TEST_P(AutomaticCodecTest, CustomDefaultCodec) {
        function TEST_P (line 1288) | TEST_P(AutomaticCodecTest, canUncompressOneBytes) {
        class ConstantCodec (line 1306) | class ConstantCodec : public Codec {
          method create (line 1308) | static std::unique_ptr<Codec> create(
          method ConstantCodec (line 1312) | explicit ConstantCodec(std::string uncompressed, CodecType type)
          method doMaxCompressedLength (line 1316) | uint64_t doMaxCompressedLength(uint64_t uncompressedLength) cons...
          method doCompress (line 1320) | std::unique_ptr<IOBuf> doCompress(const IOBuf*) override {
          method doUncompress (line 1324) | std::unique_ptr<IOBuf> doUncompress(
        class TerminalCodecTest (line 1335) | class TerminalCodecTest : public testing::TestWithParam<CodecType> {
          method SetUp (line 1337) | void SetUp() override {
        function TEST_P (line 1350) | TEST_P(TerminalCodecTest, uncompressIfDefaultThrows) {
        function TEST_P (line 1374) | TEST_P(TerminalCodecTest, terminalOverridesDefaults) {
        function TEST (line 1387) | TEST(ValidPrefixesTest, CustomCodec) {
        function TEST (line 1405) | TEST(CheckCompatibleTest, SimplePrefixSecond) {
        function TEST (line 1413) | TEST(CheckCompatibleTest, SimplePrefixFirst) {
        function TEST (line 1421) | TEST(CheckCompatibleTest, Empty) {
        function TEST (line 1428) | TEST(CheckCompatibleTest, ZstdPrefix) {
        function TEST (line 1435) | TEST(CheckCompatibleTest, ZstdDuplicate) {
        function TEST (line 1442) | TEST(CheckCompatibleTest, ZlibIsPrefix) {
        function TEST (line 1457) | TEST(ZstdTest, BackwardCompatible) {
        function TEST (line 1478) | TEST(ZstdTest, CustomOptions) {
        function TEST (line 1514) | TEST(ZstdTest, NegativeLevels) {
        function TEST (line 1536) | TEST(ZlibTest, Auto) {
        function TEST (line 1561) | TEST(ZlibTest, DefaultOptions) {
        class ZlibOptionsTest (line 1588) | class ZlibOptionsTest
          method SetUp (line 1591) | void SetUp() override {
        function TEST_P (line 1618) | TEST_P(ZlibOptionsTest, simpleRoundTripTest) {

FILE: folly/compression/test/InstructionsTest.cpp
  type InstructionsTest (line 27) | struct InstructionsTest : ::testing::Test {}
  function TYPED_TEST (line 37) | TYPED_TEST(InstructionsTest, BitExtraction) {

FILE: folly/compression/test/LargeTest.cpp
  type folly::compression::test (line 24) | namespace folly::compression::test {
    function availableCodecs (line 27) | std::vector<CodecType> availableCodecs() {
    class LargeTest (line 41) | class LargeTest : public testing::TestWithParam<CodecType> {}
    function TEST_P (line 43) | TEST_P(LargeTest, SingleLargeBuffer) {

FILE: folly/compression/test/QuotientMultiSetBenchmark.cpp
  function maxValue (line 55) | uint64_t maxValue(uint32_t nbits) {
  function mix64_to_1 (line 62) | uint64_t mix64_to_1(uint64_t word) {
  function buildQuotientMultiSet (line 67) | void buildQuotientMultiSet(std::vector<uint64_t>& keys) {
  function makeLookupKeys (line 83) | std::vector<uint64_t> makeLookupKeys(size_t n, double hitRate) {
  function benchmarkHits (line 128) | size_t benchmarkHits(const Lookup& lookup) {
  function benchmarkRandom (line 139) | size_t benchmarkRandom(const Lookup& lookup) {
  function benchmarkMixtureSerialized (line 149) | size_t benchmarkMixtureSerialized(const Lookup& lookup) {
  function benchmarkSerializedOnResultBits (line 162) | size_t benchmarkSerializedOnResultBits(const Lookup& lookup, double hitR...
  function benchmarkHitsSerialized (line 175) | size_t benchmarkHitsSerialized(const Lookup& lookup) {
  function benchmarkRandomSerialized (line 180) | size_t benchmarkRandomSerialized(const Lookup& lookup) {
  function benchmarkHitsSmallWorkingSet (line 185) | size_t benchmarkHitsSmallWorkingSet(const Lookup& lookup) {
  function benchmarkSetup (line 200) | void benchmarkSetup() {
  function BENCHMARK_MULTI (line 218) | BENCHMARK_MULTI(QuotientMultiSetGetHits) {
  function BENCHMARK_MULTI (line 227) | BENCHMARK_MULTI(QuotientMultiSetGetRandom) {
  function BENCHMARK_MULTI (line 236) | BENCHMARK_MULTI(QuotientMultiSetGetHitsSmallWorkingSet) {
  function BENCHMARK_MULTI (line 247) | BENCHMARK_MULTI(QuotientMultiSetGetMixtureSerialized) {
  function BENCHMARK_MULTI (line 258) | BENCHMARK_MULTI(QuotientMultiSetGetHitsSerialized) {
  function BENCHMARK_MULTI (line 269) | BENCHMARK_MULTI(QuotientMultiSetGetRandomSerialized) {
  function BENCHMARK_MULTI (line 284) | BENCHMARK_MULTI(F14MapHits) {
  function BENCHMARK_MULTI (line 291) | BENCHMARK_MULTI(F14MapRandom) {
  function BENCHMARK_MULTI (line 298) | BENCHMARK_MULTI(F14MapHitsSmallWorkingSet) {
  function BENCHMARK_MULTI (line 305) | BENCHMARK_MULTI(F14MapMixtureSerialized) {
  function BENCHMARK_MULTI (line 312) | BENCHMARK_MULTI(F14MapHitsSerialized) {
  function BENCHMARK_MULTI (line 325) | BENCHMARK_MULTI(EliasFanoGetHits) {
  function BENCHMARK_MULTI (line 337) | BENCHMARK_MULTI(EliasFanoGetRandom) {
  function BENCHMARK_MULTI (line 349) | BENCHMARK_MULTI(EliasFanoGetHitsSmallWorkingSet) {
  function BENCHMARK_MULTI (line 361) | BENCHMARK_MULTI(EliasFanoGetMixtureSerialized) {
  function BENCHMARK_MULTI (line 373) | BENCHMARK_MULTI(EliasFanoGetHitsSerialized) {
  function BENCHMARK_MULTI (line 387) | BENCHMARK_MULTI(EliasFanoGetRandomSerialized) {
  function main (line 402) | int main(int argc, char** argv) {

FILE: folly/compression/test/QuotientMultiSetTest.cpp
  class QuotientMultiSetTest (line 32) | class QuotientMultiSetTest : public ::testing::Test {
    method SetUp (line 36) | void SetUp() override { rng.seed(folly::randomNumberSeed()); }
    method buildAndValidate (line 38) | void buildAndValidate(
  function TEST_F (line 139) | TEST_F(QuotientMultiSetTest, Simple) {
  function TEST_F (line 145) | TEST_F(QuotientMultiSetTest, Empty) {
  function TEST_F (line 159) | TEST_F(QuotientMultiSetTest, ZeroKeyBits) {
  function TEST_F (line 164) | TEST_F(QuotientMultiSetTest, Uniform) {
  function TEST_F (line 201) | TEST_F(QuotientMultiSetTest, UniformDistributionFullLoadFactor) {
  function TEST_F (line 211) | TEST_F(QuotientMultiSetTest, Overflow) {
  function TEST_F (line 222) | TEST_F(QuotientMultiSetTest, RandomLengthRuns) {
  function TEST_F (line 235) | TEST_F(QuotientMultiSetTest, RunAcrossBlocks) {
  function TEST_F (line 249) | TEST_F(QuotientMultiSetTest, PackAtHeadSlots) {
  function TEST_F (line 259) | TEST_F(QuotientMultiSetTest, PackAtTailSlots) {
  function TEST_F (line 269) | TEST_F(QuotientMultiSetTest, KeysOnlyInHeadAndTail) {
  function TEST_F (line 282) | TEST_F(QuotientMultiSetTest, RunendRightBeforeFirstOccupiedRunend) {

FILE: folly/compression/test/Select64Test.cpp
  function check_select64_default (line 26) | uint64_t check_select64_default(uint64_t x, uint64_t k) {
  function check_select64_haswell (line 30) | uint64_t check_select64_haswell(uint64_t x, uint64_t k) {
  class Select64Test (line 35) | class Select64Test : public testing::Test {}
  function TEST_F (line 39) | TEST_F(Select64Test, SelectInByteTable) {
  function TEST_F (line 50) | TEST_F(Select64Test, Select64) {

FILE: folly/concurrency/AtomicSharedPtr.h
  function namespace (line 36) | namespace folly {
  function PackedPtr (line 336) | PackedPtr takeOwnedBase(std::memory_order order) const noexcept {
  function putOwnedBase (line 369) | void putOwnedBase(
  function operator (line 423) | operator std::shared_ptr<T>() const noexcept { return load(); }
  function noexcept (line 428) | const noexcept {
  function compare_exchange_weak (line 444) | bool compare_exchange_weak(
  function compare_exchange_strong (line 461) | bool compare_exchange_strong(

FILE: folly/concurrency/CacheLocality.cpp
  type folly (line 45) | namespace folly {
    function CacheLocality (line 50) | CacheLocality CacheLocality::readSystemLocalityInfo() {
    function CacheLocality (line 88) | const CacheLocality& CacheLocality::system<std::atomic>() {
    function parseLeadingNumber (line 173) | static size_t parseLeadingNumber(const std::string& line) {
    function CacheLocality (line 183) | CacheLocality CacheLocality::readFromSysfsTree(std::string_view root) {
    function CacheLocality (line 288) | CacheLocality CacheLocality::readFromSysfs() {
    function procCpuinfoLineRelevant (line 294) | static bool procCpuinfoLineRelevant(std::string const& line) {
    function parseProcCpuinfoLines (line 298) | std::vector<std::tuple<size_t, size_t, size_t>> parseProcCpuinfoLines(
    function CacheLocality (line 355) | CacheLocality CacheLocality::readFromProcCpuinfoLines(
    function CacheLocality (line 386) | CacheLocality CacheLocality::readFromProcCpuinfo() {
    function CacheLocality (line 405) | CacheLocality CacheLocality::uniform(size_t numCpus) {
    type detail (line 447) | namespace detail {
      type AccessSpreaderStaticInit (line 459) | struct AccessSpreaderStaticInit {
        method AccessSpreaderStaticInit (line 461) | AccessSpreaderStaticInit() { (void)AccessSpreader<>::current(~size...
    function LLCAccessSpreader (line 506) | LLCAccessSpreader& LLCAccessSpreader::get() {
    type ThreadCache (line 546) | struct ThreadCache {
    class SimpleAllocator (line 580) | class SimpleAllocator {
      type Ctor (line 583) | struct Ctor {}
      method SimpleAllocator (line 585) | SimpleAllocator(Ctor, size_t sz) : sz_(sz) {
      method SimpleAllocator (line 604) | SimpleAllocator(const SimpleAllocator&) = delete;
      method SimpleAllocator (line 605) | SimpleAllocator& operator=(const SimpleAllocator&) = delete;
      method SimpleAllocator (line 606) | SimpleAllocator(SimpleAllocator&&) = delete;
      method SimpleAllocator (line 607) | SimpleAllocator& operator=(SimpleAllocator&&) = delete;
      method deallocate (line 637) | static void deallocate(void* ptr) {
    class Allocator (line 696) | class Allocator {
      method deallocate (line 714) | static void deallocate(void* ptr) {
      method sizeClass (line 728) | std::optional<uint8_t> sizeClass(size_t size) {
    function coreFree (line 758) | void coreFree(void* ptr) {
    type detail (line 777) | namespace detail {
      type AccessSpreaderStaticInit (line 459) | struct AccessSpreaderStaticInit {
        method AccessSpreaderStaticInit (line 461) | AccessSpreaderStaticInit() { (void)AccessSpreader<>::current(~size...

FILE: folly/concurrency/CacheLocality.h
  function namespace (line 35) | namespace folly {

FILE: folly/concurrency/ConcurrentHashMap.h
  function namespace (line 26) | namespace folly {
  function empty (line 272) | bool empty() const noexcept {
  function ConstIterator (line 289) | ConstIterator find(const KeyType& k) const { return findImpl(k); }
  function ConstIterator (line 306) | ConstIterator cend() const noexcept { return ConstIterator(NumShards); }
  function ConstIterator (line 310) | ConstIterator end() const noexcept { return cend(); }
  function h (line 326) | auto h = HashFn{}
  function emplace (line 351) | bool> emplace(Args&&... args) {
  function h (line 376) | auto h = HashFn{}
  function h (line 414) | auto h = HashFn{}
  function ValueType (line 481) | const ValueType operator[](const KeyType& key) {
  function ValueType (line 492) | const ValueType at(const KeyType& key) const { return atImpl(key); }
  function size_type (line 501) | size_type erase(const key_type& k) { return eraseImpl(k); }
  function ConstIterator (line 513) | ConstIterator erase(ConstIterator& pos) {
  function size_type (line 523) | size_type erase_if_equal(const key_type& k, const ValueType& expected) {
  function clear (line 547) | void clear() {
  function reserve (line 558) | void reserve(size_t count) {
  function size (line 574) | size_t size() const noexcept {
  function max_load_factor (line 589) | void max_load_factor(float factor) {
  function class (line 600) | class ConstIterator {
  function explicit (line 651) | explicit ConstIterator(uint64_t shards) : it_(nullptr), segment_(shards) {}
  function advanceIfAtSegmentEnd (line 653) | void advanceIfAtSegmentEnd() {
  function FOLLY_ALWAYS_INLINE (line 664) | FOLLY_ALWAYS_INLINE void advanceToSegmentBegin() {
  function h (line 712) | auto h = HashFn{}
  function h (line 725) | auto h = HashFn{}
  function h (line 737) | auto h = HashFn{}
  function pickSegment (line 746) | uint64_t pickSegment(size_t h) const {
  function SegmentT (line 759) | SegmentT* ensureSegment(uint64_t i) const {
  function updateBeginAndEndSegments (line 778) | void updateBeginAndEndSegments(uint64_t i) const {
  function casSeg (line 787) | bool casSeg(Atom<uint64_t>& seg, uint64_t& expval, uint64_t newval) const {
  function newcohort (line 800) | auto newcohort = new (storage) hazptr_obj_cohort<Atom>();
  function cohort_shutdown_cleanup (line 811) | void cohort_shutdown_cleanup() {
  function size_ (line 820) | size_t size_{0}
  function max_size_ (line 821) | size_t max_size_{0}
  function mutable (line 822) | mutable Atom<hazptr_obj_cohort<Atom>*> cohort_{nullptr};

FILE: folly/concurrency/CoreCachedSharedPtr.h
  function Unit (line 41) | [[maybe_unused]] static const Unit _ = [] {
  function holder (line 67) | auto holder = std::allocate_shared<std::shared_ptr<T>>(
  function explicit (line 103) | explicit CoreCachedSharedPtr(std::shared_ptr<T> p) { reset(std::move(p)); }
  function explicit (line 134) | explicit CoreCachedWeakPtr(const CoreCachedSharedPtr<T, kMaxSlots>& p) {
  function reset (line 138) | void reset() { *this = {}; }
  function reset (line 139) | void reset(const CoreCachedSharedPtr<T, kMaxSlots>& p) {
  function explicit (line 177) | explicit AtomicCoreCachedSharedPtr(std::shared_ptr<T> p) {
  type Slots (line 226) | struct Slots

FILE: folly/concurrency/DeadlockDetector.cpp
  type folly (line 19) | namespace folly {
    function DeadlockDetectorFactory (line 20) | DeadlockDetectorFactory* DeadlockDetectorFactory::instance() {

FILE: folly/concurrency/DeadlockDetector.h
  function namespace (line 22) | namespace folly {

FILE: folly/concurrency/DynamicBoundedQueue.h
  function namespace (line 27) | namespace folly {

FILE: folly/concurrency/PriorityUnboundedQueueSet.h
  function namespace (line 26) | namespace folly {

FILE: folly/concurrency/ProcessLocalUniqueId.cpp
  type folly (line 23) | namespace folly {
    function processLocalUniqueId (line 25) | uint64_t processLocalUniqueId() {

FILE: folly/concurrency/ProcessLocalUniqueId.h
  function namespace (line 21) | namespace folly {

FILE: folly/concurrency/SingletonRelaxedCounter.h
  type CounterAndCache (line 52) | struct CounterAndCache {
  type CounterRefAndLocal (line 58) | struct CounterRefAndLocal {
  type LocalLifetime (line 63) | struct LocalLifetime
  type Global (line 69) | struct Global {
  type Arg (line 82) | struct Arg {
  type LocalLifetime (line 99) | struct LocalLifetime {
  function destroy_ (line 103) | void destroy_(GetGlobal& get_global) {
  function sub (line 220) | static void sub(Int value) { mutate(-to_signed(value)); }
  function Int (line 221) | static Int count() { return aggregate(global); }
  function LocalLifetime (line 235) | struct MonoLocalLifetime : Base::LocalLifetime {
  function FOLLY_ERASE_NOINLINE (line 248) | FOLLY_ERASE_NOINLINE static void mutate_slow(Signed v) noexcept {
  function SingletonRelaxedCountable (line 300) | SingletonRelaxedCountable(const SingletonRelaxedCountable&) noexcept
  type Tag (line 312) | struct Tag

FILE: folly/concurrency/ThreadCachedSynchronized.h
  function namespace (line 31) | namespace folly {
  function eq (line 193) | auto const eq = std::as_const(truth_.value) == std::as_const(expected);
  function FOLLY_ERASE (line 204) | FOLLY_ERASE value_type& ref() const {

FILE: folly/concurrency/UnboundedQueue.h
  function namespace (line 35) | namespace folly {

FILE: folly/concurrency/container/FlatCombiningPriorityQueue.h
  function namespace (line 31) | namespace folly {
  function size (line 114) | size_t size() const {
  function try_pop (line 135) | bool try_pop(T& val) {
  function try_peek (line 144) | bool try_peek(T& val) {
  function push (line 152) | void push(const T& val) {
  function pop (line 160) | void pop(T& val) {
  function peek (line 168) | void peek(T& val) {

FILE: folly/concurrency/container/LockFreeRingBuffer.h
  function namespace (line 32) | namespace folly {

FILE: folly/concurrency/container/RelaxedConcurrentPriorityQueue.h
  function namespace (line 116) | namespace folly {

FILE: folly/concurrency/container/SingleWriterFixedHashMap.h
  function namespace (line 25) | namespace folly {

FILE: folly/concurrency/container/atomic_grow_array.h
  function namespace (line 33) | namespace folly {
  function array (line 148) | array const* array_{}
  function size_type (line 149) | size_type index_{}
  function reference (line 213) | reference operator*() noexcept { return *array_->list[index_]; }
  function reference (line 214) | reference operator[](difference_type const n) { return *(*this + n); }
  function array (line 227) | array const* array_{}
  function explicit (line 229) | explicit basic_view(array const* arr) noexcept : array_{arr}
  function iterator (line 250) | iterator begin() noexcept { return iterator{array_, 0}; }
  function explicit (line 288) | explicit atomic_grow_array(Policy const& policy_) //
  function FOLLY_ALWAYS_INLINE (line 337) | FOLLY_ALWAYS_INLINE value_type& operator[](size_type const index) //
  function noexcept (line 396) | const_iterator(iterator that) noexcept : base{that}
  function class (line 436) | class const_view : private basic_view<true> {
  function view (line 481) | view as_view() noexcept { return view{array_.load(mo_acquire)}; }
  function FOLLY_NOINLINE (line 514) | FOLLY_NOINLINE array* at_slow(size_type const index) //
  function size_type (line 550) | static constexpr size_type array_align() {
  function size_type (line 553) | static size_type array_size(size_type const size, size_type const base) {
  function value_type (line 559) | static value_type* array_slab(array* const curr) {
  function array (line 565) | array* new_array(size_type const size, array*& next) {
  function del_array (line 598) | void del_array(array* const curr) {
  function reset (line 622) | void reset() {

FILE: folly/concurrency/container/test/FlatCombiningPriorityQueueTest.cpp
  function doWork (line 35) | void doWork(int work) {
  class BaselinePQ (line 49) | class BaselinePQ {
    method BaselinePQ (line 54) | explicit BaselinePQ(size_t maxSize = 0, PQArgs... args)
    method empty (line 57) | bool empty() const {
    method size (line 62) | size_t size() const {
    method try_push (line 67) | bool try_push(const T& val) {
    method try_pop (line 82) | bool try_pop(T& val) {
    method try_peek (line 93) | bool try_peek(T& val) {
  function run_once (line 121) | static uint64_t run_once(PriorityQueue& pq, const Func& fn) {
  function TEST (line 162) | TEST(FCPriQueue, basic) {
  function TEST (line 206) | TEST(FCPriQueue, bounded) {
  function TEST (line 219) | TEST(FCPriQueue, timeout) {
  function TEST (line 250) | TEST(FCPriQueue, pushPop) {
  type Exp (line 275) | enum Exp {
  function test (line 282) | static uint64_t test(std::string name, Exp exp, uint64_t base) {
  function TEST (line 372) | TEST(FCPriQueue, bench) {

FILE: folly/concurrency/container/test/LockFreeRingBufferTest.cpp
  type folly (line 24) | namespace folly {
    function TEST (line 26) | TEST(LockFreeRingBuffer, writeReadSequentially) {
    function TEST (line 47) | TEST(LockFreeRingBuffer, writeReadSequentiallyBackward) {
    function TEST (line 69) | TEST(LockFreeRingBuffer, readsCanBlock) {
    function value (line 96) | uint64_t value(const typename LockFreeRingBuffer<T, Atom>::Cursor& rbc...
    function runReader (line 107) | void runReader(
    function runWritesNeverFail (line 116) | void runWritesNeverFail(int capacity, int writes, int writers) {
    function TEST (line 137) | TEST(LockFreeRingBuffer, writesNeverFail) {
    function TEST (line 157) | TEST(LockFreeRingBuffer, readerCanDetectSkips) {
    function TEST (line 182) | TEST(LockFreeRingBuffer, cursorFromWrites) {
    function TEST (line 199) | TEST(LockFreeRingBuffer, moveBackwardsCanFail) {
    type S (line 219) | struct S {
    function TEST (line 227) | TEST(LockFreeRingBuffer, contendedReadsAndWrites) {
    function TEST (line 260) | TEST(LockFreeRingBuffer, cursorComparison) {

FILE: folly/concurrency/container/test/RelaxedConcurrentPriorityQueueTest.cpp
  function basicOpsTest (line 44) | void basicOpsTest() {
  function TEST (line 79) | TEST(CPQ, BasicOpsTest) {
  function run_once (line 98) | static uint64_t run_once(const Func& fn) {
  function singleThreadTest (line 123) | void singleThreadTest() {
  function TEST (line 148) | TEST(CPQ, SingleThrStrictImplTest) {
  function TEST (line 159) | TEST(CPQ, SingleThrRelaxedImplTest) {
  function concurrentPopforSharedBuffer (line 175) | void concurrentPopforSharedBuffer() {
  function TEST (line 211) | TEST(CPQ, ConcurrentPopStrictImplTest) {
  function TEST (line 228) | TEST(CPQ, ConcurrentPopRelaxedImplTest) {
  function concurrentPush (line 250) | void concurrentPush() {
  function TEST (line 280) | TEST(CPQ, ConcurrentPushStrictImplTest) {
  function TEST (line 286) | TEST(CPQ, ConcurrentPushRelaxedImplTest) {
  function concurrentOps (line 295) | void concurrentOps(int ops) {
  function concurrentSizeTest (line 356) | void concurrentSizeTest(int ops) {
  function TEST (line 387) | TEST(CPQ, ConcurrentMixedStrictImplTest) {
  function TEST (line 397) | TEST(CPQ, ConcurrentMixedRelaxedImplTest) {
  function TEST (line 410) | TEST(CPQ, StrictImplSizeTest) {
  function TEST (line 419) | TEST(CPQ, RelaxedImplSizeTest) {
  function multiPusherPopper (line 430) | void multiPusherPopper(int PushThr, int PopThr) {
  function TEST (line 483) | TEST(CPQ, PusherPopperBlockingTest) {
  function TEST (line 503) | TEST(CPQ, PusherPopperSpinningTest) {
  function blockingFirst (line 525) | void blockingFirst() {
  function concurrentBlocking (line 561) | void concurrentBlocking() {
  function TEST (line 600) | TEST(CPQ, PopBlockingTest) {
  function TEST (line 614) | TEST(CPQ, MixedBlockingTest) {
  function DSchedMixedTest (line 634) | static void DSchedMixedTest() {
  function TEST (line 686) | TEST(CPQ, DSchedMixedStrictTest) {
  function TEST (line 750) | TEST(CPQ, DSchedMixedRelaxedTest) {
  class Queue (line 835) | class Queue {
    method push (line 839) | void push(const T& val) { q_.push(val); }
    method pop (line 840) | void pop(T& val) {
  class GlobalLockPQ (line 847) | class GlobalLockPQ {
    method push (line 852) | void push(const T& val) {
    method pop (line 856) | void pop(T& val) {
  function producer_consumer_test (line 870) | static uint64_t producer_consumer_test(
  function throughtput_test (line 954) | static uint64_t throughtput_test(std::string name, uint64_t initial_size) {
  function accuracy_test (line 1005) | static void accuracy_test(
  function TEST (line 1056) | TEST(CPQ, ThroughtputBench) {
  function TEST (line 1084) | TEST(CPQ, ProducerConsumerBench) {
  function TEST (line 1159) | TEST(CPQ, Accuracy) {

FILE: folly/concurrency/container/test/SingleWriterFixedHashMapTest.cpp
  function basic_test (line 35) | void basic_test() {
  function TEST (line 66) | TEST(SingleWriterFixedHashMap, basic) {
  function iterator_test (line 70) | void iterator_test() {
  function TEST (line 85) | TEST(SingleWriterFixedHashMap, iterator) {
  function copy_test (line 89) | void copy_test() {
  function TEST (line 105) | TEST(SingleWriterFixedHashMap, copy) {
  function drf_test (line 109) | void drf_test() {
  function TEST (line 149) | TEST(SingleWriterFixedHashMap, drf) {
  function copy_tombstones_test (line 153) | void copy_tombstones_test() {
  function TEST (line 166) | TEST(SingleWriterFixedHashMap, copyTombstones) {
  function run_once (line 173) | inline uint64_t run_once(int nthr, const Func& fn) {
  function runBench (line 198) | uint64_t runBench(int ops, const RepFunc& repFn) {
  function bench_find (line 234) | uint64_t bench_find(const int nthr, const uint64_t ops) {
  function bench_iterate (line 253) | uint64_t bench_iterate(const int nthr, const uint64_t ops) {
  function bench_ctor_dtor (line 275) | uint64_t bench_ctor_dtor(const int nthr, const uint64_t ops) {
  function bench_copy_empty_dtor (line 288) | uint64_t bench_copy_empty_dtor(const int nthr, const uint64_t ops) {
  function bench_copy_nonempty_dtor (line 301) | uint64_t bench_copy_nonempty_dtor(const int nthr, const uint64_t ops) {
  function bench_copy_resize_dtor (line 315) | uint64_t bench_copy_resize_dtor(const int nthr, const uint64_t ops) {
  function dottedLine (line 329) | void dottedLine() {
  function TEST (line 337) | TEST(SingleWriterFixedHashMapBench, Bench) {

FILE: folly/concurrency/container/test/atomic_grow_array_test.cpp
  function FOLLY_KEEP (line 25) | FOLLY_KEEP int check_folly_atomic_grow_array_index(
  type AtomicGrowArrayTest (line 84) | struct AtomicGrowArrayTest : testing::Test {
    type policy_base (line 85) | struct policy_base {
  function TEST_F (line 91) | TEST_F(AtomicGrowArrayTest, example) {
  function TEST_F (line 121) | TEST_F(AtomicGrowArrayTest, empty) {
  function TEST_F (line 164) | TEST_F(AtomicGrowArrayTest, stress) {

FILE: folly/concurrency/detail/AtomicSharedPtr-detail.h
  function namespace (line 27) | namespace folly {
  function inc_shared_count (line 145) | inline void shared_ptr_internals::inc_shared_count(
  function release_shared (line 156) | void shared_ptr_internals::release_shared(

FILE: folly/concurrency/detail/ConcurrentHashMap-detail.h
  function namespace (line 46) | namespace folly {
  type DeallocateFn (line 216) | struct DeallocateFn { // Avoids dependent lambdas in function templates
  function Node (line 224) | Node* node{}
  function dismiss (line 226) | void dismiss() { node = nullptr; }
  function Node (line 227) | Node* release() { return std::exchange(node, nullptr); }
  function Node (line 245) | Node* make(Allocator alloc_, Arg&&... arg) {
  function class (line 261) | class HazptrTableDeleter {
  function explicit (line 288) | explicit NodeT(hazptr_obj_cohort<Atom>* cohort, NodeT* other)
  function release (line 302) | void release() { this->unlink(); }
  function BucketTable (line 339) | alignas(64) BucketTable {
  function size (line 382) | size_t size() { return size_.load(std::memory_order_acquire); }
  function clearSize (line 384) | void clearSize() { size_.store(0, std::memory_order_release); }
  function incSize (line 386) | void incSize() {
  function decSize (line 391) | void decSize() {
  function empty (line 397) | bool empty() { return size() == 0; }
  function rehash (line 425) | void rehash(size_t bucket_count, hazptr_obj_cohort<Atom>* cohort) {
  function erase (line 507) | size_t erase(size_t h, const K& key, Iterator* iter, MatchFunc match) {
  function destroy (line 617) | void destroy(size_t count) {
  function unlink_and_reclaim_nodes (line 625) | void unlink_and_reclaim_nodes(size_t count) {
  function FOLLY_ALWAYS_INLINE (line 648) | FOLLY_ALWAYS_INLINE explicit Iterator(std::nullptr_t) : hazptrs_() {}
  function FOLLY_ALWAYS_INLINE (line 649) | FOLLY_ALWAYS_INLINE ~Iterator() {}
  function setNode (line 651) | void setNode(
  function Buckets (line 725) | Buckets* buckets_{nullptr};
  function getBucketsAndCount (line 736) | void getBucketsAndCount(
  function Atom (line 875) | alignas(64) Atom<Buckets*> buckets_{nullptr};
  function namespace (line 887) | namespace simd {
  type alignas (line 952) | struct alignas
  function setTag (line 997) | void setTag(std::size_t index, std::size_t tag) {
  function setNodeAndTag (line 1006) | void setNodeAndTag(std::size_t index, Node* node, std::size_t tag) {
  function clearNodeAndTag (line 1014) | void clearNodeAndTag(std::size_t index) {
  function SparseMaskIter (line 1025) | SparseMaskIter tagMatchIter(std::size_t needle, svbool_t& outPred) const {
  function class (line 1221) | class Iterator {
  function rehash (line 1480) | void rehash(size_t size, hazptr_obj_cohort<Atom>* cohort) {
  function erase (line 1528) | size_t erase(size_t h, const K& key, Iterator* iter, MatchFunc match) {
  function clear (line 1583) | void clear(hazptr_obj_cohort<Atom>* cohort) {
  function max_load_factor (line 1599) | void max_load_factor(float factor) {
  function Iterator (line 1610) | Iterator cbegin() {
  function Iterator (line 1620) | Iterator cend() { return Iterator(nullptr); }
  function probeDelta (line 1634) | static size_t probeDelta(HashPair hp) { return 2 * hp.second + 1; }
  function rehash_internal (line 1744) | void rehash_internal(
  function getChunksAndCount (line 1783) | void getChunksAndCount(
  function Atom (line 1824) | alignas(64) Atom<Chunks*> chunks_{nullptr};
  function const (line 1835) | bool operator()(const ValueType& lhs) const { return lhs == rhs; }
  function ConcurrentHashMapSegment (line 1883) | alignas(64) ConcurrentHashMapSegment {
  function size (line 1916) | size_t size() { return impl_.size(); }
  function empty (line 1918) | bool empty() { return impl_.empty(); }
  function rehash (line 2082) | void rehash(size_t bucket_count) {
  function erase (line 2114) | void erase(Iterator& res, Iterator& pos, size_t h) {
  function clear (line 2120) | void clear() { impl_.clear(cohort_); }
  function max_load_factor (line 2122) | void max_load_factor(float factor) { impl_.max_load_factor(factor); }
  function Iterator (line 2124) | Iterator cbegin() { return impl_.cbegin(); }
  function Iterator (line 2126) | Iterator cend() { return impl_.cend(); }

FILE: folly/concurrency/memory/AtomicReadMostlyMainPtr.cpp
  type folly (line 21) | namespace folly {
    type detail (line 22) | namespace detail {
      type FailingExecutor (line 25) | struct FailingExecutor : folly::Executor {
        method add (line 27) | void add(Func func) override {

FILE: folly/concurrency/memory/AtomicReadMostlyMainPtr.h
  function namespace (line 28) | namespace folly {

FILE: folly/concurrency/memory/PrimaryPtr.h
  function namespace (line 28) | namespace folly {

FILE: folly/concurrency/memory/ReadMostlySharedPtr.h
  function namespace (line 24) | namespace folly {
  function reset (line 266) | void reset(detail::ReadMostlySharedPtrCore<RefCount>* impl, T* ptrRaw) {
  function T (line 282) | T* ptrRaw_{nullptr};
  function reset (line 384) | void reset() { reset(nullptr, nullptr); }
  function T (line 386) | T* get() const { return ptrRaw_; }
  function T (line 429) | T* ptrRaw_{nullptr};

FILE: folly/concurrency/memory/TLRefCount.h
  function namespace (line 23) | namespace folly {
  function Int (line 78) | Int operator*() const {
  function useGlobal (line 85) | void useGlobal() noexcept {
  function collect (line 148) | void collect() {

FILE: folly/concurrency/memory/test/AtomicReadMostlyMainPtrBenchmark.cpp
  function BENCHMARK (line 25) | BENCHMARK(SingleThreadedLoads, n) {
  function BENCHMARK (line 33) | BENCHMARK(SingleThreadedStores, n) {
  function main (line 42) | int main(int argc, char** argv) {

FILE: folly/concurrency/memory/test/AtomicReadMostlyMainPtrTest.cpp
  class AtomicReadMostlyMainPtrSimpleTest (line 30) | class AtomicReadMostlyMainPtrSimpleTest : public testing::Test {
    method AtomicReadMostlyMainPtrSimpleTest (line 32) | AtomicReadMostlyMainPtrSimpleTest()
    type CasType (line 47) | enum CasType {
    method cas (line 53) | bool cas(T0&& atom, T1&& expected, T2&& desired, CasType casType) {
    method casSuccessTest (line 63) | void casSuccessTest(CasType casType) {
    method casFailureTest (line 86) | void casFailureTest(CasType casType) {
  function TEST_F (line 114) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, StartsNull) {
  function TEST_F (line 118) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, Store) {
  function TEST_F (line 123) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, Exchange) {
  function TEST_F (line 130) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, CompareExchangeWeakSuccess) {
  function TEST_F (line 134) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, CompareExchangeStrongSuccess) {
  function TEST_F (line 138) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, CompareExchangeWeakFailure) {
  function TEST_F (line 142) | TEST_F(AtomicReadMostlyMainPtrSimpleTest, CompareExchangeStrongFailure) {
  class AtomicReadMostlyMainPtrCounterTest (line 146) | class AtomicReadMostlyMainPtrCounterTest : public testing::Test {
    type InstanceCounter (line 148) | struct InstanceCounter {
      method InstanceCounter (line 149) | explicit InstanceCounter(int* counter_) : counter(counter_) { ++*cou...
  function TEST_F (line 161) | TEST_F(AtomicReadMostlyMainPtrCounterTest, DestroysOldValuesSimple) {
  function TEST_F (line 169) | TEST_F(AtomicReadMostlyMainPtrCounterTest, DestroysOldValuesWithReuse) {
  function TEST (line 180) | TEST(AtomicReadMostlyMainPtrTest, HandlesDestructionModifications) {
  function TEST (line 239) | TEST(AtomicReadMostlyMainPtrTest, TakesMemoryOrders) {
  function TEST (line 288) | TEST(AtomicReadMostlyMainPtrTest, LongLivedReadsDoNotBlockWrites) {
  function TEST (line 303) | TEST(AtomicReadMostlyMainPtrStressTest, ReadOnly) {
  function TEST (line 323) | TEST(AtomicReadMostlyMainPtrStressTest, ReadWriteConsistency) {
  function TEST (line 413) | TEST(AtomicReadMostlyMainPtrStressTest, ReadWriteTsan) {

FILE: folly/concurrency/memory/test/PrimaryPtrTest.cpp
  function TEST (line 27) | TEST(PrimaryPtrTest, Basic) {
  type Primed (line 93) | struct Primed : folly::Cleanup, folly::EnablePrimaryFromThis<Primed> {
    method Primed (line 96) | Primed() : nested_(std::make_unique<int>(42)), pool_(4) {
    method get_shared (line 103) | std::shared_ptr<Primed> get_shared() { return masterLockFromThis(); }
  function TEST (line 106) | TEST(PrimaryPtrTest, BasicCleanup) {
  function TEST (line 137) | TEST(PrimaryPtrTest, Errors) {
  function TEST (line 173) | TEST(PrimaryPtrTest, Invariants) {
  type Derived (line 222) | struct Derived : Primed {}
  function TEST (line 224) | TEST(PrimaryPtrTest, EnablePrimaryFromThis) {
  function TEST (line 278) | TEST(PrimaryPtrTest, Moves) {
  function TEST (line 296) | TEST(PrimaryPtrTest, DefaultConstructPtrRef) {

FILE: folly/concurrency/memory/test/ReadMostlySharedPtrBenchmark.cpp
  function benchmark (line 30) | void benchmark(size_t n) {
  function constructorBenchmark (line 53) | void constructorBenchmark(size_t n) {
  function destructorBenchmark (line 70) | void destructorBenchmark(size_t n) {
  function BENCHMARK (line 90) | BENCHMARK(WeakPtrOneThread, n) {
  function BENCHMARK_RELATIVE (line 94) | BENCHMARK_RELATIVE(TLReadMostlyWeakPtrOneThread, n) {
  function BENCHMARK (line 98) | BENCHMARK(WeakPtrFourThreads, n) {
  function BENCHMARK_RELATIVE (line 102) | BENCHMARK_RELATIVE(TLReadMostlyWeakPtrFourThreads, n) {
  function BENCHMARK (line 112) | BENCHMARK(SharedPtrCtor, n) {
  function BENCHMARK_RELATIVE (line 116) | BENCHMARK_RELATIVE(TLReadMostlyMainPtrCtor, n) {
  function BENCHMARK (line 120) | BENCHMARK(SharedPtrDtor, n) {
  function BENCHMARK_RELATIVE (line 124) | BENCHMARK_RELATIVE(TLReadMostlyMainPtrDtor, n) {
  function main (line 128) | int main(int argc, char** argv) {

FILE: folly/concurrency/memory/test/ReadMostlySharedPtrStressTest.cpp
  class ReadMostlySharedPtrStressTest (line 26) | class ReadMostlySharedPtrStressTest : public ::testing::Test {}
  function TEST_F (line 28) | TEST_F(ReadMostlySharedPtrStressTest, ReaderWriter) {

FILE: folly/concurrency/memory/test/ReadMostlySharedPtrTest.cpp
  class ReadMostlySharedPtrTest (line 35) | class ReadMostlySharedPtrTest : public ::testing::Test {
    method ReadMostlySharedPtrTest (line 37) | ReadMostlySharedPtrTest() { alarm(TEST_TIMEOUT); }
  type TestObject (line 40) | struct TestObject {
    method TestObject (line 44) | TestObject(int value_, std::atomic<int>& counter_)
  class Coordinator (line 57) | class Coordinator {
    method requestAndWait (line 59) | void requestAndWait() {
    method waitForRequest (line 64) | void waitForRequest() { requestBaton_.wait(); }
    method completed (line 66) | void completed() { completeBaton_.post(); }
  function TEST_F (line 73) | TEST_F(ReadMostlySharedPtrTest, BasicStores) {
  function TEST_F (line 92) | TEST_F(ReadMostlySharedPtrTest, BasicLoads) {
  function TEST_F (line 127) | TEST_F(ReadMostlySharedPtrTest, LoadsFromThreads) {
  function TEST_F (line 192) | TEST_F(ReadMostlySharedPtrTest, Ctor) {
  function TEST_F (line 203) | TEST_F(ReadMostlySharedPtrTest, ClearingCache) {
  class TestRefCount (line 235) | class TestRefCount {
    method useGlobal (line 253) | void useGlobal() { ++useGlobalCalls; }
    method useGlobal (line 256) | static void useGlobal(const Container&) {
  function TEST_F (line 264) | TEST_F(ReadMostlySharedPtrTest, ReadMostlyMainPtrDeleter) {
  function TEST_F (line 286) | TEST_F(ReadMostlySharedPtrTest, nullptr) {
  function TEST_F (line 323) | TEST_F(ReadMostlySharedPtrTest, getStdShared) {
  type Base (line 336) | struct Base {
    method getName (line 339) | virtual std::string getName() const { return "Base"; }
  type Derived (line 342) | struct Derived : public Base {
    method getName (line 343) | std::string getName() const override { return "Derived"; }
  function TEST_F (line 346) | TEST_F(ReadMostlySharedPtrTest, casts) {

FILE: folly/concurrency/memory/test/RefCountBenchmark.cpp
  type folly (line 22) | namespace folly {
    function shutdown (line 25) | void shutdown(Counter&) {}
    function shutdown (line 27) | void shutdown(TLRefCount& c) {
    function benchmark (line 33) | void benchmark(size_t n) {
    function BENCHMARK (line 56) | BENCHMARK(TLRefCountOneThread, n) {
    function BENCHMARK (line 60) | BENCHMARK(TLRefCountFourThreads, n) {
    function BENCHMARK (line 64) | BENCHMARK(TLRefCountTwentyFourThreads, n) {
    function BENCHMARK (line 68) | BENCHMARK(AtomicOneThread, n) {
    function BENCHMARK (line 72) | BENCHMARK(AtomicFourThreads, n) {
    function BENCHMARK (line 76) | BENCHMARK(AtomicTwentyFourThreads, n) {
  function main (line 82) | int main(int argc, char** argv) {

FILE: folly/concurrency/memory/test/RefCountTest.cpp
  type folly (line 24) | namespace folly {
    function basicTest (line 27) | void basicTest() {
    function stressTest (line 87) | void stressTest(size_t itersCount) {
    function TEST (line 118) | TEST(TLRefCount, Basic) {
    function TEST (line 122) | TEST(TLRefCount, Stress) {
    function TEST (line 128) | TEST(TLRefCount, SafeToDeleteWhenReachingZero) {

FILE: folly/concurrency/test/AtomicSharedPtrCounted.h
  type counted_shared_tag (line 26) | struct counted_shared_tag {}
  function p_ (line 52) | p_(nullptr) {}
  function p_ (line 53) | p_(p) {
  function p_ (line 59) | counted_ptr(const counted_ptr& o) : p_(o.p_) {
  function explicit (line 75) | explicit counted_ptr(T* p) : p_(p) { CHECK(!p); }
  function typename (line 82) | typename std::add_lvalue_reference<T>::type operator*() const { return *...
  function T (line 84) | T* get() const { return p_; }
  function counted_base (line 119) | counted_base* get_counted_base(const counted_ptr<T, Atom>& bar) {
  function T (line 124) | T* get_shared_ptr(counted_base* base) {
  function inc_shared_count (line 145) | static void inc_shared_count(counted_base* base, int64_t count) {
  function release_shared (line 150) | void release_shared(counted_base* base, uint64_t count) {

FILE: folly/concurrency/test/AtomicSharedPtrPerformance.cpp
  function nowMicro (line 58) | static uint64_t nowMicro() {
  function uncontended_read_write (line 83) | void uncontended_read_write(
  function read_asp (line 106) | void read_asp(
  function write_asp (line 122) | void write_asp(
  function contended_read_write (line 139) | void contended_read_write(
  function document_noexcept (line 184) | void document_noexcept() {
  function runSuite (line 225) | void runSuite() {
  function main (line 242) | int main(int, char**) {
  function main (line 250) | int main(int, char**) {

FILE: folly/concurrency/test/AtomicSharedPtrTest.cpp
  type foo (line 41) | struct foo {
    method foo (line 42) | foo() { c_count++; }
  function TEST (line 46) | TEST(AtomicSharedPtr, operators) {
  function TEST (line 60) | TEST(AtomicSharedPtr, exchange) {
  function TEST (line 68) | TEST(AtomicSharedPtr, foo) {
  function TEST (line 90) | TEST(AtomicSharedPtr, counted) {
  function TEST (line 111) | TEST(AtomicSharedPtr, counted2) {
  function TEST (line 121) | TEST(AtomicSharedPtr, ConstTest) {
  function TEST (line 129) | TEST(AtomicSharedPtr, AliasingConstructorTest) {
  function TEST (line 155) | TEST(AtomicSharedPtr, AliasingWithNoControlBlockConstructorTest) {
  function TEST (line 161) | TEST(AtomicSharedPtr, AliasingWithNullptrConstructorTest) {
  function TEST (line 172) | TEST(AtomicSharedPtr, MaxPtrs) {
  function TEST (line 183) | TEST(AtomicSharedPtr, DeterministicTest) {
  function TEST (line 212) | TEST(AtomicSharedPtr, StressTest) {
  function TEST (line 254) | TEST(AtomicSharedPtr, Leak) {

FILE: folly/concurrency/test/CacheLocalityBenchmark.cpp
  function FOLLY_KEEP (line 30) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 35) | FOLLY_KEEP size_t
  type CachedCurrentTag (line 70) | struct CachedCurrentTag {}
  type folly (line 72) | namespace folly {
    function CacheLocality (line 74) | const CacheLocality& CacheLocality::system<CachedCurrentTag>() {
  function BENCHMARK (line 85) | BENCHMARK(AccessSpreaderUse, iters) {
  function BENCHMARK (line 92) | BENCHMARK(StateAccessSpreaderUse, iters) {
  function BENCHMARK (line 100) | BENCHMARK(CachedAccessSpreaderUse, iters) {
  function BENCHMARK (line 107) | BENCHMARK(LLCAccessSpreaderUse, iters) {
  function BENCHMARK (line 114) | BENCHMARK(StateCachedAccessSpreaderUse, iters) {
  function BENCHMARK (line 122) | BENCHMARK(BaselineAtomicIncrement, iters) {
  function BENCHMARK (line 130) | BENCHMARK(CachedAccessSpreaderAtomicIncrement, iters) {
  function BENCHMARK (line 139) | BENCHMARK(StateCachedAccessSpreaderAtomicIncrement, iters) {
  function contentionAtWidth (line 232) | static void contentionAtWidth(size_t iters, size_t stripes, size_t work) {
  function atomicIncrBaseline (line 301) | static void atomicIncrBaseline(
  function contentionAtWidthGetcpu (line 333) | static void contentionAtWidthGetcpu(size_t iters, size_t stripes, size_t...
  function contentionAtWidthThreadLocal (line 337) | static void contentionAtWidthThreadLocal(
  function contentionAtWidthPthreadSelf (line 342) | static void contentionAtWidthPthreadSelf(
  function contentionAtWidthCached (line 347) | static void contentionAtWidthCached(size_t iters, size_t stripes, size_t...
  function BENCHMARK (line 397) | BENCHMARK(readSystemLocalityInfo, iters) {
  function BENCHMARK (line 404) | BENCHMARK(readFromProcCpuinfo, iters) {
  function BENCHMARK (line 414) | BENCHMARK(readFromSysfs, iters) {
  function main (line 424) | int main(int argc, char** argv) {

FILE: folly/concurrency/test/CacheLocalityInitMain.cpp
  function main (line 19) | int main() {

FILE: folly/concurrency/test/CacheLocalityTest.cpp
  function TEST (line 315) | TEST(CacheLocality, FakeSysfs) {
  function TEST (line 973) | TEST(CacheLocality, ProcCpu) {
  function TEST (line 989) | TEST(CacheLocality, LinuxActual) {
  function TEST (line 1052) | TEST(CacheLocality, LogSystem) {
  function micros (line 1061) | static uint64_t micros(struct timeval& tv) {
  function logRusageFor (line 1066) | static void logRusageFor(std::string name, F func) {
  function TEST (line 1084) | TEST(CacheLocality, BenchmarkProcCpuinfo) {
  function TEST (line 1090) | TEST(CacheLocality, BenchmarkSysfs) {
  function TEST (line 1096) | TEST(Getcpu, VdsoGetcpu) {
  function TEST (line 1107) | TEST(ThreadId, SimpleTls) {
  function TEST (line 1118) | TEST(ThreadId, SimplePthread) {
  function testingGetcpu (line 1131) | static int testingGetcpu(unsigned* cpu, unsigned* node, void* /* unused ...
  function TEST (line 1141) | TEST(AccessSpreader, Simple) {
  function TEST (line 1147) | TEST(AccessSpreader, SimpleCached) {
  function TEST (line 1153) | TEST(AccessSpreader, ConcurrentAccessCached) {
  function TEST (line 1191) | TEST(AccessSpreader, Wrapping) {
  function TEST (line 1208) | TEST(CoreAllocator, Basic) {
  function TEST (line 1241) | TEST(CoreAllocator, MinimumAllocationSize) {

FILE: folly/concurrency/test/ConcurrentHashMapBench.cpp
  function run_once (line 33) | inline uint64_t run_once(int nthr, const Func& fn, const EndFunc& endFn) {
  function runBench (line 59) | uint64_t runBench(const std::string& name, int ops, const RepFunc& repFn) {
  function bench_ctor_dtor (line 90) | uint64_t bench_ctor_dtor(
  function bench_find (line 108) | uint64_t bench_find(
  function bench_iter (line 134) | uint64_t bench_iter(const int nthr, int size, const std::string& name) {
  function bench_begin (line 154) | uint64_t bench_begin(const int nthr, int size, const std::string& name) {
  function bench_empty (line 172) | uint64_t bench_empty(const int nthr, int size, const std::string& name) {
  function bench_size (line 190) | uint64_t bench_size(const int nthr, int size, const std::string& name) {
  function dottedLine (line 208) | void dottedLine() {
  function benches (line 213) | void benches() {
  function main (line 268) | int main() {

FILE: folly/concurrency/test/ConcurrentHashMapStressTest.cpp
  class ConcurrentHashMapStressTest (line 31) | class ConcurrentHashMapStressTest : public ::testing::Test {}
  type MapFactory (line 43) | struct MapFactory {
  function TYPED_TEST_P (line 67) | TYPED_TEST_P(ConcurrentHashMapStressTest, StressTestReclamation) {

FILE: folly/concurrency/test/ConcurrentHashMapTest.cpp
  class ConcurrentHashMapTest (line 40) | class ConcurrentHashMapTest : public ::testing::Test {}
  type MapFactory (line 52) | struct MapFactory {
  function TYPED_TEST_P (line 76) | TYPED_TEST_P(ConcurrentHashMapTest, MapTest) {
  function TYPED_TEST_P (line 123) | TYPED_TEST_P(ConcurrentHashMapTest, MaxSizeTest) {
  function TYPED_TEST_P (line 135) | TYPED_TEST_P(ConcurrentHashMapTest, MoveTest) {
  type foo (line 142) | struct foo {
    method foo (line 145) | foo(foo&&) noexcept { moved++; }
    method foo (line 146) | foo& operator=(foo&&) {
    method foo (line 150) | foo& operator=(const foo&) {
    method foo (line 154) | foo(const foo&) { copied++; }
    method foo (line 155) | foo() {}
  function TYPED_TEST_P (line 160) | TYPED_TEST_P(ConcurrentHashMapTest, EmplaceTest) {
  function TYPED_TEST_P (line 180) | TYPED_TEST_P(ConcurrentHashMapTest, MapInsertIteratorValueTest) {
  function TYPED_TEST_P (line 189) | TYPED_TEST_P(ConcurrentHashMapTest, MapResizeTest) {
  function TYPED_TEST_P (line 210) | TYPED_TEST_P(ConcurrentHashMapTest, ReserveTest) {
  function TYPED_TEST_P (line 231) | TYPED_TEST_P(ConcurrentHashMapTest, MapNoCopiesTest) {
  function TYPED_TEST_P (line 254) | TYPED_TEST_P(ConcurrentHashMapTest, MapMovableKeysTest) {
  function TYPED_TEST_P (line 282) | TYPED_TEST_P(ConcurrentHashMapTest, MapUpdateTest) {
  function TYPED_TEST_P (line 291) | TYPED_TEST_P(ConcurrentHashMapTest, MapIterateTest2) {
  function TYPED_TEST_P (line 298) | TYPED_TEST_P(ConcurrentHashMapTest, MapIterateTest) {
  function TYPED_TEST_P (line 321) | TYPED_TEST_P(ConcurrentHashMapTest, MoveIterateAssignIterate) {
  function TYPED_TEST_P (line 334) | TYPED_TEST_P(ConcurrentHashMapTest, EraseTest) {
  function TYPED_TEST_P (line 342) | TYPED_TEST_P(ConcurrentHashMapTest, EraseIfEqualTest) {
  function TYPED_TEST_P (line 352) | TYPED_TEST_P(ConcurrentHashMapTest, EraseIfTest) {
  function TYPED_TEST_P (line 379) | TYPED_TEST_P(ConcurrentHashMapTest, CopyIterator) {
  function TYPED_TEST_P (line 388) | TYPED_TEST_P(ConcurrentHashMapTest, EraseInIterateTest) {
  function TYPED_TEST_P (line 407) | TYPED_TEST_P(ConcurrentHashMapTest, AssignIfTest) {
  function TYPED_TEST_P (line 429) | TYPED_TEST_P(ConcurrentHashMapTest, InsertOrAssignIfTest) {
  function TYPED_TEST_P (line 488) | TYPED_TEST_P(ConcurrentHashMapTest, UpdateStressTest) {
  function TYPED_TEST_P (line 540) | TYPED_TEST_P(ConcurrentHashMapTest, EraseStressTest) {
  function TYPED_TEST_P (line 603) | TYPED_TEST_P(ConcurrentHashMapTest, TryEmplaceEraseStressTest) {
  function TYPED_TEST_P (line 624) | TYPED_TEST_P(ConcurrentHashMapTest, InsertOrAssignStressTest) {
  function TYPED_TEST_P (line 647) | TYPED_TEST_P(ConcurrentHashMapTest, IterateStressTest) {
  function TYPED_TEST_P (line 700) | TYPED_TEST_P(ConcurrentHashMapTest, insertStressTest) {
  function TYPED_TEST_P (line 734) | TYPED_TEST_P(ConcurrentHashMapTest, assignStressTest) {
  function TYPED_TEST_P (line 795) | TYPED_TEST_P(ConcurrentHashMapTest, RefcountTest) {
  type Wrapper (line 814) | struct Wrapper {
    method Wrapper (line 815) | explicit Wrapper(bool& del_) : del(del_) {}
  function TYPED_TEST_P (line 821) | TYPED_TEST_P(ConcurrentHashMapTest, Deletion) {
  function TYPED_TEST_P (line 835) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionWithErase) {
  function TYPED_TEST_P (line 850) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionWithIterator) {
  function TYPED_TEST_P (line 866) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionWithForLoop) {
  function TYPED_TEST_P (line 883) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionMultiple) {
  function TYPED_TEST_P (line 899) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionAssigned) {
  function TYPED_TEST_P (line 915) | TYPED_TEST_P(ConcurrentHashMapTest, DeletionMultipleMaps) {
  function TYPED_TEST_P (line 932) | TYPED_TEST_P(ConcurrentHashMapTest, ForEachLoop) {
  type FooBase (line 945) | struct FooBase {
    method FooBase (line 947) | explicit FooBase(typename T::ConstIterator&& it_) : it(std::move(it_)) {}
    method FooBase (line 948) | FooBase(FooBase&&) = default;
    method FooBase (line 949) | FooBase& operator=(FooBase&&) = default;
  function TYPED_TEST_P (line 952) | TYPED_TEST_P(ConcurrentHashMapTest, IteratorMove) {
  function TYPED_TEST_P (line 965) | TYPED_TEST_P(ConcurrentHashMapTest, IteratorLoop) {
  function TYPED_TEST_P (line 989) | TYPED_TEST_P(ConcurrentHashMapTest, HeterogeneousLookup) {
  function TYPED_TEST_P (line 1021) | TYPED_TEST_P(ConcurrentHashMapTest, HeterogeneousInsert) {
  function TYPED_TEST_P (line 1093) | TYPED_TEST_P(ConcurrentHashMapTest, InsertOrAssignIterator) {
  function TYPED_TEST_P (line 1102) | TYPED_TEST_P(ConcurrentHashMapTest, EraseClonedNonCopyable) {
  function TYPED_TEST_P (line 1128) | TYPED_TEST_P(ConcurrentHashMapTest, ConcurrentInsertClear) {
  type Wrong (line 1183) | struct Wrong : std::exception {
  type ValueMaybeThrow (line 1186) | struct ValueMaybeThrow {
    method ValueMaybeThrow (line 1188) | explicit ValueMaybeThrow(int i) : value{i} {
  function TYPED_TEST_P (line 1195) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowInsertSeparate) {
  function TYPED_TEST_P (line 1201) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowTryEmplaceFail) {
  function TYPED_TEST_P (line 1209) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowTryEmplaceSucc) {
  function TYPED_TEST_P (line 1215) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowEmplace) {
  function TYPED_TEST_P (line 1221) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowInsertOrAssignInsert) {
  function TYPED_TEST_P (line 1227) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowInsertOrAssignAssign) {
  function TYPED_TEST_P (line 1235) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowAssignAbsent) {
  function TYPED_TEST_P (line 1241) | TYPED_TEST_P(ConcurrentHashMapTest, ValueMaybeThrowAssignPresent) {

FILE: folly/concurrency/test/CoreCachedSharedPtrTest.cpp
  function parallelRun (line 41) | void parallelRun(
  function TEST (line 54) | TEST(CoreCachedSharedPtr, Basic) {
  function TEST (line 86) | TEST(CoreCachedSharedPtr, AtomicCoreCachedSharedPtr) {
  function testAliasingCornerCases (line 130) | void testAliasingCornerCases() {
  function TEST (line 168) | TEST(CoreCachedSharedPtr, AliasingCornerCases) {
  function TEST (line 172) | TEST(CoreCachedSharedPtr, AliasingCornerCasesAtomic) {
  function benchmarkParallelRun (line 179) | size_t benchmarkParallelRun(Operation op, size_t numThreads) {
  function benchmarkSharedPtrAcquire (line 214) | size_t benchmarkSharedPtrAcquire(size_t numThreads) {
  function benchmarkWeakPtrLock (line 219) | size_t benchmarkWeakPtrLock(size_t numThreads) {
  function benchmarkAtomicSharedPtrAcquire (line 225) | size_t benchmarkAtomicSharedPtrAcquire(size_t numThreads) {
  function benchmarkCoreCachedSharedPtrAcquire (line 232) | size_t benchmarkCoreCachedSharedPtrAcquire(size_t numThreads) {
  function benchmarkCoreCachedWeakPtrLock (line 237) | size_t benchmarkCoreCachedWeakPtrLock(size_t numThreads) {
  function benchmarkAtomicCoreCachedSharedPtrAcquire (line 243) | size_t benchmarkAtomicCoreCachedSharedPtrAcquire(size_t numThreads) {
  function benchmarkReadMostlySharedPtrAcquire (line 248) | size_t benchmarkReadMostlySharedPtrAcquire(size_t numThreads) {
  function benchmarkReadMostlyWeakPtrLock (line 253) | size_t benchmarkReadMostlyWeakPtrLock(size_t numThreads) {
  function benchmarkThreadCachedSynchronizedAcquire (line 259) | size_t benchmarkThreadCachedSynchronizedAcquire(size_t numThreads) {
  function BENCHMARK_MULTI (line 304) | BENCHMARK_MULTI(SharedPtrSingleThreadReset) {
  function BENCHMARK_MULTI (line 308) | BENCHMARK_MULTI(AtomicSharedPtrSingleThreadReset) {
  function BENCHMARK_MULTI (line 314) | BENCHMARK_MULTI(CoreCachedSharedPtrSingleThreadReset) {
  function BENCHMARK_MULTI (line 318) | BENCHMARK_MULTI(AtomicCoreCachedSharedPtrSingleThreadReset) {
  function main (line 323) | int main(int argc, char** argv) {

FILE: folly/concurrency/test/DynamicBoundedQueueTest.cpp
  function basic_test (line 48) | void basic_test() {
  function TEST (line 93) | TEST(DynamicBoundedQueue, basic) {
  function move_test (line 105) | void move_test() {
  function TEST (line 136) | TEST(DynamicBoundedQueue, move) {
  function capacity_test (line 148) | void capacity_test() {
  function TEST (line 175) | TEST(DynamicBoundedQueue, capacity) {
  function run_once (line 187) | inline uint64_t run_once(
  function enq_deq_test (line 245) | void enq_deq_test(const int nprod, const int ncons) {
  function TEST (line 308) | TEST(DynamicBoundedQueue, enqDeq) {
  function runBench (line 344) | uint64_t runBench(const std::string& name, int ops, const RepFunc& repFn) {
  function bench (line 376) | uint64_t bench(const int nprod, const int ncons, const std::string& name) {
  class MPMC (line 432) | class MPMC {
    method MPMC (line 436) | explicit MPMC(uint64_t capacity) : q_(capacity) {}
    method enqueue (line 438) | void enqueue(const T& v) { q_.blockingWrite(v); }
    method enqueue (line 440) | void enqueue(T&& v) { q_.blockingWrite(std::move(v)); }
    method try_enqueue (line 442) | bool try_enqueue(const T& v) { return q_.write(v); }
    method try_enqueue (line 444) | bool try_enqueue(const T&& v) { return q_.write(std::move(v)); }
    method try_enqueue_for (line 447) | bool try_enqueue_for(
    method dequeue (line 452) | void dequeue(T& item) { q_.blockingRead(item); }
    method try_dequeue (line 454) | bool try_dequeue(T& item) { return q_.read(item); }
    method try_dequeue_for (line 457) | bool try_dequeue_for(
  class PCQ (line 467) | class PCQ {
    method PCQ (line 471) | explicit PCQ(uint64_t capacity) : q_(capacity) {}
    method enqueue (line 473) | void enqueue(const T&) { ASSERT_TRUE(false); }
    method try_enqueue (line 475) | bool try_enqueue(const T& v) { return q_.write(v); }
    method try_enqueue (line 477) | bool try_enqueue(T&& v) { return q_.write(std::move(v)); }
    method try_enqueue_for (line 480) | bool try_enqueue_for(const T&, const std::chrono::duration<Rep, Period...
    method dequeue (line 484) | void dequeue(T&) { ASSERT_TRUE(false); }
    method try_dequeue (line 486) | bool try_dequeue(T& item) { return q_.read(item); }
    method try_dequeue_for (line 489) | bool try_dequeue_for(T&, const std::chrono::duration<Rep, Period>&) {
  type IntArray (line 498) | struct IntArray {
    method IntArray (line 500) | IntArray() {}
    method IntArray (line 501) | IntArray(int v) {
  function dottedLine (line 509) | void dottedLine() {
  function type_benches (line 515) | void type_benches(const int np, const int nc, const std::string& name) {
  function benches (line 563) | void benches(const int np, const int nc) {
  function TEST (line 572) | TEST(DynamicBoundedQueue, bench) {

FILE: folly/concurrency/test/PriorityUnboundedQueueSetTest.cpp
  class PriorityUnboundedQueueSetTest (line 26) | class PriorityUnboundedQueueSetTest : public testing::Test {}
  function TEST_F (line 28) | TEST_F(PriorityUnboundedQueueSetTest, try_dequeue) {
  function TEST_F (line 34) | TEST_F(PriorityUnboundedQueueSetTest, try_peek) {
  function TEST_F (line 42) | TEST_F(PriorityUnboundedQueueSetTest, size_empty) {
  function TEST_F (line 60) | TEST_F(PriorityUnboundedQueueSetTest, priority_order) {

FILE: folly/concurrency/test/ProcessLocalUniqueIdTest.cpp
  function TEST (line 26) | TEST(ProcessLocalUniqueIdTest, Uniqueness) {

FILE: folly/concurrency/test/SingletonRelaxedCounterBench.cpp
  type PrivateTag (line 32) | struct PrivateTag {}
  function FOLLY_KEEP (line 39) | FOLLY_KEEP void check_singleton_relaxed_counter_add_1() {
  function FOLLY_KEEP (line 42) | FOLLY_KEEP void check_singleton_relaxed_counter_add(size_t i) {
  type folly (line 46) | namespace folly {
    function noop (line 50) | [[gnu::weak]] void noop() noexcept {}
    function BENCHMARK (line 52) | BENCHMARK(MultiThreadPerformance, iters) {
  function main (line 97) | int main(int argc, char** argv) {

FILE: folly/concurrency/test/SingletonRelaxedCounterTest.cpp
  type folly (line 27) | namespace folly {
    type PrivateTag (line 30) | struct PrivateTag {}
    class SingletonRelaxedCounterTest (line 35) | class SingletonRelaxedCounterTest : public testing::Test {}
    function TEST_F (line 37) | TEST_F(SingletonRelaxedCounterTest, Basic) {
    function TEST_F (line 45) | TEST_F(SingletonRelaxedCounterTest, CompatibilityWithThreadLocal) {
    function TEST_F (line 57) | TEST_F(SingletonRelaxedCounterTest, CompatibilityWithThreadLocalMany) {
    function TEST_F (line 74) | TEST_F(SingletonRelaxedCounterTest, MultithreadCorrectness) {
    function TEST_F (line 140) | TEST_F(SingletonRelaxedCounterTest, Countable) {

FILE: folly/concurrency/test/ThreadCachedSynchronizedBench.cpp
  function FOLLY_KEEP (line 23) | FOLLY_KEEP int check_thread_cached_synchronized_int_get(
  type load_fn (line 28) | struct load_fn {
    method T (line 30) | T operator()(folly::relaxed_atomic<T> const& obj) const {
    method T (line 34) | T operator()(folly::Synchronized<T> const& obj) const {
    method T (line 38) | T operator()(folly::thread_cached_synchronized<T> const& obj) const {
  function FOLLY_NOINLINE (line 45) | FOLLY_NOINLINE void bm_read_int(Obj& obj, std::size_t iters) {
  function BENCHMARK (line 55) | BENCHMARK(read_int_atomic, iters) {
  function BENCHMARK (line 60) | BENCHMARK(read_int_synchronized, iters) {
  function BENCHMARK (line 66) | BENCHMARK(read_int_thread_cached_synchronized, iters) {
  function main (line 72) | int main(int argc, char** argv) {

FILE: folly/concurrency/test/ThreadCachedSynchronizedTest.cpp
  class ThreadCachedSynchronizedTest (line 21) | class ThreadCachedSynchronizedTest : public testing::Test {}
  function TEST_F (line 23) | TEST_F(ThreadCachedSynchronizedTest, load_store) {
  function TEST_F (line 44) | TEST_F(ThreadCachedSynchronizedTest, exchange) {
  function TEST_F (line 50) | TEST_F(ThreadCachedSynchronizedTest, compare_exchange_failure) {
  function TEST_F (line 58) | TEST_F(ThreadCachedSynchronizedTest, compare_exchange_success) {
  function TEST_F (line 66) | TEST_F(ThreadCachedSynchronizedTest, swap_member) {
  function TEST_F (line 74) | TEST_F(ThreadCachedSynchronizedTest, swap_free) {
  function TEST_F (line 82) | TEST_F(ThreadCachedSynchronizedTest, not_default_constructible) {

FILE: folly/concurrency/test/UnboundedQueueTest.cpp
  function FOLLY_ATTR_WEAK (line 51) | FOLLY_ATTR_WEAK void noop(folly::Optional<int>&&) {}
  function FOLLY_KEEP (line 53) | FOLLY_KEEP void check_uspsc_mayblock_dequeue_ref(
  function FOLLY_KEEP (line 57) | FOLLY_KEEP bool check_uspsc_mayblock_try_dequeue_ref(
  function FOLLY_KEEP (line 61) | FOLLY_KEEP bool check_uspsc_mayblock_try_dequeue_for_ref(
  function FOLLY_KEEP (line 67) | FOLLY_KEEP bool check_uspsc_mayblock_try_dequeue_until_ref(
  function FOLLY_KEEP (line 74) | FOLLY_KEEP int check_uspsc_mayblock_dequeue_ret(
  function FOLLY_KEEP (line 78) | FOLLY_KEEP void check_uspsc_mayblock_try_dequeue_ret(
  function FOLLY_KEEP (line 82) | FOLLY_KEEP void check_uspsc_mayblock_try_dequeue_for_ret(
  function FOLLY_KEEP (line 86) | FOLLY_KEEP void check_uspsc_mayblock_try_dequeue_until_ret(
  function FOLLY_KEEP (line 92) | FOLLY_KEEP void check_umpmc_mayblock_dequeue_ref(
  function FOLLY_KEEP (line 96) | FOLLY_KEEP bool check_umpmc_mayblock_try_dequeue_ref(
  function FOLLY_KEEP (line 100) | FOLLY_KEEP bool check_umpmc_mayblock_try_dequeue_for_ref(
  function FOLLY_KEEP (line 106) | FOLLY_KEEP bool check_umpmc_mayblock_try_dequeue_until_ref(
  function FOLLY_KEEP (line 113) | FOLLY_KEEP int check_umpmc_mayblock_dequeue_ret(
  function FOLLY_KEEP (line 117) | FOLLY_KEEP void check_umpmc_mayblock_try_dequeue_ret(
  function FOLLY_KEEP (line 121) | FOLLY_KEEP void check_umpmc_mayblock_try_dequeue_for_ret(
  function FOLLY_KEEP (line 125) | FOLLY_KEEP void check_umpmc_mayblock_try_dequeue_until_ret(
  function basic_test (line 132) | void basic_test() {
  function TEST (line 158) | TEST(UnboundedQueue, basic) {
  function timeout_test (line 170) | void timeout_test() {
  function TEST (line 182) | TEST(UnboundedQueue, timeout) {
  function peek_test (line 194) | void peek_test() {
  function TEST (line 210) | TEST(UnboundedQueue, peek) {
  function TEST (line 217) | TEST(UnboundedQueue, cleanupOnDestruction) {
  function run_once (line 245) | inline uint64_t run_once(
  function enq_deq_test (line 300) | void enq_deq_test(const int nprod, const int ncons) {
  function TEST (line 364) | TEST(UnboundedQueue, enqDeq) {
  function runBench (line 400) | uint64_t runBench(const std::string& name, uint64_t ops, const RepFunc& ...
  function bench (line 442) | uint64_t bench(const int nprod, const int ncons, const std::string& name) {
  class MPMC (line 488) | class MPMC {
    method MPMC (line 492) | MPMC() : q_(FLAGS_capacity) {}
    method enqueue (line 495) | void enqueue(Args&&... args) {
    method dequeue (line 499) | void dequeue(T& item) { q_.blockingRead(item); }
    method try_dequeue (line 501) | bool try_dequeue(T& item) { return q_.read(item); }
    method try_dequeue_for (line 504) | bool try_dequeue_for(
  class PCQ (line 515) | class PCQ {
    method PCQ (line 519) | PCQ() : q_(FLAGS_capacity) {}
    method enqueue (line 522) | void enqueue(Args&&... args) {
    method dequeue (line 528) | void dequeue(T&) { ASSERT_TRUE(false); }
    method try_dequeue (line 530) | bool try_dequeue(T& item) { return q_.read(item); }
    method try_dequeue_for (line 533) | bool try_dequeue_for(T&, const std::chrono::duration<Rep, Period>&) no...
  type IntArray (line 542) | struct IntArray {
    method IntArray (line 544) | IntArray() {}
    method IntArray (line 545) | IntArray(int v) {
  function dottedLine (line 553) | void dottedLine() {
  function type_benches (line 560) | void type_benches(const int np, const int nc, const std::string& name) {
  function benches (line 609) | void benches(const int np, const int nc) {
  function TEST (line 618) | TEST(UnboundedQueue, bench) {

FILE: folly/container/Access.h
  function namespace (line 21) | namespace folly {

FILE: folly/container/Array.h
  function namespace (line 33) | namespace folly {
  function namespace (line 70) | namespace array_detail {

FILE: folly/container/BitIterator.h
  function namespace (line 43) | namespace folly {

FILE: folly/container/Enumerate.h
  function namespace (line 56) | namespace folly {
  function Enumerator (line 147) | constexpr Enumerator<BeginIteratorType> begin() {
  function Enumerator (line 150) | constexpr Enumerator<EndIteratorType> end() {

FILE: folly/container/EvictingCacheMap.h
  function namespace (line 30) | namespace folly {
  function setClearSize (line 200) | void setClearSize(std::size_t clearSize) {
  function exists (line 210) | bool exists(const TKey& key) const { return existsImpl(key); }
  function iterator (line 238) | iterator find(const TKey& key) { return findImpl(*this, key); }
  function TValue (line 252) | const TValue& getWithoutPromotion(const TKey& key) const {
  function const_iterator (line 277) | const_iterator findWithoutPromotion(const TKey& key) const {
  function iterator (line 286) | iterator findWithoutPromotion(const TKey& key) {
  function TValue (line 367) | TValue tmp{value}; // can't yet rely on temporary materialization
  function TValue (line 387) | TValue tmp{value}; // can't yet rely on temporary materialization
  function TValue (line 400) | TValue tmp{value}; // can't yet rely on temporary materialization
  function setPruneHook (line 465) | void setPruneHook(PruneHookCall pruneHook) { pruneHook_ = pruneHook; }
  function PruneHookCall (line 467) | PruneHookCall getPruneHook() { return pruneHook_; }
  function iterator (line 492) | iterator begin() { return iterator(lru_.begin()); }
  function iterator (line 493) | iterator end() { return iterator(lru_.end()); }
  function reverse_iterator (line 500) | reverse_iterator rbegin() { return reverse_iterator(lru_.rbegin()); }
  function reverse_iterator (line 501) | reverse_iterator rend() { return reverse_iterator(lru_.rend()); }
  type Node (line 518) | struct Node
  type NodeList (line 536) | struct NodeList
  function THash (line 561) | struct KeyHasher : THash {
  function typename (line 656) | typename NodeList::iterator eraseImpl(
  function clampClearSize (line 744) | static std::size_t clampClearSize(std::size_t clearSize) {

FILE: folly/container/F14Map-fwd.h
  function namespace (line 24) | namespace folly {

FILE: folly/container/F14Map.h
  function namespace (line 49) | namespace folly {

FILE: folly/container/F14Set-fwd.h
  function namespace (line 22) | namespace folly {

FILE: folly/container/F14Set.h
  function namespace (line 46) | namespace folly {
  function FOLLY_ALWAYS_INLINE (line 407) | FOLLY_ALWAYS_INLINE iterator erase(const_iterator pos) {
  function iterator (line 412) | iterator erase(const_iterator first, const_iterator last) {
  function size_type (line 417) | size_type erase(key_type const& key) { return eraseInto(key, variadic_no...
  function FOLLY_ALWAYS_INLINE (line 478) | FOLLY_ALWAYS_INLINE size_type count(key_type const& key) const {
  function F14HashToken (line 505) | F14HashToken prehash(key_type const& key) const {
  function F14HashToken (line 509) | F14HashToken prehash(key_type const& key, std::size_t hash) const {
  function prefetch (line 557) | void prefetch(F14HashToken const& token) const { table_.prefetch(token); }
  function FOLLY_ALWAYS_INLINE (line 563) | FOLLY_ALWAYS_INLINE iterator find(key_type const& key) {
  function FOLLY_ALWAYS_INLINE (line 571) | FOLLY_ALWAYS_INLINE iterator
  function FOLLY_ALWAYS_INLINE (line 609) | FOLLY_ALWAYS_INLINE bool contains(key_type const& key) const {
  function FOLLY_ALWAYS_INLINE (line 619) | FOLLY_ALWAYS_INLINE bool contains(
  function max_load_factor (line 690) | void max_load_factor(float v) { table_.max_load_factor(v); }
  function rehash (line 702) | void rehash(std::size_t bucketCapacity) {
  function reserve (line 716) | void reserve(std::size_t capacity) { table_.reserve(capacity); }
  function containsEqualValue (line 746) | bool containsEqualValue(value_type const& value) const {
  type F14ValueSetTester (line 824) | struct F14ValueSetTester
  function swap (line 847) | void swap(F14ValueSet& rhs) noexcept(Policy::kSwapIsNoexcept) {
  function swap (line 960) | void swap(F14NodeSet& rhs) noexcept(Policy::kSwapIsNoexcept) {
  function iterator (line 1104) | iterator begin() { return cbegin(); }
  function iterator (line 1110) | iterator end() { return cend(); }
  function eraseUnderlyingKey (line 1139) | size_t eraseUnderlyingKey(K const& key, BeforeDestroy&& beforeDestroy) {
  function iterator (line 1154) | iterator erase(const_iterator first, const_iterator last) {
  function eraseInto (line 1188) | size_t eraseInto(key_type const& key, BeforeDestroy&& beforeDestroy) {
  function swap (line 1233) | void swap(F14VectorSet& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {
  function reverse_iterator (line 1263) | reverse_iterator rbegin() { return this->table_.values_; }
  function reverse_iterator (line 1267) | reverse_iterator rend() { return this->table_.values_ + this->table_.siz...
  function iterator (line 1274) | iterator iter(reverse_iterator riter) { return this->table_.iter(riter); }
  function const_iterator (line 1275) | const_iterator iter(const_reverse_iterator riter) const {
  function reverse_iterator (line 1279) | reverse_iterator riter(iterator it) { return this->table_.riter(it); }
  function const_reverse_iterator (line 1280) | const_reverse_iterator riter(const_iterator it) const {
  function friend (line 1284) | friend Range<const_reverse_iterator> tag_invoke(
  function swap (line 1387) | void swap(F14FastSet& rhs) noexcept(Super::Policy::kSwapIsNoexcept) {

FILE: folly/container/FBVector.h
  function namespace (line 50) | namespace folly {
  function namespace (line 77) | namespace folly {
  function D_destroy_range_a (line 357) | void D_destroy_range_a(T* first, T* last) noexcept {
  function S_destroy_range_a (line 366) | static void S_destroy_range_a(Allocator& a, T* first, T* last) noexcept {
  function S_destroy_range (line 373) | static void S_destroy_range(T* first, T* last) noexcept {
  function M_uninitialized_fill_n_e (line 396) | void M_uninitialized_fill_n_e(size_type sz) {
  function M_uninitialized_fill_n_e (line 401) | void M_uninitialized_fill_n_e(size_type sz, VT value) {
  function D_uninitialized_fill_n_a (line 407) | void D_uninitialized_fill_n_a(T* dest, size_type sz) {
  function D_uninitialized_fill_n_a (line 415) | void D_uninitialized_fill_n_a(T* dest, size_type sz, VT value) {
  function rollback (line 432) | auto rollback = makeGuard([&] { S_destroy_range_a(a, dest, b); }
  function S_uninitialized_fill_n (line 441) | static void S_uninitialized_fill_n(T* dest, size_type n) {
  function S_uninitialized_fill_n (line 469) | static void S_uninitialized_fill_n(T* dest, size_type n, const T& value) {
  function rollback (line 525) | auto rollback = makeGuard([&] { S_destroy_range_a(a, dest, b); }
  function rollback (line 536) | auto rollback = makeGuard([&] { S_destroy_range(dest, b); }
  function S_uninitialized_copy_bits (line 543) | static void S_uninitialized_copy_bits(
  function S_uninitialized_copy_bits (line 550) | static void S_uninitialized_copy_bits(
  function T (line 580) | static const T* S_copy_n(T* dest, const T* first, size_type n) {
  function std (line 589) | static std::move_iterator<T*> S_copy_n(
  type std (line 646) | typedef std::bool_constant<
  type std (line 650) | typedef std::bool_constant<
  function relocate_move (line 656) | void relocate_move(T* dest, T* first, T* last) {
  function relocate_move_or_memcpy (line 660) | void relocate_move_or_memcpy(T* dest, T* first, T* last, std::true_type) {
  function relocate_move_or_memcpy (line 666) | void relocate_move_or_memcpy(T* dest, T* first, T* last, std::false_type) {
  function relocate_move_or_copy (line 670) | void relocate_move_or_copy(T* dest, T* first, T* last, std::true_type) {
  function relocate_move_or_copy (line 674) | void relocate_move_or_copy(T* dest, T* first, T* last, std::false_type) {
  function relocate_done (line 679) | void relocate_done(T* /*dest*/, T* first, T* last) noexcept {
  function relocate_undo (line 688) | void relocate_undo(T* dest, T* first, T* last) noexcept {
  function explicit (line 710) | explicit fbvector(const Allocator& a) : impl_(a) {}
  function impl_ (line 728) | fbvector(const fbvector& other)
  function fbvector (line 737) | fbvector(const fbvector& other, const Allocator& a)
  function impl_ (line 740) | impl_(a) {
  function impl_ (line 837) | impl_(a) {
  function moveFrom (line 844) | void moveFrom(fbvector&& other, std::true_type) { swap(impl_, other.impl...
  function moveFrom (line 845) | void moveFrom(fbvector&& other, std::false_type) {
  function dataIsInternalAndNotVT (line 888) | bool dataIsInternalAndNotVT(const T& t) {
  function dataIsInternal (line 895) | bool dataIsInternal(const T& t) {
  function iterator (line 906) | iterator end() noexcept { return impl_.e_; }
  function reverse_iterator (line 908) | reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
  function const_reverse_iterator (line 909) | const_reverse_iterator rbegin() const noexcept {
  function const_reverse_iterator (line 913) | const_reverse_iterator rend() const noexcept {
  function const_reverse_iterator (line 919) | const_reverse_iterator crbegin() const noexcept {
  function resize (line 937) | void resize(size_type n) {
  function resize (line 946) | void resize(size_type n, VT t) {
  function reserve (line 963) | void reserve(size_type n) {
  function shrink_to_fit (line 986) | void shrink_to_fit() noexcept {
  function const_reference (line 1057) | const_reference operator[](size_type n) const {
  function const_reference (line 1061) | const_reference at(size_type n) const {
  function reference (line 1068) | reference at(size_type n) {
  function reference (line 1072) | reference front() {
  function reference (line 1080) | reference back() {
  function T (line 1094) | const T* data() const noexcept { return impl_.b_; }
  function push_back (line 1111) | void push_back(const T& value) {
  function push_back (line 1120) | void push_back(T&& value) {
  function pop_back (line 1129) | void pop_back() {
  function swap (line 1135) | void swap(fbvector& other) noexcept {
  function clear (line 1144) | void clear() noexcept { M_destroy_range_e(impl_.b_); }
  function emplace_back_aux_xallocx (line 1178) | static bool emplace_back_aux_xallocx(
  function rollback1 (line 1231) | auto rollback1 = makeGuard([&] { M_deallocate(newB, sz); }
  function rollback2 (line 1244) | auto rollback2 = makeGuard([&] { M_destroy(newE - 1); }
  function iterator (line 1266) | iterator erase(const_iterator first, const_iterator last) {
  function size_type (line 1301) | size_type computeInsertCapacity(size_type n) {
  function make_window (line 1362) | void make_window(iterator position, size_type n) {
  function undo_window (line 1394) | void undo_window(iterator position, size_type n) noexcept {
  function wrap_frame (line 1402) | void wrap_frame(T* ledge, size_type idx, size_type n) {
  function insert_use_fresh (line 1421) | bool insert_use_fresh(bool at_end, size_type n) {
  function rollback (line 1485) | auto rollback = makeGuard([&] {
  function rollback (line 1503) | auto rollback = makeGuard([&] {
  function iterator (line 1535) | iterator insert(const_iterator cpos, const T& value) {
  function iterator (line 1545) | iterator insert(const_iterator cpos, T&& value) {
  function iterator (line 1555) | iterator insert(const_iterator cpos, size_type n, VT value) {
  function iterator (line 1572) | iterator insert(const_iterator cpos, std::initializer_list<T> il) {
  function namespace (line 1660) | namespace detail {

FILE: folly/container/Foreach-inl.h
  function namespace (line 31) | namespace folly {

FILE: folly/container/Foreach.h
  function namespace (line 24) | namespace folly {

FILE: folly/container/HeterogeneousAccess-fwd.h
  function namespace (line 19) | namespace folly {

FILE: folly/container/HeterogeneousAccess.h
  function namespace (line 30) | namespace folly {

FILE: folly/container/IntrusiveHeap.h
  function namespace (line 36) | namespace folly {
  function update (line 153) | void update(T* x) {
  function push (line 158) | void push(T* x) {
  function erase (line 168) | void erase(T* x) {
  function contains (line 191) | bool contains(const T* x) const {
  function merge (line 203) | void merge(IntrusiveHeap other) {
  function FOLLY_ALWAYS_INLINE (line 221) | FOLLY_ALWAYS_INLINE static void merge(
  function Node (line 250) | static Node* asNode(T* x) { return NodeTraits::asNode(x); }
  function Node (line 252) | static const Node* asNode(const T* x) {
  function T (line 256) | static T* asT(Node* n) { return NodeTraits::asT(n); }
  function T (line 258) | static const T* asT(const Node* n) {
  function compare (line 262) | static bool compare(const Node* a, const Node* b) {

FILE: folly/container/IntrusiveList.h
  function namespace (line 26) | namespace folly {

FILE: folly/container/Iterator.h
  function namespace (line 32) | namespace folly {
  function namespace (line 202) | namespace detail {
  function namespace (line 257) | namespace detail {
  function iter (line 280) | container(std::addressof(c)), iter(std::move(i)) {}
  function explicit (line 295) | explicit EmplaceFront(Container& c) : container(std::addressof(c)) {}
  function explicit (line 308) | explicit EmplaceBack(Container& c) : container(std::addressof(c)) {}
  function reference (line 727) | constexpr reference operator*() const {
  function pointer (line 731) | pointer operator->() const {

FILE: folly/container/MapUtil.h
  function namespace (line 34) | namespace folly {
  function namespace (line 249) | namespace detail {

FILE: folly/container/Merge.h
  function namespace (line 43) | namespace folly {

FILE: folly/container/RegexMatchCache.cpp
  type folly (line 32) | namespace folly {
    function quote (line 34) | static std::string quote(std::string_view const s) {
    class RegexMatchCache::RegexObject (line 38) | class RegexMatchCache::RegexObject {
      method RegexObject (line 43) | explicit RegexObject(std::string_view const regex)
    type RegexMatchCache::ConsistencyReportMatcher::state (line 103) | struct RegexMatchCache::ConsistencyReportMatcher::state {

FILE: folly/container/RegexMatchCache.h
  function namespace (line 38) | namespace folly {
  function data_ (line 277) | uintptr_t data_{}
  function contains_index (line 293) | bool contains_index(size_t index) const noexcept {
  function contains_value (line 297) | bool contains_value(Value const& value) const noexcept {
  function rollback_forward (line 304) | auto rollback_forward = makeGuard([&, iter_ = iter] {
  function rollback_free (line 315) | auto rollback_free = makeGuard([&] {
  function erase_value (line 326) | bool erase_value(Value const& value) noexcept {
  function clear (line 339) | void clear() noexcept {
  function Value (line 345) | Value const& value_at_index(size_t index) const { return reverse_.at(ind...
  function index_of_value (line 347) | size_t index_of_value(Value const& value) const { return forward_.at(val...
  function class (line 349) | class forward_view {
  function class (line 385) | class RegexMatchCacheKey : public RegexMatchCacheKeyBase {
  function namespace (line 393) | namespace std {
  function explicit (line 417) | explicit RegexMatchCacheKeyAndView(std::string_view regex) noexcept
  function class (line 479) | class RegexMatchCache {

FILE: folly/container/Reserve.h
  function namespace (line 26) | namespace folly {
  function grow_capacity_by_fn (line 85) | inline constexpr grow_capacity_by_fn grow_capacity_by{}
  type reserve_if_available_fn (line 94) | struct reserve_if_available_fn {
  function reserve_if_available_fn (line 107) | inline constexpr reserve_if_available_fn reserve_if_available{}

FILE: folly/container/SparseByteSet.h
  function namespace (line 24) | namespace folly {

FILE: folly/container/StdBitset.h
  function namespace (line 27) | namespace folly {
  function std_bitset_find_first_fn (line 120) | inline constexpr std_bitset_find_first_fn std_bitset_find_first{}
  type std_bitset_find_next_fn (line 122) | struct std_bitset_find_next_fn {
  function std_bitset_find_next_fn (line 149) | inline constexpr std_bitset_find_next_fn std_bitset_find_next{}

FILE: folly/container/View.h
  function namespace (line 23) | namespace folly {

FILE: folly/container/WeightedEvictingCacheMap.h
  function namespace (line 23) | namespace folly {
  type ValueAndWeight (line 399) | struct ValueAndWeight {
  type WeightFn (line 409) | struct WeightFn {
  function explicit (line 424) | explicit WeightedEvictingCacheMap(
  function iterator (line 445) | iterator begin() { return iwecm_.ecm_.begin(); }
  function iterator (line 446) | iterator end() { return iwecm_.ecm_.end(); }
  function reverse_iterator (line 454) | reverse_iterator rbegin() { return iwecm_.ecm_.rbegin(); }
  function reverse_iterator (line 455) | reverse_iterator rend() { return iwecm_.ecm_.rend(); }
  function setMaxTotalWeight (line 492) | void setMaxTotalWeight(std::size_t newMaxTotalWeight) {
  function weight (line 543) | size_t weight) {

FILE: folly/container/detail/BitIteratorDetail.h
  function namespace (line 26) | namespace folly {
  type boost (line 73) | typedef boost::iterator_adaptor<

FILE: folly/container/detail/BoolWrapper.h
  function namespace (line 19) | namespace folly {

FILE: folly/container/detail/F14Defaults.h
  function namespace (line 23) | namespace folly {

FILE: folly/container/detail/F14IntrinsicsAvailability.h
  function namespace (line 57) | namespace folly {

FILE: folly/container/detail/F14MapFallback.h
  function namespace (line 37) | namespace folly {
  function iterator (line 124) | iterator insert(const_iterator /*hint*/, value_type const& value) {
  function iterator (line 134) | iterator insert(const_iterator /*hint*/, value_type&& value) {
  function insert (line 151) | void insert(std::initializer_list<value_type> ilist) {
  function const (line 282) | [[noreturn]] bool operator()(K2 const&, K2 const&) const {
  function mapped_type (line 330) | mapped_type const& at(key_type const& key) const { return Super::at(key); }
  function size_type (line 349) | size_type count(key_type const& key) const { return Super::count(key); }
  function contains (line 356) | bool contains(key_type const& key) const { return count(key) != 0; }
  function const_iterator (line 397) | const_iterator find(key_type const& key) const { return Super::find(key); }
  function const_iterator (line 446) | const_iterator prev{pos};
  function containsEqualValue (line 491) | bool containsEqualValue(value_type const& value) const {
  function F14HashToken (line 572) | F14HashToken prehash(key_type const&) const {
  function F14HashToken (line 575) | F14HashToken prehash(key_type const&, std::size_t) const {

FILE: folly/container/detail/F14Mask.h
  function namespace (line 32) | namespace folly {

FILE: folly/container/detail/F14Policy.h
  function isAvalanchingHasher (line 170) | static constexpr bool isAvalanchingHasher() {
  function shouldAssume32BitHash (line 174) | static constexpr bool shouldAssume32BitHash() {
  function swapBasePolicy (line 266) | void swapBasePolicy(BasePolicy& rhs) {
  function computeKeyHash (line 286) | size_t computeKeyHash(K const& key) const {
  function Key (line 296) | Key const& keyForValue(Key const& v) const { return v; }
  function Key (line 297) | Key const& keyForValue(std::pair<Key const, MappedOrBool> const& p) const {
  function Key (line 300) | Key const& keyForValue(std::pair<Key&&, MappedOrBool&&> const& p) const {
  function operator (line 458) | operator ValueContainerIterator<ValueConstPtr>() const {
  function reference (line 462) | reference operator*() const { return underlying_.item(); }
  function pointer (line 464) | pointer operator->() const {
  function explicit (line 491) | explicit ValueContainerIterator(ItemIter const& underlying)
  function prefetchBeforeRehash (line 555) | static constexpr bool prefetchBeforeRehash() { return false; }
  function prefetchBeforeCopy (line 557) | static constexpr bool prefetchBeforeCopy() { return false; }
  function prefetchBeforeDestroy (line 559) | static constexpr bool prefetchBeforeDestroy() { return false; }
  function destroyItemOnClear (line 561) | static constexpr bool destroyItemOnClear() {
  function swapPolicy (line 569) | void swapPolicy(ValueContainerPolicy& rhs) { this->swapBasePolicy(rhs); }
  function Value (line 585) | Value const& buildArgForItem(Item const& item) const& { return item; }
  function buildArgForItem (line 588) | decltype(auto) buildArgForItem(Item& item) && {
  function Value (line 592) | Value const& valueAtItem(Item const& item) const { return item; }
  function moveItemDuringRehash (line 620) | void moveItemDuringRehash(Item* itemAddr, Item& src) {
  function destroyItem (line 640) | void destroyItem(Item& item) noexcept {
  function ConstIter (line 666) | ConstIter makeConstIter(ItemIter const& underlying) const {
  function operator (line 702) | operator NodeContainerIterator<ValueConstPtr>() const {
  function reference (line 706) | reference operator*() const { return *underlying_.item(); }
  function pointer (line 708) | pointer operator->() const {
  function explicit (line 735) | explicit NodeContainerIterator(ItemIter const& underlying)
  function prefetchBeforeRehash (line 798) | static constexpr bool prefetchBeforeRehash() { return true; }
  function prefetchBeforeCopy (line 800) | static constexpr bool prefetchBeforeCopy() { return true; }
  function prefetchBeforeDestroy (line 802) | static constexpr bool prefetchBeforeDestroy() {
  function destroyItemOnClear (line 806) | static constexpr bool destroyItemOnClear() { return true; }
  function swapPolicy (line 811) | void swapPolicy(NodeContainerPolicy& rhs) { this->swapBasePolicy(rhs); }
  function Value (line 824) | Value const& buildArgForItem(Item const& item) const& { return *item; }
  function buildArgForItem (line 827) | decltype(auto) buildArgForItem(Item& item) && {
  function Value (line 831) | Value const& valueAtItem(Item const& item) const { return *item; }
  function Item (line 840) | new (itemAddr) Item{AllocTraits::allocate(a, 1)};
  function moveItemDuringRehash (line 849) | void moveItemDuringRehash(Item* itemAddr, Item& src) {
  function moveItemDuringRehash (line 1226) | void moveItemDuringRehash(Item* itemAddr, Item& src) { *itemAddr = src; }
  function prefetchValue (line 1228) | void prefetchValue(Item const& item) const {
  function destroyItem (line 1232) | void destroyItem(Item&) noexcept {}
  function transfer (line 1244) | void transfer(Alloc& a, Value* src, Value* dst, std::size_t n) {
  function beforeBuild (line 1301) | bool beforeBuild(
  function beforeBuild (line 1308) | bool beforeBuild(
  function allocSize (line 1343) | static std::size_t allocSize(
  function Iter (line 1459) | Iter linearEnd() const { return Iter{nullptr, nullptr}; }
  function ConstIter (line 1473) | ConstIter makeConstIter(ItemIter const& underlying) const {
  function Item (line 1477) | Item iterToIndex(ConstIter const& iter) const {
  function Iter (line 1483) | Iter indexToIter(Item index) const { return Iter{values_ + index, values...

FILE: folly/container/detail/F14SetFallback.h
  function namespace (line 36) | namespace f14 {
  function containsEqualValue (line 355) | bool containsEqualValue(value_type const& value) const {

FILE: folly/container/detail/F14Table.cpp
  type folly (line 22) | namespace folly {
    type f14 (line 23) | namespace f14 {
      type detail (line 24) | namespace detail {
        function tlsPendingSafeInserts (line 35) | bool tlsPendingSafeInserts(std::ptrdiff_t delta) {
        function tlsMinstdRand (line 50) | std::size_t tlsMinstdRand(std::size_t n) {

FILE: folly/container/detail/F14Table.h
  function namespace (line 100) | namespace folly {
  function namespace (line 210) | namespace f14 {
  function class (line 217) | class F14HashToken final {
  function F14HashedKey (line 422) | F14HashedKey final {
  function typename (line 1313) | typename ItemIter::Packed packedBegin_{ItemIter{}.pack()}
  function setSize (line 1322) | void setSize(uint64_t sz) { sizeAndChunkShift_.setSize(sz); }
  function incrementSize (line 1324) | void incrementSize() { sizeAndChunkShift_.setSize(size() + 1); }
  function decrementSize (line 1326) | void decrementSize() { sizeAndChunkShift_.setSize(size() - 1); }
  function setChunkCount (line 1328) | void setChunkCount(std::size_t count) {
  function typename (line 1332) | typename ItemIter::Packed& packedBegin() { return packedBegin_; }
  function swap (line 1336) | void swap(SizeAndChunkShiftAndPackedBegin& rhs) noexcept {
  function setSize (line 1354) | void setSize(uint64_t sz) { sizeAndChunkShift_.setSize(sz); }
  function incrementSize (line 1356) | void incrementSize() { sizeAndChunkShift_.setSize(size() + 1); }
  function decrementSize (line 1358) | void decrementSize() { sizeAndChunkShift_.setSize(size() - 1); }
  function setChunkCount (line 1360) | void setChunkCount(std::size_t count) {
  function typename (line 1364) | [[noreturn]] typename ItemIter::Packed& packedBegin() {
  function typename (line 1368) | [[noreturn]] typename ItemIter::Packed const& packedBegin() const {
  function ChunkPtr (line 1441) | ChunkPtr chunkAt(std::size_t i) const {
  function swapContents (line 1450) | void swapContents(F14Table& rhs) noexcept {
  function Policy (line 1460) | noexcept(Policy::kDefaultConstructIsNoexcept)
  function Policy (line 1473) | F14Table(F14Table const& rhs) : Policy{rhs}
  function noexcept (line 1487) | noexcept(kAllocIsAlwaysEqual)
  function swap (line 1539) | void swap(F14Table& rhs) noexcept(kSwapIsNoexcept) {
  function computeCapacity (line 1559) | static std::size_t computeCapacity(
  function else (line 1577) | else if (desiredCapacity <= 6) {
  function chunkAllocSize (line 1625) | static std::size_t chunkAllocSize(
  function ChunkPtr (line 1638) | ChunkPtr initializeChunks(
  function max_load_factor (line 1695) | void max_load_factor(float) noexcept {
  function FOLLY_ALWAYS_INLINE (line 1765) | FOLLY_ALWAYS_INLINE auto loadNeedleV(std::size_t needle) const {
  function Prefetch (line 1775) | enum class Prefetch { DISABLED, ENABLED };
  function prefetch (line 1857) | void prefetch(F14HashToken const& token) const {
  function ItemIter (line 1864) | ItemIter find(K const& key) const {
  function ItemIter (line 1884) | ItemIter
  function ItemIter (line 1895) | ItemIter findMatching(K const& key, F&& func) const {
  function eraseBlank (line 1948) | void eraseBlank(ItemIter iter, HashPair hp) {
  function FOLLY_NOINLINE (line 1969) | [[FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE static void eraseBlankCold(
  function adjustSizeAndBeginBeforeErase (line 1975) | void adjustSizeAndBeginBeforeErase(ItemIter iter) {
  function ItemIter (line 2003) | ItemIter allocateTag(uint8_t* fullness, HashPair hp) {
  function ByteAlloc (line 2144) | ByteAlloc a{this->alloc()};
  function ByteAlloc (line 2149) | ByteAlloc a{this->alloc()};
  function HashPair (line 2199) | HashPair hp{srcChunkIndex, srcChunk->tag(i)};
  function FOLLY_NOINLINE (line 2229) | [[FOLLY_ATTR_GNU_COLD]] FOLLY_NOINLINE static void buildFromF14TableCatc...
  function maybeRehash (line 2268) | void maybeRehash(std::size_t desiredCapacity, bool attemptExact) {
  function reserveImpl (line 2289) | void reserveImpl(std::size_t requestedCapacity) {
  function FOLLY_NOINLINE (line 2316) | FOLLY_NOINLINE void reserveForInsertImpl(
  function initialReserve (line 2348) | void initialReserve(std::size_t desiredCapacity) {
  function rehashImpl (line 2378) | void rehashImpl(
  function HashPair (line 2918) | HashPair hp{ci, tag};
  function namespace (line 2955) | namespace f14 {

FILE: folly/container/detail/Util.h
  function namespace (line 30) | namespace folly {

FILE: folly/container/detail/tape_detail.h
  function reference (line 43) | static constexpr reference make(iterator f, iterator l) {
  function reference (line 63) | static constexpr reference make(iterator f, iterator l) {
  type fake_type (line 72) | struct fake_type {}

FILE: folly/container/detail/test/BoolWrapperTest.cpp
  type folly (line 21) | namespace folly {
    function TEST (line 23) | TEST(BoolWrapperTest, Default) {
    function TEST (line 27) | TEST(BoolWrapperTest, BoolConversion) {

FILE: folly/container/detail/test/F14DetailTest.cpp
  type F14HashedKeyTest (line 25) | struct F14HashedKeyTest : testing::Test {}
  function TEST_F (line 27) | TEST_F(F14HashedKeyTest, string) {
  function TEST_F (line 47) | TEST_F(F14HashedKeyTest, transparent) {
  function TEST (line 88) | TEST(F14SizeAndChunkShift, packed) {

FILE: folly/container/heap_vector_types.h
  function namespace (line 108) | namespace folly {
  function noexcept (line 674) | const noexcept {
  function explicit (line 678) | explicit value_compare_set(const Compare& c) noexcept(
  type EBO (line 715) | struct EBO
  function reference (line 856) | reference operator*() const { return *ptr_; }
  function pointer (line 857) | pointer operator->() const {
  function m_ (line 901) | heap_vector_container(
  function explicit (line 917) | explicit heap_vector_container(const Allocator& alloc)
  function explicit (line 920) | explicit heap_vector_container(
  function explicit (line 962) | explicit heap_vector_container(
  function swap_container (line 1004) | void swap_container(Container& newContainer) {
  function swap_container (line 1010) | void swap_container(sorted_unique_t, Container& newContainer) {
  function iterator (line 1031) | iterator begin() {
  function iterator (line 1039) | iterator end() { return iterator(m_.cont_.end(), &m_.cont_); }
  function reverse_iterator (line 1062) | reverse_iterator rbegin() { return reverse_iterator(end()); }
  function reverse_iterator (line 1063) | reverse_iterator rend() { return reverse_iterator(begin()); }
  function clear (line 1077) | void clear() { return m_.cont_.clear(); }
  function reserve (line 1081) | void reserve(size_type s) { return m_.cont_.reserve(s); }
  function shrink_to_fit (line 1082) | void shrink_to_fit() { m_.cont_.shrink_to_fit(); }
  function value_type (line 1084) | const value_type* data() const noexcept { return m_.cont_.data(); }
  function iterator (line 1113) | iterator insert(const_iterator /* hint */, const value_type& value) {
  function iterator (line 1117) | iterator insert(const_iterator /* hint */, value_type&& value) {
  function insert (line 1135) | void insert(std::initializer_list<value_type> ilist) {
  function g (line 1147) | auto g = makeGuard([&]() {
  function iterator (line 1168) | iterator emplace_hint(const_iterator hint, const value_type& value) {
  function iterator (line 1172) | iterator emplace_hint(const_iterator hint, value_type&& value) {
  function size_type (line 1176) | size_type erase(const key_type& key) {
  function iterator (line 1185) | iterator erase(const_iterator it) {
  function iterator (line 1193) | iterator erase(const_iterator first, const_iterator last) {
  function iterator (line 1211) | iterator find(const key_type& key) { return find_(*this, key); }
  function const_iterator (line 1213) | const_iterator find(const key_type& key) const { return find_(*this, key...
  function size_type (line 1225) | size_type count(const key_type& key) const {
  function contains (line 1234) | bool contains(const key_type& key) const { return find(key) != end(); }
  function iterator (line 1241) | iterator lower_bound(const key_type& key) { return lower_bound(*this, ke...
  function const_iterator (line 1243) | const_iterator lower_bound(const key_type& key) const {
  function iterator (line 1257) | iterator upper_bound(const key_type& key) { return upper_bound(*this, ke...
  function const_iterator (line 1259) | const_iterator upper_bound(const key_type& key) const {
  function swap (line 1294) | void swap(heap_vector_container& o) noexcept(
  function noexcept (line 1334) | const noexcept {
  type EBO (line 1341) | struct EBO
  function explicit (line 1342) | explicit EBO(const value_compare& c, const Allocator& alloc) noexcept(
  function cmp (line 1382) | auto cmp = [&](auto const& a) { return c(self.m_.getKey(a), key); }
  function reverseCmp (line 1383) | auto reverseCmp = [&](auto const& a) { return c(key, self.m_.getKey(a)); }
  function cmp (line 1394) | auto cmp = [&](auto const& a) { return c(key, self.m_.getKey(a)); }
  function namespace (line 1454) | namespace pmr {
  function mapped_type (line 1551) | const mapped_type& at(const key_type& key) const {
  function namespace (line 1583) | namespace pmr {
  function iterator (line 1655) | iterator find(const key_type key) {
  function const_iterator (line 1662) | const_iterator find(const key_type key) const {
  function size_type (line 1671) | inline size_type find_(Self& self, K const key) {

FILE: folly/container/irange.h
  function namespace (line 24) | namespace folly {

FILE: folly/container/range_traits.h
  function namespace (line 28) | namespace folly {

FILE: folly/container/small_vector.h
  function namespace (line 68) | namespace small_vector_policy {
  function last_matching_ (line 91) | size_t last_matching_() {
  function namespace (line 138) | namespace detail {
  function isHeapifiedCapacity (line 269) | struct IntegralSizePolicyBase {
  function setSize (line 308) | void setSize(std::size_t sz) {
  function incrementSize (line 313) | void incrementSize(std::size_t n) {
  function swapSizePolicy (line 322) | void swapSizePolicy(IntegralSizePolicyBase& o) { std::swap(size_, o.size...
  function resetSizePolicy (line 324) | void resetSizePolicy() { size_ = 0; }
  type IntegralSizePolicy (line 345) | struct IntegralSizePolicy
  function rollback (line 361) | auto rollback = makeGuard([&] {
  function FOLLY_PUSH_WARNING (line 400) | FOLLY_PUSH_WARNING
  function rollback (line 412) | auto rollback = makeGuard([&] { std::destroy_n(out, pos + 1); }
  function namespace (line 486) | namespace small_vector_detail {
  function MaxInline (line 513) | static constexpr std::size_t MaxInline{
  function explicit (line 587) | explicit small_vector(size_type n) {
  function constructImpl (line 1219) | void constructImpl(size_type n, value_type const& val, std::true_type) {
  function size_type (line 1229) | size_type computeNewSize() const {
  function makeSizeInternal (line 1272) | void makeSizeInternal(
  function setCapacity (line 1353) | void setCapacity(size_type newCapacity) {
  function InternalSizeType (line 1371) | InternalSizeType getCapacity() const {
  function setCapacity (line 1383) | struct HeapPtr {
  type AllocationSize (line 1430) | struct AllocationSize {
  function freeHeap (line 1462) | void freeHeap() {
  function value_type (line 1486) | value_type* buffer() noexcept {
  function value_type (line 1490) | value_type const* buffer() const noexcept {
  function value_type (line 1493) | value_type* heap() noexcept { return pdata_.heap_; }
  function value_type (line 1494) | value_type const* heap() const noexcept { return pdata_.heap_; }
  function setCapacity (line 1497) | void setCapacity(InternalSizeType c) { pdata_.setCapacity(c); }
  function swap (line 1507) | void swap(small_vector<T, MaxInline, P>& a, small_vector<T, MaxInline, P...
  function erase (line 1512) | void erase(small_vector<T, MaxInline, P>& v, U value) {
  function erase_if (line 1517) | void erase_if(small_vector<T, MaxInline, P>& v, Predicate predicate) {
  function namespace (line 1523) | namespace detail {
  type is_small_vector (line 1536) | struct is_small_vector
  function namespace (line 1549) | namespace std {

FILE: folly/container/sorted_vector_types.h
  function namespace (line 84) | namespace folly {
  type EBO (line 283) | struct EBO
  function explicit (line 324) | explicit sorted_vector_set(const Allocator& alloc) : m_(Compare(), alloc...
  function direct_mutation_guard (line 419) | direct_mutation_guard get_container_for_direct_mutation(
  function swap (line 739) | void swap(sorted_vector_set& o) noexcept(
  type EBO (line 790) | struct EBO
  function explicit (line 791) | explicit EBO(const Compare& c, const Allocator& alloc) noexcept(
  function namespace (line 922) | namespace pmr {
  type EBO (line 969) | struct EBO
  function Compare (line 979) | struct value_compare : private Compare {
  function explicit (line 1017) | explicit sorted_vector_map(const Allocator& alloc)
  function direct_mutation_guard (line 1109) | direct_mutation_guard get_container_for_direct_mutation(
  function swap (line 1482) | void swap(sorted_vector_map& o) {
  type EBO (line 1530) | struct EBO
  function explicit (line 1531) | explicit EBO(const value_compare& c, const Allocator& alloc) noexcept(
  function namespace (line 1733) | namespace pmr {

FILE: folly/container/span.h
  function namespace (line 42) | namespace fallback_span {
  function pointer (line 173) | constexpr pointer data() const noexcept { return data_; }
  function size_type (line 175) | constexpr size_type size_bytes() const noexcept {
  function iterator (line 180) | constexpr iterator begin() const noexcept { return data_; }
  function reverse_iterator (line 182) | constexpr reverse_iterator rbegin() const noexcept {
  function reference (line 197) | constexpr reference operator[](size_type const idx) const {

FILE: folly/container/tape.h
  function namespace (line 38) | namespace folly {
  function push_back_unsafe (line 274) | void push_back_unsafe(const_reference r) {
  function iterator (line 301) | iterator insert(
  function iterator (line 306) | iterator insert(const_iterator pos, const_reference r) {
  function reserve (line 311) | void reserve(size_type records, size_type elements) {
  function reserve (line 317) | void reserve(size_type records) {
  function shrink_to_fit (line 322) | void shrink_to_fit() {
  function clear (line 333) | void clear() noexcept {
  function pop_back (line 340) | void pop_back() noexcept {
  function iterator (line 347) | iterator erase(const_iterator pos) {
  function reference (line 371) | reference scalars() const {
  function commit (line 419) | void commit() { self_->markers_.push_back(self_->data_.size()); }
  function abort (line 422) | void abort() { self_->data_.resize(self_->markers_.back()); }
  function iterator (line 426) | [[nodiscard]] iterator begin() noexcept {
  function const_iterator (line 432) | [[nodiscard]] const_iterator cbegin() const noexcept { return begin(); }
  function const_iterator (line 438) | [[nodiscard]] const_iterator cend() const noexcept { return end(); }
  function reference (line 454) | [[nodiscard]] reference operator[](size_type i) noexcept {
  function const_reference (line 458) | [[nodiscard]] const_reference operator[](size_type i) const noexcept {
  function reference (line 462) | [[nodiscard]] reference at(size_type i) {
  function const_reference (line 470) | [[nodiscard]] const_reference at(size_type i) const {
  function reference (line 478) | [[nodiscard]] reference back() { return self_->data_.back(); }
  function explicit (line 486) | explicit record_builder(tape& self) : self_(&self) {}

FILE: folly/container/test/AccessTest.cpp
  class AccessTest (line 25) | class AccessTest : public testing::Test {}
  function TEST_F (line 27) | TEST_F(AccessTest, size_vector) {
  function TEST_F (line 31) | TEST_F(AccessTest, size_array) {
  function TEST_F (line 37) | TEST_F(AccessTest, size_carray) {
  function TEST_F (line 43) | TEST_F(AccessTest, size_initializer_list) {
  function TEST_F (line 47) | TEST_F(AccessTest, empty_vector) {
  function TEST_F (line 52) | TEST_F(AccessTest, empty_array) {
  function TEST_F (line 65) | TEST_F(AccessTest, empty_carray) {
  function TEST_F (line 72) | TEST_F(AccessTest, empty_initializer_list) {
  function TEST_F (line 77) | TEST_F(AccessTest, data_vector) {
  function TEST_F (line 84) | TEST_F(AccessTest, data_array) {
  function TEST_F (line 90) | TEST_F(AccessTest, data_carray) {
  function TEST_F (line 96) | TEST_F(AccessTest, data_initializer_list) {
  function TEST_F (line 100) | TEST_F(AccessTest, begin_vector) {
  function TEST_F (line 105) | TEST_F(AccessTest, begin_array) {
  function TEST_F (line 110) | TEST_F(AccessTest, begin_carray) {
  function TEST_F (line 115) | TEST_F(AccessTest, begin_initializer_list) {
  function TEST_F (line 120) | TEST_F(AccessTest, end_vector) {
  function TEST_F (line 125) | TEST_F(AccessTest, end_array) {
  function TEST_F (line 130) | TEST_F(AccessTest, end_carray) {
  function TEST_F (line 135) | TEST_F(AccessTest, end_initializer_list) {

FILE: folly/container/test/ArrayTest.cpp
  function TEST (line 26) | TEST(makeArray, baseCase) {
  function TEST (line 34) | TEST(makeArray, deduceSizePrimitive) {
  function TEST (line 42) | TEST(makeArray, deduceSizeClass) {
  function TEST (line 51) | TEST(makeArray, deduceEverything) {
  function TEST (line 60) | TEST(makeArray, fixedCommonType) {
  function TEST (line 68) | TEST(makeArray, deducedCommonType) {
  function TEST (line 76) | TEST(makeArrayWith, example) {

FILE: folly/container/test/BitIteratorBench.cpp
  function simpleFFS (line 32) | BitIterator<BaseIter> simpleFFS(
  function runFFSTest (line 38) | void runFFSTest(FFS fn) {
  function runSimpleFFSTest (line 78) | void runSimpleFFSTest(int iters) {
  function runRealFFSTest (line 84) | void runRealFFSTest(int iters) {
  function BENCHMARK (line 92) | BENCHMARK(SimpleFFSTest, iters) {
  function BENCHMARK (line 95) | BENCHMARK(RealFFSTest, iters) {
  function main (line 108) | int main(int argc, char** argv) {

FILE: folly/container/test/BitIteratorTest.cpp
  function checkIt (line 32) | void checkIt(INT exp, IT& it) {
  function checkRange (line 44) | void checkRange(INT exp, IT begin, IT end) {
  function TEST (line 58) | TEST(BitIterator, Simple) {
  function TEST (line 80) | TEST(BitIterator, Const) {
  function TEST (line 89) | TEST(BitIterator, IteratorCategory) {

FILE: folly/container/test/CollectionUtilTest.cpp
  function TEST (line 35) | TEST(CollectionUtilTest, simpleContains) {
  function TEST (line 71) | TEST(CollectionUtilTest, vectorContains) {
  function TEST (line 85) | TEST(CollectionUtilTest, hasContains) {
  class OnlyHasFind (line 113) | class OnlyHasFind {
    method insert (line 116) | void insert(K key, V value) {
    method const_iterator (line 120) | const_iterator find(const K& key) const { return map_.find(key); }
    method const_iterator (line 121) | const_iterator end() const { return map_.end(); }
  function TEST (line 127) | TEST(CollectionUtilTest, hasFind) {
  function TEST (line 141) | TEST(CollectionUtilTest, dynamicContains) {

FILE: folly/container/test/EnumerateTest.cpp
  type IsConstReference (line 28) | struct IsConstReference {
  type IsConstReference<const T&> (line 32) | struct IsConstReference<const T&> {
  function basicSum (line 36) | constexpr int basicSum(const std::array<int, 3>& test) {
  function cpp17StructuredBindingSum (line 44) | constexpr int cpp17StructuredBindingSum(const std::array<int, 3>& test) {
  function TEST (line 54) | TEST(Enumerate, Basic) {
  function TEST (line 73) | TEST(Enumerate, BasicRRef) {
  function TEST (line 92) | TEST(Enumerate, BasicConst) {
  function TEST (line 106) | TEST(Enumerate, BasicConstRef) {
  function TEST (line 120) | TEST(Enumerate, BasicConstRRef) {
  function TEST (line 134) | TEST(Enumerate, BasicVecBool) {
  function TEST (line 146) | TEST(Enumerate, BasicVecBoolRRef) {
  function TEST (line 158) | TEST(Enumerate, Temporary) {
  function TEST (line 171) | TEST(Enumerate, BasicConstArg) {
  function TEST (line 186) | TEST(Enumerate, TemporaryConstEnumerate) {
  function TEST (line 200) | TEST(Enumerate, RangeSupport) {
  function TEST (line 213) | TEST(Enumerate, EmptyRange) {
  class CStringRange (line 221) | class CStringRange {
    type Sentinel (line 225) | struct Sentinel {}
    method CStringRange (line 227) | explicit CStringRange(const char* cstr_) : cstr(cstr_) {}
    method Sentinel (line 230) | Sentinel end() const { return Sentinel{}; }
  function TEST (line 237) | TEST(Enumerate, Cpp17Support) {
  function TEST (line 245) | TEST(Enumerate, Cpp17StructuredBindingConstRef) {
  function TEST (line 253) | TEST(Enumerate, Cpp17StructuredBindingConstRRef) {
  function TEST (line 261) | TEST(Enumerate, Cpp17StructuredBindingConstVector) {
  function TEST (line 271) | TEST(Enumerate, Cpp17StructuredBindingModify) {
  function TEST (line 282) | TEST(Enumerate, BasicConstexpr) {
  function TEST (line 288) | TEST(Enumerate, Cpp17StructuredBindingConstexpr) {

FILE: folly/container/test/EvictingCacheMapBench.cpp
  function key (line 23) | inline uint64_t key(size_t i) {
  function scanCache (line 35) | void scanCache(uint32_t n, size_t numElts) {
  function insertCache (line 51) | void insertCache(uint32_t n, size_t numElts) {
  function main (line 77) | int main(int argc, char** argv) {

FILE: folly/container/test/EvictingCacheMapTest.cpp
  function TEST (line 25) | TEST(EvictingCacheMap, SanityTest) {
  function TEST (line 81) | TEST(EvictingCacheMap, PruneTest) {
  function TEST (line 163) | TEST(EvictingCacheMap, PruneHookTest) {
  function TEST (line 300) | TEST(EvictingCacheMap, SetMaxSize) {
  function TEST (line 322) | TEST(EvictingCacheMap, SetClearSize) {
  function TEST (line 345) | TEST(EvictingCacheMap, DestructorInvocationTest) {
  function TEST (line 489) | TEST(EvictingCacheMap, LruSanityTest) {
  function TEST (line 515) | TEST(EvictingCacheMap, LruPromotionTest) {
  function TEST (line 546) | TEST(EvictingCacheMap, LruNoPromotionTest) {
  function TEST (line 577) | TEST(EvictingCacheMap, IteratorSanityTest) {
  function TEST (line 597) | TEST(EvictingCacheMap, FindTest) {
  function TEST (line 628) | TEST(EvictingCacheMap, FindWithoutPromotionTest) {
  function TEST (line 649) | TEST(EvictingCacheMap, IteratorOrderingTest) {
  function TEST (line 694) | TEST(EvictingCacheMap, MoveTest) {
  function TEST (line 720) | TEST(EvictingCacheMap, CustomKeyEqual) {
  function TEST (line 743) | TEST(EvictingCacheMap, InvalidHashPartlyUsable) {
  function TEST (line 754) | TEST(EvictingCacheMap, IteratorConversion) {
  function TEST (line 772) | TEST(EvictingCacheMap, HeterogeneousAccess) {
  function TEST (line 823) | TEST(EvictingCacheMap, ApproximateEntryMemUsage) {
  function TEST (line 836) | TEST(EvictingCacheMap, PiecewiseConstructTest) {
  function TEST (line 844) | TEST(EvictingCacheMap, ZeroClearSizeClampingTest) {
  function TEST (line 870) | TEST(EvictingCacheMap, SetClearSizeZeroClampingTest) {

FILE: folly/container/test/F14AsanSupportTest.cpp
  function useIteratorAfterInsertSmall (line 24) | void useIteratorAfterInsertSmall() {
  function useIteratorAfterInsertLarge (line 32) | void useIteratorAfterInsertLarge() {
  function useReferenceAfterInsertSmall (line 45) | void useReferenceAfterInsertSmall() {
  function useReferenceAfterInsertLarge (line 53) | void useReferenceAfterInsertLarge() {
  function repeat (line 66) | void repeat(F const& func) {
  function asanFailuresExpected (line 72) | bool asanFailuresExpected() {
  function expectAsanFailure (line 79) | void expectAsanFailure(F const& func) {
  function TEST (line 86) | TEST(F14AsanSupportTest, F14ValueIterInsertSmall) {
  function TEST (line 89) | TEST(F14AsanSupportTest, F14NodeIterInsertSmall) {
  function TEST (line 92) | TEST(F14AsanSupportTest, F14VectorIterInsertSmall) {
  function TEST (line 95) | TEST(F14AsanSupportTest, F14FastIterInsertSmall) {
  function TEST (line 99) | TEST(F14AsanSupportTest, F14ValueIterInsertLarge) {
  function TEST (line 102) | TEST(F14AsanSupportTest, F14NodeIterInsertLarge) {
  function TEST (line 105) | TEST(F14AsanSupportTest, F14VectorIterInsertLarge) {
  function TEST (line 108) | TEST(F14AsanSupportTest, F14FastIterInsertLarge) {
  function TEST (line 112) | TEST(F14AsanSupportTest, F14ValueRefInsertSmall) {
  function TEST (line 115) | TEST(F14AsanSupportTest, F14VectorRefInsertSmall) {
  function TEST (line 118) | TEST(F14AsanSupportTest, F14FastRefInsertSmall) {
  function TEST (line 122) | TEST(F14AsanSupportTest, F14ValueRefInsertLarge) {
  function TEST (line 125) | TEST(F14AsanSupportTest, F14VectorRefInsertLarge) {
  function TEST (line 128) | TEST(F14AsanSupportTest, F14FastRefInsertLarge) {
  function TEST (line 132) | TEST(F14AsanSupportTest, F14VectorErase) {

FILE: folly/container/test/F14FwdTest.cpp
  function foo (line 23) | void foo(TContainer*) {}
  function TEST (line 26) | TEST(F14Fwd, simple) {

FILE: folly/container/test/F14InterprocessTest.cpp
  function makeRandomName (line 111) | std::string makeRandomName() {
  function makeShmSegment (line 115) | std::shared_ptr<managed_shared_memory> makeShmSegment(
  function runSimpleMapTest (line 128) | void runSimpleMapTest() {
  function runSimpleSetTest (line 143) | void runSimpleSetTest() {
  function TEST (line 156) | TEST(ShmF14ValueMap, simple) {
  function TEST (line 159) | TEST(ShmF14NodeMap, simple) {
  function TEST (line 162) | TEST(ShmF14VectorMap, simple) {
  function TEST (line 165) | TEST(ShmF14ValueSet, simple) {
  function TEST (line 168) | TEST(ShmF14NodeSet, simple) {
  function TEST (line 171) | TEST(ShmF14VectorSet, simple) {
  function runSimultaneousAccessMapTest (line 176) | void runSimultaneousAccessMapTest() {
  function TEST (line 207) | TEST(ShmF14ValueMap, simultaneous) {
  function TEST (line 210) | TEST(ShmF14NodeMap, simultaneous) {
  function TEST (line 213) | TEST(ShmF14VectorMap, simultaneous) {
  function checkSingleLocation (line 218) | void checkSingleLocation(
  function checkLocation (line 248) | void checkLocation(
  function checkLocation (line 256) | void checkLocation(
  function checkLocation (line 266) | auto checkLocation(
  function runScopedAllocatorTest (line 279) | void runScopedAllocatorTest() {
  function TEST (line 303) | TEST(ShmF14ValueI2VVI, scopedAllocator) {
  function TEST (line 306) | TEST(ShmF14NodeI2VVI, scopedAllocator) {
  function TEST (line 309) | TEST(ShmF14VectorI2VVI, scopedAllocator) {
  function runMultiScopeTest (line 314) | void runMultiScopeTest() {
  function TEST (line 396) | TEST(ShmF14ValueI2VVI, multiScope) {
  function TEST (line 399) | TEST(ShmF14NodeI2VVI, multiScope) {
  function TEST (line 402) | TEST(ShmF14VectorI2VVI, multiScope) {

FILE: folly/container/test/F14MapTest.cpp
  function runSanityChecks (line 50) | void runSanityChecks(T const& t) {
  function testCustomSwap (line 59) | void testCustomSwap() {
  function TEST (line 75) | TEST(F14Map, customSwap) {
  function runAllocatedMemorySizeTest (line 86) | void runAllocatedMemorySizeTest() {
  function runAllocatedMemorySizeTests (line 139) | void runAllocatedMemorySizeTests() {
  function TEST (line 146) | TEST(F14Map, getAllocatedMemorySize) {
  function runVisitContiguousRangesTest (line 157) | void runVisitContiguousRangesTest(int n) {
  function runVisitContiguousRangesTest (line 187) | void runVisitContiguousRangesTest() {
  function TEST (line 193) | TEST(F14ValueMap, visitContiguousRanges) {
  function TEST (line 197) | TEST(F14NodeMap, visitContiguousRanges) {
  function TEST (line 201) | TEST(F14VectorMap, visitContiguousRanges) {
  function TEST (line 205) | TEST(F14FastMap, visitContiguousRanges) {
  function TEST (line 210) | TEST(F14Map, pmrEmpty) {
  type NestedHash (line 220) | struct NestedHash {
  type Nested (line 226) | struct Nested {
    method Nested (line 229) | explicit Nested(int depth)
  function testNestedMapEquality (line 257) | void testNestedMapEquality() {
  function testEqualityRefinement (line 270) | void testEqualityRefinement() {
  function TEST (line 290) | TEST(F14Map, nestedMapEquality) {
  function TEST (line 297) | TEST(F14Map, equalityRefinement) {
  function s (line 305) | std::string s(char const* p) {
  function runSimple (line 311) | void runSimple() {
  function runEraseWhileIterating (line 449) | void runEraseWhileIterating() {
  function runRehash (line 475) | void runRehash() {
  function runRandom (line 492) | void runRandom() {
  function TEST (line 757) | TEST(F14ValueMap, simple) {
  function TEST (line 761) | TEST(F14NodeMap, simple) {
  function TEST (line 765) | TEST(F14VectorMap, simple) {
  function TEST (line 769) | TEST(F14FastMap, simple) {
  function TEST (line 774) | TEST(F14ValueMap, pmrSimple) {
  function TEST (line 778) | TEST(F14NodeMap, pmrSimple) {
  function TEST (line 782) | TEST(F14VectorMap, pmrSimple) {
  function TEST (line 786) | TEST(F14FastMap, pmrSimple) {
  function TEST (line 792) | TEST(F14VectorMap, reverseIterator) {
  function TEST (line 832) | TEST(F14VectorMap, OrderPreservingReinsertionView) {
  function TEST (line 847) | TEST(F14ValueMap, eraseWhileIterating) {
  function TEST (line 851) | TEST(F14NodeMap, eraseWhileIterating) {
  function TEST (line 855) | TEST(F14VectorMap, eraseWhileIterating) {
  function TEST (line 859) | TEST(F14FastMap, eraseWhileIterating) {
  function TEST (line 863) | TEST(F14ValueMap, rehash) {
  function TEST (line 867) | TEST(F14NodeMap, rehash) {
  function TEST (line 871) | TEST(F14VectorMap, rehash) {
  function TEST (line 875) | TEST(F14FastMap, rehash) {
  function runPrehash (line 880) | void runPrehash() {
  function TEST (line 912) | TEST(F14ValueMap, prehash) {
  function TEST (line 916) | TEST(F14NodeMap, prehash) {
  function TEST (line 920) | TEST(F14VectorMap, prehash) {
  function TEST (line 924) | TEST(F14FastMap, prehash) {
  function TEST (line 928) | TEST(F14ValueMap, random) {
  function TEST (line 937) | TEST(F14NodeMap, random) {
  function TEST (line 946) | TEST(F14VectorMap, random) {
  function TEST (line 955) | TEST(F14FastMap, random) {
  function TEST (line 964) | TEST(F14ValueMap, growStats) {
  function TEST (line 976) | TEST(F14ValueMap, steadyStateStats) {
  function TEST (line 1004) | TEST(F14VectorMap, steadyStateStats) {
  function TEST (line 1032) | TEST(Tracked, baseline) {
  function runInsertCases (line 1100) | void runInsertCases(
  type DoInsert (line 1298) | struct DoInsert {
  type DoEmplace1 (line 1305) | struct DoEmplace1 {
  type DoEmplace2 (line 1312) | struct DoEmplace2 {
  type DoEmplace3 (line 1324) | struct DoEmplace3 {
  type DoEmplace3Value (line 1346) | struct DoEmplace3Value {
  function runInsertAndEmplace (line 1365) | void runInsertAndEmplace(std::string const& name) {
  function TEST (line 1386) | TEST(F14ValueMap, destructuring) {
  function TEST (line 1390) | TEST(F14NodeMap, destructuring) {
  function TEST (line 1394) | TEST(F14VectorMap, destructuring) {
  function TEST (line 1400) | TEST(F14VectorMap, destructuringErase) {
  function TEST (line 1419) | TEST(F14ValueMap, maxSize) {
  function TEST (line 1429) | TEST(F14NodeMap, maxSize) {
  function TEST (line 1439) | TEST(F14VectorMap, vectorMaxSize) {
  function runMoveOnlyTest (line 1453) | void runMoveOnlyTest() {
  function TEST (line 1466) | TEST(F14ValueMap, moveOnly) {
  function TEST (line 1472) | TEST(F14NodeMap, moveOnly) {
  function TEST (line 1478) | TEST(F14VectorMap, moveOnly) {
  function TEST (line 1484) | TEST(F14FastMap, moveOnly) {
  function runEraseIntoTest (line 1491) | void runEraseIntoTest() {
  function TEST (line 1534) | TEST(F14ValueMap, eraseInto) {
  function TEST (line 1538) | TEST(F14NodeMap, eraseInto) {
  function TEST (line 1542) | TEST(F14VectorMap, eraseInto) {
  function TEST (line 1546) | TEST(F14FastMap, eraseInto) {
  function runEraseIntoEmptyFromEraseTest (line 1551) | void runEraseIntoEmptyFromEraseTest() {
  function TEST (line 1565) | TEST(F14ValueMap, eraseIntoEmptyFromErase) {
  function TEST (line 1570) | TEST(F14NodeMap, eraseIntoEmptyFromErase) {
  function TEST (line 1575) | TEST(F14VectorMap, eraseIntoEmptyFromErase) {
  function TEST (line 1580) | TEST(F14FastMap, eraseIntoEmptyFromErase) {
  function runEraseIntoEmptyFromReserveTest (line 1586) | void runEraseIntoEmptyFromReserveTest() {
  function TEST (line 1599) | TEST(F14ValueMap, eraseIntoEmptyFromReserve) {
  function TEST (line 1604) | TEST(F14NodeMap, eraseIntoEmptyFromReserve) {
  function TEST (line 1609) | TEST(F14VectorMap, eraseIntoEmptyFromReserve) {
  function TEST (line 1614) | TEST(F14FastMap, eraseIntoEmptyFromReserve) {
  function runPermissiveConstructorTest (line 1620) | void runPermissiveConstructorTest() {
  function TEST (line 1641) | TEST(F14ValueMap, permissiveConstructor) {
  function TEST (line 1647) | TEST(F14NodeMap, permissiveConstructor) {
  function TEST (line 1652) | TEST(F14VectorMap, permissiveConstructor) {
  function TEST (line 1658) | TEST(F14FastMap, permissiveConstructor) {
  function TEST (line 1663) | TEST(F14ValueMap, heterogeneousLookup) {
  function runStatefulFunctorTest (line 1720) | void runStatefulFunctorTest() {
  function TEST (line 1761) | TEST(F14ValueMap, statefulFunctors) {
  function TEST (line 1770) | TEST(F14NodeMap, statefulFunctors) {
  function TEST (line 1779) | TEST(F14VectorMap, statefulFunctors) {
  function TEST (line 1788) | TEST(F14FastMap, statefulFunctors) {
  function runHeterogeneousInsertTest (line 1798) | void runHeterogeneousInsertTest() {
  function runHeterogeneousInsertStringTest (line 1872) | void runHeterogeneousInsertStringTest() {
  function TEST (line 1924) | TEST(F14ValueMap, heterogeneousInsert) {
  function TEST (line 1938) | TEST(F14NodeMap, heterogeneousInsert) {
  function TEST (line 1952) | TEST(F14VectorMap, heterogeneousInsert) {
  function TEST (line 1966) | TEST(F14FastMap, heterogeneousInsert) {
  type A (line 1989) | struct A {
  type AHasher (line 1995) | struct AHasher {
  type B (line 2000) | struct B {
    method B (line 2003) | explicit B(int v) : value(v) {}
    method B (line 2005) | B(A const& v) : value(v.value) {}
  type C (line 2010) | struct C {
  function TEST (line 2020) | TEST(F14FastMap, disabledDoubleTransparent) {
  function runRandomInsertOrderTest (line 2038) | void runRandomInsertOrderTest() {
  function TEST (line 2071) | TEST(F14Map, randomInsertOrder) {
  function runContinuousCapacityTest (line 2080) | void runContinuousCapacityTest(std::size_t minSize, std::size_t maxSize) {
  function TEST (line 2127) | TEST(F14Map, continuousCapacitySmall0) {
  function TEST (line 2131) | TEST(F14Map, continuousCapacitySmall1) {
  function TEST (line 2135) | TEST(F14Map, continuousCapacitySmall2) {
  function TEST (line 2139) | TEST(F14Map, continuousCapacitySmall3) {
  function TEST (line 2143) | TEST(F14Map, continuousCapacityBig0) {
  function TEST (line 2148) | TEST(F14Map, continuousCapacityBig1) {
  function TEST (line 2153) | TEST(F14Map, continuousCapacityBig2) {
  function TEST (line 2158) | TEST(F14Map, continuousCapacityBig3) {
  function TEST (line 2163) | TEST(F14Map, continuousCapacityF12) {
  function testContainsWithPrecomputedHash (line 2170) | void testContainsWithPrecomputedHash() {
  function TEST (line 2184) | TEST(F14Map, containsWithPrecomputedHash) {
  function testFindHashedKey (line 2193) | void testFindHashedKey() {
  function TEST (line 2206) | TEST(F14Map, findHashedKey) {
  function testFindHashedKeyTransparent (line 2214) | void testFindHashedKeyTransparent() {
  function TEST (line 2236) | TEST(F14Map, findHashedKeyTransparent) {
  function testContainsHashedKey (line 2244) | void testContainsHashedKey() {
  function TEST (line 2257) | TEST(F14Map, containsHashedKey) {
  function testContainsHeterogeneousHashedKey (line 2265) | void testContainsHeterogeneousHashedKey() {
  function TEST (line 2278) | TEST(F14Map, containsHeterogeneousHashedKey) {
  function testInsertOrAssignHashedKey (line 2286) | void testInsertOrAssignHashedKey() {
  function TEST (line 2299) | TEST(F14Map, insertOrAssignHashedKey) {
  function testInsertOrAssignRValueHashedKey (line 2307) | void testInsertOrAssignRValueHashedKey() {
  function TEST (line 2320) | TEST(F14Map, insertOrAssignRValueHashedKey) {
  function testContainsWithPrecomputedHashKeyWrapperTransparent (line 2328) | void testContainsWithPrecomputedHashKeyWrapperTransparent() {
  function TEST (line 2381) | TEST(F14Map, containsWithPrecomputedHashKeyWrapperTransparent) {
  function testEraseIf (line 2390) | void testEraseIf() {
  function TEST (line 2399) | TEST(F14Map, eraseIf) {
  type DivideBy (line 2408) | struct DivideBy {
  function testCopyAfterRemovedCollisions (line 2417) | void testCopyAfterRemovedCollisions() {
  function TEST (line 2439) | TEST(F14Map, copyAfterRemovedCollisions) {
  function testIterDeductionGuide (line 2447) | void testIterDeductionGuide() {
  function TEST (line 2499) | TEST(F14Map, iterDeductionGuide) {
  function testInitializerListDeductionGuide (line 2507) | void testInitializerListDeductionGuide() {
  function TEST (line 2562) | TEST(F14Map, initializerListDeductionGuide) {
  type TracedMovable (line 2571) | struct TracedMovable {
    method TracedMovable (line 2573) | TracedMovable() = default;
    method TracedMovable (line 2575) | TracedMovable& operator=(TracedMovable&& other) noexcept {
    method TracedMovable (line 2582) | TracedMovable(TracedMovable&& other) noexcept {
  function testInsertOrAssignUnchangedIfNoInsert (line 2592) | void testInsertOrAssignUnchangedIfNoInsert() {
  function TEST (line 2602) | TEST(F14Map, insertOrAssignUnchangedIfNoInsert) {
  function runSimpleShrinkToFitTest (line 2612) | void runSimpleShrinkToFitTest(float expectedLoadFactor) {
  function TEST (line 2624) | TEST(F14Map, shrinkToFit) {
  function runDefactoShrinkToFitTest (line 2631) | void runDefactoShrinkToFitTest(float expectedLoadFactor) {
  function TEST (line 2646) | TEST(F14Map, defactoShrinkToFit) {
  function runInitialReserveTest (line 2653) | void runInitialReserveTest(float expectedLoadFactor) {
  function TEST (line 2680) | TEST(F14Map, initialReserve) {
  function runReserveMoreTest (line 2687) | void runReserveMoreTest(int n) {
  function TEST (line 2703) | TEST(F14Map, reserveMoreNeverShrinks) {
  function TEST (line 2712) | TEST(F14Map, reserveBadAlloc) {
  function TEST (line 2724) | TEST(F14Map, InsertOrAssignShouldNotMoveTheData) {

FILE: folly/container/test/F14PolicyTest.cpp
  type folly (line 24) | namespace folly {
    type NormalHash (line 26) | struct NormalHash {
    type Force32BitHash (line 30) | struct Force32BitHash {
    type F14ValueSetTester (line 36) | struct F14ValueSetTester {
      method test (line 37) | static void test() {
    function TEST (line 45) | TEST(F14Policy, assume32BitTag) {

FILE: folly/container/test/F14SetTest.cpp
  function FOLLY_KEEP (line 50) | FOLLY_KEEP int check_std_unordered_set_int_accumulate(
  function FOLLY_KEEP (line 54) | FOLLY_KEEP int check_folly_f14_node_set_int_accumulate(
  function FOLLY_KEEP (line 58) | FOLLY_KEEP int check_folly_f14_vector_set_int_accumulate(
  function FOLLY_KEEP (line 62) | FOLLY_KEEP int check_folly_f14_value_set_int_accumulate(
  function FOLLY_KEEP (line 67) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 71) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 75) | FOLLY_KEEP size_t
  function FOLLY_KEEP (line 79) | FOLLY_KEEP size_t
  function runSanityChecks (line 88) | void runSanityChecks(T const& t) {
  function testCustomSwap (line 96) | void testCustomSwap() {
  function TEST (line 107) | TEST(F14Set, customSwap) {
  function runAllocatedMemorySizeTest (line 118) | void runAllocatedMemorySizeTest() {
  function runAllocatedMemorySizeTests (line 171) | void runAllocatedMemorySizeTests() {
  function TEST (line 179) | TEST(F14Set, getAllocatedMemorySize) {
  function runVisitContiguousRangesTest (line 189) | void runVisitContiguousRangesTest(int n) {
  function runVisitContiguousRangesTest (line 219) | void runVisitContiguousRangesTest() {
  function TEST (line 225) | TEST(F14ValueSet, visitContiguousRanges) {
  function TEST (line 229) | TEST(F14NodeSet, visitContiguousRanges) {
  function TEST (line 233) | TEST(F14VectorSet, visitContiguousRanges) {
  function TEST (line 237) | TEST(F14FastSet, visitContiguousRanges) {
  function TEST (line 242) | TEST(F14Set, pmrEmpty) {
  type NestedHash (line 252) | struct NestedHash {
  type Nested (line 258) | struct Nested {
    method Nested (line 261) | explicit Nested(int depth)
  function testNestedSetEquality (line 289) | void testNestedSetEquality() {
  function testEqualityRefinement (line 302) | void testEqualityRefinement() {
  function TEST (line 322) | TEST(F14Set, nestedSetEquality) {
  function TEST (line 329) | TEST(F14Set, equalityRefinement) {
  function s (line 337) | std::string s(char const* p) {
  function runSimple (line 343) | void runSimple() {
  function runEraseWhileIterating (line 473) | void runEraseWhileIterating() {
  function runRehash (line 499) | void runRehash() {
  function runRandom (line 511) | void runRandom() {
  function TEST (line 700) | TEST(F14ValueSet, simple) {
  function TEST (line 704) | TEST(F14NodeSet, simple) {
  function TEST (line 708) | TEST(F14VectorSet, simple) {
  function TEST (line 712) | TEST(F14FastSet, simple) {
  function TEST (line 719) | TEST(F14ValueSet, pmrSimple) {
  function TEST (line 723) | TEST(F14NodeSet, pmrSimple) {
  function TEST (line 727) | TEST(F14VectorSet, pmrSimple) {
  function TEST (line 731) | TEST(F14FastSet, pmrSimple) {
  function TEST (line 740) | TEST(F14Set, ContainerSize) {
  function TEST (line 773) | TEST(F14VectorMap, reverseIterator) {
  function TEST (line 812) | TEST(F14VectorSet, OrderPreservingReinsertionView) {
  function TEST (line 828) | TEST(F14ValueSet, eraseWhileIterating) {
  function TEST (line 832) | TEST(F14NodeSet, eraseWhileIterating) {
  function TEST (line 836) | TEST(F14VectorSet, eraseWhileIterating) {
  function TEST (line 840) | TEST(F14ValueSet, rehash) {
  function TEST (line 844) | TEST(F14NodeSet, rehash) {
  function TEST (line 848) | TEST(F14VectorSet, rehash) {
  function TEST (line 852) | TEST(F14ValueSet, random) {
  function TEST (line 856) | TEST(F14NodeSet, random) {
  function TEST (line 860) | TEST(F14VectorSet, random) {
  function TEST (line 866) | TEST(F14ValueSet, growStats) {
  function TEST (line 878) | TEST(F14ValueSet, steadyStateStats) {
  function runInsertCases (line 909) | void runInsertCases(std::string const& /* name */, F const& insertFunc) {
  type DoInsert (line 931) | struct DoInsert {
  type DoEmplace1 (line 938) | struct DoEmplace1 {
  function runInsertAndEmplace (line 946) | void runInsertAndEmplace() {
  function TEST (line 1058) | TEST(F14ValueSet, destructuring) {
  function TEST (line 1062) | TEST(F14NodeSet, destructuring) {
  function TEST (line 1066) | TEST(F14VectorSet, destructuring) {
  function TEST (line 1071) | TEST(F14ValueSet, maxSize) {
  function TEST (line 1081) | TEST(F14NodeSet, maxSize) {
  function TEST (line 1091) | TEST(F14VectorSet, maxSize) {
  function runMoveOnlyTest (line 1104) | void runMoveOnlyTest() {
  function TEST (line 1116) | TEST(F14ValueSet, moveOnly) {
  function TEST (line 1120) | TEST(F14NodeSet, moveOnly) {
  function TEST (line 1124) | TEST(F14VectorSet, moveOnly) {
  function TEST (line 1128) | TEST(F14FastSet, moveOnly) {
  function runEraseIntoTest (line 1133) | void runEraseIntoTest() {
  function TEST (line 1179) | TEST(F14ValueSet, eraseInto) {
  function TEST (line 1183) | TEST(F14NodeSet, eraseInto) {
  function TEST (line 1187) | TEST(F14VectorSet, eraseInto) {
  function TEST (line 1191) | TEST(F14FastSet, eraseInto) {
  function TEST (line 1195) | TEST(F14ValueSet, heterogeneous) {
  function runStatefulFunctorTest (line 1253) | void runStatefulFunctorTest() {
  function TEST (line 1294) | TEST(F14ValueSet, statefulFunctors) {
  function TEST (line 1302) | TEST(F14NodeSet, statefulFunctors) {
  function TEST (line 1310) | TEST(F14VectorSet, statefulFunctors) {
  function TEST (line 1318) | TEST(F14FastSet, statefulFunctors) {
  function runHeterogeneousInsertTest (line 1327) | void runHeterogeneousInsertTest() {
  function runHeterogeneousInsertStringTest (line 1381) | void runHeterogeneousInsertStringTest() {
  function TEST (line 1410) | TEST(F14ValueSet, heterogeneousInsert) {
  function TEST (line 1422) | TEST(F14NodeSet, heterogeneousInsert) {
  function TEST (line 1434) | TEST(F14VectorSet, heterogeneousInsert) {
  function TEST (line 1446) | TEST(F14FastSet, heterogeneousInsert) {
  type A (line 1467) | struct A {
  type AHasher (line 1473) | struct AHasher {
  type B (line 1478) | struct B {
    method B (line 1481) | explicit B(int v) : value(v) {}
    method B (line 1483) | B(A const& v) : value(v.value) {}
  type C (line 1488) | struct C {
  function TEST (line 1498) | TEST(F14FastSet, disabledDoubleTransparent) {
  type CharArrayHasher (line 1511) | struct CharArrayHasher {
  type RunAllValueSizeTests (line 1521) | struct RunAllValueSizeTests {
  type RunAllValueSizeTests<S, 0> (line 1540) | struct RunAllValueSizeTests<S, 0> {
  function TEST (line 1545) | TEST(F14ValueSet, valueSize) {
  function runRandomInsertOrderTest (line 1550) | void runRandomInsertOrderTest(F&& func) {
  function TEST (line 1577) | TEST(F14Set, randomInsertOrder) {
  function testContainsWithPrecomputedHash (line 1586) | void testContainsWithPrecomputedHash() {
  function TEST (line 1599) | TEST(F14Set, containsWithPrecomputedHash) {
  function testFindHashedKey (line 1608) | void testFindHashedKey() {
  function TEST (line 1621) | TEST(F14Set, findHashedKey) {
  function testContainsHashedKey (line 1629) | void testContainsHashedKey() {
  function TEST (line 1642) | TEST(F14Set, containsHashedKey) {
  function testEraseIf (line 1652) | void testEraseIf() {
  function TEST (line 1661) | TEST(F14Set, eraseIf) {
  function testExceptionOnInsert (line 1669) | void testExceptionOnInsert() {
  function TEST (line 1676) | TEST(F14Set, ExceptionOnInsert) {
  function testIterDeductionGuide (line 1684) | void testIterDeductionGuide() {
  function TEST (line 1732) | TEST(F14Set, iterDeductionGuide) {
  function testInitializerListDeductionGuide (line 1740) | void testInitializerListDeductionGuide() {
  function TEST (line 1773) | TEST(F14Set, initializerListDeductionGuide) {

FILE: folly/container/test/F14SmallOverheads.cpp
  type LoggingAlloc (line 32) | struct LoggingAlloc {
    method LoggingAlloc (line 35) | LoggingAlloc() {}
    method LoggingAlloc (line 38) | explicit LoggingAlloc(A&&) {}
    method T (line 40) | T* allocate(std::size_t n) {
    method deallocate (line 45) | void deallocate(T* ptr, std::size_t n) {
    type rebind (line 64) | struct rebind {
    method T (line 68) | T* address(T& v) const { return &v; }
    method T (line 69) | T const* address(T const& v) const { return &v; }
    method max_size (line 70) | std::size_t max_size() const {
  function runSingleInsert (line 100) | void runSingleInsert(std::string const& name) {
  function runSingleInserts (line 116) | void runSingleInserts(std::string const& name) {
  function FOLLY_KEEP (line 126) | FOLLY_KEEP int codeSize_find_Std(
  function FOLLY_KEEP (line 132) | FOLLY_KEEP int codeSize_find_F14Value(
  function FOLLY_KEEP (line 138) | FOLLY_KEEP int codeSize_find_F14Node(F14NodeMap<int16_t, float>& m, int1...
  function FOLLY_KEEP (line 143) | FOLLY_KEEP int codeSize_find_F14Vector(
  function FOLLY_KEEP (line 149) | FOLLY_KEEP void codeSize_bracket_Std(
  function FOLLY_KEEP (line 154) | FOLLY_KEEP void codeSize_bracket_F14Value(
  function FOLLY_KEEP (line 159) | FOLLY_KEEP void codeSize_bracket_F14Node(
  function FOLLY_KEEP (line 164) | FOLLY_KEEP void codeSize_bracket_F14Vector(
  function FOLLY_KEEP (line 169) | FOLLY_KEEP void codeSize_erase_Std(
  function FOLLY_KEEP (line 175) | FOLLY_KEEP void codeSize_erase_F14Value(
  function FOLLY_KEEP (line 181) | FOLLY_KEEP void codeSize_erase_F14Node(
  function FOLLY_KEEP (line 187) | FOLLY_KEEP void codeSize_erase_F14Vector(
  function main (line 193) | int main(int, char**) {

FILE: folly/container/test/F14TestUtil.h
  type Histo (line 30) | struct Histo {
  function expectedProbe (line 56) | inline double expectedProbe(std::vector<std::size_t> const& probeLengths) {
  function p99Probe (line 68) | inline std::size_t p99Probe(std::vector<std::size_t> const& probeLengths) {

FILE: folly/container/test/FBVectorBenchmark.cpp
  function main (line 96) | int main(int argc, char** argv) {

FILE: folly/container/test/FBVectorBenchmarks.cpp.h
  function BENCHMARK (line 22) | BENCHMARK(BENCHFUN(zzInitRNG)) {

FILE: folly/container/test/FBVectorTest.cpp
  function TEST (line 45) | TEST(fbvector, clause233613Ambiguity) {
  function TEST (line 53) | TEST(fbvector, clause2336111Ambiguity) {
  function TEST (line 62) | TEST(fbvector, clause233626) {
  function TEST (line 73) | TEST(fbvector, clause23364Ambiguity) {
  function TEST (line 83) | TEST(fbvector, composition) {
  function TEST (line 87) | TEST(fbvector, worksWithStdString) {
  type UserDefinedType (line 94) | struct UserDefinedType {
  function TEST (line 101) | TEST(fbvector, worksWithUserDefinedType) {
  function TEST (line 107) | TEST(fbvector, moveConstruction) {
  function TEST (line 125) | TEST(fbvector, emplace) {
  function TEST (line 135) | TEST(fbvector, initializerLists) {
  function TEST (line 159) | TEST(fbvector, uniquePtr) {
  function TEST (line 173) | TEST(FBVector, task858056) {
  function TEST (line 187) | TEST(FBVector, moveIterator) {
  function TEST (line 210) | TEST(FBVector, reserveConsistency) {
  function TEST (line 223) | TEST(FBVector, vectorOfMaps) {
  function TEST (line 240) | TEST(FBVector, shrinkToFitAfterClear) {
  function TEST (line 250) | TEST(FBVector, zeroLen) {
  function TEST (line 264) | TEST(FBVector, deductionGuides) {
  function TEST (line 274) | TEST(FBVector, erase) {
  function TEST (line 284) | TEST(FBVector, eraseIf) {
  function TEST (line 294) | TEST(FBVector, overflowConstruct) {
  function TEST (line 300) | TEST(FBVector, overflowResize) {
  function TEST (line 305) | TEST(FBVector, overflowAssign) {
  function TEST (line 313) | TEST(FBVector, zeroInit) {

FILE: folly/container/test/FBVectorTests.cpp.h
  function TESTFUN (line 22) | TESTFUN(clause_23_3_6_1_1) {
  function TESTFUN (line 30) | TESTFUN(clause_23_3_6_1_3) {
  function TESTFUN (line 39) | TESTFUN(clause_23_3_6_1_9) {
  function TESTFUN (line 55) | TESTFUN(clause_23_3_6_1_11) {
  function TESTFUN (line 84) | TESTFUN(clause_23_3_6_1_12) {
  function TESTFUN (line 95) | TESTFUN(clause_23_3_6_2_1) {
  function TESTFUN (line 102) | TESTFUN(clause_23_3_6_2_7) {
  function TESTFUN (line 119) | TESTFUN(clause_23_3_6_2_9) {
  function TESTFUN (line 131) | TESTFUN(clause_23_3_6_2_11) {
  function TESTFUN (line 149) | TESTFUN(clause_absent_element_access) {
  function TESTFUN (line 166) | TESTFUN(clause_23_3_6_3_1) {
  function TESTFUN (line 174) | TESTFUN(clause_23_3_6_4_1_a) {
  function TESTFUN (line 199) | TESTFUN(clause_23_3_6_4_1_c) {
  function TESTFUN (line 228) | TESTFUN(clause_23_3_6_4_1_d) {
  function TESTFUN (line 248) | TESTFUN(clause_23_3_6_4_3) {
  function TESTFUN (line 271) | TESTFUN(clause_23_3_6_4_4) {
  function TESTFUN (line 295) | TESTFUN(clause_23_3_6_4_clear) {

FILE: folly/container/test/ForeachBenchmark.cpp
  function setupBenchmark (line 42) | void setupBenchmark(size_t iters) {
  function setupCharVecBenchmark (line 54) | void setupCharVecBenchmark(size_t iters) {
  function BENCHMARK (line 61) | BENCHMARK(ForEachFunctionNoAssign, iters) {
  function BENCHMARK (line 77) | BENCHMARK(StdForEachFunctionNoAssign, iters) {
  function BENCHMARK (line 93) | BENCHMARK(RangeBasedForLoopNoAssign, iters) {
  function BENCHMARK (line 108) | BENCHMARK(ManualLoopNoAssign, iters) {
  function BENCHMARK (line 124) | BENCHMARK(ForEachFunctionAssign, iters) {
  function BENCHMARK (line 141) | BENCHMARK(StdForEachFunctionAssign, iters) {
  function BENCHMARK (line 158) | BENCHMARK(RangeBasedForLoopAssign, iters) {
  function BENCHMARK (line 175) | BENCHMARK(ManualLoopAssign, iters) {
  function BENCHMARK (line 192) | BENCHMARK(ForEachFunctionNoAssignWithIndexManipulation, iters) {
  function BENCHMARK (line 208) | BENCHMARK(StdForEachFunctionNoAssignWithIndexManipulation, iters) {
  function BENCHMARK (line 226) | BENCHMARK(RangeBasedForLoopNoAssignWithIndexManipulation, iters) {
  function BENCHMARK (line 243) | BENCHMARK(ForEachFunctionFetch, iters) {
  function BENCHMARK (line 254) | BENCHMARK(StdForEachFunctionFetch, iters) {
  function BENCHMARK (line 266) | BENCHMARK(ForLoopFetch, iters) {
  function BENCHMARK (line 278) | BENCHMARK(ForEachKVNoMacroAssign, iters) {
  function FOR_EACH (line 286) | FOR_EACH (iter, bmMap) {
  function BENCHMARK (line 294) | BENCHMARK(ForEachKVNoMacroNoAssign, iters) {
  function FOR_EACH (line 302) | FOR_EACH (iter, bmMap) {
  function BENCHMARK (line 308) | BENCHMARK(ForEachManual, iters) {
  function BENCHMARK (line 316) | BENCHMARK(ForEachRange, iters) {
  function BENCHMARK (line 324) | BENCHMARK(ForEachDescendingManual, iters) {
  function BENCHMARK (line 332) | BENCHMARK(CharVecForRange, iters) {
  function BENCHMARK (line 343) | BENCHMARK(CharVecForRangeExplicitIndex, iters) {
  function BENCHMARK (line 356) | BENCHMARK(CharVecForEach, iters) {
  function BENCHMARK (line 365) | BENCHMARK(CharVecForEachIndex, iters) {
  function BENCHMARK (line 374) | BENCHMARK(CharVecForRangeEnumerate, iters) {
  function main (line 385) | int main(int argc, char** argv) {

FILE: folly/container/test/ForeachTest.cpp
  type folly (line 33) | namespace folly {
    type test (line 34) | namespace test {
      class TestRValueConstruct (line 36) | class TestRValueConstruct {
        method TestRValueConstruct (line 38) | TestRValueConstruct() = default;
        method TestRValueConstruct (line 39) | TestRValueConstruct(TestRValueConstruct&&) noexcept {
        method TestRValueConstruct (line 42) | TestRValueConstruct(const TestRValueConstruct&) {
        method TestRValueConstruct (line 45) | TestRValueConstruct& operator=(const TestRValueConstruct&) = delete;
        method TestRValueConstruct (line 46) | TestRValueConstruct& operator=(TestRValueConstruct&&) = delete;
      class TestAdlIterable (line 51) | class TestAdlIterable {
      function begin (line 56) | auto begin(TestAdlIterable& instance) {
      function begin (line 59) | auto begin(const TestAdlIterable& instance) {
      function end (line 62) | auto end(TestAdlIterable& instance) {
      function end (line 65) | auto end(const TestAdlIterable& instance) {
      class TestBothIndexingAndIter (line 69) | class TestBothIndexingAndIter {
        class Iterator (line 71) | class Iterator {
          method Iterator (line 79) | Iterator operator+(int) { return *this; }
          method Iterator (line 80) | explicit Iterator(int& val_in) : val{val_in} {}
        method begin (line 83) | auto begin() {
        method end (line 87) | auto end() { return Iterator{val}; }
  function TEST (line 96) | TEST(Foreach, ForEachFunctionBasic) {
  function TEST (line 110) | TEST(Foreach, ForEachFunctionBasicRuntimeOneArg) {
  function TEST (line 125) | TEST(Foreach, ForEachFunctionBasicRuntimeTwoArg) {
  function TEST (line 139) | TEST(Foreach, ForEachFunctionBasicRuntimeThreeArg) {
  function TEST (line 150) | TEST(Foreach, ForEachFunctionBasicTupleOneArg) {
  function TEST (line 165) | TEST(Foreach, ForEachFunctionBasicTupleTwoArg) {
  function TEST (line 179) | TEST(Foreach, ForEachFunctionBreakRuntimeOneArg) {
  function TEST (line 192) | TEST(Foreach, ForEachFunctionBreakRuntimeTwoArg) {
  function TEST (line 205) | TEST(Foreach, ForEachFunctionBreakRuntimeThreeArg) {
  function TEST (line 218) | TEST(Foreach, ForEachFunctionBreakTupleOneArg) {
  function TEST (line 231) | TEST(Foreach, ForEachFunctionBreakTupleTwoArg) {
  function TEST (line 244) | TEST(Foreach, ForEachFunctionArray) {
  function TEST (line 257) | TEST(Foreach, ForEachFunctionInitializerListBasic) {
  function TEST (line 261) | TEST(Foreach, ForEachFunctionTestForward) {
  function TEST (line 275) | TEST(Foreach, ForEachFunctionAdlIterable) {
  function TEST (line 285) | TEST(ForEach, FetchRandomAccessIterator) {
  function TEST (line 293) | TEST(ForEach, FetchIndexing) {
  function TEST (line 301) | TEST(ForEach, FetchTuple) {
  function TEST (line 309) | TEST(ForEach, FetchTestPreferIterator) {
  type LargeTuple (line 319) | struct LargeTuple {}
  type std (line 326) | namespace std {
  type tuple_size<LargeTuple<T...>> (line 328) | struct tuple_size<LargeTuple<T...>>
  type LargeTupleTestHelper (line 333) | struct LargeTupleTestHelper
  type LargeTupleTestHelper<std::index_sequence<I...>> (line 335) | struct LargeTupleTestHelper<std::index_sequence<I...>> {
  function TEST (line 341) | TEST(ForEach, LargeTuple) {
  function TEST (line 349) | TEST(Foreach, ForEachRvalue) {
  function TEST (line 363) | TEST(Foreach, ForEachNested) {

FILE: folly/container/test/HashMapsBench.cpp
  type NonSSOString (line 59) | struct NonSSOString : public std::string {
    method NonSSOString (line 61) | explicit NonSSOString(Args&&... args)
    method NonSSOString (line 64) | NonSSOString(NonSSOString const&) = default;
    method NonSSOString (line 65) | NonSSOString& operator=(NonSSOString const&) = default;
    method NonSSOString (line 66) | NonSSOString(NonSSOString&&) = default;
    method NonSSOString (line 67) | NonSSOString& operator=(NonSSOString&&) = default;
  type std (line 71) | namespace std {
    type hash<NonSSOString> (line 73) | struct hash<NonSSOString> {
    type __is_fast_hash<hash<NonSSOString>> (line 79) | struct __is_fast_hash<hash<NonSSOString>> : public std::false_type {}
  type folly (line 89) | namespace folly {
    type IsAvalanchingHasher<std::hash<NonSSOString>, K> (line 91) | struct IsAvalanchingHasher<std::hash<NonSSOString>, K> : std::true_typ...
  function K (line 97) | K keyGen(uint32_t key) {
  function NonSSOString (line 102) | NonSSOString keyGen<NonSSOString>(uint32_t key) {
    method NonSSOString (line 61) | explicit NonSSOString(Args&&... args)
    method NonSSOString (line 64) | NonSSOString(NonSSOString const&) = default;
    method NonSSOString (line 65) | NonSSOString& operator=(NonSSOString const&) = default;
    method NonSSOString (line 66) | NonSSOString(NonSSOString&&) = default;
    method NonSSOString (line 67) | NonSSOString& operator=(NonSSOString&&) = default;
  function prepare (line 113) | void prepare(size_t max) {
  function K (line 123) | const K& key(int index) {
  function TArray (line 128) | TArray value(int i) {
  function benchmarkFilledMap (line 135) | void benchmarkFilledMap(int runs, int size, const Test& test, int div = ...
  function benchmarkManyFilledMapsByKey (line 157) | void benchmarkManyFilledMapsByKey(
  function benchmarkFilledMapByKey (line 183) | void benchmarkFilledMapByKey(
  function benchmarkFromEmptyArgs (line 214) | void benchmarkFromEmptyArgs(int runs, int size, Test test, Args... args) {
  function benchmarkInsert (line 229) | void benchmarkInsert(int runs, int size) {
  function benchmarkInsertGrow (line 240) | void benchmarkInsertGrow(int runs, int size) {
  function benchmarkInsertSqBr (line 247) | void benchmarkInsertSqBr(int runs, int size) {
  function benchmarkFind (line 254) | void benchmarkFind(int runs, int size) {
  function benchmarkManyFind (line 270) | void benchmarkManyFind(int runs, int size) {
  function benchmarkSqBrFind (line 286) | void benchmarkSqBrFind(int runs, int size) {
  function benchmarkErase (line 299) | void benchmarkErase(int runs, int size) {
  function benchmarkDtor (line 307) | void benchmarkDtor(int runs, int size) {
  function benchmarkClear (line 321) | void benchmarkClear(int runs, int size) {
  function benchmarkCopyCtor (line 328) | void benchmarkCopyCtor(int runs, int size) {
  function benchmarkIter (line 337) | void benchmarkIter(int runs, int size) {
  function benchmarkSparseIter (line 348) | void benchmarkSparseIter(int runs, int size) {
  function benchmarkCtorWithCapacity (line 363) | void benchmarkCtorWithCapacity(int runs, int size) {
  function runAllHashMapTests (line 379) | void runAllHashMapTests() {
  function main (line 456) | int main(int argc, char** argv) {

FILE: folly/container/test/HeterogeneousAccessTest.cpp
  function checkTransparent (line 35) | void checkTransparent() {
  function checkNotTransparent (line 41) | void checkNotTransparent() {
  type StringVector (line 46) | struct StringVector {
  type std (line 56) | namespace std {
    type hash<StringVector> (line 58) | struct hash<StringVector> {
  function TEST (line 65) | TEST(HeterogeneousAccess, transparentIsSelected) {
  function TEST (line 112) | TEST(HeterogeneousAccess, transparentIsNotSelected) {
  function runTestMatches2 (line 121) | void runTestMatches2(S src) {
  function runTestMatches (line 159) | void runTestMatches(S const& src) {
  function foo (line 192) | Range<int const*> foo(small_vector<int, 2> const& sv) {
  function TEST (line 196) | TEST(HeterogeneousAccess, transparentMatches) {

FILE: folly/container/test/IRangeTest.cpp
  function TEST (line 21) | TEST(IRangeTest, SingleArg) {
  function TEST (line 29) | TEST(IRangeTest, TwoArg) {
  function TEST (line 37) | TEST(IRangeTest, BigFirst) {
  function TEST (line 45) | TEST(IRangeTest, FirstConvertsBig) {

FILE: folly/container/test/IntrusiveHeapTest.cpp
  type folly (line 31) | namespace folly {
    type A (line 35) | struct A
    type B (line 36) | struct B
    type TaskBase (line 38) | struct TaskBase {
      method TaskBase (line 39) | explicit TaskBase(char id) : id(id) {}
    type Task (line 51) | struct Task
    type TrackedTask (line 58) | struct TrackedTask : public Task {
    class TaskWithComposition (line 68) | class TaskWithComposition : public TaskBase {
    class IntrusiveHeapTest (line 82) | class IntrusiveHeapTest {
      method print (line 85) | static void print(const Heap& heap, std::ostream& os) {
      method check (line 94) | static void check(const Heap& heap) {
      method check (line 100) | static void check(
      method print (line 117) | static void print(
    function TEST (line 138) | TEST(IntrusiveHeap, Static) {
    function testBasic (line 152) | void testBasic() {
    function TEST (line 187) | TEST(IntrusiveHeap, BasicDerived) {
    function TEST (line 191) | TEST(IntrusiveHeap, BasicComposition) {
    function TEST (line 201) | TEST(IntrusiveHeap, Fuzz) {

FILE: folly/container/test/IteratorTest.cpp
  class IteratorTest (line 40) | class IteratorTest : public testing::Test {}
  function TEST_F (line 42) | TEST_F(IteratorTest, iterator_has_known_distance_v) {
  function TEST_F (line 47) | TEST_F(IteratorTest, range_has_known_distance_v) {
  function TEST_F (line 52) | TEST_F(IteratorTest, iterator_category_t) {
  function TEST_F (line 65) | TEST_F(IteratorTest, iterator_category_matches_v) {
  function TEST_F (line 78) | TEST_F(IteratorTest, iterator_value_type_t) {
  function TEST_F (line 94) | TEST_F(IteratorTest, iterator_key_type_t) {
  function TEST_F (line 116) | TEST_F(IteratorTest, iterator_mapped_type_t) {
  type Object (line 153) | struct Object {
    method Object (line 154) | Object() { ++gDefaultCtrCnt; }
    method Object (line 155) | Object(const Object&) { ++gCopyCtrCnt; }
    method Object (line 156) | Object(Object&&) noexcept { ++gMoveCtrCnt; }
    method Object (line 157) | explicit Object(int) { ++gExplicitCtrCnt; }
    method Object (line 158) | explicit Object(int, int) { ++gMultiargCtrCnt; }
    method Object (line 159) | Object& operator=(const Object&) {
    method Object (line 163) | Object& operator=(Object&&) noexcept {
    method Object (line 167) | [[maybe_unused]] Object& operator=(int) noexcept {
  function init_counters (line 176) | void init_counters() {
  function copy_and_move_test (line 185) | void copy_and_move_test(Container<int>& q, Iterator it) {
  function emplace_test (line 204) | void emplace_test(Container<Object>& q, Iterator it) {
  function TEST (line 246) | TEST(EmplaceIterator, EmplacerTest) {
  function TEST (line 271) | TEST(EmplaceIterator, FrontEmplacerTest) {
  function TEST (line 296) | TEST(EmplaceIterator, BackEmplacerTest) {
  function TEST (line 321) | TEST(EmplaceIterator, HintEmplacerTest) {
  function TEST (line 374) | TEST(EmplaceIterator, Copy) {
  function TEST (line 394) | TEST(EmplaceIterator, Transform) {
  function TEST (line 415) | TEST(EmplaceIterator, EmplaceArgs) {
  function TEST (line 577) | TEST(EmplaceIterator, ImplicitUnpack) {
  type index_iterator_type_tests (line 615) | namespace index_iterator_type_tests {
    type WeirdContainer (line 618) | struct WeirdContainer {
    type ref_type (line 645) | struct ref_type {}
    type cref_type (line 646) | struct cref_type {}
    type just_operator (line 648) | struct just_operator {
      method ref_type (line 650) | ref_type operator[](std::size_t) { return {}; }
      method cref_type (line 651) | cref_type operator[](std::size_t) const { return {}; }
    type has_size_type (line 654) | struct has_size_type : just_operator {
    type has_difference_type (line 658) | struct has_difference_type : just_operator {
    type has_both_size_and_difference_type (line 662) | struct has_both_size_and_difference_type : just_operator {
    type no_operator (line 667) | struct no_operator {
      method ref_type (line 670) | ref_type tag_invoke(
      method cref_type (line 675) | cref_type tag_invoke(
    type no_operator_private (line 684) | struct no_operator_private {
      method ref_type (line 688) | ref_type tag_invoke(
      method cref_type (line 695) | cref_type tag_invoke(
    function is_same_test (line 712) | void is_same_test(T, T) {}
    function TEST (line 716) | TEST(IndexIterator, Types) {
  function TEST (line 757) | TEST(IndexIterator, Sort) {
  function accessTest (line 772) | constexpr bool accessTest() {
  function mutationsTest (line 793) | constexpr bool mutationsTest(I i0, I i1) {
  type IndexedVector (line 841) | struct IndexedVector {
    method iterator (line 857) | iterator begin() { return {*this, 0}; }
    method const_iterator (line 858) | const_iterator begin() const { return cbegin(); }
    method const_iterator (line 859) | const_iterator cbegin() const { return {*this, 0}; }
    method iterator (line 861) | iterator end() { return {*this, v_.size()}; }
    method const_iterator (line 862) | const_iterator end() const { return cend(); }
    method const_iterator (line 863) | const_iterator cend() const { return {*this, v_.size()}; }
  type CustomMapWithIndexedIterator (line 866) | struct CustomMapWithIndexedIterator {
    method iterator (line 876) | iterator begin() { return {*this, 0}; }
    method const_iterator (line 877) | const_iterator cbegin() const { return {*this, 0}; }
    method tag_invoke (line 883) | std::pair<int, int> tag_invoke(
  function TEST (line 893) | TEST(IndexIterator, UseProxyReferences) {
  function TEST (line 939) | TEST(IndexIterator, OperatorArrowForNonProxies) {
  function TEST (line 959) | TEST(IndexIterator, NoOperatorIntegration) {

FILE: folly/container/test/MapUtilTest.cpp
  function TEST (line 30) | TEST(MapUtil, getDefault) {
  function TEST (line 38) | TEST(MapUtil, getDefaultFunction) {
  function TEST (line 46) | TEST(MapUtil, getOrThrow) {
  function TEST (line 60) | TEST(MapUtil, getOrThrowSpecified) {
  function TEST (line 67) | TEST(MapUtil, getOptional) {
  function TEST (line 75) | TEST(MapUtil, getOptionalView) {
  function TEST (line 83) | TEST(MapUtil, getOptionalPathSimple) {
  function TEST (line 97) | TEST(MapUtil, getOptionalPathMixed) {
  function TEST (line 111) | TEST(MapUtil, getOptionalStd) {
  function TEST (line 124) | TEST(MapUtil, getRefDefault) {
  function TEST (line 133) | TEST(MapUtil, getRefDefaultFunction) {
  function TEST (line 148) | TEST(MapUtil, getPtr) {
  function TEST (line 161) | TEST(MapUtil, getPtr2) {
  function TEST (line 179) | TEST(MapUtil, getPtrReferenceValueType) {
  function TEST (line 188) | TEST(MapUtil, getPtrPathSimple) {
  function TEST (line 212) | TEST(MapUtil, getPtrPathMixed) {
  type element_type (line 233) | struct element_type {
  type element_type<T()> (line 238) | struct element_type<T()> {
  type Compiles (line 246) | struct Compiles : std::false_type {}
  type Compiles<
    T,
    void_t<decltype(get_ref_default(
        std::declval<std::map<int, element_type_t<T>>>(),
        std::declval<int>(),
        std::declval<T>()))>> (line 249) | struct Compiles<
  function TEST (line 257) | TEST(MapUtil, getDefaultTemporary) {
  function TEST (line 268) | TEST(MapUtil, getDefaultPath) {
  function TEST (line 276) | TEST(MapUtil, getDefaultPathMixed) {
  function TEST (line 292) | TEST(MapUtil, getRefDefaultPath) {
  function TEST (line 301) | TEST(MapUtil, getRefDefaultPathMixed) {
  type GetRefDefaultPathCompiles (line 319) | struct GetRefDefaultPathCompiles : std::false_type {}
  type GetRefDefaultPathCompiles<
    T,
    void_t<decltype(get_ref_default(
        std::declval<std::map<int, std::map<int, element_type_t<T>>>>(),
        std::declval<int>(),
        std::declval<int>(),
        std::declval<T>()))>> (line 322) | struct GetRefDefaultPathCompiles<
  function TEST (line 331) | TEST(MapUtil, getRefDefaultPathTemporary) {
  class TestConstruction (line 340) | class TestConstruction {
    method TestConstruction (line 342) | [[maybe_unused]] TestConstruction() { EXPECT_TRUE(false); }
    method TestConstruction (line 343) | [[maybe_unused]] TestConstruction(TestConstruction&&) { EXPECT_TRUE(fa...
    method TestConstruction (line 344) | TestConstruction(const TestConstruction&) { EXPECT_TRUE(false); }
    method TestConstruction (line 346) | explicit TestConstruction(std::string&& string)
    method TestConstruction (line 348) | explicit TestConstruction(int&& integer) : integer_{integer} {}
    method TestConstruction (line 350) | TestConstruction& operator=(const TestConstruction&) = delete;
    method TestConstruction (line 351) | TestConstruction& operator=(TestConstruction&&) = delete;
  function TEST (line 359) | TEST(MapUtil, testGetDefaultDeferredConstruction) {

FILE: folly/container/test/MergeTest.cpp
  function TEST (line 24) | TEST(MergeTest, NonOverlapping) {
  function TEST (line 36) | TEST(MergeTest, OverlappingInSingleInputRange) {
  function TEST (line 52) | TEST(MergeTest, OverlappingInDifferentInputRange) {

FILE: folly/container/test/RegexMatchCacheTest.cpp
  function FOLLY_KEEP (line 48) | FOLLY_KEEP size_t check_folly_regex_match_cache_dynamic_bitset_count(
  type test_ref (line 60) | struct test_ref : std::reference_wrapper<T> {
  type fmt (line 68) | namespace fmt {
    type formatter<test_ref<T>> (line 70) | struct formatter<test_ref<T>> : private formatter<std::remove_const_t<...
      method format (line 76) | auto format(test_ref<T> const ref, Context& ctx) const {
      method format (line 81) | auto format(test_ref<T> const ref, Context& ctx) {
  type unordered_vector_set (line 97) | struct unordered_vector_set : private unordered_vector_set_base<T> {
    method to_span (line 101) | static folly::span<T const> to_span(
    method to_span (line 107) | static folly::span<T const> to_span(
    method to_span (line 111) | folly::span<T const> to_span() const noexcept { return to_span(*this); }
    method begin (line 118) | auto begin() const noexcept { return to_span().begin(); }
    method end (line 119) | auto end() const noexcept { return to_span().end(); }
    method insert (line 123) | void insert(T const& value) { base::insert(value); }
    method erase (line 124) | void erase(T const& value) { base::erase(value); }
  type RegexMatchCacheDynamicBitsetTest (line 127) | struct RegexMatchCacheDynamicBitsetTest : testing::Test {}
  function TEST_F (line 129) | TEST_F(RegexMatchCacheDynamicBitsetTest, example) {
  function TEST_F (line 161) | TEST_F(RegexMatchCacheDynamicBitsetTest, combinatorics) {
  type RegexMatchCacheIndexedVectorTest (line 210) | struct RegexMatchCacheIndexedVectorTest : testing::Test {}
  function TEST_F (line 212) | TEST_F(RegexMatchCacheIndexedVectorTest, example) {
  type RegexMatchCacheTest (line 260) | struct RegexMatchCacheTest : testing::Test {
    class KeyMap (line 264) | class KeyMap final : public RegexMatchCache::KeyMap {
      method add (line 269) | void add(regex_key_and_view const& regex) {
      method lookup (line 274) | std::string_view lookup(regex_key const& regex) const override {
    class ConsistencyReportCache (line 281) | class ConsistencyReportCache
      method empty (line 290) | bool empty() const noexcept { return cache_.empty(); }
      method size (line 292) | size_t size() const noexcept { return cache_.size(); }
      method match (line 294) | bool match(
      method clear (line 304) | void clear() { cache_.clear(); }
      method map (line 306) | map const& get_map() const noexcept { return cache_; }
      method eraseRegex (line 308) | void eraseRegex(regex_key const regex) {
    class ConsistencyReport (line 320) | class ConsistencyReport {
      method ConsistencyReport (line 326) | ConsistencyReport() = default;
      method ConsistencyReport (line 327) | explicit ConsistencyReport(std::vector<std::string>&& lines) noexcept
      method print (line 330) | void print(std::ostream& o) const {
      method consistent (line 342) | bool consistent() const noexcept { return lines_.empty(); }
    method checkConsistency (line 350) | void checkConsistency(RegexMatchCache const& cache) {
    method ConsistencyReport (line 355) | ConsistencyReport getConsistencyReport(RegexMatchCache const& cache) {
      method ConsistencyReport (line 326) | ConsistencyReport() = default;
      method ConsistencyReport (line 327) | explicit ConsistencyReport(std::vector<std::string>&& lines) noexcept
      method print (line 330) | void print(std::ostream& o) const {
      method consistent (line 342) | bool consistent() const noexcept { return lines_.empty(); }
    method inspect (line 363) | auto inspect(RegexMatchCache const& cache) const {
    method getRegexList (line 367) | auto getRegexList(RegexMatchCache const& cache) const {
    method lookup (line 375) | auto lookup(RegexMatchCache& cache, std::string_view regex, time_point...
  function TEST_F (line 388) | TEST_F(RegexMatchCacheTest, clean) {
  function TEST_F (line 393) | TEST_F(RegexMatchCacheTest, clean_lookup) {
  function TEST_F (line 403) | TEST_F(RegexMatchCacheTest, add_strings_erase_add) {
  function TEST_F (line 422) | TEST_F(RegexMatchCacheTest, add_strings_lookup) {
  function TEST_F (line 439) | TEST_F(RegexMatchCacheTest, add_strings_lookup_erase_string) {
  function TEST_F (line 461) | TEST_F(RegexMatchCacheTest, add_strings_lookup_repeat) {
  function TEST_F (line 491) | TEST_F(RegexMatchCacheTest, add_string) {
  function TEST_F (line 512) | TEST_F(RegexMatchCacheTest, add_regex) {
  function TEST_F (line 534) | TEST_F(RegexMatchCacheTest, add_regex_add_string) {
  function TEST_F (line 554) | TEST_F(RegexMatchCacheTest, combinatorics) {

FILE: folly/container/test/ReserveTest.cpp
  class CountingAlloc (line 30) | class CountingAlloc : private std::allocator<T> {
    method CountingAlloc (line 34) | CountingAlloc() = default;
    method CountingAlloc (line 37) | explicit CountingAlloc(const CountingAlloc<U>& /*unused*/) noexcept
    method getCount (line 40) | int getCount() const { return *counter_; }
    method T (line 42) | T* allocate(size_t size) {
    method deallocate (line 47) | void deallocate(T* p, size_t size) { std::allocator<T>::deallocate(p, ...
  function TEST (line 57) | TEST(ReserveUtil, VectorGrowBy) {
  function getUniqueId (line 79) | auto getUniqueId(int i, int j) {
  function testMapGrowBy (line 84) | void testMapGrowBy() {
  function TEST (line 146) | TEST(ReserveUtil, F14VectorMapGrowBy) {
  function TEST (line 150) | TEST(ReserveUtil, F14ValueMapGrowBy) {
  function TEST (line 154) | TEST(ReserveUtil, F14NodeMapGrowBy) {
  function TEST (line 158) | TEST(ReserveUtil, UnorderedMapGrowBy) {
  function TEST (line 162) | TEST(ReserveUtil, ReserveIfAvailableVector) {
  function TEST (line 169) | TEST(ReserveUtil, ReserveIfAvailableList) {

FILE: folly/container/test/SparseByteSetBenchmark.cpp
  class BitSetWrapper (line 39) | class BitSetWrapper {
    method add (line 41) | inline bool add(uint8_t i) {
    method contains (line 48) | inline bool contains(uint8_t i) { return rep_[i]; }
  class BoolArraySet (line 53) | class BoolArraySet {
    method BoolArraySet (line 55) | BoolArraySet() { memset(rep_, 0, sizeof(rep_)); }
    method add (line 56) | inline bool add(uint8_t i) {
    method contains (line 63) | inline bool contains(uint8_t i) { return rep_[i]; }
  function rand_bench (line 70) | void rand_bench(int iters, size_t size_add, size_t size_contains) {
  function setup_rand_bench (line 98) | void setup_rand_bench() {
  function main (line 149) | int main(int argc, char** argv) {

FILE: folly/container/test/SparseByteSetTest.cpp
  class SparseByteSetTest (line 31) | class SparseByteSetTest : public testing::Test {
  function TEST_F (line 39) | TEST_F(SparseByteSetTest, empty) {
  function TEST_F (line 45) | TEST_F(SparseByteSetTest, each) {
  function TEST_F (line 56) | TEST_F(SparseByteSetTest, each_random) {
  function TEST_F (line 70) | TEST_F(SparseByteSetTest, clear) {
  function TEST_F (line 81) | TEST_F(SparseByteSetTest, remove) {
  function TEST_F (line 102) | TEST_F(SparseByteSetTest, remove_nop) {
  function TEST_F (line 107) | TEST_F(SparseByteSetTest, size) {

FILE: folly/container/test/StdBitsetBenchmark.cpp
  function createRandomBitset (line 27) | std::bitset<N> createRandomBitset(size_t seed, double density = 0.5) {
  function createSparseBitset (line 41) | std::bitset<N> createSparseBitset(size_t seed) {
  function createDenseBitset (line 54) | std::bitset<N> createDenseBitset(size_t seed) {
  function BENCHMARK (line 60) | BENCHMARK(StdBitsetFindFirst_64_Sparse, iters) {
  function BENCHMARK (line 71) | BENCHMARK(StdBitsetFindFirst_64_Dense, iters) {
  function BENCHMARK (line 82) | BENCHMARK(StdBitsetFindFirst_64_Random, iters) {
  function BENCHMARK (line 93) | BENCHMARK(StdBitsetFindFirst_256_Sparse, iters) {
  function BENCHMARK (line 104) | BENCHMARK(StdBitsetFindFirst_256_Dense, iters) {
  function BENCHMARK (line 115) | BENCHMARK(StdBitsetFindFirst_256_Random, iters) {
  function BENCHMARK (line 126) | BENCHMARK(StdBitsetFindFirst_1024_Sparse, iters) {
  function BENCHMARK (line 137) | BENCHMARK(StdBitsetFindFirst_1024_Dense, iters) {
  function BENCHMARK (line 148) | BENCHMARK(StdBitsetFindFirst_1024_Random, iters) {
  function BENCHMARK (line 159) | BENCHMARK(StdBitsetFindNext_64_Sparse, iters) {
  function BENCHMARK (line 179) | BENCHMARK(StdBitsetFindNext_64_Dense, iters) {
  function BENCHMARK (line 199) | BENCHMARK(StdBitsetFindNext_64_Random, iters) {
  function BENCHMARK (line 219) | BENCHMARK(StdBitsetFindNext_256_Sparse, iters) {
  function BENCHMARK (line 239) | BENCHMARK(StdBitsetFindNext_256_Dense, iters) {
  function BENCHMARK (line 259) | BENCHMARK(StdBitsetFindNext_256_Random, iters) {
  function BENCHMARK (line 279) | BENCHMARK(StdBitsetFindNext_1024_Sparse, iters) {
  function BENCHMARK (line 299) | BENCHMARK(StdBitsetFindNext_1024_Dense, iters) {
  function BENCHMARK (line 319) | BENCHMARK(StdBitsetFindNext_1024_Random, iters) {
  function BENCHMARK (line 339) | BENCHMARK(StdBitsetIterateAllBits_1024, iters) {
  function main (line 358) | int main(int argc, char** argv) {

FILE: folly/container/test/StdBitsetTest.cpp
  function TEST (line 25) | TEST(BitSetTest, FindFirst) {
  function TEST (line 44) | TEST(BitSetTest, FindNext) {

FILE: folly/container/test/TrackingTypes.h
  function namespace (line 29) | namespace folly {
  type PermissiveConstructorTestInt (line 84) | struct PermissiveConstructorTestInt {
  function rhs (line 105) | bool operator==(PermissiveConstructorTestInt const& rhs) const {
  function rhs (line 108) | bool operator!=(PermissiveConstructorTestInt const& rhs) const {
  type Counts (line 114) | struct Counts {
  function moveConstruct (line 116) | uint64_t moveConstruct{0}
  function copyConvert (line 117) | uint64_t copyConvert{0}
  function moveConvert (line 118) | uint64_t moveConvert{0}
  function copyAssign (line 119) | uint64_t copyAssign{0}
  function moveAssign (line 120) | uint64_t moveAssign{0}
  function defaultConstruct (line 121) | uint64_t defaultConstruct{0}
  function destroyed (line 122) | uint64_t destroyed{0}
  function dist (line 148) | uint64_t dist(Counts const& rhs) const {
  function operator (line 160) | bool operator!=(Counts const& rhs) const { return !(*this == rhs); }
  function Counts (line 202) | inline Counts& sumCounts() {
  function Counts (line 211) | static Counts& counts() {
  function val_ (line 222) | Tracked(uint64_t const& val) : val_{val}
  function val_ (line 230) | Tracked(Tracked const& rhs) : val_{rhs.val_}
  function operator (line 268) | bool operator==(Tracked const& rhs) const { return val_ == rhs.val_; }
  function operator (line 269) | bool operator!=(Tracked const& rhs) const { return !(*this == rhs); }
  function const (line 276) | size_t operator()(Tracked<Tag> const& tracked) const {
  function const (line 279) | size_t operator()(uint64_t v) const { return v ^ Tag; }
  function unwrap (line 286) | uint64_t unwrap(Tracked<Tag> const& v) const { return v.val_; }
  function unwrap (line 287) | uint64_t unwrap(uint64_t v) const { return v; }
  function testAllocatedMemorySize (line 295) | inline size_t& testAllocatedMemorySize() {
  function testAllocatedBlockCount (line 300) | inline size_t& testAllocatedBlockCount() {
  function testAllocationCount (line 305) | inline size_t& testAllocationCount() {
  function testAllocationMaxCount (line 310) | inline size_t& testAllocationMaxCount() {
  function unlimitTestAllocations (line 319) | inline void unlimitTestAllocations() {
  function resetTracking (line 323) | inline void resetTracking() {
  function T (line 378) | T* allocate(size_t n) {
  function deallocate (line 392) | void deallocate(T* p, size_t n) {
  function T (line 478) | T* allocate(size_t n) { return static_cast<T*>((*alloc_)(n * sizeof(T))); }
  function deallocate (line 479) | void deallocate(T* p, size_t n) {
  function const (line 512) | bool operator()(T const& lhs, T const& rhs) const {
  type HashFirst (line 537) | struct HashFirst {
  type EqualFirst (line 544) | struct EqualFirst {
  function namespace (line 554) | namespace std {

FILE: folly/container/test/UtilTest.cpp
  type folly (line 28) | namespace folly {
    function TEST (line 30) | TEST(Tracked, baseline) {
    function runKeyExtractCases (line 99) | void runKeyExtractCases(
    type DoEmplace1 (line 302) | struct DoEmplace1 {
    type DoEmplace2 (line 311) | struct DoEmplace2 {
    type DoEmplace3 (line 327) | struct DoEmplace3 {
    type DoEmplace3Value (line 355) | struct DoEmplace3Value {
    function TEST (line 379) | TEST(Util, callWithExtractedKey) {
    function TEST (line 398) | TEST(Util, callWithConstructedKey) {
    type ExpectArgTypes (line 476) | struct ExpectArgTypes {
    function TEST (line 497) | TEST(Util, callWithExtractedHeterogeneousKey) {
    function TEST (line 558) | TEST(Util, callWithConstructedHeterogeneousKey) {

FILE: folly/container/test/WeightedEvictingCacheMapTest.cpp
  type ValueStringLength (line 25) | struct ValueStringLength {
  function TEST (line 31) | TEST(ImplicitlyWeightedEvictingCacheMap, Misc) {
  function TEST (line 165) | TEST(ImplicitlyWeightedEvictingCacheMap, ConstAndMove) {
  function TEST (line 204) | TEST(ImplicitlyWeightedEvictingCacheMap, Scalars) {
  function TEST (line 216) | TEST(ImplicitlyWeightedEvictingCacheMap, NonCopyableAndIterator) {
  function TEST (line 324) | TEST(ImplicitlyWeightedEvictingCacheMap, PruneHook) {
  function TEST (line 352) | TEST(WeightedEvictingCacheMap, Misc) {
  function TEST (line 472) | TEST(WeightedEvictingCacheMap, OverMaxWeight) {
  function TEST (line 593) | TEST(WeightedEvictingCacheMap, ConstAndIterator) {
  function TEST (line 693) | TEST(WeightedEvictingCacheMap, NonCopyableAndIteratorMutation) {
  function TEST (line 745) | TEST(WeightedEvictingCacheMap, Scalars) {
  function TEST (line 760) | TEST(WeightedEvictingCacheMap, ApproximateEntryMemUsage) {
  function TEST (line 783) | TEST(WeightedEvictingCacheMap, PruneHook) {

FILE: folly/container/test/heap_vector_types_test.cpp
  type less_invert (line 39) | struct less_invert {
  function check_invariant (line 44) | void check_invariant(Container& c) {
  type OneAtATimePolicy (line 57) | struct OneAtATimePolicy {
    method increase_capacity (line 59) | void increase_capacity(Container& c) {
  type CountingAllocator (line 67) | struct CountingAllocator : std::allocator<T> {
    method T (line 68) | T* allocate(std::size_t n) {
    type rebind (line 75) | struct rebind {
  type CountCopyCtor (line 80) | struct CountCopyCtor {
    method CountCopyCtor (line 81) | explicit CountCopyCtor() : val_(0), count_(0) {}
    method CountCopyCtor (line 83) | explicit CountCopyCtor(int val) : val_(val), count_(0) {}
    method CountCopyCtor (line 85) | CountCopyCtor(const CountCopyCtor& c) noexcept
    method CountCopyCtor (line 90) | CountCopyCtor& operator=(const CountCopyCtor&) = default;
  type KeyCopiedException (line 101) | struct KeyCopiedException : public std::exception {}
  type KeyThatThrowsOnCopies (line 106) | struct KeyThatThrowsOnCopies {
    method KeyThatThrowsOnCopies (line 110) | KeyThatThrowsOnCopies(int32_t key) noexcept
    method KeyThatThrowsOnCopies (line 112) | KeyThatThrowsOnCopies(int32_t key, bool throwOnCopy) noexcept
    method KeyThatThrowsOnCopies (line 117) | KeyThatThrowsOnCopies(KeyThatThrowsOnCopies const& other)
    method KeyThatThrowsOnCopies (line 124) | KeyThatThrowsOnCopies(KeyThatThrowsOnCopies&& other) noexcept = default;
    method KeyThatThrowsOnCopies (line 126) | KeyThatThrowsOnCopies& operator=(KeyThatThrowsOnCopies const& other) {
    method KeyThatThrowsOnCopies (line 135) | KeyThatThrowsOnCopies& operator=(KeyThatThrowsOnCopies&& other) noexce...
  function TEST (line 150) | TEST(HeapVectorTypes, SetAssignmentInitListTest) {
  function TEST (line 159) | TEST(HeapVectorTypes, SimpleSetTest) {
  function TEST (line 237) | TEST(HeapVectorTypes, TransparentSetTest) {
  function TEST (line 293) | TEST(HeapVectorTypes, BadHints) {
  function TEST (line 308) | TEST(HeapVectorTypes, MapAssignmentInitListTest) {
  function TEST (line 329) | TEST(HeapVectorTypes, MapAssignmentInitListTestEnum) {
  function TEST (line 351) | TEST(HeapVectorTypes, MapBadHints) {
  function TEST (line 379) | TEST(HeapVectorTypes, FromVector) {
  function TEST (line 412) | TEST(HeapVectorTypes, IterateOverVectorWithinMap) {
  function TEST (line 455) | TEST(HeapVectorTypes, SimpleMapTest) {
  function TEST (line 537) | TEST(HeapVectorTypes, SimpleSmallMapTest) {
  function TEST (line 619) | TEST(HeapVectorTypes, TransparentMapTest) {
  function TEST (line 669) | TEST(HeapVectorTypes, Sizes) {
  function TEST (line 699) | TEST(HeapVectorTypes, Iterators) {
  function TEST (line 728) | TEST(HeapVectorTypes, IteratorsCombinatorics) {
  function TEST (line 771) | TEST(HeapVectorTypes, InitializerLists) {
  function TEST (line 817) | TEST(HeapVectorTypes, CustomCompare) {
  function TEST (line 832) | TEST(HeapVectorTypes, GrowthPolicy) {
  function TEST (line 858) | TEST(HeapVectorTest, EmptyTest) {
  function TEST (line 876) | TEST(HeapVectorTest, MoveTest) {
  function TEST (line 903) | TEST(HeapVectorTest, ShrinkTest) {
  function TEST (line 917) | TEST(HeapVectorTypes, EraseTest) {
  function TEST (line 959) | TEST(HeapVectorTypes, EraseTest2) {
  function TEST (line 1037) | TEST(HeapVectorTypes, TestSetBulkInsertionSortMerge) {
  function TEST (line 1052) | TEST(HeapVectorTypes, TestBulkInsertionUncopyableTypes) {
  function TEST (line 1079) | TEST(HeapVectorTypes, TestSetBulkInsertionMiddleValuesEqualDuplication) {
  function TEST (line 1093) | TEST(HeapVectorTypes, TestSetBulkInsertionSortMergeDups) {
  function TEST (line 1107) | TEST(HeapVectorTypes, TestSetInsertionDupsOneByOne) {
  function TEST (line 1123) | TEST(HeapVectorTypes, TestSetBulkInsertionSortNoMerge) {
  function TEST (line 1137) | TEST(HeapVectorTypes, TestSetBulkInsertionNoSortMerge) {
  function TEST (line 1151) | TEST(HeapVectorTypes, TestSetBulkInsertionNoSortNoMerge) {
  function TEST (line 1165) | TEST(HeapVectorTypes, TestSetBulkInsertionEmptyRange) {
  type Movable (line 1187) | struct Movable {
    method Movable (line 1189) | explicit Movable(int x) : x_(x) {}
    method Movable (line 1190) | Movable(const Movable&) { ADD_FAILURE() << "Copy ctor should not be ca...
    method Movable (line 1191) | Movable& operator=(const Movable&) {
    method Movable (line 1196) | Movable(Movable&&) = default;
    method Movable (line 1197) | Movable& operator=(Movable&&) = default;
  function TEST (line 1200) | TEST(HeapVectorTypes, TestBulkInsertionMovableTypes) {
  function TEST (line 1215) | TEST(HeapVectorTypes, TestBulkInsertionMovableTypesSmall) {
  function TEST (line 1230) | TEST(HeapVectorTypes, TestSetCreationFromVector) {
  function TEST (line 1237) | TEST(HeapVectorTypes, TestMapCreationFromVector) {
  function TEST (line 1261) | TEST(HeapVectorTypes, TestMapCreationFromVectorSmall) {
  function TEST (line 1282) | TEST(HeapVectorTypes, TestSetCreationFromSmallVector) {
  function TEST (line 1296) | TEST(HeapVectorTypes, TestMapCreationFromSmallVector) {
  function TEST (line 1319) | TEST(HeapVectorTypes, TestBulkInsertionWithDuplicatesIntoEmptySet) {
  function TEST (line 1328) | TEST(HeapVectorTypes, TestBulkInsertionWithDuplicatesIntoEmptyMap) {
  function TEST (line 1350) | TEST(HeapVectorTypes, TestBulkInsertionWithDuplicatesIntoEmptyMapSmall) {
  function TEST (line 1372) | TEST(HeapVectorTypes, TestDataPointsToFirstElement) {
  function TEST (line 1385) | TEST(HeapVectorTypes, TestDataPointsToFirstElementSmall) {
  function TEST (line 1398) | TEST(HeapVectorTypes, TestEmplaceHint) {
  function TEST (line 1416) | TEST(HeapVectorTypes, TestExceptionSafety) {
  type test_resource (line 1459) | struct test_resource : public memory_resource {
    method do_deallocate (line 1464) | void do_deallocate(
    method do_is_equal (line 1469) | bool do_is_equal(const memory_resource& other) const noexcept override {
  function TEST (line 1476) | TEST(HeapVectorTypes, TestPmrAllocatorSimple) {
  function TEST (line 1486) | TEST(HeapVectorTypes, TestPmrCopyConstructSameAlloc) {
  function TEST (line 1514) | TEST(HeapVectorTypes, TestPmrCopyConstructDifferentAlloc) {
  function TEST (line 1541) | TEST(HeapVectorTypes, TestPmrMoveConstructSameAlloc) {
  function TEST (line 1574) | TEST(HeapVectorTypes, TestPmrMoveConstructDifferentAlloc) {
  function TEST (line 1610) | TEST(HeapVectorTypes, TestCreationFromPmrVector) {
  function TEST (line 1650) | TEST(HeapVectorTypes, TestPmrAllocatorScoped) {
  function TEST (line 1710) | TEST(HeapVectorTypes, TestInsertHintCopy) {
  function TEST (line 1736) | TEST(HeapVectorTypes, TestIterator) {
  function TEST (line 1766) | TEST(HeapVectorTypes, TestGetContainer) {
  function TEST (line 1775) | TEST(HeapVectorTypes, TestSwapContainer) {

FILE: folly/container/test/range_traits_test.cpp
  type RangeTraitsTest (line 31) | struct RangeTraitsTest : testing::Test {}
  function TEST_F (line 33) | TEST_F(RangeTraitsTest, is_contiguous_range_v) {

FILE: folly/container/test/small_vector_test.cpp
  type same_ (line 46) | struct same_
  type same_<T, T> (line 48) | struct same_<T, T> {}
  type NontrivialType (line 140) | struct NontrivialType {
    method NontrivialType (line 142) | explicit NontrivialType() : a(0) {}
    method NontrivialType (line 144) | NontrivialType(int a_) : a(a_) { ++ctored; }
    method NontrivialType (line 146) | NontrivialType(NontrivialType const& /* s */) { ++ctored; }
    method NontrivialType (line 148) | NontrivialType& operator=(NontrivialType const& o) {
  type TestException (line 161) | struct TestException {}
  function MaybeThrow (line 164) | void MaybeThrow() {
  type Thrower (line 171) | struct Thrower {
    method Thrower (line 174) | Thrower() : magic(kMagic) {
    method Thrower (line 179) | Thrower(Thrower const& other) : magic(other.magic) {
    method Thrower (line 190) | Thrower& operator=(Thrower const& /* other */) {
  type NoncopyableCounter (line 205) | struct NoncopyableCounter {
    method NoncopyableCounter (line 207) | NoncopyableCounter() { ++alive; }
    method NoncopyableCounter (line 209) | NoncopyableCounter(NoncopyableCounter&&) noexcept { ++alive; }
    method NoncopyableCounter (line 210) | NoncopyableCounter(NoncopyableCounter const&) = delete;
    method NoncopyableCounter (line 211) | NoncopyableCounter& operator=(NoncopyableCounter const&) const = delete;
    method NoncopyableCounter (line 212) | NoncopyableCounter& operator=(NoncopyableCounter&&) { return *this; }
  type TestBasicGuarantee (line 225) | struct TestBasicGuarantee {
    method TestBasicGuarantee (line 229) | explicit TestBasicGuarantee(int prepopulate_) : prepopulate(prepopulat...
  function testBasicGuarantee (line 270) | void testBasicGuarantee() {
  function TEST (line 316) | TEST(smallVector, BasicGuarantee) {
  function TEST (line 335) | TEST(smallVector, leakTest) {
  function TEST (line 351) | TEST(smallVector, leakTestWithTracking) {
  function TEST (line 367) | TEST(smallVector, leakTestWithLeakedObject) {
  function TEST (line 388) | TEST(smallVector, InsertTrivial) {
  function TEST (line 410) | TEST(smallVector, InsertNontrivial) {
  function TEST (line 434) | TEST(smallVector, InsertFromBidirectionalList) {
  function testSwap (line 445) | void testSwap() {
  function TEST (line 489) | TEST(smallVector, Swap) {
  function testEmplace (line 508) | void testEmplace() {
  function TEST (line 544) | TEST(smallVector, Emplace) {
  function TEST (line 550) | TEST(smallVector, Erase) {
  function testGrowShrinkGrow (line 587) | void testGrowShrinkGrow() {
  function TEST (line 620) | TEST(smallVector, GrowShrinkGrow) {
  function TEST (line 626) | TEST(smallVector, ShrinkToFitMoveOnly) {
  function TEST (line 641) | TEST(smallVector, Iteration) {
  function TEST (line 665) | TEST(smallVector, NonCopyableType) {
  function testMoveConstructor (line 711) | void testMoveConstructor() {
  function TEST (line 726) | TEST(smallVector, MoveConstructor) {
  function TEST (line 731) | TEST(smallVector, NoHeap) {
  function TEST (line 774) | TEST(smallVector, MaxSize) {
  function TEST (line 781) | TEST(smallVector, AllHeap) {
  function testBasic (line 800) | void testBasic() {
  function TEST (line 844) | TEST(smallVector, Basic) {
  function TEST (line 849) | TEST(smallVector, Capacity) {
  function testSelfPushBack (line 894) | void testSelfPushBack() {
  function TEST (line 908) | TEST(smallVector, SelfPushBack) {
  function testSelfEmplaceBack (line 914) | void testSelfEmplaceBack() {
  function TEST (line 928) | TEST(smallVector, SelfEmplaceBack) {
  function testSelfInsert (line 934) | void testSelfInsert() {
  function TEST (line 981) | TEST(smallVector, SelfInsert) {
  type CheckedInt (line 987) | struct CheckedInt {
    method CheckedInt (line 989) | CheckedInt() : value(DEFAULT_VALUE) {}
    method CheckedInt (line 990) | explicit CheckedInt(int value_) : value(value_) {}
    method CheckedInt (line 991) | CheckedInt(const CheckedInt& rhs, int) : value(rhs.value) {}
    method CheckedInt (line 992) | CheckedInt(const CheckedInt& rhs) : value(rhs.value) {}
    method CheckedInt (line 993) | CheckedInt(CheckedInt&& rhs) noexcept : value(rhs.value) {
    method CheckedInt (line 996) | CheckedInt& operator=(const CheckedInt& rhs) {
    method CheckedInt (line 1000) | CheckedInt& operator=(CheckedInt&& rhs) noexcept {
  function TEST (line 1009) | TEST(smallVector, ForwardingEmplaceInsideVector) {
  function TEST (line 1018) | TEST(smallVector, LVEmplaceInsideVector) {
  function TEST (line 1027) | TEST(smallVector, CLVEmplaceInsideVector) {
  function TEST (line 1037) | TEST(smallVector, RVEmplaceInsideVector) {
  function TEST (line 1047) | TEST(smallVector, LVPushValueInsideVector) {
  function TEST (line 1056) | TEST(smallVector, RVPushValueInsideVector) {
  function TEST (line 1066) | TEST(smallVector, EmplaceIterCtor) {
  function TEST (line 1074) | TEST(smallVector, InputIterator) {
  function TEST (line 1095) | TEST(smallVector, NoCopyCtor) {
  function TEST (line 1111) | TEST(smallVector, ZeroInitializable) {
  function TEST (line 1119) | TEST(smallVector, InsertMoreThanGrowth) {
  function TEST (line 1127) | TEST(smallVector, EmplaceBackExponentialGrowth) {
  function TEST (line 1140) | TEST(smallVector, InsertExponentialGrowth) {
  function TEST (line 1153) | TEST(smallVector, InsertNExponentialGrowth) {
  type Counts (line 1167) | struct Counts {
  class Counter (line 1172) | class Counter {
    method Counter (line 1176) | explicit Counter(Counts& counts_) : counts(&counts_) {}
    method Counter (line 1177) | Counter(Counter const& other) noexcept : counts(other.counts) {
    method Counter (line 1180) | Counter(Counter&& other) noexcept : counts(other.counts) {
    method Counter (line 1183) | Counter& operator=(Counter const& rhs) noexcept {
    method Counter (line 1188) | [[maybe_unused]] Counter& operator=(Counter&& rhs) noexcept {
  function TEST (line 1196) | TEST(smallVector, EmplaceBackEfficiency) {
  function TEST (line 1212) | TEST(smallVector, RVPushBackEfficiency) {
  function TEST (line 1230) | TEST(smallVector, CLVPushBackEfficiency) {
  function TEST (line 1249) | TEST(smallVector, StorageForSortedVectorMap) {
  function TEST (line 1261) | TEST(smallVector, NoHeapStorageForSortedVectorMap) {
  function TEST (line 1273) | TEST(smallVector, StorageForSortedVectorSet) {
  function TEST (line 1285) | TEST(smallVector, NoHeapStorageForSortedVectorSet) {
  function TEST (line 1297) | TEST(smallVector, SelfMoveAssignmentForVectorOfPair) {
  function TEST (line 1307) | TEST(smallVector, SelfCopyAssignmentForVectorOfPair) {
  type NonAssignableType (line 1318) | struct NonAssignableType {
  function TEST (line 1323) | TEST(smallVector, PopBackNonAssignableType) {
  function TEST (line 1331) | TEST(smallVector, erase) {
  function TEST (line 1341) | TEST(smallVector, eraseIf) {
  class NonTrivialInt (line 1353) | class NonTrivialInt {
    method NonTrivialInt (line 1355) | NonTrivialInt() {}
    method NonTrivialInt (line 1356) | NonTrivialInt(int value)
  function testMoveAndCopy (line 1368) | void testMoveAndCopy() {
  function TEST (line 1456) | TEST(smallVector, MoveAndCopyTrivial) {
  function TEST (line 1464) | TEST(smallVector, MoveAndCopyNonTrivial) {
  function TEST (line 1469) | TEST(smallVector, PolicyMaxSizeExceeded) {

FILE: folly/container/test/sorted_vector_test.cpp
  type less_invert (line 84) | struct less_invert {
  function check_invariant (line 89) | void check_invariant(Container& c) {
  type OneAtATimePolicy (line 102) | struct OneAtATimePolicy {
    method increase_capacity (line 104) | void increase_capacity(Container& c) {
  type CountCopyCtor (line 111) | struct CountCopyCtor {
    method CountCopyCtor (line 112) | explicit CountCopyCtor() : val_(0), count_(0) {}
    method CountCopyCtor (line 114) | explicit CountCopyCtor(int val) : val_(val), count_(0) {}
    method CountCopyCtor (line 116) | CountCopyCtor(const CountCopyCtor& c) noexcept
    method CountCopyCtor (line 121) | CountCopyCtor& operator=(const CountCopyCtor&) = default;
  type KeyCopiedException (line 132) | struct KeyCopiedException : public std::exception {}
  type KeyThatThrowsOnCopies (line 137) | struct KeyThatThrowsOnCopies {
    method KeyThatThrowsOnCopies (line 141) | [[maybe_unused]] KeyThatThrowsOnCopies() {}
    method KeyThatThrowsOnCopies (line 143) | KeyThatThrowsOnCopies(int32_t key) noexcept
    method KeyThatThrowsOnCopies (line 145) | KeyThatThrowsOnCopies(int32_t key, bool throwOnCopy) noexcept
    method KeyThatThrowsOnCopies (line 150) | KeyThatThrowsOnCopies(KeyThatThrowsOnCopies const& other)
    method KeyThatThrowsOnCopies (line 157) | KeyThatThrowsOnCopies(KeyThatThrowsOnCopies&& other) noexcept = default;
    method KeyThatThrowsOnCopies (line 159) | KeyThatThrowsOnCopies& operator=(KeyThatThrowsOnCopies const& other) {
    method KeyThatThrowsOnCopies (line 168) | KeyThatThrowsOnCopies& operator=(KeyThatThrowsOnCopies&& other) noexce...
  function TEST (line 183) | TEST(SortedVectorTypes, SetAssignmentInitListTest) {
  function TEST (line 192) | TEST(SortedVectorTypes, SetUnderlyingContainerDirectFillInWithGuardTest) {
  function TEST (line 205) | TEST(
  function TEST (line 220) | TEST(SortedVectorTypes, MapAssignmentInitListTest) {
  function TEST (line 231) | TEST(SortedVectorTypes, MapUnderlyingContainerDirectFillInWithGuardTest) {
  function TEST (line 246) | TEST(
  function TEST (line 263) | TEST(SortedVectorTypes, SimpleSetTest) {
  function TEST (line 341) | TEST(SortedVectorTypes, TransparentSetTest) {
  function TEST (line 407) | TEST(SortedVectorTypes, BadHints) {
  function TEST (line 422) | TEST(SortedVectorTypes, SimpleMapTest) {
  function TEST (line 504) | TEST(SortedVectorTypes, TransparentMapTest) {
  function TEST (line 554) | TEST(SortedVectorTypes, Find2) {
  function TEST (line 591) | TEST(SortedVectorTypes, Sizes) {
  function TEST (line 615) | TEST(SortedVectorTypes, InitializerLists) {
  function TEST (line 645) | TEST(SortedVectorTypes, CustomCompare) {
  function TEST (line 659) | TEST(SortedVectorTypes, GrowthPolicy) {
  function TEST (line 697) | TEST(SortedVectorTest, EmptyTest) {
  function TEST (line 708) | TEST(SortedVectorTest, MoveTest) {
  function TEST (line 726) | TEST(SortedVectorTest, ShrinkTest) {
  function TEST (line 740) | TEST(SortedVectorTypes, EraseTest) {
  function TEST (line 748) | TEST(SortedVectorTypes, EraseTest2) {
  function TEST (line 798) | TEST(SortedVectorTypes, EraseIfTest) {
  function TEST (line 811) | TEST(SortedVectorTypes, TestSetBulkInsertionSortMerge) {
  function TEST (line 826) | TEST(SortedVectorTypes, TestSetBulkInsertionMiddleValuesEqualDuplication) {
  function TEST (line 840) | TEST(SortedVectorTypes, TestSetBulkInsertionSortMergeDups) {
  function TEST (line 854) | TEST(SortedVectorTypes, TestSetInsertionDupsOneByOne) {
  function TEST (line 870) | TEST(SortedVectorTypes, TestSetBulkInsertionSortNoMerge) {
  function TEST (line 884) | TEST(SortedVectorTypes, TestSetBulkInsertionNoSortMerge) {
  function TEST (line 907) | TEST(SortedVectorTypes, TestSetBulkInsertionNoSortNoMerge) {
  function TEST (line 930) | TEST(SortedVectorTypes, TestSetBulkInsertionEmptyRange) {
  function TEST (line 952) | TEST(SortedVectorTypes, TestBulkInsertionUncopyableTypes) {
  type Movable (line 967) | struct Movable {
    method Movable (line 969) | explicit Movable(int x) : x_(x) {}
    method Movable (line 970) | Movable(const Movable&) { ADD_FAILURE() << "Copy ctor should not be ca...
    method Movable (line 971) | Movable& operator=(const Movable&) {
    method Movable (line 976) | Movable(Movable&&) = default;
    method Movable (line 977) | Movable& operator=(Movable&&) = default;
  function TEST (line 980) | TEST(SortedVectorTypes, TestBulkInsertionMovableTypes) {
  function TEST (line 995) | TEST(SortedVectorTypes, TestSetCreationFromVector) {
  function TEST (line 1002) | TEST(SortedVectorTypes, TestMapCreationFromVector) {
  function TEST (line 1018) | TEST(SortedVectorTypes, TestSetCreationFromSmallVector) {
  function TEST (line 1026) | TEST(SortedVectorTypes, TestMapCreationFromSmallVector) {
  function TEST (line 1042) | TEST(SortedVectorTypes, TestBulkInsertionWithDuplicatesIntoEmptySet) {
  function TEST (line 1051) | TEST(SortedVectorTypes, TestDataPointsToFirstElement) {
  function TEST (line 1066) | TEST(SortedVectorTypes, TestEmplaceHint) {
  function TEST (line 1092) | TEST(SortedVectorTypes, TestExceptionSafety) {
  type test_resource (line 1134) | struct test_resource : public memory_resource {
    method do_deallocate (line 1139) | void do_deallocate(
    method do_is_equal (line 1144) | bool do_is_equal(const memory_resource& other) const noexcept override {
  function TEST (line 1151) | TEST(SortedVectorTypes, TestPmrAllocatorSimple) {
  function TEST (line 1161) | TEST(SortedVectorTypes, TestPmrCopyConstructSameAlloc) {
  function TEST (line 1189) | TEST(SortedVectorTypes, TestPmrCopyConstructDifferentAlloc) {
  function TEST (line 1217) | TEST(SortedVectorTypes, TestPmrMoveConstructSameAlloc) {
  function TEST (line 1251) | TEST(SortedVectorTypes, TestPmrMoveConstructDifferentAlloc) {
  function TEST (line 1288) | TEST(SortedVectorTypes, TestCreationFromPmrVector) {
  function TEST (line 1328) | TEST(SortedVectorTypes, TestPmrAllocatorScoped) {
  function TEST (line 1413) | TEST(SortedVectorTypes, TestInsertHintCopy) {
  function TEST (line 1439) | TEST(SortedVectorTypes, TestTryEmplace) {
  function TEST (line 1481) | TEST(SortedVectorTypes, TestInsertOrAssign) {
  function TEST (line 1515) | TEST(SortedVectorTypes, TestInsertOrAssignWithHintExtensive) {
  function TEST (line 1534) | TEST(SortedVectorTypes, TestInsertOrAssignWithHint) {
  function TEST (line 1575) | TEST(SortedVectorTypes, TestGetContainer) {
  function TEST (line 1582) | TEST(SortedVectorTypes, Comparisons) {
  function TEST (line 1639) | TEST(SortedVectorTypes, TestSwapContainer) {

FILE: folly/container/test/span_test.cpp
  type SpanTest (line 40) | struct SpanTest : public testing::TestWithParam<Param> {}
  type quote (line 44) | struct quote {
  function TYPED_TEST_P (line 49) | TYPED_TEST_P(SpanTest, dyn_traits) {
  function TYPED_TEST_P (line 57) | TYPED_TEST_P(SpanTest, dyn_ctor_default) {
  function TYPED_TEST_P (line 67) | TYPED_TEST_P(SpanTest, dyn_ctor_pointer_size) {
  function TYPED_TEST_P (line 78) | TYPED_TEST_P(SpanTest, dyn_ctor_pointer_pointer) {
  function TYPED_TEST_P (line 89) | TYPED_TEST_P(SpanTest, dyn_ctor_c_array) {
  function TYPED_TEST_P (line 100) | TYPED_TEST_P(SpanTest, dyn_ctor_std_array) {
  function TYPED_TEST_P (line 111) | TYPED_TEST_P(SpanTest, dyn_ctor_std_vector) {
  function TYPED_TEST_P (line 122) | TYPED_TEST_P(SpanTest, dyn_access) {
  function TYPED_TEST_P (line 133) | TYPED_TEST_P(SpanTest, dyn_static_subspan) {
  function TYPED_TEST_P (line 152) | TYPED_TEST_P(SpanTest, dyn_dynamic_subspan) {
  function TYPED_TEST_P (line 171) | TYPED_TEST_P(SpanTest, dyn_as_bytes) {
  function TYPED_TEST_P (line 184) | TYPED_TEST_P(SpanTest, nul_traits) {
  function TYPED_TEST_P (line 192) | TYPED_TEST_P(SpanTest, nul_ctor_default) {
  function TYPED_TEST_P (line 202) | TYPED_TEST_P(SpanTest, fix_traits) {
  function TYPED_TEST_P (line 210) | TYPED_TEST_P(SpanTest, fix_ctor_pointer_size) {
  function TYPED_TEST_P (line 221) | TYPED_TEST_P(SpanTest, fix_ctor_pointer_pointer) {
  function TYPED_TEST_P (line 232) | TYPED_TEST_P(SpanTest, fix_ctor_c_array) {
  function TYPED_TEST_P (line 243) | TYPED_TEST_P(SpanTest, fix_ctor_std_array) {
  function TYPED_TEST_P (line 254) | TYPED_TEST_P(SpanTest, fix_ctor_std_vector) {
  function TYPED_TEST_P (line 265) | TYPED_TEST_P(SpanTest, fix_access) {
  function TYPED_TEST_P (line 276) | TYPED_TEST_P(SpanTest, fix_static_subspan) {
  function TYPED_TEST_P (line 295) | TYPED_TEST_P(SpanTest, fix_dynamic_subspan) {
  function TYPED_TEST_P (line 314) | TYPED_TEST_P(SpanTest, fix_as_bytes) {
  function TYPED_TEST_P (line 327) | TYPED_TEST_P(SpanTest, reverse_iterator) {
  type fallback_span_ctad (line 338) | namespace fallback_span_ctad {
  type SpanCastTest (line 474) | struct SpanCastTest : testing::Test {
    method test (line 476) | static auto test(To to, From from) {
  function TEST_F (line 487) | TEST_F(SpanCastTest, array) {
  function TEST_F (line 493) | TEST_F(SpanCastTest, vector) {
  function TEST_F (line 499) | TEST_F(SpanCastTest, const_cast) {
  function TEST_F (line 504) | TEST_F(SpanCastTest, all_casts) {
  function TEST_F (line 511) | TEST_F(SpanCastTest, static_cast_constexpr) {

FILE: folly/container/test/tape_bench.cpp
  type ContGenerator (line 33) | struct ContGenerator {
    method ContGenerator (line 34) | ContGenerator(std::size_t minLen, std::size_t maxLen)
    method Cont (line 37) | const Cont& operator()() {
  function constructorStrings (line 89) | void constructorStrings(std::size_t iters) {
  function pushBackByOne (line 99) | void pushBackByOne(
  function pushBackByOne (line 110) | void pushBackByOne(
  function pushBackInts (line 126) | void pushBackInts(std::size_t iters) {
  function iterateBenchImpl (line 137) | void iterateBenchImpl(const std::vector<Container>& copies, std::size_t ...
  function iterateInts (line 158) | void iterateInts(std::size_t iters) {
  function iterateStrings (line 169) | void iterateStrings(std::size_t iters) {
  function BENCHMARK (line 177) | BENCHMARK(IterateVecIntsCacheMiss_20_0_15,     n) { iterateInts   <vv_in...
  function BENCHMARK (line 178) | BENCHMARK(IterateTapeIntsCacheMiss_20_0_15,    n) { iterateInts   <tv_in...
  function BENCHMARK (line 179) | BENCHMARK(IterateVecStringsCacheMiss_20_0_15,  n) { iterateStrings<vec_s...
  function BENCHMARK (line 180) | BENCHMARK(IterateTapeStringsCacheMiss_20_0_15, n) { iterateStrings<st_ta...
  function BENCHMARK (line 182) | BENCHMARK(PushBackVecInts_20_0_15,   n) { pushBackInts<vv_int, 20, 0, 15...
  function BENCHMARK (line 183) | BENCHMARK(PushBackTapeInts_20_0_15,  n) { pushBackInts<tv_int, 20, 0, 15...
  function BENCHMARK (line 185) | BENCHMARK(ConstructVecSmallStrings_20_0_15,   n) { constructorStrings<ve...
  function BENCHMARK (line 186) | BENCHMARK(ConstructTapeSmallStrings_20_0_15,  n) { constructorStrings<st...
  function BENCHMARK (line 187) | BENCHMARK(ConstructVecLargeStrings_20_16_32,  n) { constructorStrings<ve...
  function BENCHMARK (line 188) | BENCHMARK(ConstructTapeLargeStrings_20_16_32, n) { constructorStrings<st...
  function BENCHMARK (line 190) | BENCHMARK(ConstructVec2SmallStrings,    n) { constructorStrings<vec_str,...
  function BENCHMARK (line 191) | BENCHMARK(ConstructTape2SmallStrings,   n) { constructorStrings<st_tape,...
  function main (line 196) | int main(int argc, char** argv) {

FILE: folly/container/test/tape_test.cpp
  type InputIter (line 29) | struct InputIter {
    method InputIter (line 38) | InputIter& operator++() {
    method reference (line 43) | reference operator*() const { return *wrapped; }
  type InputRange (line 56) | struct InputRange {
    method iterator (line 60) | iterator begin() const { return iterator{c_.begin()}; }
    method iterator (line 61) | iterator end() const { return iterator{c_.end()}; }
  function asRange (line 70) | auto asRange(const std::vector<T>& c, std::input_iterator_tag) {
  function asRange (line 75) | auto asRange(const std::vector<T>& c, std::forward_iterator_tag) {
  function asRange (line 80) | auto asRange(const std::vector<T>& c, std::random_access_iterator_tag) {
  function TEST (line 109) | TEST(Tape, SmokeTest) {
  function TEST (line 121) | TEST(Tape, IntTape) {
  function TEST (line 131) | TEST(Tape, Count) {
  function TEST (line 140) | TEST(Tape, At) {
  function TEST (line 148) | TEST(Tape, Move) {
  function TEST (line 184) | TEST(Tape, TwoItersConstructor) {
  function TEST (line 218) | TEST(Tape, InitListNotStrings) {
  function TEST (line 228) | TEST(Tape, Ordering) {
  function TEST (line 244) | TEST(Tape, RecordBuilder) {
  function TEST (line 372) | TEST(Tape, PushBack) {
  function TEST (line 401) | TEST(Tape, PushBackStr) {
  function TEST (line 414) | TEST(Tape, EmptyRecord) {
  function TEST (line 425) | TEST(Tape, Resize) {
  function TEST (line 447) | TEST(Tape, EmptyStrings) {
  function TEST (line 464) | TEST(Tape, InsertOne) {
  function TEST (line 500) | TEST(Tape, InsertOneStr) {
  function TEST (line 527) | TEST(Tape, EraseOne) {
  function TEST (line 551) | TEST(Tape, EraseRange) {
  function TEST (line 563) | TEST(Tape, Iteration) {
  function TEST (line 571) | TEST(Tape, ReserveShrink) {
  function TEST (line 590) | TEST(Tape, TapeOfTapes) {

FILE: folly/container/test/vector_bool_test.cpp
  type folly (line 24) | namespace folly {
    function TEST (line 26) | TEST(VectorBoolTest, Example) {
    function TEST (line 32) | TEST(VectorBoolTest, CustomAllocator) {
    function TEST (line 39) | TEST(VectorBoolTest, PmrAllocator) {

FILE: folly/container/vector_bool.h
  function namespace (line 25) | namespace folly {

FILE: folly/coro/Accumulate-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/coro/Accumulate.h
  function namespace (line 25) | namespace folly {

FILE: folly/coro/AsyncGenerator.h
  function namespace (line 48) | namespace folly {
  function class (line 434) | class NextAwaitable {
  function namespace (line 559) | namespace detail {
  function setState (line 609) | void setState(State s) { tailStorage_ = s; }
  function delete (line 640) | static void operator delete(void* ptr, std::size_t size) {
  function suspend_always (line 650) | suspend_always initial_suspend() noexcept { return {}; }
  function YieldAwaiter (line 652) | YieldAwaiter final_suspend() noexcept {
  function YieldAwaiter (line 657) | YieldAwaiter yield_value(Reference&& value) noexcept(
  function YieldAwaiter (line 684) | YieldAwaiter yield_value(co_error&& error) noexcept {
  function YieldAwaiter (line 692) | YieldAwaiter yield_value(co_result<Value>&& res) noexcept {
  function YieldAwaiter (line 703) | YieldAwaiter yield_value(
  function unhandled_exception (line 729) | void unhandled_exception() noexcept {
  function return_void (line 735) | void return_void() noexcept {
  function setExecutor (line 740) | void setExecutor(folly::Executor::KeepAlive<> executor) noexcept {
  function setContinuation (line 745) | void setContinuation(ExtendedCoroutineHandle continuation) noexcept {
  function throwIfException (line 758) | void throwIfException() {
  function getRvalue (line 764) | decltype(auto) getRvalue() noexcept {
  function clearValue (line 769) | void clearValue() noexcept {
  function std (line 784) | static std::optional<ExtendedCoroutineHandle::ErrorHandle> getErrorHandl...
  function clearContext (line 792) | void clearContext() noexcept {
  function friend (line 799) | friend coroutine_handle<ScopeExitTaskPromiseBase> tag_invoke(

FILE: folly/coro/AsyncPipe.h
  function namespace (line 32) | namespace folly {
  function class (line 154) | class OnClosedCallback {
  function explicit (line 174) | explicit AsyncPipe(
  function guard (line 217) | auto guard = folly::makeGuard(
  function signalingGenerator (line 222) | auto signalingGenerator = co_invoke(
  function else (line 253) | else if (waitResult.hasException()) {
  function getAvailableSpace (line 269) | size_t getAvailableSpace() { return semaphore_->getAvailableTokens(); }
  function getOccupiedSpace (line 271) | size_t getOccupiedSpace() {
  function close (line 275) | void close(exception_wrapper&& w) && { std::move(pipe_).close(std::move(...
  function close (line 276) | void close() && { std::move(pipe_).close(); }

FILE: folly/coro/AsyncScope.h
  function throwOnJoin_ (line 203) | bool throwOnJoin_{false};

FILE: folly/coro/AsyncStack.h
  function namespace (line 27) | namespace folly {

FILE: folly/coro/AutoCleanup-fwd.h
  function namespace (line 24) | namespace folly::coro {

FILE: folly/coro/AutoCleanup.h
  function namespace (line 27) | namespace detail {
  function explicit (line 73) | explicit AutoCleanup(T&& object, CleanupFn cleanupFn = CleanupFn{}) noex...

FILE: folly/coro/BasePromise.h
  function namespace (line 30) | namespace folly::coro::detail {
  function noexcept (line 124) | auto await_transform(co_current_executor_t) noexcept {
  function noexcept (line 128) | auto await_transform(co_current_cancellation_token_t) noexcept {

FILE: folly/coro/Baton.h
  function namespace (line 26) | namespace folly {

FILE: folly/coro/BlockingWait.h
  function namespace (line 42) | namespace folly {
  function BlockingWaitTask (line 253) | inline BlockingWaitTask<void>
  function add (line 286) | void add(Func func) override {
  function drive (line 299) | void drive() override {
  function keepAliveRelease (line 322) | void keepAliveRelease() noexcept override {
  type BlockingWaitTaskInfo (line 341) | struct BlockingWaitTaskInfo {
  type blocking_wait_fn (line 369) | struct blocking_wait_fn {
  function blocking_wait_fn (line 476) | inline constexpr blocking_wait_fn blocking_wait{}

FILE: folly/coro/BoundedQueue.h
  function namespace (line 26) | namespace folly {

FILE: folly/coro/Cleanup.h
  function namespace (line 23) | namespace folly::coro {

FILE: folly/coro/Collect-inl.h
  function namespace (line 32) | namespace folly {
  function co_return (line 120) | co_return std::tuple<>{}
  function co_await (line 158) | co_await UnsafeResumeInlineSemiAwaitable{barrier.arriveAndWait()};
  function co_await (line 241) | co_await UnsafeResumeInlineSemiAwaitable{barrier.arriveAndWait()};
  type SharedState (line 260) | struct SharedState {
  function sharedState (line 266) | auto sharedState = std::make_shared<SharedState>(std::move(pipe));
  function CancellationCallback (line 300) | CancellationCallback cancelCallback(
  function trySetFirstException (line 658) | const auto trySetFirstException = [&](exception_wrapper&& e) noexcept {
  function makeWorker (line 675) | auto makeWorker = [&]() -> detail::BarrierTask {
  function co_await (line 746) | co_await detail::UnsafeResumeInlineSemiAwaitable{barrier.arriveAndWait()};
  function trySetFirstException (line 774) | auto trySetFirstException = [&](exception_wrapper&& e) noexcept {
  function makeWorker (line 802) | auto makeWorker = [&]() -> detail::BarrierTask {
  function co_await (line 891) | co_await detail::UnsafeResumeInlineSemiAwaitable{barrier.arriveAndWait()};

FILE: folly/coro/Collect.h
  function namespace (line 269) | namespace detail {

FILE: folly/coro/Concat-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/coro/Concat.h
  function namespace (line 24) | namespace folly {

FILE: folly/coro/Coroutine.h
  function namespace (line 55) | namespace folly {
  function namespace (line 60) | namespace folly::coro {
  function await_suspend_return_coroutine_fn (line 138) | inline constexpr await_suspend_return_coroutine_fn
  function detect_promise_return_object_eager_conversion (line 289) | inline bool detect_promise_return_object_eager_conversion() {
  function namespace (line 299) | namespace detail {
  function class (line 306) | class ExtendedCoroutineHandle {
  function class (line 349) | class PromiseBase {
  function resume (line 386) | void resume() { basic_.resume(); }
  function destroy (line 388) | void destroy() { basic_.destroy(); }
  function ErrorHandle (line 392) | ErrorHandle getErrorHandle(exception_wrapper& ex) {
  function PromiseBase (line 414) | PromiseBase* extended_{nullptr};
  function ExtendedCoroutineHandle (line 443) | static ExtendedCoroutineHandle::PromiseBase* getPromiseBase(

FILE: folly/coro/CurrentExecutor.h
  function namespace (line 29) | namespace folly {

FILE: folly/coro/DetachOnCancel.h
  function namespace (line 30) | namespace folly {

FILE: folly/coro/Error.h
  function namespace (line 27) | namespace folly::coro {

FILE: folly/coro/Filter-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/coro/Filter.h
  function namespace (line 24) | namespace folly {

FILE: folly/coro/FutureUtil.h
  function namespace (line 30) | namespace folly {

FILE: folly/coro/Generator.h
  function namespace (line 30) | namespace folly {

FILE: folly/coro/GmockHelpers.h
  function namespace (line 31) | namespace folly {
  function ptr (line 288) | auto ptr = std::make_shared<detail::OnceForwarder<T&&>>(std::move(ret));

FILE: folly/coro/GtestHelpers.h
  function namespace (line 27) | namespace folly {
  function GTEST_TEST_CLASS_NAME_ (line 175) | int GTEST_TEST_CLASS_NAME_(                                             ...

FILE: folly/coro/Invoke.h
  function namespace (line 22) | namespace folly {

FILE: folly/coro/Merge-inl.h
  function namespace (line 36) | namespace coro {

FILE: folly/coro/Merge.h
  function namespace (line 24) | namespace folly {

FILE: folly/coro/Mutex.h
  function namespace (line 29) | namespace folly {

FILE: folly/coro/Nothrow.h
  function namespace (line 28) | namespace folly::coro {

FILE: folly/coro/Promise.h
  function namespace (line 31) | namespace folly::coro {
  function class (line 246) | class WaitOperation : private Baton::WaitOperation {
  function hasCancelTokenOverride_ (line 310) | bool hasCancelTokenOverride_{false};
  function Future (line 347) | inline Future<void> makeFuture() {

FILE: folly/coro/Result.h
  function namespace (line 27) | namespace folly::coro {

FILE: folly/coro/Retry.h
  function namespace (line 59) | namespace folly::coro {
  function namespace (line 113) | namespace detail {
  function namespace (line 166) | namespace detail {

FILE: folly/coro/RustAdaptors.h
  function namespace (line 29) | namespace folly {

FILE: folly/coro/ScopeExit.h
  function namespace (line 37) | namespace folly {
  function friend (line 209) | friend auto co_viaIfAsync(Executor::KeepAlive<>, ScopeExitTask&& t) noex...
  function class (line 294) | class co_scope_exit_fn {
  function co_scope_exit_fn (line 358) | inline constexpr co_scope_exit_fn co_scope_exit{}

FILE: folly/coro/SerialQueueRunner.cpp
  type folly::coro (line 25) | namespace folly::coro {

FILE: folly/coro/SerialQueueRunner.h
  function namespace (line 31) | namespace folly::coro {

FILE: folly/coro/SharedLock.h
  function namespace (line 33) | namespace folly {

FILE: folly/coro/SharedMutex.h
  function namespace (line 34) | namespace folly {

FILE: folly/coro/SharedPromise.h
  function namespace (line 32) | namespace folly::coro {

FILE: folly/coro/Sleep-inl.h
  function namespace (line 23) | namespace folly {

FILE: folly/coro/Sleep.h
  function namespace (line 25) | namespace folly {

FILE: folly/coro/SmallUnboundedQueue.h
  function namespace (line 27) | namespace folly {

FILE: folly/coro/Synchronized.h
  function namespace (line 31) | namespace detail {
  function explicit (line 106) | explicit Synchronized(const Inner& rhs) noexcept(noexcept(Inner(rhs)))
  function explicit (line 109) | explicit Synchronized(Inner&& rhs) noexcept(noexcept(Inner(std::move(rhs...
  function explicit (line 160) | explicit GenericLockedPtr(LockType&& lock, ValueType* ptr)
  function co_return (line 172) | co_return WriteLockedPtr{std::move(lock), &inner_};
  function co_return (line 177) | co_return ReadLockedPtr{std::move(lock), &inner_};
  function ReadLockedPtr (line 180) | ReadLockedPtr tryRLock() const {
  function co_return (line 202) | co_return func(ReadLockedPtr{std::move(lock), &inner_});
  function co_return (line 211) | co_return co_await func(ReadLockedPtr{std::move(lock), &inner_});
  function co_return (line 218) | co_return func(WriteLockedPtr{std::move(lock), &inner_});
  function co_return (line 227) | co_return co_await func(WriteLockedPtr{std::move(lock), &inner_});

FILE: folly/coro/Task.h
  function namespace (line 59) | namespace folly::coro {
  function noexcept (line 202) | auto await_transform(co_safe_point_t /*unused*/) noexcept {
  function std (line 207) | static std::optional<ExtendedCoroutineHandle::ErrorHandle> getErrorHandl...
  function else (line 238) | else if constexpr (
  function return_void (line 263) | void return_void() noexcept { this->result_.emplace(); }
  function namespace (line 273) | namespace adl {
  function swap (line 332) | void swap(TaskWithExecutor& t) noexcept { std::swap(coro_, t.coro_); }
  function FOLLY_NOINLINE (line 338) | FOLLY_NOINLINE SemiFuture<lift_unit_t<StorageType>> start() && {
  function FOLLY_NOINLINE (line 389) | FOLLY_NOINLINE SemiFuture<lift_unit_t<StorageType>> startInlineUnsafe() ...
  function InlineTaskDetached (line 431) | InlineTaskDetached startImpl(TaskWithExecutor task, F cb) {
  function InlineTaskDetached (line 440) | InlineTaskDetached startInlineImpl(TaskWithExecutor task, F cb) {
  function RequestContextScopeGuard (line 509) | RequestContextScopeGuard contextScope{std::move(ctx)}
  function T (line 514) | T await_resume() {
  function class (line 545) | class InlineTryAwaitable {
  function friend (line 614) | friend ViaIfAsyncAwaitable<TaskWithExecutor> co_viaIfAsync(
  function explicit (line 645) | explicit TaskWithExecutor(handle_t coro) noexcept : coro_(coro) {}
  function FOLLY_CORO_TASK_ATTRS (line 683) | FOLLY_CORO_TASK_ATTRS Task {
  function friend (line 773) | friend auto co_viaIfAsync(
  function coro_ (line 890) | Task(handle_t coro) noexcept : coro_(coro) {}
  function Task (line 903) | inline Task<void> makeTask() {
  function Task (line 907) | inline Task<void> makeTask(Unit /*unused*/) {

FILE: folly/coro/TaskWrapper.h
  function namespace (line 96) | namespace folly::coro {
  type DoesNotWrapAwaitable (line 270) | struct DoesNotWrapAwaitable {
  function friend (line 303) | friend auto co_viaIfAsync(
  function explicit (line 337) | explicit TaskWrapperCrtp(Inner t) noexcept
  function Inner (line 349) | Inner unwrapTask() && noexcept {
  function explicit (line 407) | explicit TaskWithExecutorWrapperCrtp(Inner t) noexcept(noexcept(Inner{
  function friend (line 435) | friend Derived co_withCancellation(

FILE: folly/coro/TimedWait.h
  function namespace (line 33) | namespace coro {

FILE: folly/coro/Timeout-inl.h
  function namespace (line 23) | namespace folly::coro {

FILE: folly/coro/Timeout.h
  function namespace (line 31) | namespace folly::coro {

FILE: folly/coro/Traits.h
  function namespace (line 26) | namespace folly {
  type get_awaiter_fn (line 146) | struct get_awaiter_fn {
  function get_awaiter_fn (line 181) | constexpr inline get_awaiter_fn get_awaiter{}
  function namespace (line 216) | namespace detail {

FILE: folly/coro/Transform-inl.h
  function namespace (line 23) | namespace coro {

FILE: folly/coro/Transform.h
  function namespace (line 26) | namespace folly {

FILE: folly/coro/UnboundedQueue.h
  function namespace (line 26) | namespace folly {

FILE: folly/coro/ValueOrError.h
  function namespace (line 52) | namespace detail {
  function Awaitable (line 228) | [[FOLLY_ATTR_CLANG_CORO_AWAIT_ELIDABLE_ARGUMENT]] Awaitable awaitable) {

FILE: folly/coro/ValueOrFatal.h
  type will_fatal_t (line 71) | struct will_fatal_t {}
  function will_fatal_t (line 72) | inline constexpr will_fatal_t will_fatal{}
  function nv (line 169) | auto nv = std::move(res).non_value();
  function else (line 175) | else if constexpr (std::is_void_v<RetT>) {
  function namespace (line 233) | namespace detail {
  type detail (line 327) | struct detail

FILE: folly/coro/ViaIfAsync.h
  function namespace (line 38) | namespace folly::coro {
  function operator (line 443) | auto operator co_await() && {
  function friend (line 474) | friend StackAwareViaIfAsyncAwaitable<Awaitable> tag_invoke(
  function namespace (line 485) | namespace detail {
  function namespace (line 502) | namespace adl {
  function namespace (line 602) | namespace detail {
  type value_only_awaitable_ (line 654) | struct value_only_awaitable_
  function namespace (line 672) | namespace detail {
  function noexcept (line 840) | noexcept(noexcept(T{std::move(mover.template get<0>())()}))
  function Awaitable (line 879) | [[FOLLY_ATTR_CLANG_CORO_AWAIT_ELIDABLE_ARGUMENT]] Awaitable awaitable) {

FILE: folly/coro/WithAsyncStack.h
  function namespace (line 32) | namespace folly::coro {
  function decltype (line 128) | auto await_ready() noexcept(noexcept(std::declval<Awaiter&>().await_read...
  type WithAsyncStackFunction (line 227) | struct WithAsyncStackFunction {

FILE: folly/coro/WithCancellation.h
  function namespace (line 34) | namespace folly {

FILE: folly/coro/detail/Barrier.h
  function namespace (line 32) | namespace folly {

FILE: folly/coro/detail/BarrierTask.h
  function namespace (line 29) | namespace folly {

FILE: folly/coro/detail/CurrentAsyncFrame.h
  function namespace (line 33) | namespace folly {

FILE: folly/coro/detail/Helpers.h
  function namespace (line 27) | namespace folly {

FILE: folly/coro/detail/InlineTask.h
  function namespace (line 32) | namespace folly {
  function return_void (line 141) | void return_void() noexcept {}
  function unhandled_exception (line 143) | void unhandled_exception() noexcept {
  function result (line 147) | void result() { return result_.value(); }
  function class (line 171) | class Awaiter {
  function explicit (line 207) | explicit InlineTask(handle_t coro) noexcept : coro_(coro) {}
  function InlineTask (line 217) | inline InlineTask<void> InlineTaskPromise<void>::get_return_object() noe...
  function await_resume (line 234) | struct InlineTaskDetached {
  function delete (line 250) | static void operator delete(void* ptr, std::size_t size) {
  function InlineTaskDetached (line 258) | InlineTaskDetached get_return_object() noexcept {
  function FOLLY_NOINLINE (line 292) | FOLLY_NOINLINE void start() noexcept {
  function start (line 296) | void start(void* returnAddress) noexcept {

FILE: folly/coro/detail/Malloc.cpp
  function FOLLY_NOINLINE (line 24) | FOLLY_NOINLINE
  function FOLLY_NOINLINE (line 35) | FOLLY_NOINLINE

FILE: folly/coro/detail/ManualLifetime.h
  function namespace (line 25) | namespace folly {
  function construct (line 69) | void construct(T& value) noexcept { ptr_ = std::addressof(value); }
  function destruct (line 71) | void destruct() noexcept { ptr_ = nullptr; }
  function noexcept (line 73) | const noexcept { return *ptr_; }
  function construct (line 85) | void construct(T&& value) noexcept { ptr_ = std::addressof(value); }
  function destruct (line 87) | void destruct() noexcept { ptr_ = nullptr; }
  function noexcept (line 89) | const noexcept { return static_cast<T&&>(*ptr_); }
  function destruct (line 100) | void destruct() noexcept {}
  function guard (line 117) | auto guard = makeGuard([p]() noexcept { p->~ManualLifetime(); }

FILE: folly/coro/detail/PickTaskWrapper.h
  function namespace (line 36) | namespace folly::coro {

FILE: folly/coro/detail/Traits.h
  function namespace (line 21) | namespace folly {

FILE: folly/coro/detail/test/PickTaskWrapperTest.cpp
  type folly::coro (line 27) | namespace folly::coro {
    function TEST (line 29) | TEST(PickTaskWrapperTest, AllTestsAreStatic) {}

FILE: folly/coro/safe/AsyncClosure-fwd.h
  function namespace (line 19) | namespace folly::coro {

FILE: folly/coro/safe/AsyncClosure.h
  type async_closure_config (line 64) | struct async_closure_config {
  function namespace (line 95) | namespace detail {

FILE: folly/coro/safe/BindCaptures.h
  function namespace (line 37) | namespace folly::bind {

FILE: folly/coro/safe/Captures.h
  function namespace (line 37) | namespace folly {
  function namespace (line 42) | namespace folly::coro {
  function friend (line 516) | friend auto async_closure_make_cleanup_tuple(
  function noexcept (line 614) | [[nodiscard]] constexpr decltype(auto) operator->() & noexcept {
  function noexcept (line 617) | [[nodiscard]] constexpr decltype(auto) operator->() const& noexcept {
  function noexcept (line 620) | [[nodiscard]] constexpr decltype(auto) operator->() && noexcept {
  function noexcept (line 624) | [[nodiscard]] constexpr decltype(auto) operator->() const&& noexcept {
  type capture_safety (line 682) | struct capture_safety

FILE: folly/coro/safe/NowTask.h
  function namespace (line 72) | namespace detail {
  function namespace (line 106) | namespace detail {
  function now_task (line 174) | inline now_task<> make_now_task() {
  function now_task (line 178) | inline now_task<> make_now_task(Unit /*unused*/) {

FILE: folly/coro/safe/SafeTask.h
  function namespace (line 25) | namespace folly::coro {
  function namespace (line 444) | namespace detail {
  type folly (line 476) | struct folly

FILE: folly/coro/safe/detail/AsyncClosure.h
  function namespace (line 32) | namespace folly::coro::detail {
  function explicit (line 244) | explicit async_closure_wrap_coro(OuterMover outer_mover)
  function consteval (line 259) | static consteval bool is_safe() {
  function exception (line 294) | struct BUG_co_cleanup_must_not_copy_error : std::exception {}
  function fn (line 437) | auto fn = [&]() -> decltype(auto) {
  function pick_safest_b_tup (line 621) | auto pick_safest_b_tup = [&]() -> auto& {

FILE: folly/coro/safe/detail/BindAsyncClosure.h
  function namespace (line 98) | namespace folly::bind::ext {
  function namespace (line 114) | namespace folly::coro {
  function namespace (line 123) | namespace folly::coro::detail {
  function else (line 554) | else if constexpr (std::is_same_v<capture_ref_measurement_stub, T>) {
  function capture_needs_outer_coro (line 595) | bool capture_needs_outer_coro() {
  type async_closure_bindings_cfg (line 601) | struct async_closure_bindings_cfg {
  function maybe_make_bindings_for (line 850) | auto maybe_make_bindings_for =

FILE: folly/coro/safe/detail/test/BindAsyncClosureTest.cpp
  type folly::coro::detail (line 24) | namespace folly::coro::detail {
    type HasCleanup (line 26) | struct HasCleanup : NonCopyableNonMovable {
      method co_cleanup (line 27) | value_or_fatal<Task<>, on_stopped_void> co_cleanup(async_closure_pri...
    function capture_private_t (line 32) | constexpr capture_private_t coro_safe_detail_bindings_test_private() {
    function TEST (line 38) | TEST(BindingsTest, all_tests_run_at_build_time) {}
    type MoveMe (line 40) | struct MoveMe : folly::MoveOnly {
    function check_one_no_shared_cleanup (line 48) | constexpr void check_one_no_shared_cleanup(auto arg_fn) {
    function check_one_shared_cleanup (line 65) | constexpr void check_one_shared_cleanup(auto arg_fn) {
    function check_one (line 92) | constexpr void check_one(auto arg_fn) {
    function check_empty (line 100) | constexpr bool check_empty() {
    function check_regular_args (line 122) | constexpr bool check_regular_args() {
    function check_capture_val_to_ref (line 155) | constexpr bool check_capture_val_to_ref() {
    function check_capture_lref_to_lref (line 225) | constexpr bool check_capture_lref_to_lref() {
    function check_capture_lref_to_rref (line 295) | constexpr bool check_capture_lref_to_rref() {
    function check_capture_rref_to_rref (line 330) | constexpr bool check_capture_rref_to_rref() {
    function check_owned_capture_int (line 362) | constexpr bool check_owned_capture_int() {
    function check_parent_capture_ref (line 376) | constexpr bool check_parent_capture_ref() {
    function check_owned_cleanup_capture (line 416) | constexpr bool check_owned_cleanup_capture() {
    function check_emit_now_task_blocks_ref_upgrade (line 444) | constexpr bool check_emit_now_task_blocks_ref_upgrade() {
    function check_force_outer_coro (line 508) | constexpr bool check_force_outer_coro() {
    function check_is_invoke_member_implicit_capture (line 550) | constexpr bool check_is_invoke_member_implicit_capture() {

FILE: folly/coro/safe/detail/test/DefineMovableDeepConstLrefCopyableTest.cpp
  type Foo (line 22) | struct Foo {
  function TEST (line 29) | TEST(DefineMovableDeepConstLrefCopyableTest, all_tests_run_at_build_time...

FILE: folly/coro/safe/test/AsyncClosureTest.cpp
  type folly::coro (line 26) | namespace folly::coro {
    function CO_TEST (line 31) | CO_TEST(AsyncClosure, invalid_co_cleanup) {
    function intTask (line 80) | closure_task<int> intTask(int x) {
    type StatelessIntCallable (line 83) | struct StatelessIntCallable {
    type StatelessGenericCallable (line 86) | struct StatelessGenericCallable {
    function checkSafety (line 94) | void checkSafety() {
    function TEST (line 148) | TEST(AsyncClosure, safetyNoOuter) {
    function TEST (line 151) | TEST(AsyncClosure, safety) {
    function asyncClosureCheckType (line 160) | constexpr auto asyncClosureCheckType(auto fn, auto bargs) {
    function checkNoArgs (line 170) | Task<void> checkNoArgs() {
    function CO_TEST (line 176) | CO_TEST(AsyncClosure, noArgsNoOuter) {
    function CO_TEST (line 179) | CO_TEST(AsyncClosure, noArgs) {
    function checkReturnsVoid (line 188) | Task<void> checkReturnsVoid() {
    function CO_TEST (line 199) | CO_TEST(AsyncClosure, returnsVoidNoOuter) {
    function CO_TEST (line 202) | CO_TEST(AsyncClosure, returnsVoid) {
    function checkPlainArgs (line 207) | Task<void> checkPlainArgs() {
    function CO_TEST (line 222) | CO_TEST(AsyncClosure, plainArgsNoOuter) {
    function CO_TEST (line 225) | CO_TEST(AsyncClosure, plainArgsOuter) {
    function funcTemplate (line 229) | closure_task<std::string> funcTemplate(auto hi) {
    function CO_TEST (line 234) | CO_TEST(AsyncClosure, callFuncTemplate) {
    type ImmovableString (line 245) | struct ImmovableString : private NonCopyableNonMovable {
      method ImmovableString (line 246) | explicit ImmovableString(std::string s) : s_(std::move(s)) {}
    function funcNoOuter (line 253) | closure_task<std::string> funcNoOuter(capture_heap<ImmovableString> hi) {
    function funcWithOuter (line 257) | closure_task<std::string> funcWithOuter(capture<ImmovableString&> hi) {
    function CO_TEST (line 262) | CO_TEST(AsyncClosure, callFunctionNoOuter) {
    function CO_TEST (line 268) | CO_TEST(AsyncClosure, callFunctionWithOuter) {
    type TakesBackref (line 276) | struct TakesBackref {
    function CO_TEST (line 281) | CO_TEST(AsyncClosure, captureBackref) {
    function CO_TEST (line 335) | CO_TEST(AsyncClosure, simpleCancellation) {
    type InPlaceOnly (line 348) | struct InPlaceOnly : folly::NonCopyableNonMovable {
      method InPlaceOnly (line 349) | explicit InPlaceOnly(bool* made, int n) : n_(n) {
    function assertArgConst (line 357) | void assertArgConst(auto& arg) {
    function checkInPlaceArgs (line 364) | Task<void> checkInPlaceArgs() {
    function CO_TEST (line 398) | CO_TEST(AsyncClosure, inPlaceArgsNoOuter) {
    function CO_TEST (line 401) | CO_TEST(AsyncClosure, inPlaceArgs) {
    function CO_TEST (line 412) | CO_TEST(AsyncClosureTest, constAutoArgWithOuterCoro) {
    function CO_TEST (line 436) | CO_TEST(AsyncClosure, noOuterCoroGetsCaptureValue) {
    function CO_TEST (line 442) | CO_TEST(AsyncClosure, outerCoroGetsCaptureRef) {
    function CO_TEST (line 450) | CO_TEST(AsyncClosure, nestedRefsWithOuterCoro) {
    type ImmovableInt (line 506) | struct ImmovableInt : private NonCopyableNonMovable {
      method ImmovableInt (line 507) | explicit ImmovableInt(int n) : n_(std::move(n)) {}
    function CO_TEST (line 522) | CO_TEST(AsyncClosure, nestedRefsWithoutOuterCoro) {
    type ErrorObliviousHasCleanup (line 569) | struct ErrorObliviousHasCleanup : NonCopyableNonMovable {
      method ErrorObliviousHasCleanup (line 570) | explicit ErrorObliviousHasCleanup(int* p) : cleanBits_(p) {}
      method co_cleanup (line 572) | value_or_fatal<Task<>, on_stopped_void> co_cleanup(async_closure_pri...
    function CO_TEST (line 578) | CO_TEST(AsyncClosure, errorObliviousCleanup) {
    type HasCleanup (line 586) | struct HasCleanup : NonCopyableNonMovable {
      method HasCleanup (line 587) | explicit HasCleanup(auto* p) : optCleanupErrPtr_(p) {}
      method co_cleanup (line 591) | value_or_fatal<Task<>, on_stopped_void> co_cleanup(
    function CO_TEST (line 598) | CO_TEST(AsyncClosure, cleanupAfterSuccess) {
    function CO_TEST (line 606) | CO_TEST(AsyncClosure, cleanupAfterError) {
    type CustomDerefCleanupProxy (line 622) | struct CustomDerefCleanupProxy : NonCopyableNonMovable {
      method CustomDerefCleanupProxy (line 623) | explicit CustomDerefCleanupProxy(int y) : y_(y) {}
    type CustomDerefCleanup (line 628) | struct CustomDerefCleanup : HasCleanup {
      method CustomDerefCleanup (line 629) | explicit CustomDerefCleanup(auto* p) : HasCleanup(p) {}
      method capture_proxy (line 632) | auto capture_proxy(folly::coro::ext::capture_proxy_tag<Kind>, T&) {
    function check_pass_cleanup_arg_to_subclosure (line 648) | Task<void> check_pass_cleanup_arg_to_subclosure(auto validate_ref) {
    function CO_TEST (line 668) | CO_TEST(AsyncClosure, passCleanupArgToSubclosure) {
    function CO_TEST (line 673) | CO_TEST(AsyncClosure, passCustomDerefCleanupArgToSubclosure) {
    function TEST (line 686) | TEST(AsyncClosure, nonSafeTaskIsNotAwaited) {
    type HasMemberTask (line 703) | struct HasMemberTask {
      method task (line 705) | member_task<int> task(auto x, auto y) { co_return x + *y + z; }
    function CO_TEST (line 712) | CO_TEST(AsyncClosure, memberTask) {
    function intAsyncNowClosure (line 749) | now_task<int> intAsyncNowClosure(auto&& bargs, auto&& fn) {
    function check_now_closure_no_outer_coro_unsafe_task (line 755) | now_task<void> check_now_closure_no_outer_coro_unsafe_task() {
    function check_now_closure_with_outer_coro (line 791) | now_task<void> check_now_closure_with_outer_coro() {
    function CO_TEST (line 799) | CO_TEST(AsyncClosure, nowClosure) {
    function CO_TEST (line 831) | CO_TEST(AsyncClosure, captureByReference) {
    function checkNowClosureCoCleanup (line 857) | now_task<> checkNowClosureCoCleanup() {
    function CO_TEST (line 873) | CO_TEST(AsyncClosure, nowClosureCoCleanup) {
    function check_value_or_fatal_closures (line 879) | constexpr bool check_value_or_fatal_closures() {
    function TEST (line 918) | TEST(AsyncClosure, throwingMoveCtor) {
    type OrderTracker (line 945) | struct OrderTracker : NonCopyableNonMovable {
      method OrderTracker (line 951) | explicit OrderTracker(int& n, int& cleanupN)
      method co_cleanup (line 954) | value_or_fatal<Task<>, on_stopped_void> co_cleanup(async_closure_pri...
    function CO_TEST (line 966) | CO_TEST(AsyncClosure, ctorCleanupDtorOrdering) {
  function main (line 995) | int main(int argc, char** argv) {

FILE: folly/coro/safe/test/CapturesTest.cpp
  type folly::coro::detail (line 27) | namespace folly::coro::detail {
    type SimpleCleanup (line 29) | struct SimpleCleanup : NonCopyableNonMovable {
      method co_cleanup (line 30) | void co_cleanup(async_closure_private_t) {}
      method x (line 31) | int x() & { return 1001; }
      method x (line 32) | int x() const& { return 2002; }
      method x (line 33) | int x() && { return 3003; }
      method canMutate (line 34) | void canMutate() {}
    function get_address (line 37) | decltype(auto) get_address(const auto& v) {
    function check_capture_same_address (line 42) | void check_capture_same_address(TA&& a, TB&& b) {
    type CapturesTest (line 47) | struct CapturesTest : testing::Test {
      method make (line 52) | static constexpr auto make(auto&& arg) {
      method make_co_cleanup (line 58) | auto make_co_cleanup(auto&&... args) {
      method shared_cleanup_ref (line 67) | auto shared_cleanup_ref(Arg&& arg) {
      method independent_cleanup_ref (line 71) | auto independent_cleanup_ref(Arg&& arg) {
      method check_ref_from_mutable (line 76) | void check_ref_from_mutable(int expected, auto a, auto make_ref) {
      method check_ref_from_const (line 114) | void check_ref_from_const(int expected, auto a, auto make_ref) {
      method check_ref_from_cleanup (line 141) | void check_ref_from_cleanup(auto a, auto make_ref) {
      method check_to_capture_ref (line 162) | void check_to_capture_ref(auto make_ref_fn) {
      type TestStruct (line 207) | struct TestStruct {
      method check_member_access (line 218) | static constexpr void check_member_access() {
      method test_member_value_category (line 254) | static constexpr bool test_member_value_category() {
    function TEST_F (line 274) | TEST_F(CapturesTest, indirect_getUnderlyingUnsafe) {
    function TEST_F (line 282) | TEST_F(CapturesTest, to_capture_ref_sharedCleanup) {
    function TEST_F (line 291) | TEST_F(CapturesTest, to_capture_ref_independentCleanup) {
    function TEST_F (line 299) | TEST_F(CapturesTest, capture_implicitRefConversion) {
    function TEST_F (line 390) | TEST_F(CapturesTest, make_in_place) {
    function TEST_F (line 398) | TEST_F(CapturesTest, noCustomDereference) {
    type CustomDerefCleanupRef (line 423) | struct CustomDerefCleanupRef : NonCopyableNonMovable {
      method CustomDerefCleanupRef (line 424) | explicit CustomDerefCleanupRef(int y) : y_(y) {}
    type CustomDerefCleanup (line 429) | struct CustomDerefCleanup : NonCopyableNonMovable {
      method co_cleanup (line 430) | void co_cleanup(async_closure_private_t) {}
      method capture_proxy (line 434) | auto capture_proxy(ext::capture_proxy_tag<Kind>, T&) {
      method capture_restricted_proxy (line 450) | auto capture_restricted_proxy(ext::capture_proxy_tag<Kind>, T&) {
    function TEST_F (line 465) | TEST_F(CapturesTest, customDereference) {
    function TEST_F (line 491) | TEST_F(CapturesTest, copyLValueRef) {
    function TEST_F (line 533) | TEST_F(CapturesTest, moveLValueRef) {
    function TEST_F (line 585) | TEST_F(CapturesTest, onlyMoveRValueRef) {

FILE: folly/coro/safe/test/NowTaskTest.cpp
  type folly::coro (line 31) | namespace folly::coro {
    function demoTask (line 39) | Task<int> demoTask(int x) {
    function demoNowTask (line 42) | now_task<int> demoNowTask(int x) {
    function CO_TEST (line 88) | CO_TEST(NowTaskTest, simple) {
    function CO_TEST (line 118) | CO_TEST(NowTaskTest, awaitFromGenerator) {
    function CO_TEST (line 130) | CO_TEST(NowTaskTest, withExecutor) {
    function CO_TEST (line 183) | CO_TEST(NowTaskTest, nothrow) {
    function CO_TEST (line 244) | CO_TEST(NowTaskTest, awaitTry) {
    function TEST (line 280) | TEST(NowTaskTest, blockingWait) {
    function TEST (line 295) | TEST(NowTaskTest, blockingWaitTry) {
    function CO_TEST (line 316) | CO_TEST(NowTaskTest, passByRef) {
    function CO_TEST (line 320) | CO_TEST(NowTaskTest, lambdaWithCaptures) {
    function CO_TEST (line 326) | CO_TEST(NowTaskTest, to_now_task) {
    function CO_TEST (line 341) | CO_TEST(NowTaskTest, asUnsafe) {
    function CO_TEST (line 352) | CO_TEST(NowTaskTest, asUnsafeWithExecutor) {
    function processData (line 366) | now_task<int> processData(const int& x) {
    function processDataCoInvoke (line 373) | folly::SemiFuture<int> processDataCoInvoke(const int& x) {
    function processDataDefer (line 389) | folly::SemiFuture<int> processDataDefer(const int& x) {
    function TEST (line 405) | TEST(NowTaskTest, asUnsafeSemiFutureWithCoInvokeGuard) {
    function TEST (line 416) | TEST(NowTaskTest, asUnsafeSemiFutureWithDeferGuard) {

FILE: folly/coro/safe/test/SafeTaskTest.cpp
  type StatelessClass (line 30) | struct StatelessClass {
    method validSafeTask (line 31) | value_task<void> validSafeTask() { co_return; }
  type StatefulClass (line 34) | struct StatefulClass {
  type SafeStatefulClass (line 38) | struct SafeStatefulClass {
  type UnsafeStatefulClass (line 46) | struct UnsafeStatefulClass {
  function TEST (line 54) | TEST(SafeTask, isSafeTaskValid) {
  function TEST (line 142) | TEST(SafeTask, safe_alias_of_v) {
  function CO_TEST (line 152) | CO_TEST(SafeTask, trivial) {
  function CO_TEST (line 157) | CO_TEST(CoCleanupSafeTask, trivial) {
  function CO_TEST (line 165) | CO_TEST(PreCleanupTask, trivial) {
  function intFunc (line 178) | value_task<int> intFunc(auto x) {
  function CO_TEST (line 183) | CO_TEST(SafeTask, returnsNonVoid) {
  function voidFunc (line 193) | value_task<void> voidFunc(auto x) {
  function CO_TEST (line 199) | CO_TEST(SafeTask, returnsVoid) {
  function CO_TEST (line 213) | CO_TEST(SafeTask, awaitsTask) {
  function CO_TEST (line 220) | CO_TEST(SafeTask, cancellation) {
  type MyError (line 232) | struct MyError : std::exception {}
  function CO_TEST (line 235) | CO_TEST(SafeTask, throws) {
  function CO_TEST (line 241) | CO_TEST(SafeTask, co_awaitTry) {
  type folly::coro::detail (line 248) | namespace folly::coro::detail {
    type SafeTaskTest (line 250) | struct SafeTaskTest : testing::Test {
      method withNewSafety (line 252) | auto withNewSafety(auto t) {
    function CO_TEST_F (line 259) | CO_TEST_F(SafeTaskTest, withNewSafety) {
    function CO_TEST_F (line 269) | CO_TEST_F(SafeTaskTest, ClosureTask) {
    type HasMemberTask (line 282) | struct HasMemberTask {
      method task (line 283) | member_task<int> task(auto x) { co_return 1300 + x; }
    function CO_TEST_F (line 289) | CO_TEST_F(SafeTaskTest, MemberTask) {
  function main (line 309) | int main(int argc, char** argv) {

FILE: folly/coro/scripts/co_bt.py
  class DebuggerValue (line 27) | class DebuggerValue(abc.ABC):
    method nullptr (line 35) | def nullptr() -> "DebuggerValue":
    method parse_and_eval (line 43) | def parse_and_eval(expr: str) -> "DebuggerValue":
    method execute (line 51) | def execute(expr: str) -> str:
    method get_current_pthread_addr (line 59) | def get_current_pthread_addr() -> "DebuggerValue":
    method get_register (line 67) | def get_register(register: str) -> "DebuggerValue":
    method get_field (line 74) | def get_field(self, n: int) -> "DebuggerValue":
    method is_nullptr (line 82) | def is_nullptr(self) -> bool:
    method int_value (line 89) | def int_value(self) -> int:
    method to_hex (line 96) | def to_hex(self) -> str:
    method get_file_name_and_line (line 103) | def get_file_name_and_line(self) -> tuple[str, int] | None:
    method get_func_name (line 112) | def get_func_name(self) -> str | None:
  class AsyncStackRootHolder (line 155) | class AsyncStackRootHolder:
    method from_addr (line 159) | def from_addr(addr: DebuggerValue) -> "AsyncStackRootHolder":
  class AsyncStackRoot (line 166) | class AsyncStackRoot:
    method from_addr (line 173) | def from_addr(addr: DebuggerValue) -> "AsyncStackRoot":
  class AsyncStackFrame (line 183) | class AsyncStackFrame:
    method from_addr (line 189) | def from_addr(addr: DebuggerValue) -> "AsyncStackFrame":
  class StackFrame (line 198) | class StackFrame:
    method from_addr (line 203) | def from_addr(addr: DebuggerValue) -> "StackFrame":
  function get_async_stack_root_addr (line 210) | def get_async_stack_root_addr(
  function print_async_stack_addrs (line 264) | def print_async_stack_addrs(addrs: list[DebuggerValue]) -> None:
  function get_async_stack_addrs_from_initial_frame (line 285) | def get_async_stack_addrs_from_initial_frame(
  function walk_normal_stack (line 299) | def walk_normal_stack(
  class WalkAsyncStackResult (line 324) | class WalkAsyncStackResult:
  function walk_async_stack (line 334) | def walk_async_stack(
  function get_async_stack_addrs (line 394) | def get_async_stack_addrs(
  function print_async_stack_root_addrs (line 442) | def print_async_stack_root_addrs(addrs: list[DebuggerValue]) -> None:
  function get_async_stack_root_addrs (line 472) | def get_async_stack_root_addrs(
  function backtrace_command (line 487) | def backtrace_command(
  function async_stack_roots_command (line 510) | def async_stack_roots_command(debugger_value_class: type[DebuggerValue])...
  function co_bt_info (line 515) | def co_bt_info() -> str:
  function co_async_stack_root_info (line 524) | def co_async_stack_root_info() -> str:
  class DebuggerType (line 531) | class DebuggerType(enum.Enum):
  class GdbValue (line 542) | class GdbValue(DebuggerValue):
    method __init__ (line 550) | def __init__(self, value: gdb.Value) -> None:
    method nullptr (line 554) | def nullptr() -> DebuggerValue:
    method parse_and_eval (line 558) | def parse_and_eval(expr: str) -> DebuggerValue:
    method execute (line 562) | def execute(expr: str) -> str:
    method get_current_pthread_addr (line 566) | def get_current_pthread_addr() -> DebuggerValue:
    method get_register (line 586) | def get_register(register: str) -> DebuggerValue:
    method get_field (line 589) | def get_field(self, n: int) -> DebuggerValue:
    method is_nullptr (line 592) | def is_nullptr(self) -> bool:
    method int_value (line 595) | def int_value(self) -> int:
    method to_hex (line 598) | def to_hex(self) -> str:
    method get_file_name_and_line (line 601) | def get_file_name_and_line(self) -> tuple[str, int] | None:
    method get_func_name (line 613) | def get_func_name(self) -> str | None:
    method __eq__ (line 621) | def __eq__(self, other) -> bool:
  class GdbCoroBacktraceCommand (line 625) | class GdbCoroBacktraceCommand(gdb.Command):
    method __init__ (line 626) | def __init__(self):
    method invoke (line 630) | def invoke(self, arg: str, from_tty: bool):
  class GdbCoroAsyncStackRootsCommand (line 633) | class GdbCoroAsyncStackRootsCommand(gdb.Command):
    method __init__ (line 634) | def __init__(self):
    method invoke (line 638) | def invoke(self, arg: str, from_tty: bool):
  class LldbValue (line 650) | class LldbValue(DebuggerValue):
    method __init__ (line 661) | def __init__(self, value: lldb.SBValue) -> None:
    method nullptr (line 665) | def nullptr() -> DebuggerValue:
    method parse_and_eval (line 669) | def parse_and_eval(expr: str) -> DebuggerValue:
    method execute (line 679) | def execute(expr: str) -> str:
    method get_current_pthread_addr (line 689) | def get_current_pthread_addr() -> DebuggerValue:
    method get_register (line 717) | def get_register(register: str) -> DebuggerValue:
    method get_field (line 720) | def get_field(self, n: int) -> DebuggerValue:
    method is_nullptr (line 740) | def is_nullptr(self) -> bool:
    method int_value (line 743) | def int_value(self) -> int:
    method to_hex (line 746) | def to_hex(self) -> str:
    method _get_symbol_context (line 752) | def _get_symbol_context(self) -> "lldb.SBSymbolContext":
    method get_file_name_and_line (line 760) | def get_file_name_and_line(self) -> tuple[str, int] | None:
    method get_func_name (line 768) | def get_func_name(self) -> str | None:
    method __eq__ (line 774) | def __eq__(self, other) -> bool:
  class LldbCoroBacktraceCommand (line 777) | class LldbCoroBacktraceCommand:
    method __init__ (line 780) | def __init__(self, debugger, internal_dict):
    method register_lldb_command (line 784) | def register_lldb_command(cls, debugger, module_name):
    method get_short_help (line 790) | def get_short_help(self):
    method get_long_help (line 793) | def get_long_help(self):
    method __call__ (line 796) | def __call__(self, debugger, command, exe_ctx, result):
  class LldbCoroAsyncStackRootsCommand (line 800) | class LldbCoroAsyncStackRootsCommand:
    method __init__ (line 803) | def __init__(self, debugger, internal_dict):
    method register_lldb_command (line 807) | def register_lldb_command(cls, debugger, module_name):
    method get_short_help (line 813) | def get_short_help(self):
    method get_long_help (line 816) | def get_long_help(self):
    method __call__ (line 819) | def __call__(self, debugger, command, exe_ctx, result):
  function info (line 828) | def info():
  function load (line 836) | def load(debugger=None) -> None:
  function __lldb_init_module (line 851) | def __lldb_init_module(debugger, internal_dict) -> None:

FILE: folly/coro/scripts/test/co_bt.py
  class Lldb (line 23) | class Lldb:
    class Command (line 24) | class Command:
    class SBExecutionContext (line 27) | class SBExecutionContext:
    class SBValue (line 30) | class SBValue:
      method __init__ (line 33) | def __init__(self, value: str) -> None:
    method parse_and_eval (line 36) | def parse_and_eval(self, b):
  class CoBt (line 40) | class CoBt(unittest.TestCase):
    method setUp (line 41) | def setUp(self) -> None:
    method test_null_eq (line 45) | def test_null_eq(self) -> None:

FILE: folly/coro/test/AccumulateTest.cpp
  function generateInts (line 30) | AsyncGenerator<int> generateInts(int begin, int end) {
  class AccumulateTest (line 39) | class AccumulateTest : public testing::Test {}
  function TEST_F (line 41) | TEST_F(AccumulateTest, NoOperationProvided) {
  function TEST_F (line 48) | TEST_F(AccumulateTest, OperationProvided) {

FILE: folly/coro/test/AsyncGeneratorBenchmark.cpp
  type SomeError (line 32) | struct SomeError : std::exception {}
  function BENCHMARK (line 34) | BENCHMARK(asyncGeneratorThrowError, iters) {
  function BENCHMARK (line 52) | BENCHMARK(asyncGeneratorThrowErrorAwaitTry, iters) {
  function BENCHMARK (line 70) | BENCHMARK(asyncGeneratorYieldError, iters) {
  function BENCHMARK (line 88) | BENCHMARK(asyncGeneratorYieldErrorAwaitTry, iters) {
  function BENCHMARK (line 119) | BENCHMARK(asyncGeneratorYieldValues, iters) {
  function BENCHMARK (line 133) | BENCHMARK(compareToSynchronousGeneratorYieldValues, iters) {
  function main (line 147) | int main(int argc, char** argv) {

FILE: folly/coro/test/AsyncGeneratorTest.cpp
  function check_for_size_regressions (line 44) | constexpr bool check_for_size_regressions() {
  class AsyncGeneratorTest (line 68) | class AsyncGeneratorTest : public testing::Test {}
  function TEST_F (line 70) | TEST_F(AsyncGeneratorTest, DefaultConstructedGeneratorIsEmpty) {
  function TEST_F (line 78) | TEST_F(AsyncGeneratorTest, GeneratorDestroyedBeforeCallingBegin) {
  function TEST_F (line 93) | TEST_F(AsyncGeneratorTest, PartiallyConsumingSequenceDestroysObjectsInSc...
  function TEST_F (line 121) | TEST_F(AsyncGeneratorTest, FullyConsumeSequence) {
  type SomeError (line 148) | struct SomeError : std::exception {}
  function TEST_F (line 151) | TEST_F(AsyncGeneratorTest, ThrowExceptionBeforeFirstYield) {
  function TEST_F (line 172) | TEST_F(AsyncGeneratorTest, ThrowExceptionAfterFirstYield) {
  function TEST_F (line 194) | TEST_F(
  function TEST_F (line 212) | TEST_F(AsyncGeneratorTest, ProduceResultsAsynchronously) {
  type ConvertibleToIntReference (line 240) | struct ConvertibleToIntReference {
  function TEST_F (line 245) | TEST_F(AsyncGeneratorTest, GeneratorOfLValueReference) {
  type ConvertibleToInt (line 270) | struct ConvertibleToInt {
  function TEST_F (line 274) | TEST_F(AsyncGeneratorTest, GeneratorOfConstLValueReference) {
  function TEST_F (line 299) | TEST_F(AsyncGeneratorTest, GeneratorOfRValueReference) {
  type MoveOnly (line 325) | struct MoveOnly {
    method MoveOnly (line 326) | explicit MoveOnly(int value) : value_(value) {}
    method MoveOnly (line 327) | MoveOnly(MoveOnly&& other) noexcept
    method MoveOnly (line 330) | MoveOnly& operator=(MoveOnly&&) = delete;
    method value (line 331) | int value() const { return value_; }
  function TEST_F (line 337) | TEST_F(AsyncGeneratorTest, GeneratorOfMoveOnlyType) {
  function TEST_F (line 362) | TEST_F(AsyncGeneratorTest, GeneratorOfConstValue) {
  function TEST_F (line 388) | TEST_F(AsyncGeneratorTest, ExplicitValueType) {
  function TEST_F (line 419) | TEST_F(AsyncGeneratorTest, InvokeLambda) {
  function TEST_F (line 439) | TEST_F(AsyncGeneratorTest, InvokeLambdaRequiresCleanup) {
  function neverStream (line 461) | folly::coro::AsyncGenerator<Ref, Value> neverStream() {
  function TEST_F (line 469) | TEST_F(AsyncGeneratorTest, CancellationTokenPropagatesFromConsumer) {
  function TEST_F (line 496) | TEST_F(AsyncGeneratorTest, BlockingWaitOnFinalNextDoesNotDeadlock) {
  function TEST_F (line 506) | TEST_F(AsyncGeneratorTest, BlockingWaitOnThrowingFinalNextDoesNotDeadloc...
  function sizeRange (line 522) | folly::coro::AsyncGenerator<size_t> sizeRange(size_t from, size_t to) {
  function TEST_F (line 528) | TEST_F(AsyncGeneratorTest, SymmetricTransfer) {
  function TEST (line 569) | TEST(AsyncGenerator, YieldCoError) {
  function TEST (line 598) | TEST(AsyncGenerator, YieldCoResult) {
  function TEST (line 629) | TEST(AsyncGenerator, CoResultProxyExample) {
  function TEST (line 670) | TEST(AsyncGenerator, CoAwaitTry) {
  function TEST (line 691) | TEST(AsyncGenerator, CoAwaitValueOrError) {
  function CO_TEST (line 715) | CO_TEST(AsyncGenerator, ValueOrErrorPropagatesStopped) {
  function TEST (line 740) | TEST(AsyncGenerator, SafePoint) {
  function TEST_F (line 772) | TEST_F(AsyncGeneratorTest, NextAfterCancel) {
  function TEST (line 801) | TEST(AsyncGenerator, CoAwaitNothrow) {
  function TEST (line 829) | TEST(AsyncGenerator, CoAwaitNothrowMultiTask) {

FILE: folly/coro/test/AsyncPipeTest.cpp
  function TEST (line 30) | TEST(AsyncPipeTest, PublishConsume) {
  function TEST (line 44) | TEST(AsyncPipeTest, PublishLRValue) {
  function TEST (line 60) | TEST(AsyncPipeTest, PublishConsumeClose) {
  function TEST (line 79) | TEST(AsyncPipeTest, PublishConsumeError) {
  function TEST (line 97) | TEST(AsyncPipeTest, PublishConsumeDestroy) {
  function TEST (line 118) | TEST(AsyncPipeTest, PublishConsumeWithMoves) {
  function TEST (line 146) | TEST(AsyncPipeTest, BrokenPipe) {
  function TEST (line 156) | TEST(AsyncPipeTest, IsClosed) {
  function TEST (line 166) | TEST(AsyncPipeTest, WriteWhileBlocking) {
  function TEST (line 188) | TEST(AsyncPipeTest, CloseWhileBlocking) {
  function TEST (line 210) | TEST(AsyncPipeTest, DestroyWhileBlocking) {
  function TEST (line 234) | TEST(AsyncPipeTest, OnClosedCallbackCalledWhenGeneratorDestroyed) {
  function TEST (line 264) | TEST(AsyncPipeTest, OnClosedCallbackCalledWhenPublisherClosesPipe) {
  function TEST (line 277) | TEST(AsyncPipeTest, OnClosedCallbackCalledWhenPublisherClosesPipeWithErr...
  function TEST (line 290) | TEST(
  function TEST (line 340) | TEST(AsyncPipeTest, PublisherMustCloseIfCallbackSetAndGeneratorAlive) {
  function TEST (line 359) | TEST(BoundedAsyncPipeTest, PublishConsume) {
  function TEST (line 375) | TEST(BoundedAsyncPipeTest, PipeCapacity) {
  function TEST (line 395) | TEST(BoundedAsyncPipeTest, PublisherBlocks) {
  function TEST (line 426) | TEST(BoundedAsyncPipeTest, IsClosed) {
  function TEST (line 438) | TEST(BoundedAsyncPipeTest, BlockingPublisherCanceledOnDestroy) {
  function TEST (line 476) | TEST(BoundedAsyncPipeTest, PublisherFailsAfterDestroyWithRemainingTokens) {
  function TEST (line 494) | TEST(BoundedAsyncPipeTest, BlockingPublisherCancelsWithParent) {
  function TEST (line 525) | TEST(BoundedAsyncPipeTest, ClosingPublisherEndsConsumer) {
  function TEST (line 541) | TEST(BoundedAsyncPipeTest, ClosingPublisherWithException) {

FILE: folly/coro/test/AsyncScopeTest.cpp
  type AsyncScopeTest (line 33) | struct AsyncScopeTest : public testing::Test {}
  function TEST_F (line 35) | TEST_F(AsyncScopeTest, ConstructDestruct) {
  function CO_TEST_F (line 40) | CO_TEST_F(AsyncScopeTest, AddAndJoin) {
  function CO_TEST_F (line 57) | CO_TEST_F(AsyncScopeTest, StartChildTasksAfterCleanupStarted) {
  function CO_TEST_F (line 84) | CO_TEST_F(AsyncScopeTest, QueryRemainingCount) {
  function CO_TEST_F (line 104) | CO_TEST_F(AsyncScopeTest, QueryRemainingCountAfterJoined) {
  function crash (line 130) | folly::coro::Task<> crash() {
  function CO_TEST_F (line 142) | CO_TEST_F(AsyncScopeTest, DontThrowOnJoin) {
  function CO_TEST_F (line 147) | CO_TEST_F(AsyncScopeTest, ThrowOnJoin) {
  type CancellableAsyncScopeTest (line 159) | struct CancellableAsyncScopeTest : public testing::Test {}
  function TEST_F (line 161) | TEST_F(CancellableAsyncScopeTest, ConstructDestruct) {
  function CO_TEST_F (line 166) | CO_TEST_F(CancellableAsyncScopeTest, AddAndJoin) {
  function CO_TEST_F (line 185) | CO_TEST_F(CancellableAsyncScopeTest, StartChildTasksAfterCleanupStarted) {
  function CO_TEST_F (line 212) | CO_TEST_F(CancellableAsyncScopeTest, QueryRemainingCount) {
  function CO_TEST_F (line 232) | CO_TEST_F(CancellableAsyncScopeTest, QueryIsCancellationRequested) {
  function CO_TEST_F (line 307) | CO_TEST_F(CancellableAsyncScopeTest, CancelSuspendedWork) {
  function CO_TEST_F (line 356) | CO_TEST_F(CancellableAsyncScopeTest, CancelSuspendedWorkCoSchedule) {

FILE: folly/coro/test/AsyncStackTest.cpp
  class AsyncStackTest (line 36) | class AsyncStackTest : public testing::Test {}
  function TEST_F (line 38) | TEST_F(AsyncStackTest, SimpleStackTrace) {
  function TEST_F (line 53) | TEST_F(AsyncStackTest, NestedStackTrace) {
  function TEST_F (line 76) | TEST_F(AsyncStackTest, CollectAll) {
  type stack_frame (line 118) | struct stack_frame {
  function FOLLY_NOINLINE (line 123) | FOLLY_NOINLINE std::vector<std::uintptr_t> walk_stack() {
  function FOLLY_NOINLINE (line 149) | FOLLY_NOINLINE void normalFunction() {
  function coro1 (line 173) | folly::coro::Task<void> coro1() {
  function coro2 (line 178) | folly::coro::Task<void> coro2() {
  function TEST_F (line 182) | TEST_F(AsyncStackTest, MixedStackWalk) {

FILE: folly/coro/test/BatonTest.cpp
  class BatonTest (line 30) | class BatonTest : public testing::Test {}
  function TEST_F (line 32) | TEST_F(BatonTest, Ready) {
  function TEST_F (line 41) | TEST_F(BatonTest, InitiallyReady) {
  function TEST_F (line 48) | TEST_F(BatonTest, AwaitBaton) {
  function TEST_F (line 77) | TEST_F(BatonTest, MultiAwaitBaton) {

FILE: folly/coro/test/BlockingWaitBenchmark.cpp
  function BENCHMARK (line 27) | BENCHMARK(blockingWaitRVOInt, iters) {
  function BENCHMARK (line 41) | BENCHMARK(blockingWaitRVOStrings, iters) {
  type IdentityMatrix (line 51) | struct IdentityMatrix {}
  type Matrix (line 53) | struct Matrix {
    method Matrix (line 54) | Matrix(IdentityMatrix) noexcept {
    method Matrix (line 62) | Matrix(const Matrix&) noexcept = default;
    method Matrix (line 63) | Matrix& operator=(const Matrix&) noexcept = default;
  function BENCHMARK (line 68) | BENCHMARK(blockingWaitRVO, iters) {
  function main (line 80) | int main(int argc, char** argv) {

FILE: folly/coro/test/BlockingWaitTest.cpp
  class BlockingWaitTest (line 62) | class BlockingWaitTest : public testing::Test {}
  function TEST_F (line 64) | TEST_F(BlockingWaitTest, AwaitNowTask) {
  function TEST_F (line 73) | TEST_F(BlockingWaitTest, AwaitNowTaskWithExecutor) {
  function TEST_F (line 83) | TEST_F(BlockingWaitTest, SynchronousCompletionVoidResult) {
  function TEST_F (line 87) | TEST_F(BlockingWaitTest, SynchronousCompletionPRValueResult) {
  function TEST_F (line 96) | TEST_F(BlockingWaitTest, SynchronousCompletionLValueResult) {
  function TEST_F (line 104) | TEST_F(BlockingWaitTest, SynchronousCompletionRValueResult) {
  type TrickyAwaitable (line 117) | struct TrickyAwaitable {
    type Awaiter (line 118) | struct Awaiter {
      method await_ready (line 121) | bool await_ready() const noexcept { return false; }
      method await_suspend (line 123) | bool await_suspend(folly::coro::coroutine_handle<>) noexcept {
    method Awaiter (line 131) | Awaiter operator co_await() { return {}; }
      method await_ready (line 121) | bool await_ready() const noexcept { return false; }
      method await_suspend (line 123) | bool await_suspend(folly::coro::coroutine_handle<>) noexcept {
  function TEST_F (line 134) | TEST_F(BlockingWaitTest, ReturnRvalueReferenceFromAwaiter) {
  function TEST_F (line 145) | TEST_F(BlockingWaitTest, AsynchronousCompletionOnAnotherThread) {
  class SimplePromise (line 155) | class SimplePromise {
    class WaitOperation (line 157) | class WaitOperation {
      method WaitOperation (line 159) | explicit WaitOperation(
      method await_ready (line 163) | bool await_ready() noexcept { return awaiter_.await_ready(); }
      method await_suspend (line 166) | auto await_suspend(folly::coro::coroutine_handle<Promise> h) noexcept {
      method T (line 170) | T&& await_resume() {
    method SimplePromise (line 180) | SimplePromise() = default;
    method WaitOperation (line 182) | WaitOperation operator co_await() { return WaitOperation{baton_, value...
      method WaitOperation (line 159) | explicit WaitOperation(
      method await_ready (line 163) | bool await_ready() noexcept { return awaiter_.await_ready(); }
      method await_suspend (line 166) | auto await_suspend(folly::coro::coroutine_handle<Promise> h) noexcept {
      method T (line 170) | T&& await_resume() {
    method emplace (line 185) | void emplace(Args&&... args) {
  function TEST_F (line 195) | TEST_F(BlockingWaitTest, WaitOnSimpleAsyncPromise) {
  type MoveCounting (line 205) | struct MoveCounting {
    method MoveCounting (line 207) | MoveCounting() noexcept : count_(0) {}
    method MoveCounting (line 208) | MoveCounting(MoveCounting&& other) noexcept : count_(other.count_ + 1) {}
    method MoveCounting (line 209) | MoveCounting& operator=(MoveCounting&& other) = delete;
  function TEST_F (line 212) | TEST_F(BlockingWaitTest, WaitOnMoveOnlyAsyncPromise) {
  function TEST_F (line 228) | TEST_F(BlockingWaitTest, moveCountingAwaitableReady) {
  function TEST_F (line 240) | TEST_F(BlockingWaitTest, WaitInFiber) {
  function TEST_F (line 259) | TEST_F(BlockingWaitTest, WaitTaskInFiber) {
  type ExpectedException (line 284) | struct ExpectedException {}
  function TEST_F (line 286) | TEST_F(BlockingWaitTest, WaitTaskInFiberException) {
  function TEST_F (line 305) | TEST_F(BlockingWaitTest, WaitOnSemiFuture) {
  function TEST_F (line 310) | TEST_F(BlockingWaitTest, RequestContext) {
  function TEST_F (line 337) | TEST_F(BlockingWaitTest, DrivableExecutor) {
  function TEST_F (line 348) | TEST_F(BlockingWaitTest, ReleaseExecutorFromAnotherThread) {
  function TEST_F (line 376) | TEST_F(BlockingWaitTest, ReleaseManualExecutorFromAnotherThread) {

FILE: folly/coro/test/BoundedQueueTest.cpp
  type SlowMover (line 36) | struct SlowMover {
    method SlowMover (line 37) | explicit SlowMover(bool slow = false) : slow(slow) {}
    method SlowMover (line 38) | SlowMover(SlowMover&& other) noexcept { *this = std::move(other); }
    method SlowMover (line 39) | SlowMover& operator=(SlowMover&& other) noexcept {
  function CO_TEST (line 52) | CO_TEST(BoundedQueueTest, EnqueueDeque) {
  function CO_TEST (line 71) | CO_TEST(BoundedQueueTest, DequeueWhileBlocking) {
  function CO_TEST (line 85) | CO_TEST(BoundedQueueTest, EnqueueDequeMultiProducer) {
  function CO_TEST (line 115) | CO_TEST(BoundedQueueTest, EnqueueDequeMultiConsumer) {
  function CO_TEST (line 139) | CO_TEST(BoundedQueueTest, EnqueueDequeMPMCWithSingleSlot) {
  function CO_TEST (line 180) | CO_TEST(
  function CO_TEST (line 193) | CO_TEST(BoundedQueueTest, EnqueueWait) {
  function CO_TEST (line 210) | CO_TEST(BoundedQueueTest, DequeueWait) {
  function CO_TEST (line 227) | CO_TEST(BoundedQueueTest, TryEnqueue) {
  function CO_TEST (line 237) | CO_TEST(BoundedQueueTest, TryDequeue) {
  function TEST (line 245) | TEST(BoundedQueueTest, UnorderedEnqueueCompletion) {
  function TEST (line 282) | TEST(BoundedQueueTest, UnorderedDequeueCompletion) {
  function TEST (line 310) | TEST(BoundedQueueTest, TryDequeueFor) {

FILE: folly/coro/test/CollectAllBenchmark.cpp
  function doWork (line 25) | void doWork() {}
  function collectAllFuture (line 29) | void collectAllFuture(size_t batchSize) {
  function collectAllFutureInline (line 37) | void collectAllFutureInline(size_t batchSize) {
  function co_doWork (line 48) | folly::coro::Task<void> co_doWork() {
  function collectAllCoro (line 53) | void collectAllCoro(size_t batchSize) {
  function collectAllBaton (line 66) | void collectAllBaton(size_t batchSize) {
  function BENCHMARK (line 78) | BENCHMARK(collectAllFuture10000, iters) {
  function BENCHMARK (line 84) | BENCHMARK(collectAllFutureInline10000, iters) {
  function BENCHMARK (line 90) | BENCHMARK(collectAllCoro10000, iters) {
  function BENCHMARK (line 96) | BENCHMARK(collectAllBaton10000, iters) {
  function BENCHMARK (line 102) | BENCHMARK(collectAllFuture100, iters) {
  function BENCHMARK (line 108) | BENCHMARK(collectAllFutureInline100, iters) {
  function BENCHMARK (line 114) | BENCHMARK(collectAllCoro100, iters) {
  function BENCHMARK (line 120) | BENCHMARK(collectAllBaton100, iters) {
  function main (line 126) | int main(int argc, char** argv) {

FILE: folly/coro/test/CollectAllTryBenchmark.cpp
  type BenchmarkError (line 38) | struct BenchmarkError : std::exception {}
  function succeedingTask (line 40) | folly::coro::Task<int> succeedingTask(int value) {
  function failingTask (line 44) | folly::coro::Task<int> failingTask() {
  type folly::coro (line 51) | namespace folly::coro {
    type benchmark_detail (line 53) | namespace benchmark_detail {
      function collectAllTryRangeWithTryCatchImpl (line 55) | auto collectAllTryRangeWithTryCatchImpl(InputRange awaitables)
    function collectAllTryRangeWithTryCatch (line 113) | auto collectAllTryRangeWithTryCatch(std::vector<SemiAwaitable> awaitab...
  function BENCHMARK (line 125) | BENCHMARK(coAwaitTry_AllSucceed_100, iters) {
  function BENCHMARK_RELATIVE (line 139) | BENCHMARK_RELATIVE(tryCatch_AllSucceed_100, iters) {
  function BENCHMARK (line 159) | BENCHMARK(coAwaitTry_AllFail_100, iters) {
  function BENCHMARK_RELATIVE (line 173) | BENCHMARK_RELATIVE(tryCatch_AllFail_100, iters) {
  function BENCHMARK (line 193) | BENCHMARK(coAwaitTry_HalfFail_100, iters) {
  function BENCHMARK_RELATIVE (line 211) | BENCHMARK_RELATIVE(tryCatch_HalfFail_100, iters) {
  function BENCHMARK (line 235) | BENCHMARK(coAwaitTry_SingleSuccess, iters) {
  function BENCHMARK_RELATIVE (line 244) | BENCHMARK_RELATIVE(tryCatch_SingleSuccess, iters) {
  function BENCHMARK (line 260) | BENCHMARK(coAwaitTry_SingleFailure, iters) {
  function BENCHMARK_RELATIVE (line 269) | BENCHMARK_RELATIVE(tryCatch_SingleFailure, iters) {
  function main (line 285) | int main(int argc, char** argv) {

FILE: folly/coro/test/CollectTest.cpp
  type folly::coro (line 41) | namespace folly::coro {
    type CollectAll (line 43) | struct CollectAll {
    type CollectAllTry (line 49) | struct CollectAllTry {
    type SafeTaskTypeAssertions (line 56) | struct SafeTaskTypeAssertions {
    type SafeTaskTypeAssertions<CollectAll, int, int> (line 109) | struct SafeTaskTypeAssertions<CollectAll, int, int>
    type SafeTaskTypeAssertions<CollectAllTry, int, Try<int>> (line 112) | struct SafeTaskTypeAssertions<CollectAllTry, int, Try<int>>
  function sleepThatShouldBeCancelled (line 118) | folly::coro::Task<void> sleepThatShouldBeCancelled(
  class CollectAllTest (line 123) | class CollectAllTest : public testing::Test {}
  function CO_TEST_F (line 125) | CO_TEST_F(CollectAllTest, NowTask) {
  function TEST_F (line 133) | TEST_F(CollectAllTest, WithNoArgs) {
  function TEST_F (line 143) | TEST_F(CollectAllTest, OneTaskWithValue) {
  function TEST_F (line 178) | TEST_F(CollectAllTest, OneVoidTask) {
  function TEST_F (line 193) | TEST_F(CollectAllTest, CollectAllDoesntCompleteUntilAllTasksComplete) {
  type ErrorA (line 236) | struct ErrorA : std::exception {}
  type ErrorB (line 237) | struct ErrorB : std::exception {}
  type ErrorC (line 238) | struct ErrorC : std::exception {}
  function TEST_F (line 240) | TEST_F(CollectAllTest, ThrowsFirstError) {
  function TEST_F (line 283) | TEST_F(CollectAllTest, SynchronousCompletionInLoopDoesntCauseStackOverfl...
  type OperationCancelled (line 297) | struct OperationCancelled : std::exception {}
  function parallelAccumulate (line 304) | folly::coro::Task<InitialValue> parallelAccumulate(
  function TEST_F (line 319) | TEST_F(CollectAllTest, ParallelAccumulate) {
  function TEST_F (line 339) | TEST_F(CollectAllTest, CollectAllCancelsSubtasksWhenASubtaskFails) {
  function TEST_F (line 370) | TEST_F(CollectAllTest, CollectAllCancelsSubtasksWhenParentTaskCancelled) {
  function TEST_F (line 402) | TEST_F(CollectAllTest, CancellationTokenRemainsActiveAfterReturn) {
  class TestRequestData (line 431) | class TestRequestData : public folly::RequestData {
    method TestRequestData (line 433) | explicit TestRequestData() noexcept {}
    method hasCallback (line 435) | bool hasCallback() override { return false; }
  function TEST_F (line 440) | TEST_F(CollectAllTest, CollectAllKeepsRequestContextOfChildTasksIndepend...
  function TEST_F (line 476) | TEST_F(CollectAllTest, TaskWithExecutorUsage) {
  class CollectAllTryTest (line 492) | class CollectAllTryTest : public testing::Test {}
  function CO_TEST_F (line 494) | CO_TEST_F(CollectAllTryTest, NowTask) {
  function TEST_F (line 507) | TEST_F(CollectAllTryTest, WithNoArgs) {
  function TEST_F (line 517) | TEST_F(CollectAllTryTest, OneTaskWithValue) {
  function TEST_F (line 552) | TEST_F(CollectAllTryTest, OneTaskWithError) {
  function TEST_F (line 567) | TEST_F(CollectAllTryTest, PartialFailure) {
  function TEST_F (line 591) | TEST_F(CollectAllTryTest, CollectAllTryDoesNotCancelSubtasksWhenASubtask...
  function TEST_F (line 629) | TEST_F(CollectAllTryTest, CollectAllCancelsSubtasksWhenParentTaskCancell...
  function TEST_F (line 661) | TEST_F(CollectAllTryTest, CancellationTokenRemainsActiveAfterReturn) {
  function TEST_F (line 688) | TEST_F(CollectAllTryTest, KeepsRequestContextOfChildTasksIndependent) {
  class CollectAllRangeTest (line 724) | class CollectAllRangeTest : public testing::Test {}
  function TEST_F (line 726) | TEST_F(CollectAllRangeTest, EmptyRangeOfVoidTask) {
  function TEST_F (line 738) | TEST_F(CollectAllRangeTest, RangeOfVoidAllSucceeding) {
  function TEST_F (line 757) | TEST_F(CollectAllRangeTest, RangeOfVoidSomeFailing) {
  function TEST_F (line 784) | TEST_F(CollectAllRangeTest, RangeOfNonVoid) {
  function TEST_F (line 817) | TEST_F(CollectAllRangeTest, SubtasksCancelledWhenASubtaskFails) {
  function TEST_F (line 853) | TEST_F(CollectAllRangeTest, FailsWithErrorOfFirstTaskToFailWhenMultipleE...
  function TEST_F (line 877) | TEST_F(CollectAllRangeTest, SubtasksCancelledWhenParentTaskCancelled) {
  function TEST_F (line 914) | TEST_F(CollectAllRangeTest, CancellationTokenRemainsActiveAfterReturn) {
  function TEST_F (line 944) | TEST_F(CollectAllRangeTest, KeepsRequestContextOfChildTasksIndependent) {
  function TEST_F (line 985) | TEST_F(CollectAllRangeTest, VectorOfTaskWithExecutorUsage) {
  function TEST_F (line 1006) | TEST_F(CollectAllRangeTest, GeneratorFromRange) {
  function CO_TEST_F (line 1031) | CO_TEST_F(CollectAllRangeTest, GeneratorFromVoidRange) {
  function TEST_F (line 1061) | TEST_F(CollectAllRangeTest, GeneratorFromRangePartialConsume) {
  function TEST_F (line 1081) | TEST_F(CollectAllRangeTest, GeneratorFromRangeFailed) {
  function TEST_F (line 1111) | TEST_F(CollectAllRangeTest, GeneratorFromRangeCancelled) {
  function TEST_F (line 1141) | TEST_F(CollectAllRangeTest, GeneratorFromRangeCancelledFromScope) {
  function TEST_F (line 1171) | TEST_F(CollectAllRangeTest, GeneratorFromEmptyRange) {
  class CollectAllTryRangeTest (line 1184) | class CollectAllTryRangeTest : public testing::Test {}
  function TEST_F (line 1186) | TEST_F(CollectAllTryRangeTest, RangeOfVoidSomeFailing) {
  function TEST_F (line 1214) | TEST_F(CollectAllTryRangeTest, RangeOfValueSomeFailing) {
  function TEST_F (line 1248) | TEST_F(CollectAllTryRangeTest, NotCancelledWhenSubtaskFails) {
  function TEST_F (line 1282) | TEST_F(CollectAllTryRangeTest, SubtasksCancelledWhenParentTaskCancelled) {
  function TEST_F (line 1324) | TEST_F(CollectAllTryRangeTest, CancellationTokenRemainsActiveAfterReturn) {
  function TEST_F (line 1355) | TEST_F(CollectAllTryRangeTest, KeepsRequestContextOfChildTasksIndependen...
  function TEST_F (line 1396) | TEST_F(CollectAllTryRangeTest, GeneratorFromRange) {
  function TEST_F (line 1420) | TEST_F(CollectAllTryRangeTest, GeneratorFromRangeFailed) {
  function TEST_F (line 1451) | TEST_F(CollectAllTryRangeTest, GeneratorFromRangeCancelled) {
  class CollectAllWindowedTest (line 1481) | class CollectAllWindowedTest : public testing::Test {}
  function TEST_F (line 1483) | TEST_F(CollectAllWindowedTest, ConcurrentTasks) {
  function TEST_F (line 1506) | TEST_F(CollectAllWindowedTest, WithGeneratorOfTaskOfValue) {
  function TEST_F (line 1548) | TEST_F(CollectAllWindowedTest, WithGeneratorOfTaskOfVoid) {
  function TEST_F (line 1578) | TEST_F(CollectAllWindowedTest, VectorOfVoidTask) {
  function TEST_F (line 1598) | TEST_F(CollectAllWindowedTest, VectorOfValueTask) {
  function TEST_F (line 1623) | TEST_F(CollectAllWindowedTest, MultipleFailuresPropagatesFirstError) {
  function TEST_F (line 1650) | TEST_F(CollectAllWindowedTest, SubtasksCancelledWhenASubtaskFails) {
  function TEST_F (line 1682) | TEST_F(CollectAllWindowedTest, SubtasksCancelledWhenParentTaskCancelled) {
  function TEST_F (line 1722) | TEST_F(CollectAllWindowedTest, CancellationTokenRemainsActiveAfterReturn) {
  function TEST_F (line 1753) | TEST_F(CollectAllWindowedTest, KeepsRequestContextOfChildTasksIndependen...
  function TEST_F (line 1794) | TEST_F(CollectAllWindowedTest, VectorOfTaskWithExecutorUsage) {
  class CollectAllTryWindowedTest (line 1816) | class CollectAllTryWindowedTest : public testing::Test {}
  function TEST_F (line 1818) | TEST_F(CollectAllTryWindowedTest, PartialFailure) {
  function TEST_F (line 1854) | TEST_F(CollectAllTryWindowedTest, GeneratorFailure) {
  function TEST_F (line 1887) | TEST_F(CollectAllTryWindowedTest, NotCancelledWhenSubtaskFails) {
  function TEST_F (line 1917) | TEST_F(CollectAllTryWindowedTest, SubtasksCancelledWhenParentTaskCancell...
  function TEST_F (line 1961) | TEST_F(CollectAllTryWindowedTest, CancellationTokenRemainsActiveAfterRet...
  class CollectAnyTest (line 1992) | class CollectAnyTest : public testing::Test {}
  function TEST_F (line 1994) | TEST_F(CollectAnyTest, OneTaskWithValue) {
  function TEST_F (line 2030) | TEST_F(CollectAnyTest, OneVoidTask) {
  function TEST_F (line 2045) | TEST_F(CollectAnyTest, MoveOnlyType) {
  function TEST_F (line 2061) | TEST_F(CollectAnyTest, CollectAnyDoesntCompleteUntilAllTasksComplete) {
  function TEST_F (line 2107) | TEST_F(CollectAnyTest, ThrowsFirstError) {
  function TEST_F (line 2149) | TEST_F(CollectAnyTest, CollectAnyCancelsSubtasksWhenASubtaskCompletes) {
  function TEST_F (line 2180) | TEST_F(CollectAnyTest, CollectAnyCancelsSubtasksWhenParentTaskCancelled) {
  function TEST_F (line 2210) | TEST_F(CollectAnyTest, CancellationTokenRemainsActiveAfterReturn) {
  class CollectAnyWithoutExceptionTest (line 2237) | class CollectAnyWithoutExceptionTest : public testing::Test {}
  function TEST_F (line 2239) | TEST_F(CollectAnyWithoutExceptionTest, OneTaskWithValue) {
  function TEST_F (line 2276) | TEST_F(CollectAnyWithoutExceptionTest, OneVoidTask) {
  function TEST_F (line 2292) | TEST_F(CollectAnyWithoutExceptionTest, MoveOnlyType) {
  function TEST_F (line 2308) | TEST_F(CollectAnyWithoutExceptionTest, DoesntCompleteUntilAllTasksComple...
  function TEST_F (line 2354) | TEST_F(CollectAnyWithoutExceptionTest, ThrowsLastError) {
  function TEST_F (line 2391) | TEST_F(CollectAnyWithoutExceptionTest, ReturnsFirstValueWithoutException) {
  function TEST_F (line 2414) | TEST_F(CollectAnyWithoutExceptionTest, CancelsSubtasksWhenASubtaskComple...
  function TEST_F (line 2442) | TEST_F(CollectAnyWithoutExceptionTest, CancelsSubtasksWhenParentTaskCanc...
  function TEST_F (line 2472) | TEST_F(
  class CollectAnyNoDiscardTest (line 2501) | class CollectAnyNoDiscardTest : public testing::Test {}
  function TEST_F (line 2503) | TEST_F(CollectAnyNoDiscardTest, OneTask) {
  function TEST_F (line 2518) | TEST_F(CollectAnyNoDiscardTest, MultipleTasksWithValues) {
  function TEST_F (line 2541) | TEST_F(CollectAnyNoDiscardTest, OneVoidTask) {
  function TEST_F (line 2557) | TEST_F(CollectAnyNoDiscardTest, DoesntCompleteUntilAllTasksComplete) {
  function TEST_F (line 2604) | TEST_F(CollectAnyNoDiscardTest, ThrowsAllErrors) {
  function TEST_F (line 2630) | TEST_F(CollectAnyNoDiscardTest, CancelSubtasksWhenASubtaskCompletes) {
  function TEST_F (line 2659) | TEST_F(CollectAnyNoDiscardTest, CancelSubtasksWhenParentTaskCancelled) {
  function TEST_F (line 2692) | TEST_F(CollectAnyNoDiscardTest, CancellationTokenRemainsActiveAfterRetur...
  class CollectAnyRangeTest (line 2720) | class CollectAnyRangeTest : public testing::Test {}
  function TEST_F (line 2722) | TEST_F(CollectAnyRangeTest, OneTaskWithValue) {
  function TEST_F (line 2761) | TEST_F(CollectAnyRangeTest, OneVoidTask) {
  function TEST_F (line 2780) | TEST_F(CollectAnyRangeTest, MoveOnlyType) {
  function TEST_F (line 2799) | TEST_F(CollectAnyRangeTest, CollectAnyDoesntCompleteUntilAllTasksComplet...
  function TEST_F (line 2852) | TEST_F(CollectAnyRangeTest, ThrowsFirstError) {
  function TEST_F (line 2900) | TEST_F(CollectAnyRangeTest, CollectAnyCancelsSubtasksWhenASubtaskComplet...
  function TEST_F (line 2933) | TEST_F(CollectAnyRangeTest, CollectAnyCancelsSubtasksWhenParentTaskCance...
  function TEST_F (line 2965) | TEST_F(CollectAnyRangeTest, CancellationTokenRemainsActiveAfterReturn) {
  class CollectAnyWithoutExceptionRangeTest (line 2995) | class CollectAnyWithoutExceptionRangeTest : public testing::Test {}
  function TEST_F (line 2997) | TEST_F(CollectAnyWithoutExceptionRangeTest, OneTaskWithValue) {
  function TEST_F (line 3036) | TEST_F(CollectAnyWithoutExceptionRangeTest, OneVoidTask) {
  function TEST_F (line 3055) | TEST_F(CollectAnyWithoutExceptionRangeTest, MoveOnlyType) {
  function TEST_F (line 3074) | TEST_F(
  function TEST_F (line 3128) | TEST_F(CollectAnyWithoutExceptionRangeTest, ThrowsLastError) {
  function TEST_F (line 3171) | TEST_F(CollectAnyWithoutExceptionRangeTest, ReturnsFirstValueWithoutExce...
  function TEST_F (line 3198) | TEST_F(
  function TEST_F (line 3229) | TEST_F(
  function TEST_F (line 3264) | TEST_F(
  class CollectAnyNoDiscardRangeTest (line 3298) | class CollectAnyNoDiscardRangeTest : public testing::Test {}
  function TEST_F (line 3300) | TEST_F(CollectAnyNoDiscardRangeTest, OneTask) {
  function TEST_F (line 3327) | TEST_F(CollectAnyNoDiscardRangeTest, MultipleTasksWithValues) {
  function TEST_F (line 3355) | TEST_F(CollectAnyNoDiscardRangeTest, OneVoidTask) {
  function TEST_F (line 3373) | TEST_F(CollectAnyNoDiscardRangeTest, DoesntCompleteUntilAllTasksComplete) {
  function TEST_F (line 3428) | TEST_F(CollectAnyNoDiscardRangeTest, ThrowsAllErrors) {
  function TEST_F (line 3459) | TEST_F(CollectAnyNoDiscardRangeTest, CancelSubtasksWhenASubtaskCompletes) {
  function TEST_F (line 3493) | TEST_F(CollectAnyNoDiscardRangeTest, CancelSubtasksWhenParentTaskCancell...
  function TEST_F (line 3531) | TEST_F(
  function TEST (line 3561) | TEST(MakeUnorderedAsyncGeneratorTest, GeneratorEarlyDestroy) {

FILE: folly/coro/test/ConcatTest.cpp
  function generateInts (line 31) | AsyncGenerator<int> generateInts(int begin, int end) {
  function toVector (line 38) | Task<std::vector<int>> toVector(AsyncGenerator<int> generator) {
  class ConcatTest (line 48) | class ConcatTest : public testing::Test {}
  function TEST_F (line 50) | TEST_F(ConcatTest, ConcatSingle) {
  function TEST_F (line 58) | TEST_F(ConcatTest, ConcatMultiple) {

FILE: folly/coro/test/CoroBenchmarkAllocator.cpp
  class Wait (line 25) | class Wait {
    class promise_type (line 27) | class promise_type {
      method Wait (line 29) | Wait get_return_object() { return Wait(promise_.get_future()); }
      method initial_suspend (line 31) | folly::coro::suspend_never initial_suspend() noexcept { return {}; }
      method final_suspend (line 33) | folly::coro::suspend_never final_suspend() noexcept { return {}; }
      method return_void (line 35) | void return_void() { promise_.set_value(); }
      method unhandled_exception (line 37) | void unhandled_exception() {
    method Wait (line 45) | explicit Wait(std::future<void> future) : future_(std::move(future)) {}
    method Wait (line 47) | Wait(Wait&&) = default;
    method detach (line 49) | void detach() { future_ = {}; }
  class InlineTask (line 62) | class InlineTask {
    method InlineTask (line 64) | InlineTask(const InlineTask&) = delete;
    method InlineTask (line 65) | InlineTask(InlineTask&& other)
    method await_ready (line 70) | bool await_ready() const noexcept { return false; }
    method await_suspend (line 72) | folly::coro::coroutine_handle<> await_suspend(
    method T (line 79) | T await_resume() {
    class promise_type (line 87) | class promise_type {
      method InlineTask (line 89) | InlineTask get_return_object() { return InlineTask(this); }
      method return_value (line 92) | void return_value(U&& value) {
      method unhandled_exception (line 96) | void unhandled_exception() { std::terminate(); }
      method initial_suspend (line 98) | folly::coro::suspend_always initial_suspend() { return {}; }
      class FinalSuspender (line 100) | class FinalSuspender {
        method await_ready (line 102) | bool await_ready() noexcept { return false; }
        method await_suspend (line 104) | auto await_suspend(
        method await_resume (line 109) | void await_resume() noexcept {}
      method FinalSuspender (line 112) | FinalSuspender final_suspend() noexcept { return FinalSuspender{}; }
        method await_ready (line 102) | bool await_ready() noexcept { return false; }
        method await_suspend (line 104) | auto await_suspend(
        method await_resume (line 109) | void await_resume() noexcept {}
    method InlineTask (line 124) | explicit InlineTask(promise_type* promise) : promise_(promise) {}
  class StackAllocator (line 130) | class StackAllocator {
    method StackAllocator (line 132) | explicit StackAllocator(size_t bytes) : buffer_(new char[bytes]) {}
    method StackAllocator (line 134) | StackAllocator(const StackAllocator&) = delete;
    method deallocate (line 142) | void deallocate(void*, size_t bytes) { buffer_ -= bytes; }
  class InlineTaskAllocator (line 153) | class InlineTaskAllocator {
    method InlineTaskAllocator (line 155) | InlineTaskAllocator(const InlineTaskAllocator&) = delete;
    method InlineTaskAllocator (line 156) | InlineTaskAllocator(InlineTaskAllocator&& other)
    method await_ready (line 161) | bool await_ready() const noexcept { return false; }
    method await_suspend (line 163) | folly::coro::coroutine_handle<> await_suspend(
    method T (line 170) | T await_resume() {
    class promise_type (line 178) | class promise_type {
      method InlineTaskAllocator (line 195) | InlineTaskAllocator get_return_object() {
      method return_value (line 200) | void return_value(U&& value) {
      method unhandled_exception (line 204) | [[noreturn]] void unhandled_exception() noexcept { std::terminate(); }
      method initial_suspend (line 206) | folly::coro::suspend_always initial_suspend() noexcept { return {}; }
      class FinalSuspender (line 208) | class FinalSuspender {
        method await_ready (line 210) | bool await_ready() noexcept { return false; }
        method await_suspend (line 212) | auto await_suspend(
        method await_resume (line 217) | void await_resume() noexcept {}
      method FinalSuspender (line 220) | FinalSuspender final_suspend() noexcept { return FinalSuspender{}; }
        method await_ready (line 210) | bool await_ready() noexcept { return false; }
        method await_suspend (line 212) | auto await_suspend(
        method await_resume (line 217) | void await_resume() noexcept {}
    method InlineTaskAllocator (line 232) | explicit InlineTaskAllocator(promise_type* promise) : promise_(promise...
  class Recursion (line 238) | class Recursion {
    method create (line 240) | static std::unique_ptr<Recursion> create(size_t depth) {
    method co_allocator (line 261) | InlineTaskAllocator<int> co_allocator() {
    method Recursion (line 269) | explicit Recursion(std::unique_ptr<Recursion> child)
  function coroRecursion (line 275) | void coroRecursion(size_t times, size_t iters) {
  function BENCHMARK (line 285) | BENCHMARK(coroRecursionDepth10, iters) {
  function BENCHMARK (line 289) | BENCHMARK(coroRecursionDepth1000, iters) {
  function coroRecursionAllocator (line 293) | void coroRecursionAllocator(size_t times, size_t iters) {
  function BENCHMARK (line 303) | BENCHMARK(coroRecursionAllocatorDepth10, iters) {
  function BENCHMARK (line 307) | BENCHMARK(coroRecursionAllocatorDepth1000, iters) {
  function recursion (line 311) | void recursion(size_t times, size_t iters) {
  function BENCHMARK (line 318) | BENCHMARK(recursionDepth10, iters) {
  function BENCHMARK (line 322) | BENCHMARK(recursionDepth1000, iters) {
  function main (line 327) | int main(int argc, char** argv) {

FILE: folly/coro/test/CoroBenchmarkNRVO.cpp
  type ExpensiveCopy (line 24) | struct ExpensiveCopy {
    method ExpensiveCopy (line 25) | ExpensiveCopy() {}
    method ExpensiveCopy (line 27) | ExpensiveCopy(const ExpensiveCopy&) {
    method ExpensiveCopy (line 31) | ExpensiveCopy& operator=(const ExpensiveCopy&) = default;
  class Wait (line 36) | class Wait {
    class promise_type (line 38) | class promise_type {
      method Wait (line 40) | Wait get_return_object() { return Wait(promise_.get_future()); }
      method initial_suspend (line 42) | folly::coro::suspend_never initial_suspend() noexcept { return {}; }
      method final_suspend (line 44) | folly::coro::suspend_never final_suspend() noexcept { return {}; }
      method return_void (line 46) | void return_void() { promise_.set_value(); }
      method unhandled_exception (line 48) | void unhandled_exception() {
    method Wait (line 56) | explicit Wait(std::future<void> future) : future_(std::move(future)) {}
    method Wait (line 58) | Wait(Wait&&) = default;
    method detach (line 60) | void detach() { future_ = {}; }
  class InlineTask (line 73) | class InlineTask {
    method InlineTask (line 75) | InlineTask(const InlineTask&) = delete;
    method InlineTask (line 76) | InlineTask(InlineTask&& other)
    method await_ready (line 81) | bool await_ready() const noexcept { return false; }
    method await_suspend (line 83) | folly::coro::coroutine_handle<> await_suspend(
    method T (line 90) | T await_resume() {
    class promise_type (line 98) | class promise_type {
      method InlineTask (line 100) | InlineTask get_return_object() { return InlineTask(this); }
      method return_value (line 103) | void return_value(U&& value) {
      method unhandled_exception (line 107) | void unhandled_exception() { std::terminate(); }
      method initial_suspend (line 109) | folly::coro::suspend_always initial_suspend() { return {}; }
      class FinalSuspender (line 111) | class FinalSuspender {
        method FinalSuspender (line 113) | explicit FinalSuspender(folly::coro::coroutine_handle<> awaiter) n...
        method await_ready (line 116) | bool await_ready() noexcept { return false; }
        method await_suspend (line 118) | auto await_suspend(folly::coro::coroutine_handle<>) noexcept {
        method await_resume (line 122) | void await_resume() noexcept {}
      method FinalSuspender (line 128) | FinalSuspender final_suspend() noexcept {
        method FinalSuspender (line 113) | explicit FinalSuspender(folly::coro::coroutine_handle<> awaiter) n...
        method await_ready (line 116) | bool await_ready() noexcept { return false; }
        method await_suspend (line 118) | auto await_suspend(folly::coro::coroutine_handle<>) noexcept {
        method await_resume (line 122) | void await_resume() noexcept {}
    method InlineTask (line 142) | explicit InlineTask(promise_type* promise) : promise_(promise) {}
  function co_nestedCalls (line 148) | InlineTask<ExpensiveCopy> co_nestedCalls(size_t times) {
  function coroNRVO (line 156) | void coroNRVO(size_t times, size_t iters) {
  function BENCHMARK (line 165) | BENCHMARK(coroNRVOOneAwait, iters) {
  function BENCHMARK (line 169) | BENCHMARK(coroNRVOTenAwaits, iters) {
  function ExpensiveCopy (line 174) | ExpensiveCopy nestedCalls(size_t times) {
    method ExpensiveCopy (line 25) | ExpensiveCopy() {}
    method ExpensiveCopy (line 27) | ExpensiveCopy(const ExpensiveCopy&) {
    method ExpensiveCopy (line 31) | ExpensiveCopy& operator=(const ExpensiveCopy&) = default;
  function NRVO (line 183) | void NRVO(size_t times, size_t iters) {
  function BENCHMARK (line 189) | BENCHMARK(NRVOOneAwait, iters) {
  function BENCHMARK (line 193) | BENCHMARK(NRVOTenAwaits, iters) {
  function main (line 197) | int main(int argc, char** argv) {

FILE: folly/coro/test/CoroTest.cpp
  class CoroTest (line 45) | class CoroTest : public testing::Test {}
  function TEST_F (line 47) | TEST_F(CoroTest, Basic) {
  function TEST_F (line 60) | TEST_F(CoroTest, BasicSemiFuture) {
  function TEST_F (line 73) | TEST_F(CoroTest, BasicFuture) {
  function taskVoid (line 84) | coro::Task<void> taskVoid() {
  function TEST_F (line 90) | TEST_F(CoroTest, Basic2) {
  function TEST_F (line 101) | TEST_F(CoroTest, TaskOfMoveOnly) {
  function taskSleep (line 111) | coro::Task<void> taskSleep() {
  function TEST_F (line 116) | TEST_F(CoroTest, Sleep) {
  function TEST_F (line 132) | TEST_F(CoroTest, ExecutorKeepAlive) {
  function TEST_F (line 141) | TEST_F(CoroTest, ExecutorKeepAliveDummy) {
  function TEST_F (line 176) | TEST_F(CoroTest, FutureThrow) {
  function taskRecursion (line 193) | coro::Task<int> taskRecursion(int depth) {
  function TEST_F (line 203) | TEST_F(CoroTest, LargeStack) {
  function TEST_F (line 210) | TEST_F(CoroTest, NestedThreads) {
  function TEST_F (line 241) | TEST_F(CoroTest, CurrentExecutor) {
  function TEST_F (line 256) | TEST_F(CoroTest, TimedWaitFuture) {
  function TEST_F (line 304) | TEST_F(CoroTest, TimedWaitTask) {
  function TEST_F (line 342) | TEST_F(CoroTest, TimedWaitKeepAlive) {
  function TEST_F (line 353) | TEST_F(CoroTest, TimedWaitNonCopyable) {
  type AwaitableInt (line 369) | struct AwaitableInt {
    method await_ready (line 370) | bool await_ready() const noexcept { return true; }
    method await_suspend (line 372) | bool await_suspend(coro::coroutine_handle<>) { assume_unreachable(); }
    method await_resume (line 374) | int await_resume() { return value; }
  type AwaitableWithOperator (line 377) | struct AwaitableWithOperator {}
  type AwaitableWithMemberOperator (line 383) | struct AwaitableWithMemberOperator {
  function TEST_F (line 394) | TEST_F(CoroTest, AwaitableWithOperator) {
  function TEST_F (line 402) | TEST_F(CoroTest, AwaitableWithMemberOperator) {
  function TEST_F (line 410) | TEST_F(CoroTest, Baton) {
  function TEST_F (line 433) | TEST_F(CoroTest, FulfilledFuture) {
  function TEST_F (line 441) | TEST_F(CoroTest, MoveOnlyReturn) {
  function TEST_F (line 449) | TEST_F(CoroTest, co_invoke) {
  function TEST_F (line 470) | TEST_F(CoroTest, Semaphore) {
  function TEST_F (line 528) | TEST_F(CoroTest, SemaphoreWaitWhenCancellationAlreadyRequested) {
  function TEST_F (line 550) | TEST_F(CoroTest, CancelOutstandingSemaphoreWait) {
  function TEST_F (line 572) | TEST_F(CoroTest, CancelOneSemaphoreWaitDoesNotAffectOthers) {
  function TEST_F (line 594) | TEST_F(CoroTest, FutureTry) {
  function TEST_F (line 629) | TEST_F(CoroTest, CancellableSleep) {
  function TEST_F (line 655) | TEST_F(CoroTest, DefaultConstructible) {
  function TEST (line 668) | TEST(Coro, CoReturnTry) {
  function TEST (line 693) | TEST(Coro, CoThrow) {
  function TEST_F (line 715) | TEST_F(CoroTest, DetachOnCancel) {
  type CountingManualExecutor (line 756) | struct CountingManualExecutor : public folly::ManualExecutor {
    method add (line 757) | void add(Func func) override {
    method getAddCount (line 762) | ssize_t getAddCount() const { return addCount_.load(); }
  function runAndCountExecutorAdd (line 768) | ssize_t runAndCountExecutorAdd(folly::coro::Task<void> task) {
  function TEST_F (line 778) | TEST_F(CoroTest, SemiNoReschedule) {
  function CO_TEST (line 800) | CO_TEST(FutureAwaiter, InvalidFutureTerminates) {
  function CO_TEST (line 807) | CO_TEST(FutureAwaiter, AlreadyContinuedReturnsError) {

FILE: folly/coro/test/CoroutineTest.cpp
  function FOLLY_KEEP (line 24) | FOLLY_KEEP bool
  type CoroutineTest (line 29) | struct CoroutineTest : testing::Test {}
  function TEST_F (line 31) | TEST_F(CoroutineTest, detect_promise_return_object_eager_conversion) {

FILE: folly/coro/test/CurrentExecutorTest.cpp
  class CoRescheduleOnCurrentExecutorTest (line 29) | class CoRescheduleOnCurrentExecutorTest : public testing::Test {}
  function TEST_F (line 31) | TEST_F(CoRescheduleOnCurrentExecutorTest, example) {

FILE: folly/coro/test/ErrorTest.cpp
  function TEST (line 34) | TEST(CoErrorTest, constructible) {
  function CO_TEST (line 48) | CO_TEST(CoCancellationTest, propagateOperationCancelled) {

FILE: folly/coro/test/FilterTest.cpp
  class FilterTest (line 28) | class FilterTest : public testing::Test {}
  function TEST_F (line 30) | TEST_F(FilterTest, SimpleStream) {
  function TEST_F (line 46) | TEST_F(FilterTest, EmptyInputStream) {
  function TEST_F (line 53) | TEST_F(FilterTest, EmptyOutputStream) {
  function TEST_F (line 64) | TEST_F(FilterTest, ThrowingStream) {
  function TEST_F (line 81) | TEST_F(FilterTest, ThrowingPredicate) {

FILE: folly/coro/test/FutureUtilTest.cpp
  function makeTask (line 31) | static folly::coro::Task<int> makeTask() {
  function makeGen (line 34) | static folly::coro::AsyncGenerator<int> makeGen() {
  function makeVoidTask (line 37) | static folly::coro::Task<void> makeVoidTask() {
  function TEST (line 41) | TEST(FutureUtilTest, ToTask) {
  function TEST (line 53) | TEST(FutureUtilTest, ToSemiFuture) {
  function TEST (line 85) | TEST(FutureUtilTest, ToFuture) {
  function TEST (line 111) | TEST(FutureUtilTest, VoidRoundtrip) {
  function CO_TEST (line 119) | CO_TEST(FutureUtilTest, ToTaskInterruptOnCancelFutureWithCancellation) {

FILE: folly/coro/test/GeneratorTest.cpp
  type folly (line 27) | namespace folly {
    type coro (line 28) | namespace coro {
      class GeneratorTest (line 30) | class GeneratorTest : public testing::Test {}
      function TEST_F (line 32) | TEST_F(GeneratorTest, DefaultConstructed_EmptySequence) {
      function TEST_F (line 37) | TEST_F(GeneratorTest, NonRecursiveUse) {
      function TEST_F (line 52) | TEST_F(GeneratorTest, ThrowsBeforeYieldingFirstElement_RethrowsFromB...
      function TEST_F (line 64) | TEST_F(GeneratorTest, ThrowsAfterYieldingFirstElement_RethrowsFromIn...
      function TEST_F (line 78) | TEST_F(GeneratorTest, NotStartedUntilCalled) {
      function TEST_F (line 105) | TEST_F(GeneratorTest, DestroyedBeforeCompletion_DestructsObjectsOnSt...
      function TEST_F (line 131) | TEST_F(GeneratorTest, SimpleRecursiveYield) {
      function TEST_F (line 171) | TEST_F(GeneratorTest, NestedEmptyYield) {
      function TEST_F (line 189) | TEST_F(GeneratorTest, ExceptionThrownFromRecursiveCall_CanBeCaughtBy...
      function TEST_F (line 220) | TEST_F(GeneratorTest, ExceptionThrownFromNestedCall_CanBeCaughtByCal...
      function iterate_range (line 276) | Generator<std::uint32_t> iterate_range(std::uint32_t begin, std::uin...
      function TEST_F (line 289) | TEST_F(GeneratorTest, UsageInStandardAlgorithms) {
      function TEST_F (line 303) | TEST_F(GeneratorTest, InvokeLambda) {

FILE: folly/coro/test/GmockHelpersTest.cpp
  class Foo (line 40) | class Foo {
  class MockFoo (line 51) | class MockFoo : Foo {
  class ExplicitlyCopyableString (line 60) | class ExplicitlyCopyableString : public std::string {
    method ExplicitlyCopyableString (line 62) | explicit ExplicitlyCopyableString(const char* cstr) : std::string(cstr...
    method ExplicitlyCopyableString (line 63) | explicit ExplicitlyCopyableString(const ExplicitlyCopyableString&) = d...
    method ExplicitlyCopyableString (line 64) | ExplicitlyCopyableString(ExplicitlyCopyableString&&) = default;
    method ExplicitlyCopyableString (line 65) | ExplicitlyCopyableString& operator=(const ExplicitlyCopyableString&) =...
    method ExplicitlyCopyableString (line 66) | [[maybe_unused]] ExplicitlyCopyableString& operator=(
  function TEST (line 71) | TEST(CoroGTestHelpers, CoInvokeAvoidsDanglingReferences) {
  function TEST (line 88) | TEST(CoroGTestHelpers, CoInvokeWithoutArgsTest) {
  function TEST (line 111) | TEST(CoroGTestHelpers, CoReturnTest) {
  function TEST (line 123) | TEST(CoroGTestHelpers, CoReturnExplicitCopyTest) {
  function TEST (line 136) | TEST(CoroGTestHelpers, CoReturnWithImplicitConversionTest) {
  function TEST (line 148) | TEST(CoroGTestHelpers, CoReturnByMoveTest) {
  function TEST (line 158) | TEST(CoroGTestHelpers, CoReturnByMoveWithImplicitConversionTest) {
  function TEST (line 181) | TEST(CoroGTestHelpers, CoVoidReturnTypeTest) {
  function TEST (line 189) | TEST(CoroLambdaGtest, CoThrowTest) {
  function CO_TEST (line 204) | CO_TEST(CoAssertThat, CoAssertThat) {
  function CO_TEST (line 208) | CO_TEST(CoroGTestHelpers, CoInvokeMemberFunction) {
  function TEST (line 223) | TEST(CoroGTestHelpers, CoThrowsMatcherBasic) {
  function TEST (line 232) | TEST(CoroGTestHelpers, CoThrowsMatcherWithExceptionMatcher) {
  function TEST (line 242) | TEST(CoroGTestHelpers, CoThrowsMessageMatcher) {
  function TEST (line 251) | TEST(CoroGTestHelpers, CoThrowsMessageMatcherExactMatch) {
  function TEST (line 260) | TEST(CoroGTestHelpers, CoThrowsNoExceptionFails) {
  function TEST (line 266) | TEST(CoroGTestHelpers, CoThrowsWrongExceptionTypeFails) {

FILE: folly/coro/test/GtestHelpersTest.cpp
  function co_getInt (line 24) | folly::coro::Task<int> co_getInt(int x) {
  type GtestHelpersMultiplicationTestParam (line 28) | struct GtestHelpersMultiplicationTestParam {
  class GtestHelpersMultiplicationTest (line 35) | class GtestHelpersMultiplicationTest
  function CO_TEST_P (line 38) | CO_TEST_P(GtestHelpersMultiplicationTest, BasicTest) {
  type GtestHelpersTypedTest (line 60) | struct GtestHelpersTypedTest : public ::testing::Test {
    method type_str (line 63) | folly::coro::Task<std::string> type_str() const {
  type Foo (line 68) | struct Foo {}
  type GtestHelpersTypedTest<Foo> (line 72) | struct GtestHelpersTypedTest<Foo> : public ::testing::Test {
    method type_str (line 75) | folly::coro::Task<std::string> type_str() const { co_return "Foo_x"; }
  function CO_TYPED_TEST (line 82) | CO_TYPED_TEST(GtestHelpersTypedTest, Test_type_str) {
  class GtestHelpersTypedTest2 (line 95) | class GtestHelpersTypedTest2 : public GtestHelpersTypedTest<T> {}
  function CO_TYPED_TEST_P (line 99) | CO_TYPED_TEST_P(GtestHelpersTypedTest2, Test_type_str) {
  function CO_TEST (line 116) | CO_TEST(GtestHelpersTest, testCoAssertNoThrow) {
  function CO_TEST (line 120) | CO_TEST(GtestHelpersTest, testCoAssertThrow) {

FILE: folly/coro/test/InlineTaskTest.cpp
  class InlineTaskTest (line 30) | class InlineTaskTest : public testing::Test {}
  function TEST_F (line 32) | TEST_F(InlineTaskTest, CallVoidTaskWithoutAwaitingNeverRuns) {
  function TEST_F (line 45) | TEST_F(InlineTaskTest, CallValueTaskWithoutAwaitingNeverRuns) {
  function TEST_F (line 58) | TEST_F(InlineTaskTest, CallRefTaskWithoutAwaitingNeverRuns) {
  function TEST_F (line 72) | TEST_F(InlineTaskTest, SimpleVoidTask) {
  function TEST_F (line 84) | TEST_F(InlineTaskTest, SimpleValueTask) {
  function TEST_F (line 96) | TEST_F(InlineTaskTest, SimpleRefTask) {
  function TEST_F (line 110) | TEST_F(InlineTaskTest, ReturnValueWithInitializerListSyntax) {
  function TEST_F (line 125) | TEST_F(InlineTaskTest, ReturnValueWithInitializerListSyntax2) {
  type MoveOnlyType (line 145) | struct MoveOnlyType {
    method MoveOnlyType (line 148) | explicit MoveOnlyType(int value) noexcept : value_(value) {}
    method MoveOnlyType (line 150) | MoveOnlyType(MoveOnlyType&& other) noexcept
    method MoveOnlyType (line 153) | [[maybe_unused]] MoveOnlyType& operator=(MoveOnlyType&& other) noexcept {
  function TEST_F (line 163) | TEST_F(InlineTaskTest, TaskOfMoveOnlyType) {
  function TEST_F (line 181) | TEST_F(InlineTaskTest, MoveOnlyTypeNRVO) {
  function TEST_F (line 191) | TEST_F(InlineTaskTest, ReturnLvalueReference) {
  function TEST_F (line 199) | TEST_F(InlineTaskTest, ExceptionsPropagateFromVoidTask) {
  function TEST_F (line 209) | TEST_F(InlineTaskTest, ExceptionsPropagateFromValueTask) {
  function TEST_F (line 219) | TEST_F(InlineTaskTest, ExceptionsPropagateFromRefTask) {
  function TEST_F (line 229) | TEST_F(InlineTaskTest, ExceptionsPropagateFromReturnValueConstructor) {
  function TEST_F (line 247) | TEST_F(InlineTaskTest, DeepRecursionDoesntStackOverflow) {
  function TEST_F (line 259) | TEST_F(InlineTaskTest, DeepRecursionOfValueTaskDoesntStackOverflow) {
  function TEST_F (line 272) | TEST_F(InlineTaskTest, DeepRecursionOfExceptions) {

FILE: folly/coro/test/MergeTest.cpp
  class MergeTest (line 37) | class MergeTest : public testing::Test {}
  function TEST_F (line 39) | TEST_F(MergeTest, SimpleMerge) {
  function TEST_F (line 67) | TEST_F(MergeTest, TruncateStream) {
  function TEST_F (line 108) | TEST_F(MergeTest, TruncateStreamMultiThreaded) {
  function TEST_F (line 142) | TEST_F(MergeTest, SequencesOfRValueReferences) {
  function TEST_F (line 167) | TEST_F(MergeTest, SequencesOfLValueReferences) {
  function neverStream (line 208) | folly::coro::AsyncGenerator<Ref, Value> neverStream() {
  function TEST_F (line 216) | TEST_F(MergeTest, CancellationTokenPropagatesToOuterFromConsumer) {
  function TEST_F (line 245) | TEST_F(MergeTest, CancellationTokenPropagatesToInnerFromConsumer) {
  function TEST_F (line 280) | TEST_F(MergeTest, SourcesAreDestroyedBeforeEof) {
  function TEST_F (line 379) | TEST_F(MergeTest, DontLeakRequestContext) {
  function TEST_F (line 430) | TEST_F(MergeTest, SimpleMergeWithRValueGeneratorType) {

FILE: folly/coro/test/MutexTest.cpp
  class MutexTest (line 34) | class MutexTest : public testing::Test {}
  function TEST_F (line 36) | TEST_F(MutexTest, TryLock) {
  function TEST_F (line 44) | TEST_F(MutexTest, ScopedLock) {
  function TEST_F (line 60) | TEST_F(MutexTest, LockAsync) {
  function TEST_F (line 102) | TEST_F(MutexTest, ScopedLockAsync) {
  function TEST_F (line 143) | TEST_F(MutexTest, ThreadSafety) {

FILE: folly/coro/test/PromiseBenchmark.cpp
  function resetMallocStats (line 28) | void resetMallocStats() {
  function setMallocStats (line 36) | void setMallocStats(folly::UserCounters& counters) {
  function BENCHMARK_COUNTERS (line 45) | BENCHMARK_COUNTERS(CoroFutureImmediateUnwrapped, counters, iters) {
  function BENCHMARK_COUNTERS (line 60) | BENCHMARK_COUNTERS(CoroFutureImmediate, counters, iters) {
  function BENCHMARK_COUNTERS (line 72) | BENCHMARK_COUNTERS(FuturesFutureImmediate, counters, iters) {
  function BENCHMARK_COUNTERS (line 84) | BENCHMARK_COUNTERS(CoroFutureSuspend, counters, iters) {
  function BENCHMARK_COUNTERS (line 105) | BENCHMARK_COUNTERS(FuturesFutureSuspend, counters, iters) {
  function main (line 128) | int main(int argc, char** argv) {

FILE: folly/coro/test/PromiseTest.cpp
  function CO_TEST (line 41) | CO_TEST(PromiseTest, ImmediateValue) {
  function CO_TEST (line 53) | CO_TEST(PromiseTest, CollectImmediateValue) {
  function CO_TEST (line 68) | CO_TEST(PromiseTest, ImmediateWithValue) {
  function CO_TEST (line 75) | CO_TEST(PromiseTest, ImmediateWithValueThrows) {
  function CO_TEST (line 84) | CO_TEST(PromiseTest, ImmediateWithValueImplicit) {
  function CO_TEST (line 91) | CO_TEST(PromiseTest, ImmediateValueMultiple) {
  function CO_TEST (line 100) | CO_TEST(PromiseTest, ImmediateTry) {
  function CO_TEST (line 107) | CO_TEST(PromiseTest, ImmediateWithTry) {
  function CO_TEST (line 114) | CO_TEST(PromiseTest, ImmediateWithTryThrows) {
  function CO_TEST (line 123) | CO_TEST(PromiseTest, ImmediateException) {
  function CO_TEST (line 130) | CO_TEST(PromiseTest, ImmediateWithException) {
  function CO_TEST (line 139) | CO_TEST(PromiseTest, ImmediateWithExceptionImplicit) {
  function CO_TEST (line 148) | CO_TEST(PromiseTest, ImmediateWithExceptionThrows) {
  function CO_TEST (line 157) | CO_TEST(PromiseTest, ImmediateExceptionVoid) {
  function CO_TEST (line 163) | CO_TEST(PromiseTest, ImmediateWithExceptionVoid) {
  function CO_TEST (line 171) | CO_TEST(PromiseTest, SuspendValue) {
  function CO_TEST (line 187) | CO_TEST(PromiseTest, SuspendException) {
  function CO_TEST (line 203) | CO_TEST(PromiseTest, ImmediateCancel) {
  function CO_TEST (line 218) | CO_TEST(PromiseTest, CancelFulfilled) {
  function CO_TEST (line 232) | CO_TEST(PromiseTest, SuspendCancel) {
  function CO_TEST (line 253) | CO_TEST(PromiseTest, ImmediateBreakPromise) {
  function CO_TEST (line 264) | CO_TEST(PromiseTest, SuspendBreakPromise) {
  function CO_TEST (line 280) | CO_TEST(PromiseTest, Lifetime) {
  function TEST (line 299) | TEST(PromiseTest, DropFuture) {
  function CO_TEST (line 316) | CO_TEST(PromiseTest, MoveOnly) {
  function CO_TEST (line 323) | CO_TEST(PromiseTest, Void) {
  function TEST (line 329) | TEST(PromiseTest, IsReady) {
  function CO_TEST (line 336) | CO_TEST(PromiseTest, MakeFuture) {
  function CO_TEST (line 359) | CO_TEST(PromiseTest, MoveAssign) {

FILE: folly/coro/test/RequestContextTest.cpp
  class TagData (line 32) | class TagData : public folly::RequestData {
    method hasCallback (line 36) | bool hasCallback() override { return false; }
    method TagData (line 38) | TagData() = default;
    method TagData (line 39) | explicit TagData(int t) : tag(t) {}
  function getTag (line 43) | static int getTag() {
  function setTag (line 52) | static void setTag(int t) {
  function clearTag (line 57) | static void clearTag() {
  function TEST (line 61) | TEST(RequestContextTest, Main) {

FILE: folly/coro/test/RetryTest.cpp
  type SomeError (line 34) | struct SomeError : std::exception {
    method SomeError (line 35) | explicit SomeError(int v) : value(v) {}
  function TEST (line 41) | TEST(RetryN, Success) {
  function TEST (line 52) | TEST(RetryN, Failure) {
  function TEST (line 66) | TEST(RetryN, EventualSuccess) {
  function TEST (line 81) | TEST(RetryN, NeverRetry) {
  function TEST (line 98) | TEST(RetryWithJitter, Success) {
  function TEST (line 115) | TEST(RetryWithJitter, Failure) {
  function TEST (line 138) | TEST(RetryWithJitter, EventualSuccess) {
  function TEST (line 166) | TEST(RetryWithDecider, AlwaysRetry) {
  function TEST (line 180) | TEST(RetryWithDecider, NeverRetry) {
  function TEST (line 199) | TEST(RetryWithDecider, SometimesRetry) {

FILE: folly/coro/test/RustAdaptorsTest.cpp
  function T (line 31) | T getPollFuture(folly::coro::PollFuture<T> future) {
  function getNextPollStream (line 43) | folly::Optional<T> getNextPollStream(folly::coro::PollStream<T>& stream) {
  function task42 (line 54) | folly::coro::Task<int> task42() {
  function TEST (line 60) | TEST(RustAdaptorsTest, PollFuture) {
  function TEST (line 64) | TEST(RustAdaptorsTest, PollFutureSemiFuture) {
  function stream123 (line 68) | folly::coro::AsyncGenerator<int> stream123() {
  function TEST (line 79) | TEST(RustAdaptorsTest, PollStream) {
  function cancellationTask (line 87) | folly::coro::Task<void> cancellationTask(bool& done) {
  function TEST (line 95) | TEST(RustAdaptorsTest, PollFutureCancellation) {
  function cancellationStream (line 105) | folly::coro::AsyncGenerator<int> cancellationStream(bool& done) {
  function TEST (line 111) | TEST(RustAdaptorsTest, PollStreamCancellation) {

FILE: folly/coro/test/ScopeExitTest.cpp
  class ScopeExitTest (line 32) | class ScopeExitTest : public testing::Test {
  class AsyncGeneratorScopeExitTest (line 37) | class AsyncGeneratorScopeExitTest : public ScopeExitTest {}
  class AutoCleanupScopeExitTest (line 39) | class AutoCleanupScopeExitTest : public ScopeExitTest {}
  function TEST_F (line 42) | TEST_F(ScopeExitTest, OneExitAction) {
  function TEST_F (line 54) | TEST_F(ScopeExitTest, TwoExitActions) {
  function TEST_F (line 70) | TEST_F(ScopeExitTest, OneExitActionWithException) {
  function TEST_F (line 84) | TEST_F(ScopeExitTest, ExceptionInExitActionCausesTermination) {
  function TEST_F (line 94) | TEST_F(ScopeExitTest, ExceptionInExitActionDuringExceptionCausesTerminat...
  function TEST_F (line 105) | TEST_F(ScopeExitTest, StatefulExitAction) {
  function TEST_F (line 119) | TEST_F(ScopeExitTest, NonMoveableState) {
  function TEST_F (line 138) | TEST_F(ScopeExitTest, OneExitActionThroughNoThrow) {
  function TEST_F (line 154) | TEST_F(ScopeExitTest, ExitActionInsideNoThrow) {
  function TEST_F (line 174) | TEST_F(AsyncGeneratorScopeExitTest, PartiallyConsumed) {
  function TEST_F (line 196) | TEST_F(AsyncGeneratorScopeExitTest, FullyConsumed) {
  function TEST_F (line 219) | TEST_F(AsyncGeneratorScopeExitTest, TwoExitActions) {
  function TEST_F (line 246) | TEST_F(AsyncGeneratorScopeExitTest, StatefulExitAction) {
  function TEST_F (line 272) | TEST_F(AsyncGeneratorScopeExitTest, OneExitActionThroughNoThrow) {
  function TEST_F (line 296) | TEST_F(AsyncGeneratorScopeExitTest, NextAfterCancel) {
  function TEST_F (line 337) | TEST_F(AutoCleanupScopeExitTest, AsyncGeneratorAutoCleanup) {
  function TEST_F (line 356) | TEST_F(AutoCleanupScopeExitTest, AsyncGeneratorAutoCleanupMove) {
  function TEST_F (line 377) | TEST_F(AsyncGeneratorScopeExitTest, AsyncGeneratorAutoCleanupFn) {
  function TEST_F (line 391) | TEST_F(AsyncGeneratorScopeExitTest, AsyncGeneratorAutoCleanupFnMove) {

FILE: folly/coro/test/SerialQueueRunnerTest.cpp
  type QueueRunnerTest (line 25) | struct QueueRunnerTest : testing::Test {}
  function CO_TEST_F (line 27) | CO_TEST_F(QueueRunnerTest, example) {

FILE: folly/coro/test/SharedMutexBenchmark.cpp
  function runBenchmark (line 28) | void runBenchmark(double writePercent, size_t numThreads, size_t numTask...
  function BENCHMARK (line 62) | BENCHMARK(SharedMutex_all_read_1thread_10000task, iters) {
  function BENCHMARK (line 67) | BENCHMARK(SharedMutex_all_read_4thread_10000task, iters) {
  function BENCHMARK (line 72) | BENCHMARK(SharedMutex_all_read_8thread_10000task, iters) {
  function BENCHMARK (line 77) | BENCHMARK(SharedMutex_all_read_16thread_10000task, iters) {
  function BENCHMARK (line 82) | BENCHMARK(SharedMutex_all_read_32thread_10000task, iters) {
  function BENCHMARK (line 88) | BENCHMARK(SharedMutex_1pct_write_1thread_10000task, iters) {
  function BENCHMARK (line 93) | BENCHMARK(SharedMutex_1pct_write_4thread_10000task, iters) {
  function BENCHMARK (line 98) | BENCHMARK(SharedMutex_1pct_write_8thread_10000task, iters) {
  function BENCHMARK (line 103) | BENCHMARK(SharedMutex_1pct_write_16thread_10000task, iters) {
  function BENCHMARK (line 108) | BENCHMARK(SharedMutex_1pct_write_32thread_10000task, iters) {
  function BENCHMARK (line 114) | BENCHMARK(SharedMutex_10pct_write_1thread_10000task, iters) {
  function BENCHMARK (line 119) | BENCHMARK(SharedMutex_10pct_write_4thread_10000task, iters) {
  function BENCHMARK (line 124) | BENCHMARK(SharedMutex_10pct_write_8thread_10000task, iters) {
  function BENCHMARK (line 129) | BENCHMARK(SharedMutex_10pct_write_16thread_10000task, iters) {
  function BENCHMARK (line 134) | BENCHMARK(SharedMutex_10pct_write_32thread_10000task, iters) {
  function BENCHMARK (line 140) | BENCHMARK(SharedMutex_all_write_1thread_10000task, iters) {
  function BENCHMARK (line 145) | BENCHMARK(SharedMutex_all_write_4thread_10000task, iters) {
  function BENCHMARK (line 150) | BENCHMARK(SharedMutex_all_write_8thread_10000task, iters) {
  function BENCHMARK (line 155) | BENCHMARK(SharedMutex_all_write_16thread_10000task, iters) {
  function BENCHMARK (line 160) | BENCHMARK(SharedMutex_all_write_32thread_10000task, iters) {
  function main (line 166) | int main(int argc, char** argv) {

FILE: folly/coro/test/SharedMutexTest.cpp
  class SharedMutexTest (line 34) | class SharedMutexTest : public testing::Test {}
  function TEST_F (line 36) | TEST_F(SharedMutexTest, TryLock) {
  function TEST_F (line 144) | TEST_F(SharedMutexTest, ManualLockAsync) {
  function testAllStateTransitions (line 203) | void testAllStateTransitions(
  function TEST_F (line 728) | TEST_F(SharedMutexTest, ManualLockAllStateTransitions) {
  function TEST_F (line 751) | TEST_F(SharedMutexTest, ScopedLockAsync) {
  function TEST_F (line 806) | TEST_F(SharedMutexTest, MultipleWaiters) {
  function TEST_F (line 897) | TEST_F(SharedMutexTest, ScopedLockAllStateTransitions) {
  function TEST_F (line 916) | TEST_F(SharedMutexTest, AsyncLockTransition) {
  function TEST_F (line 966) | TEST_F(SharedMutexTest, ThreadSafety) {
  function TEST_F (line 1013) | TEST_F(SharedMutexTest, StressTest) {

FILE: folly/coro/test/SharedPromiseTest.cpp
  class BlockingWaitWaitInterface (line 31) | class BlockingWaitWaitInterface {
    method waitAndGetValue (line 33) | std::string waitAndGetValue(folly::coro::Future<std::string> future) {
  class CPUThreadPoolWaitInterface (line 38) | class CPUThreadPoolWaitInterface {
    method waitAndGetValue (line 40) | std::string waitAndGetValue(folly::coro::Future<std::string> future) {
    method coGet (line 48) | folly::coro::Task<std::string> coGet(
  class ValueInterface (line 58) | class ValueInterface : public WaitInterface {
    method set (line 60) | void set(std::string value, SharedPromise<std::string>& promise) {
    method get (line 64) | std::string get(folly::coro::Future<std::string> future) {
  class ExceptionInterface (line 70) | class ExceptionInterface : public WaitInterface {
    class StringException (line 71) | class StringException : public std::exception {
      method StringException (line 73) | explicit StringException(std::string string) : string_{string} {}
      method get (line 74) | std::string get() { return string_; }
    method set (line 81) | void set(std::string value, SharedPromise<std::string>& promise) {
    method get (line 85) | std::string get(folly::coro::Future<std::string> future) {
  class SharedPromiseTest (line 98) | class SharedPromiseTest : public ::testing::Test, public TestInterface {}
  function TYPED_TEST (line 108) | TYPED_TEST(SharedPromiseTest, Basic) {
  function TYPED_TEST (line 116) | TYPED_TEST(SharedPromiseTest, MultipleFutures) {
  function TYPED_TEST (line 129) | TYPED_TEST(SharedPromiseTest, BrokenPromise) {
  function TYPED_TEST (line 146) | TYPED_TEST(SharedPromiseTest, PromiseAlreadySatisfied) {
  function TYPED_TEST (line 170) | TYPED_TEST(SharedPromiseTest, FutureAfterFulfilled) {
  function TYPED_TEST (line 185) | TYPED_TEST(SharedPromiseTest, PostMoveConstruction) {
  function TYPED_TEST (line 202) | TYPED_TEST(SharedPromiseTest, PostMoveAssignment) {
  class FallibleExecutor (line 221) | class FallibleExecutor : public folly::Executor {
    method FallibleExecutor (line 223) | explicit FallibleExecutor(std::unique_ptr<folly::Executor> executor)
    method add (line 226) | void add(folly::Function<void()> function) override {
    method fail (line 236) | void fail() { failed_.store(true); }
  function TYPED_TEST (line 244) | TYPED_TEST(SharedPromiseTest, CleanlyCancellableWait) {
  function TYPED_TEST (line 288) | TYPED_TEST(SharedPromiseTest, NoHeapAllocation) {
  function TEST (line 295) | TEST(SharedPromiseTest, BasicVoid) {
  function CO_TEST (line 311) | CO_TEST(SharedPromiseTest, Swap) {
  function CO_TEST (line 321) | CO_TEST(SharedPromiseTest, MoveFrom) {
  function CO_TEST (line 331) | CO_TEST(SharedPromiseTest, SelfMove) {
  function TEST (line 340) | TEST(SharedPromiseTest, Exchange) {
  function TEST (line 346) | TEST(SharedPromiseTest, Poll) {

FILE: folly/coro/test/SleepTest.cpp
  type SleepTest (line 28) | struct SleepTest : testing::Test {}
  function CO_TEST_F (line 30) | CO_TEST_F(SleepTest, Basic) {

FILE: folly/coro/test/SmallUnboundedQueueTest.cpp
  function TEST (line 31) | TEST(SmallUnboundedQueueTest, EnqueueDeque) {
  function TEST (line 45) | TEST(SmallUnboundedQueueTest, DequeueWhileBlocking) {
  function TEST (line 59) | TEST(SmallUnboundedQueueTest, EnqueueDequeMultiProducer) {
  function TEST (line 87) | TEST(SmallUnboundedQueueTest, EnqueueDequeMultiConsumer) {
  function TEST (line 110) | TEST(SmallUnboundedQueueTest, EnqueueDequeMPMC) {
  function TEST (line 146) | TEST(SmallUnboundedQueueTest, CancelledDequeueThrowsOperationCancelled) {
  function TEST (line 166) | TEST(

FILE: folly/coro/test/SuspendedStackTest.cpp
  function FOLLY_NOINLINE (line 32) | FOLLY_NOINLINE folly::coro::Task<void> waitOn(Awaitable&& aw) {
  function expectSuspendedFrames (line 41) | static void expectSuspendedFrames(size_t numFrames, size_t stackDepth = ...
  function CO_TEST (line 77) | CO_TEST(SuspendedStacksTest, testBaton) {
  function CO_TEST (line 99) | CO_TEST(SuspendedStacksTest, testFibersBaton) {
  function CO_TEST (line 119) | CO_TEST(SuspendedStacksTest, testLock) {
  function CO_TEST (line 141) | CO_TEST(SuspendedStacksTest, testFuture) {

FILE: folly/coro/test/SynchronizedTest.cpp
  function T (line 35) | T& assumeInitialized(T& value) {
  class SynchronizedTest (line 41) | class SynchronizedTest : public testing::Test {}
  function TEST_F (line 43) | TEST_F(SynchronizedTest, MoveLockingPtr) {
  function TEST_F (line 71) | TEST_F(SynchronizedTest, ConcurrentReads) {
  function TEST_F (line 112) | TEST_F(SynchronizedTest, ConcurrentReadsWithUnlock) {
  function TEST_F (line 164) | TEST_F(SynchronizedTest, ThreadSafety) {
  function CO_TEST_F (line 189) | CO_TEST_F(SynchronizedTest, SwapAndCopy) {
  function TEST_F (line 200) | TEST_F(SynchronizedTest, TryLock) {

FILE: folly/coro/test/TaskBenchmark.cpp
  function BENCHMARK (line 28) | BENCHMARK(SingleVoidSynchronousTaskInLoop, iters) {
  function BENCHMARK (line 37) | BENCHMARK(AsyncTaskInLoop, iters) {
  function BENCHMARK (line 48) | BENCHMARK(AsyncRescheduleNoTask, iters) {
  class Base (line 56) | class Base {
  class Derived (line 64) | class Derived : public Base {
  function FOLLY_NOINLINE (line 70) | FOLLY_NOINLINE
  function BENCHMARK (line 82) | BENCHMARK(VirtualTaskMethod, iters) {
  function staticNestedCalls (line 96) | static folly::coro::Task<void> staticNestedCalls() {
  function benchStaticNestedCalls (line 104) | static void benchStaticNestedCalls(size_t iters) {
  function BENCHMARK (line 112) | BENCHMARK(StaticNestedCalls3, iters) {
  function BENCHMARK (line 116) | BENCHMARK(StaticNestedCalls10, iters) {
  function nestedCalls (line 120) | static folly::coro::Task<void> nestedCalls(size_t depth) {
  function benchNestedCalls (line 127) | static void benchNestedCalls(size_t depth, size_t iters) {
  function BENCHMARK (line 135) | BENCHMARK(NestedCalls3, iters) {
  function BENCHMARK (line 139) | BENCHMARK(NestedCalls10, iters) {
  function benchNestedCallsWithCancellation (line 143) | static void benchNestedCallsWithCancellation(size_t depth, size_t iters) {
  function BENCHMARK (line 154) | BENCHMARK(NestedCallsWithCancellation3, iters) {
  function BENCHMARK (line 158) | BENCHMARK(NestedCallsWithCancellation10, iters) {
  function main (line 164) | int main(int argc, char** argv) {

FILE: folly/coro/test/TaskTest.cpp
  function check_for_size_regressions (line 42) | constexpr bool check_for_size_regressions() {
  class TestRequestData (line 100) | class TestRequestData : public RequestData {
    method TestRequestData (line 102) | explicit TestRequestData(std::string key) noexcept : key_(std::move(ke...
    method hasCallback (line 104) | bool hasCallback() override { return false; }
  function childRequest (line 114) | static coro::Task<void> childRequest(coro::Mutex& m, coro::Baton& b) {
  function parentRequest (line 165) | static coro::Task<void> parentRequest(int id) {
  class TaskTest (line 214) | class TaskTest : public testing::Test {}
  function TEST_F (line 216) | TEST_F(TaskTest, RequestContextIsPreservedAcrossSuspendResume) {
  function TEST_F (line 266) | TEST_F(TaskTest, ContextPreservedAcrossMutexLock) {
  function TEST_F (line 319) | TEST_F(TaskTest, RequestContextSideEffectsArePreserved) {
  function TEST_F (line 365) | TEST_F(TaskTest, FutureTailCall) {
  function TEST_F (line 376) | TEST_F(TaskTest, FutureRoundtrip) {
  function checkAwaitingFutureOfUnitDoesntWarnAboutDiscardedResult (line 398) | [[maybe_unused]] folly::coro::Task<void>
  function TEST_F (line 408) | TEST_F(TaskTest, TaskOfLvalueReference) {
  function TEST_F (line 419) | TEST_F(TaskTest, TaskOfLvalueReferenceAsTry) {
  function TEST_F (line 435) | TEST_F(TaskTest, TaskOfLvalueReferenceAsResult) {
  function TEST_F (line 452) | TEST_F(TaskTest, CancellationPropagation) {
  function TEST_F (line 478) | TEST_F(TaskTest, CancellationPropagatesThroughCoAwaitTry) {
  function TEST_F (line 492) | TEST_F(TaskTest, StartInlineUnsafe) {
  function TEST_F (line 517) | TEST_F(TaskTest, StartInlineUnsafePreservesRequestContext) {
  function TEST_F (line 543) | TEST_F(TaskTest, YieldTry) {
  function TEST_F (line 585) | TEST_F(TaskTest, MakeTask) {
  function TEST_F (line 624) | TEST_F(TaskTest, ScheduleOnRestoresExecutor) {
  function TEST_F (line 644) | TEST_F(TaskTest, CoAwaitTryWithScheduleOn) {
  function TEST_F (line 654) | TEST_F(TaskTest, CoAwaitTryWithScheduleOnAndCancellation) {
  function TEST_F (line 686) | TEST_F(TaskTest, Moved) {
  function TEST_F (line 698) | TEST_F(TaskTest, SafePoint) {
  function TEST_F (line 729) | TEST_F(TaskTest, CoAwaitNothrow) {
  function TEST_F (line 751) | TEST_F(TaskTest, CoAwaitNothrowWithScheduleOn) {
  function TEST_F (line 775) | TEST_F(TaskTest, CoAwaitThrowAfterNothrow) {
  function TEST_F (line 797) | TEST_F(TaskTest, CoAwaitNothrowDestructorOrdering) {
  type ExpectedException (line 820) | struct ExpectedException : public std::runtime_error {
    method ExpectedException (line 821) | ExpectedException() : std::runtime_error("expected") {}
  function TEST_F (line 824) | TEST_F(TaskTest, CoYieldCoErrorSameExecutor) {

FILE: folly/coro/test/TaskWrapperTest.cpp
  type folly::coro (line 24) | namespace folly::coro {
    class tiny_now_task (line 27) | class tiny_now_task
    class tiny_now_task_with_executor (line 29) | class tiny_now_task_with_executor
    type detail (line 31) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    class tiny_now_task_with_executor (line 45) | class [[nodiscard]] tiny_now_task_with_executor final
    type detail (line 52) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    class FOLLY_CORO_TASK_ATTRS (line 69) | class FOLLY_CORO_TASK_ATTRS
    class TinyMovableTask (line 80) | class TinyMovableTask
    class TinyMovableTaskWithExecutor (line 82) | class TinyMovableTaskWithExecutor
    type detail (line 84) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    class TinyMovableTaskWithExecutor (line 97) | class [[nodiscard]] TinyMovableTaskWithExecutor final
    type detail (line 104) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    class FOLLY_CORO_TASK_ATTRS (line 121) | class FOLLY_CORO_TASK_ATTRS
    type TaskWrapperTest (line 134) | struct TaskWrapperTest : testing::Test {
      method intFunc (line 135) | static TaskT<int> intFunc(int x) { co_return x; }
      method intPtrFunc (line 136) | static TaskT<int> intPtrFunc(auto x) { co_return *x; }
      method voidFunc (line 137) | static TaskT<void> voidFunc(auto x, int* ran) {
      method checkBasics (line 143) | Task<void> checkBasics() {
      method checkCancellation (line 183) | Task<void> checkCancellation() {
      method checkNestedCancellation (line 197) | now_task<> checkNestedCancellation() {
      method checkWithExecutor (line 215) | Task<void> checkWithExecutor() {
      type MyError (line 224) | struct MyError : std::exception {}
      method checkException (line 226) | Task<void> checkException() {
    function CO_TEST_F (line 242) | CO_TEST_F(NowTaskWrapperTest, basics) {
    function CO_TEST_F (line 245) | CO_TEST_F(MovableTaskWrapperTest, basics) {
    function CO_TEST_F (line 249) | CO_TEST_F(NowTaskWrapperTest, withExecutor) {
    function CO_TEST_F (line 252) | CO_TEST_F(MovableTaskWrapperTest, withExecutor) {
    function CO_TEST_F (line 256) | CO_TEST_F(NowTaskWrapperTest, cancellation) {
    function CO_TEST_F (line 259) | CO_TEST_F(MovableTaskWrapperTest, cancellation) {
    function CO_TEST_F (line 263) | CO_TEST_F(NowTaskWrapperTest, nestedCancellation) {
    function CO_TEST_F (line 266) | CO_TEST_F(MovableTaskWrapperTest, nestedCancellation) {
    function CO_TEST_F (line 270) | CO_TEST_F(NowTaskWrapperTest, exceptions) {
    function CO_TEST_F (line 273) | CO_TEST_F(MovableTaskWrapperTest, exceptions) {
    type RecursiveWrapTask (line 278) | struct RecursiveWrapTask
    type detail (line 280) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    type FOLLY_CORO_TASK_ATTRS (line 308) | struct FOLLY_CORO_TASK_ATTRS
    type detail (line 319) | namespace detail {
      type tiny_now_task_with_executor_cfg (line 33) | struct tiny_now_task_with_executor_cfg : DoesNotWrapAwaitable {
      class tiny_now_task_promise (line 54) | class tiny_now_task_promise final
      type tiny_now_task_cfg (line 57) | struct tiny_now_task_cfg : DoesNotWrapAwaitable {
      type TinyMovableTaskWithExecutorCfg (line 86) | struct TinyMovableTaskWithExecutorCfg : DoesNotWrapAwaitable {
      class TinyMovableTaskPromise (line 106) | class TinyMovableTaskPromise final
      type TinyMovableTaskCfg (line 109) | struct TinyMovableTaskCfg : DoesNotWrapAwaitable {
      class RecursiveTaskPromiseWrapper (line 283) | class RecursiveTaskPromiseWrapper final
      type RecursiveTaskWrapperConfig (line 287) | struct RecursiveTaskWrapperConfig : DoesNotWrapAwaitable {
    function CO_TEST (line 327) | CO_TEST(TaskWrapper, recursiveUnwrap) {

FILE: folly/coro/test/TimeoutTest.cpp
  type folly::coro (line 41) | namespace folly::coro {
  type Timeout (line 85) | struct Timeout {
  type TimeoutNoDiscard (line 93) | struct TimeoutNoDiscard {
  type TimeoutFixture (line 102) | struct TimeoutFixture : public ::testing::Test {
  function TYPED_TEST (line 109) | TYPED_TEST(TimeoutFixture, CompletesSynchronously) {
  function TYPED_TEST (line 132) | TYPED_TEST(TimeoutFixture, CompletesWithinTimeout) {
  function TEST (line 165) | TEST(TimeoutNoDiscard, ResultOnTimeout) {
  function TYPED_TEST (line 200) | TYPED_TEST(TimeoutFixture, TimeoutElapsed) {
  function TYPED_TEST (line 250) | TYPED_TEST(TimeoutFixture, CancelParent) {
  function TYPED_TEST (line 277) | TYPED_TEST(TimeoutFixture, AsyncGenerator) {
  function TYPED_TEST (line 300) | TYPED_TEST(TimeoutFixture, RequestContextInCancellationCallback) {
  function TYPED_TEST (line 321) | TYPED_TEST(TimeoutFixture, TimeoutTaskType) {

FILE: folly/coro/test/TraitsTest.cpp
  type SomeAwaiter1 (line 29) | struct SomeAwaiter1 {
  type SomeAwaiter2 (line 36) | struct SomeAwaiter2 {
  type SomeAwaiter3 (line 43) | struct SomeAwaiter3 {
  type MissingAwaitReady (line 49) | struct MissingAwaitReady {
  type WrongAwaitReadyReturnType (line 54) | struct WrongAwaitReadyReturnType {
  type MissingAwaitResume (line 60) | struct MissingAwaitResume {
  type MemberOperatorCoAwait (line 65) | struct MemberOperatorCoAwait {
  type FreeOperatorCoAwait (line 71) | struct FreeOperatorCoAwait {}
  type MoveOnlyFreeOperatorCoAwait (line 74) | struct MoveOnlyFreeOperatorCoAwait {}
  type MemberOperatorCoAwaitWithInvalidAwaiter (line 77) | struct MemberOperatorCoAwaitWithInvalidAwaiter {

FILE: folly/coro/test/TransformTest.cpp
  class TransformTest (line 35) | class TransformTest : public testing::Test {}
  function ints (line 37) | AsyncGenerator<int> ints(int n) {
  function TEST_F (line 44) | TEST_F(TransformTest, SimpleStream) {
  function neverStream (line 111) | folly::coro::AsyncGenerator<Ref, Value> neverStream() {
  function TEST_F (line 119) | TEST_F(TransformTest, CancellationTokenPropagatesFromConsumer) {
  function floatRefs (line 148) | AsyncGenerator<float&> floatRefs(int n) {
  function useStream (line 157) | auto useStream(AsyncGenerator<T> ag) {
  function TEST_F (line 167) | TEST_F(TransformTest, TransformDeducesTypesCorrectlySyncFun) {

FILE: folly/coro/test/UnboundedQueueTest.cpp
  function TEST (line 34) | TEST(UnboundedQueueTest, EnqueueDeque) {
  function TEST (line 58) | TEST(UnboundedQueueTest, DequeueWhileBlocking) {
  function TEST (line 72) | TEST(UnboundedQueueTest, EnqueueDequeMultiProducer) {
  function TEST (line 101) | TEST(UnboundedQueueTest, EnqueueDequeMultiConsumer) {
  function TEST (line 125) | TEST(UnboundedQueueTest, EnqueueDequeMPMC) {
  function TEST (line 163) | TEST(UnboundedQueueTest, CancelledDequeueThrowsOperationCancelled) {
  function TEST (line 183) | TEST(UnboundedQueueTest, CancelledDequeueCompletesNormallyIfAnItemIsAvai...
  function TEST (line 197) | TEST(UnboundedQueueTest, TryDequeue) {
  function TEST (line 215) | TEST(UnboundedQueueTest, TryPeekSingleConsumer) {
  function TEST (line 238) | TEST(UnboundedQueueTest, TryDequeueFor) {

FILE: folly/coro/test/ValueOrErrorTest.cpp
  type folly::coro (line 30) | namespace folly::coro {
    function CO_TEST (line 32) | CO_TEST(ValueOrErrorTest, valueOrErrorOrStoppedOfError) {
    function CO_TEST (line 48) | CO_TEST(ValueOrErrorTest, valueOrErrorOrStoppedOfValue) {
    function CO_TEST (line 73) | CO_TEST(ValueOrErrorTest, valueOrErrorOrStoppedOfVoid) {
    function CO_TEST (line 95) | CO_TEST(ValueOrErrorTest, valueOrErrorOrStoppedStopped) {
    function TEST (line 113) | TEST(ValueOrErrorTest, coNothrowValueOrErrorOrStopped) {
    type ThrowingMove (line 131) | struct ThrowingMove {
      method ThrowingMove (line 132) | ThrowingMove(const ThrowingMove&) = default;
      method ThrowingMove (line 133) | ThrowingMove& operator=(const ThrowingMove&) = default;
      method ThrowingMove (line 135) | ThrowingMove(ThrowingMove&&) {}
      method ThrowingMove (line 137) | ThrowingMove& operator=(ThrowingMove&&) { return *this; }
    type NothrowMove (line 139) | struct NothrowMove {}
    type ThrowingAwaitSuspendAwaitable (line 152) | struct ThrowingAwaitSuspendAwaitable {
      method await_ready (line 153) | bool await_ready() noexcept { return false; }
      method await_suspend (line 154) | void await_suspend(coro::coroutine_handle<>) {}
      method await_resume (line 155) | int await_resume() noexcept { return 0; }
      method await_resume_try (line 156) | Try<int> await_resume_try() noexcept { return Try<int>{0}; }
      method ThrowingAwaitSuspendAwaitable (line 157) | ThrowingAwaitSuspendAwaitable&& co_viaIfAsync(
    function CO_TEST (line 164) | CO_TEST(ValueOrErrorTest, requiresNoexceptAwait) {
    function CO_TEST (line 171) | CO_TEST(ValueOrErrorTest, coAwaitTryRequiresNoexceptAwait) {
    function CO_TEST (line 185) | CO_TEST(ValueOrErrorTest, valueOrErrorAroundValueOnlyAwaitable) {

FILE: folly/coro/test/ValueOrFatalTest.cpp
  type folly::coro (line 26) | namespace folly::coro {
    function fatal_on_non_value (line 30) | auto fatal_on_non_value(Awaitable awaitable) {
    type MyErr (line 104) | struct MyErr : std::exception {}
    type ThrowOnMove (line 107) | struct ThrowOnMove {
      method ThrowOnMove (line 108) | ThrowOnMove() = default;
      method ThrowOnMove (line 109) | [[noreturn]] ThrowOnMove(ThrowOnMove&&) { throw MyErr{}; }
    function throwOnMoveTask (line 111) | value_or_fatal<Task<ThrowOnMove>, on_stopped_and_error<will_fatal>>
    function instantiateThrowOnMoveTask (line 115) | [[maybe_unused]] void instantiateThrowOnMoveTask() {
    function checkFatalOnNonValue (line 121) | now_task<void> checkFatalOnNonValue() {
    function CO_TEST (line 186) | CO_TEST(ValueOrFatalTest, task) {
    function CO_TEST (line 190) | CO_TEST(ValueOrFatalTest, nowTask) {
    function CO_TEST (line 207) | CO_TEST(ValueOrFatalTest, nowTaskIsImmediate) {
    function check_value_or_fatal_awaiter (line 239) | consteval bool check_value_or_fatal_awaiter() {
    function checkValueOrFatalAllFatal (line 301) | now_task<void> checkValueOrFatalAllFatal() {
    function CO_TEST (line 323) | CO_TEST(ValueOrFatalTest, allFatalTask) {
    function CO_TEST (line 342) | CO_TEST(ValueOrFatalTest, allFatalNowTask) {
    function CO_TEST (line 347) | CO_TEST(ValueOrFatalTest, successfulCompletion) {
    function intTaskThrows (line 363) | value_or_fatal<now_task<int>, Policy> intTaskThrows() {
    function voidTaskThrows (line 369) | value_or_fatal<now_task<>, Policy> voidTaskThrows() {
    function CO_TEST (line 375) | CO_TEST(ValueOrFatalTest, policySubstitutesValue) {
    function CO_TEST (line 444) | CO_TEST(ValueOrFatalTest, valueOrErrorComposition) {

FILE: folly/coro/test/WithAsyncStackTest.cpp
  type folly::coro (line 25) | namespace folly::coro {
    type Err (line 28) | struct Err {}
    type TestAwaiter (line 32) | struct TestAwaiter {
      method await_ready (line 33) | bool await_ready() noexcept { return false; }
      method await_suspend (line 36) | auto await_suspend(coroutine_handle<Promise>) noexcept(IsNoexcept) {
      method await_resume (line 45) | void await_resume() noexcept {}
      method check_wrapped (line 48) | static constexpr void check_wrapped() {
    function CO_TEST (line 59) | CO_TEST(WithAsyncStackTest, AwaitSuspendNoexceptPropagates) {

FILE: folly/crypto/Blake2xb.cpp
  type folly (line 22) | namespace folly {
    type crypto (line 23) | namespace crypto {
      type _blake2b_state (line 32) | struct _blake2b_state {
      function initStateFromParams (line 54) | void initStateFromParams(

FILE: folly/crypto/Blake2xb.h
  function namespace (line 23) | namespace folly {

FILE: folly/crypto/LtHash-inl.h
  function namespace (line 25) | namespace folly {
  function getChecksumSizeBytes (line 119) | constexpr size_t getChecksumSizeBytes() {

FILE: folly/crypto/LtHash.cpp
  type folly (line 23) | namespace folly {
    type crypto (line 24) | namespace crypto {
      type detail (line 25) | namespace detail {
        function allocateCacheAlignedIOBuf (line 27) | folly::IOBuf allocateCacheAlignedIOBuf(size_t size) {
        function allocateCacheAlignedIOBufUnique (line 40) | std::unique_ptr<folly::IOBuf> allocateCacheAlignedIOBufUnique(size...
        function isCacheAlignedAddress (line 44) | bool isCacheAlignedAddress(const void* addr) {
        type MathOperation<MathEngine::AUTO> (line 181) | struct MathOperation<MathEngine::AUTO>

FILE: folly/crypto/LtHash.h
  function namespace (line 28) | namespace folly {
  function namespace (line 300) | namespace folly {

FILE: folly/crypto/detail/LtHashInternal.h
  function namespace (line 21) | namespace folly {

FILE: folly/crypto/detail/MathOperation_AVX2.cpp
  type folly (line 32) | namespace folly {
    type crypto (line 33) | namespace crypto {
      type detail (line 34) | namespace detail {
        type MathOperation<MathEngine::AVX2> (line 267) | struct MathOperation<MathEngine::AVX2>

FILE: folly/crypto/detail/MathOperation_SSE2.cpp
  type folly (line 32) | namespace folly {
    type crypto (line 33) | namespace crypto {
      type detail (line 34) | namespace detail {
        type MathOperation<MathEngine::SSE2> (line 267) | struct MathOperation<MathEngine::SSE2>

FILE: folly/crypto/detail/MathOperation_Simple.cpp
  type folly (line 26) | namespace folly {
    type crypto (line 27) | namespace crypto {
      type detail (line 28) | namespace detail {
        type MathOperation<MathEngine::SIMPLE> (line 209) | struct MathOperation<MathEngine::SIMPLE>

FILE: folly/crypto/test/Blake2xbBenchmark.cpp
  function benchmarkBlake2b (line 28) | void benchmarkBlake2b(size_t inputSize, size_t n) {
  function benchmarkBlake2bMultiple (line 43) | void benchmarkBlake2bMultiple(size_t inputSize, size_t m, size_t n) {
  function benchmarkBlake2xb (line 79) | void benchmarkBlake2xb(size_t inputSize, size_t outputSize, size_t n) {
  function BENCHMARK (line 91) | BENCHMARK(blake2b_100b_in_64b_out, n) {
  function BENCHMARK_RELATIVE (line 95) | BENCHMARK_RELATIVE(blake2xb_100b_in_64b_out, n) {
  function BENCHMARK (line 99) | BENCHMARK(blake2b_100b_in_128b_out, n) {
  function BENCHMARK_RELATIVE (line 103) | BENCHMARK_RELATIVE(blake2xb_100b_in_128b_out, n) {
  function BENCHMARK (line 107) | BENCHMARK(blake2b_100b_in_1024b_out, n) {
  function BENCHMARK_RELATIVE (line 111) | BENCHMARK_RELATIVE(blake2xb_100b_in_1024b_out, n) {
  function BENCHMARK (line 115) | BENCHMARK(blake2b_100b_in_4096b_out, n) {
  function BENCHMARK_RELATIVE (line 119) | BENCHMARK_RELATIVE(blake2xb_100b_in_4096b_out, n) {
  function BENCHMARK (line 123) | BENCHMARK(blake2b_1000b_in_64b_out, n) {
  function BENCHMARK_RELATIVE (line 127) | BENCHMARK_RELATIVE(blake2xb_1000b_in_64b_out, n) {
  function BENCHMARK (line 131) | BENCHMARK(blake2b_1000b_in_128b_out, n) {
  function BENCHMARK_RELATIVE (line 135) | BENCHMARK_RELATIVE(blake2xb_1000b_in_128b_out, n) {
  function BENCHMARK (line 139) | BENCHMARK(blake2b_1000b_in_1024b_out, n) {
  function BENCHMARK_RELATIVE (line 143) | BENCHMARK_RELATIVE(blake2xb_1000b_in_1024b_out, n) {
  function BENCHMARK (line 147) | BENCHMARK(blake2b_1000b_in_4096b_out, n) {
  function BENCHMARK_RELATIVE (line 151) | BENCHMARK_RELATIVE(blake2xb_1000b_in_4096b_out, n) {
  function main (line 155) | int main(int argc, char** argv) {

FILE: folly/crypto/test/Blake2xbTest.cpp
  class Blake2xbTestBase (line 33) | class Blake2xbTestBase : public ::testing::Test {
    method getHashInput (line 35) | static folly::ByteRange getHashInput() {
    method checkTestVector (line 49) | void checkTestVector(const std::vector<std::string>& testVector) {
  class Blake2xbTest (line 65) | class Blake2xbTest : public Blake2xbTestBase {
    method getHashKey (line 67) | folly::ByteRange getHashKey() const override { return {}; }
  function TEST_F (line 1451) | TEST_F(Blake2xbTest, checkTestVectors) {
  class Blake2xbKeyedTest (line 1455) | class Blake2xbKeyedTest : public Blake2xbTestBase {
    method getHashKey (line 2837) | folly::ByteRange getHashKey() const override {
  function TEST_F (line 2850) | TEST_F(Blake2xbKeyedTest, checkTestVector) {

FILE: folly/crypto/test/LtHashBenchmark.cpp
  function makeRandomData (line 35) | std::unique_ptr<folly::IOBuf> makeRandomData(size_t length) {
  function runBenchmark (line 44) | void runBenchmark(size_t n) {
  function BENCHMARK (line 52) | BENCHMARK(single_blake2b, n) {
  function BENCHMARK_RELATIVE (line 64) | BENCHMARK_RELATIVE(LtHash_element_count_1024_length_16, n) {
  function BENCHMARK_RELATIVE (line 68) | BENCHMARK_RELATIVE(LtHash_element_count_1008_length_20, n) {
  function BENCHMARK_RELATIVE (line 72) | BENCHMARK_RELATIVE(LtHash_element_count_1024_length_32, n) {
  function BENCHMARK_RELATIVE (line 76) | BENCHMARK_RELATIVE(LtHash_element_count_2048_length_32, n) {
  function BENCHMARK (line 80) | BENCHMARK(calculateChecksumFor100KObjects_B20_N1008) {
  function BENCHMARK_RELATIVE (line 88) | BENCHMARK_RELATIVE(calculateChecksumFor100KObjects_B16_N1024) {
  function BENCHMARK_RELATIVE (line 96) | BENCHMARK_RELATIVE(calculateChecksumFor100KObjects_B32_N1024) {
  function BENCHMARK (line 104) | BENCHMARK(subtractChecksumFor100KObjects_B20_N1008) {
  function BENCHMARK_RELATIVE (line 112) | BENCHMARK_RELATIVE(subtractChecksumFor100KObjects_B16_N1024) {
  function BENCHMARK_RELATIVE (line 120) | BENCHMARK_RELATIVE(subtractChecksumFor100KObjects_B32_N1024) {
  function main (line 128) | int main(int argc, char** argv) {

FILE: folly/crypto/test/LtHashTest.cpp
  function toHex (line 35) | std::string toHex(const folly::IOBuf& buf) {
  function makeRandomData (line 39) | std::unique_ptr<folly::IOBuf> makeRandomData(size_t length) {
  type IsLtHash (line 47) | struct IsLtHash {
    method value (line 48) | static inline constexpr bool value() { return false; }
  type IsLtHash<LtHash<B, N>> (line 52) | struct IsLtHash<LtHash<B, N>> {
    method value (line 53) | static inline constexpr bool value() { return true; }
  type folly::crypto (line 58) | namespace folly::crypto {
  class LtHashTest (line 70) | class LtHashTest : public ::testing::Test {
    method kChecksumLength (line 79) | static size_t kChecksumLength() {
    method H (line 83) | static const H& kEmptyHash() {
  function TYPED_TEST (line 105) | TYPED_TEST(LtHashTest, empty) {
  function TYPED_TEST (line 114) | TYPED_TEST(LtHashTest, reset) {
  function TYPED_TEST (line 122) | TYPED_TEST(LtHashTest, copyAssignment) {
  function TYPED_TEST (line 132) | TYPED_TEST(LtHashTest, checksumEquals) {
  function TYPED_TEST (line 153) | TYPED_TEST(LtHashTest, moveAssignment) {
  function TYPED_TEST (line 172) | TYPED_TEST(LtHashTest, addObjectCommutative) {
  function TYPED_TEST (line 185) | TYPED_TEST(LtHashTest, addTwoLtHashes) {
  function TYPED_TEST (line 203) | TYPED_TEST(LtHashTest, subtractTwoLtHashes) {
  function TYPED_TEST (line 221) | TYPED_TEST(LtHashTest, addObjectChaining) {
  function TYPED_TEST (line 232) | TYPED_TEST(LtHashTest, addDifferentObjects) {
  function TYPED_TEST (line 242) | TYPED_TEST(LtHashTest, addAndremoveObjectSame) {
  function TYPED_TEST (line 251) | TYPED_TEST(LtHashTest, addObjectWithInitialChecksum) {
  function TYPED_TEST (line 266) | TYPED_TEST(LtHashTest, addObjectVariadic) {
  function TYPED_TEST (line 283) | TYPED_TEST(LtHashTest, removeObjectVariadic) {
  function TYPED_TEST (line 306) | TYPED_TEST(LtHashTest, getChecksumDeepCopy) {
  function TYPED_TEST (line 323) | TYPED_TEST(LtHashTest, addObjectRandomShuffle) {
  function TYPED_TEST (line 350) | TYPED_TEST(LtHashTest, addAndremoveObjectRandom) {
  function TYPED_TEST (line 376) | TYPED_TEST(LtHashTest, setChecksum) {
  function TYPED_TEST (line 392) | TYPED_TEST(LtHashTest, setChecksumWithChainedIOBuf) {
  function TYPED_TEST (line 411) | TYPED_TEST(LtHashTest, setChecksumFailure) {
  function TYPED_TEST (line 432) | TYPED_TEST(LtHashTest, addObjectWithKnownValue) {
  function TYPED_TEST (line 709) | TYPED_TEST(LtHashTest, setKeyTooShort) {
  function TYPED_TEST (line 715) | TYPED_TEST(LtHashTest, setKeyTooLong) {
  function TYPED_TEST (line 722) | TYPED_TEST(LtHashTest, subtractWithDifferentKeysFail) {
  function TYPED_TEST (line 733) | TYPED_TEST(LtHashTest, addWithDifferentKeysFail) {
  function TYPED_TEST (line 744) | TYPED_TEST(LtHashTest, keyedLtHashesEqual) {
  function TYPED_TEST (line 759) | TYPED_TEST(LtHashTest, keyedLtHashesDifferentKeysNotEqual) {

FILE: folly/debugging/exception_tracer/ExceptionAbi.h
  function namespace (line 31) | namespace __cxxabiv1 {

FILE: folly/debugging/exception_tracer/ExceptionCounterLib.cpp
  type ExceptionStatsStorage (line 47) | struct ExceptionStatsStorage {
    method appendTo (line 48) | void appendTo(ExceptionStatsHolderType& data) {
  class Tag (line 63) | class Tag {}
  type folly (line 70) | namespace folly {
    type exception_tracer (line 71) | namespace exception_tracer {
      function getExceptionStatistics (line 73) | std::vector<ExceptionStats> getExceptionStatistics() {
      function exceptionStatsThrowHandler (line 107) | void exceptionStatsThrowHandler(

FILE: folly/debugging/exception_tracer/ExceptionCounterLib.h
  function namespace (line 29) | namespace folly {

FILE: folly/debugging/exception_tracer/ExceptionCounterLibStaticRegistration.cpp
  type Initializer (line 24) | struct Initializer {
    method Initializer (line 25) | Initializer() {

FILE: folly/debugging/exception_tracer/ExceptionStackTraceLib.cpp
  function StackTraceStack (line 50) | const StackTraceStack*
  function StackTraceStack (line 54) | const StackTraceStack*
  type folly (line 59) | namespace folly {
    type detail (line 61) | namespace detail {
      type access_cxxabi (line 80) | namespace access_cxxabi {
        function get_caught_exceptions_handler_count (line 82) | static auto get_caught_exceptions_handler_count() {
    function stackDepth (line 92) | size_t stackDepth(const StackTraceStack& stack) {
    function addActiveException (line 102) | void addActiveException() {
    function moveTopException (line 126) | void moveTopException(StackTraceStack& from, StackTraceStack& to) {
    type Initializer (line 137) | struct Initializer {
      method Initializer (line 138) | Initializer() {

FILE: folly/debugging/exception_tracer/ExceptionTracer.cpp
  type folly (line 59) | namespace folly {
    type exception_tracer (line 60) | namespace exception_tracer {
      function printExceptionInfo (line 67) | void printExceptionInfo(
      type ArmAbiTag (line 120) | struct ArmAbiTag {}
      type AnyAbiTag (line 121) | struct AnyAbiTag {}
      function isAbiCppException (line 123) | [[maybe_unused]] bool isAbiCppException(ArmAbiTag, const char (&klaz...
      function isAbiCppException (line 128) | [[maybe_unused]] bool isAbiCppException(AnyAbiTag, const uint64_t& k...
      function isAbiCppException (line 135) | bool isAbiCppException(const __cxa_exception* exc) {
      function getCurrentExceptions (line 142) | std::vector<ExceptionInfo> getCurrentExceptions() {
      function dumpExceptionStack (line 246) | void dumpExceptionStack(const char* prefix) {
      function terminateHandler (line 258) | void terminateHandler() {
      function installHandlers (line 265) | void installHandlers() {

FILE: folly/debugging/exception_tracer/ExceptionTracer.h
  function namespace (line 29) | namespace folly {

FILE: folly/debugging/exception_tracer/ExceptionTracerLib.cpp
  type __cxxabiv1 (line 32) | namespace __cxxabiv1 {
    function __wrap___cxa_throw (line 127) | [[noreturn]] void __wrap___cxa_throw(
    function __wrap___cxa_rethrow (line 134) | [[noreturn]] void __wrap___cxa_rethrow() {
    function __wrap___cxa_end_catch (line 151) | void __wrap___cxa_end_catch() {
    function __cxa_throw (line 159) | __attribute__((__noreturn__)) void __cxa_throw(
    function __cxa_rethrow (line 168) | __attribute__((__noreturn__)) void __cxa_rethrow() {
    function __cxa_end_catch (line 190) | void __cxa_end_catch() {
  class CallbackHolder (line 73) | class CallbackHolder {
    method registerCallback (line 75) | void registerCallback(Sig& f) { callbacks_.wlock()->push_back(f); }
    method unregisterCallback (line 76) | void unregisterCallback(Sig& f) {
    method FOLLY_ALWAYS_INLINE (line 83) | FOLLY_ALWAYS_INLINE void invoke(Args... args) {
  type folly (line 96) | namespace folly {
    type exception_tracer (line 97) | namespace exception_tracer {
  type __cxxabiv1 (line 122) | namespace __cxxabiv1 {
    function __wrap___cxa_throw (line 127) | [[noreturn]] void __wrap___cxa_throw(
    function __wrap___cxa_rethrow (line 134) | [[noreturn]] void __wrap___cxa_rethrow() {
    function __wrap___cxa_end_catch (line 151) | void __wrap___cxa_end_catch() {
    function __cxa_throw (line 159) | __attribute__((__noreturn__)) void __cxa_throw(
    function __cxa_rethrow (line 168) | __attribute__((__noreturn__)) void __cxa_rethrow() {
    function __cxa_end_catch (line 190) | void __cxa_end_catch() {
  function __wrap__ZSt17rethrow_exceptionNSt15__exception_ptr13exception_ptrE (line 207) | [[noreturn]] void
  function __wrap__ZSt17rethrow_exceptionSt13exception_ptr (line 217) | [[noreturn]] void __wrap__ZSt17rethrow_exceptionSt13exception_ptr(
  type folly (line 228) | namespace folly {
    type exception_tracer (line 97) | namespace exception_tracer {
  type std (line 234) | namespace std {
    function rethrow_exception (line 236) | __attribute__((__noreturn__)) void rethrow_exception(std::exception_pt...

FILE: folly/debugging/exception_tracer/ExceptionTracerLib.h
  function namespace (line 26) | namespace folly {

FILE: folly/debugging/exception_tracer/SmartExceptionStackTraceHooks.cpp
  type folly::exception_tracer (line 25) | namespace folly::exception_tracer {
    function metaDeleter (line 29) | void metaDeleter(void* ex) noexcept {
    function throwCallback (line 48) | void throwCallback(
    type Initialize (line 87) | struct Initialize {
      method Initialize (line 88) | Initialize() {

FILE: folly/debugging/exception_tracer/SmartExceptionTracer.cpp
  type folly (line 33) | namespace folly {
    type exception_tracer (line 34) | namespace exception_tracer {
      function ExceptionInfo (line 43) | ExceptionInfo getTraceWithFunc(
      function ExceptionInfo (line 64) | ExceptionInfo getTraceWithFunc(
      function ExceptionInfo (line 74) | ExceptionInfo getTraceWithFunc(
      function ExceptionInfo (line 83) | ExceptionInfo getTraceWithFunc(
      function getAsyncStackTraceItPair (line 88) | auto getAsyncStackTraceItPair(const detail::ExceptionMeta& meta) {
      function getNormalStackTraceItPair (line 93) | auto getNormalStackTraceItPair(const detail::ExceptionMeta& meta) {
      function ExceptionInfo (line 100) | ExceptionInfo getTrace(const std::exception_ptr& ptr) {
      function ExceptionInfo (line 104) | ExceptionInfo getTrace(const exception_wrapper& ew) {
      function ExceptionInfo (line 108) | ExceptionInfo getTrace(const std::exception& ex) {
      function ExceptionInfo (line 112) | ExceptionInfo getAsyncTrace(const std::exception_ptr& ptr) {
      function ExceptionInfo (line 116) | ExceptionInfo getAsyncTrace(const exception_wrapper& ew) {
      function ExceptionInfo (line 120) | ExceptionInfo getAsyncTrace(const std::exception& ex) {

FILE: folly/debugging/exception_tracer/SmartExceptionTracer.h
  function namespace (line 33) | namespace folly::exception_tracer {

FILE: folly/debugging/exception_tracer/SmartExceptionTracerSingleton.cpp
  type folly::exception_tracer::detail (line 25) | namespace folly::exception_tracer::detail {
    function isSmartExceptionTracerHookEnabled (line 39) | bool isSmartExceptionTracerHookEnabled() {
    function setSmartExceptionTracerHookEnabled (line 42) | void setSmartExceptionTracerHookEnabled(bool enabled) {

FILE: folly/debugging/exception_tracer/SmartExceptionTracerSingleton.h
  function namespace (line 23) | namespace folly::exception_tracer::detail {

FILE: folly/debugging/exception_tracer/StackTrace.cpp
  type folly (line 25) | namespace folly {
    type exception_tracer (line 26) | namespace exception_tracer {
      class StackTraceStack::Node (line 28) | class StackTraceStack::Node : public StackTrace {
        method Node (line 36) | Node() : next(nullptr) {}
      function StackTrace (line 97) | StackTrace* StackTraceStack::top() {
      function StackTrace (line 101) | const StackTrace* StackTraceStack::top() const {
      function StackTrace (line 105) | StackTrace* StackTraceStack::next(StackTrace* p) {
      function StackTrace (line 110) | const StackTrace* StackTraceStack::next(const StackTrace* p) const {

FILE: folly/debugging/exception_tracer/StackTrace.h
  function namespace (line 25) | namespace folly {

FILE: folly/debugging/exception_tracer/test/ExceptionCounterTest.cpp
  type MyException (line 28) | struct MyException {}
  function bar (line 31) | [[noreturn]] void bar() {
  function foo (line 35) | [[noreturn]] void foo() {
  function baz (line 39) | [[noreturn]] void baz() {
  function throwAndCatch (line 47) | void throwAndCatch(F f) {
  function TEST (line 55) | TEST(ExceptionCounter, oneThread) {
  function TEST (line 71) | TEST(ExceptionCounter, testClearExceptionStatistics) {
  function TEST (line 79) | TEST(ExceptionCounter, testDifferentStacks) {
  function TEST (line 86) | TEST(ExceptionCounter, multyThreads) {

FILE: folly/debugging/exception_tracer/test/ExceptionTracerBenchmark.cpp
  function recurse (line 29) | void recurse(int level) {
  function loop (line 37) | void loop(int iters) {
  function BENCHMARK (line 47) | BENCHMARK(ExceptionTracer, iters) {
  function main (line 61) | int main(int argc, char* argv[]) {

FILE: folly/debugging/exception_tracer/test/ExceptionTracerTest.cpp
  function bar (line 25) | [[noreturn]] void bar() {
  function dumpExceptions (line 30) | void dumpExceptions(const char* prefix) {
  function foo (line 38) | void foo() {
  function baz (line 51) | [[noreturn]] void baz() {
  function testExceptionPtr1 (line 65) | void testExceptionPtr1() {
  function testExceptionPtr2 (line 80) | void testExceptionPtr2() {
  function main (line 95) | int main(int /* argc */, char* /* argv */[]) {
  function main (line 105) | int main(int /* argc */, char* /* argv */[]) {}

FILE: folly/debugging/exception_tracer/test/ExceptionTracerUncaughtTest.cpp
  function foo (line 19) | __attribute__((noinline)) [[noreturn]] void foo() {
  function main (line 23) | int main() {

FILE: folly/debugging/exception_tracer/test/SmartExceptionTracerBenchmark.cpp
  function FOLLY_NOINLINE (line 32) | [[noreturn]] FOLLY_NOINLINE void throwRuntimeError() {
  function FOLLY_NOINLINE (line 36) | FOLLY_NOINLINE ExceptionInfo recurse(int n) {
  function ExceptionInfo (line 48) | ExceptionInfo makeExceptionWithStackDepthMeasureThrow(int n) {
  function ExceptionInfo (line 57) | ExceptionInfo makeExceptionRefWithStackDepthMeasureRetrieve(int n) {
  function ExceptionInfo (line 66) | ExceptionInfo makeExceptionPtrWithStackDepthMeasureRetrieve(int n) {
  function ExceptionInfo (line 76) | ExceptionInfo makeExceptionWrapperWithStackDepthMeasureRetrieve(int n) {
  function captureException (line 88) | void captureException(int iterations, int stackDepth) {
  function retrieveStackTracePtr (line 95) | void retrieveStackTracePtr(int iterations, int stackDepth) {
  function retrieveStackTraceRef (line 102) | void retrieveStackTraceRef(int iterations, int stackDepth) {
  function retrieveStackTraceWrapper (line 109) | void retrieveStackTraceWrapper(int iterations, int stackDepth) {
  function main (line 142) | int main(int, char**) {

FILE: folly/debugging/exception_tracer/test/SmartExceptionTracerTest.cpp
  function FOLLY_NOINLINE (line 27) | [[noreturn]] FOLLY_NOINLINE void testThrowException() {
  function TEST (line 31) | TEST(SmartExceptionTracer, ExceptionPtr) {
  function TEST (line 40) | TEST(SmartExceptionTracer, ExceptionWrapper) {
  function TEST (line 49) | TEST(SmartExceptionTracer, StdException) {
  function TEST (line 61) | TEST(SmartExceptionTracer, EmptyExceptionWrapper) {
  function TEST (line 71) | TEST(SmartExceptionTracer, NonStdException) {
  function TEST (line 83) | TEST(SmartExceptionTracer, UnthrownException) {
  function funcD (line 95) | [[noreturn]] void funcD() {
  function FOLLY_NOINLINE (line 99) | FOLLY_NOINLINE folly::coro::Task<void> co_funcC() {
  function FOLLY_NOINLINE (line 104) | FOLLY_NOINLINE folly::coro::Task<void> co_funcB() {
  function FOLLY_NOINLINE (line 108) | FOLLY_NOINLINE folly::coro::Task<void> co_funcA() {
  function TEST (line 114) | TEST(SmartExceptionTracer, AsyncStackTrace) {
  class ExceptionE (line 146) | class ExceptionE : virtual public std::runtime_error {
    method ExceptionE (line 148) | ExceptionE() : std::runtime_error("ExceptionA") {}
  class ExceptionF (line 151) | class ExceptionF : virtual public std::runtime_error {
    method ExceptionF (line 153) | ExceptionF() : std::runtime_error("ExceptionB") {}
  class ExceptionG (line 156) | class ExceptionG : virtual public ExceptionE, virtual public ExceptionF {
    method ExceptionG (line 158) | ExceptionG() : std::runtime_error("ExceptionC"), ExceptionE(), Excepti...
  function FOLLY_NOINLINE (line 161) | [[noreturn]] FOLLY_NOINLINE void throwDiamond() {
  function TEST (line 165) | TEST(SmartExceptionTracer, diamondExceptionPointer) {
  function TEST (line 181) | TEST(SmartExceptionTracer, diamondStdException) {

FILE: folly/debugging/exception_tracer/test/exception_tracer_uncaught_test.py
  class ExceptionTracerUncaughtTest (line 24) | class ExceptionTracerUncaughtTest(unittest.TestCase):
    method setUp (line 25) | def setUp(self) -> None:
    method test_uncaught_exception (line 31) | def test_uncaught_exception(self) -> None:

FILE: folly/debugging/symbolizer/Dwarf.cpp
  type folly (line 32) | namespace folly {
    type symbolizer (line 33) | namespace symbolizer {
      function findDebugInfoOffset (line 72) | bool findDebugInfoOffset(

FILE: folly/debugging/symbolizer/Dwarf.h
  function namespace (line 28) | namespace folly {

FILE: folly/debugging/symbolizer/DwarfImpl.cpp
  type folly (line 38) | namespace folly {
    type symbolizer (line 39) | namespace symbolizer {
      type CallLocation (line 42) | struct CallLocation {
      function CompilationUnit (line 345) | CompilationUnit DwarfImpl::findCompilationUnit(

FILE: folly/debugging/symbolizer/DwarfImpl.h
  function namespace (line 32) | namespace folly {

FILE: folly/debugging/symbolizer/DwarfLineNumberVM.cpp
  type folly (line 24) | namespace folly {
    type symbolizer (line 25) | namespace symbolizer {
      type LineNumberAttribute (line 59) | struct LineNumberAttribute {
      function readLineNumberAttribute (line 65) | folly::Optional<LineNumberAttribute> readLineNumberAttribute(
      function Path (line 635) | Path DwarfLineNumberVM::getFullFileName(uint64_t index) const {
      type State (line 658) | enum State {

FILE: folly/debugging/symbolizer/DwarfLineNumberVM.h
  function namespace (line 23) | namespace folly {

FILE: folly/debugging/symbolizer/DwarfSection.cpp
  type folly (line 23) | namespace folly {
    type symbolizer (line 24) | namespace symbolizer {

FILE: folly/debugging/symbolizer/DwarfSection.h
  function namespace (line 23) | namespace folly {

FILE: folly/debugging/symbolizer/DwarfUtil.cpp
  type folly (line 38) | namespace folly {
    type symbolizer (line 39) | namespace symbolizer {
      function getElfSection (line 41) | folly::StringPiece getElfSection(const ElfFile* elf, const char* nam...
      function readU64 (line 56) | uint64_t readU64(folly::StringPiece& sp) {
      function readULEB (line 65) | uint64_t readULEB(folly::StringPiece& sp, uint8_t& shift, uint8_t& v...
      function readULEB (line 76) | uint64_t readULEB(folly::StringPiece& sp) {
      function readSLEB (line 83) | int64_t readSLEB(folly::StringPiece& sp) {
      function readOffset (line 96) | uint64_t readOffset(folly::StringPiece& sp, bool is64Bit) {
      function readBytes (line 101) | folly::StringPiece readBytes(folly::StringPiece& sp, uint64_t len) {
      function readNullTerminated (line 109) | folly::StringPiece readNullTerminated(folly::StringPiece& sp) {
      function getStringFromStringSection (line 117) | folly::StringPiece getStringFromStringSection(
      function AttributeSpec (line 124) | AttributeSpec readAttributeSpec(folly::StringPiece& sp) {
      function readAbbreviation (line 135) | bool readAbbreviation(folly::StringPiece& section, DIEAbbreviation& ...
      function DIEAbbreviation (line 166) | DIEAbbreviation getAbbreviation(
      function findCompiliationOffset (line 184) | bool findCompiliationOffset(
      function parseCompilationUnitMetadata (line 273) | bool parseCompilationUnitMetadata(CompilationUnit& cu, size_t offset) {
      function CompilationUnits (line 385) | CompilationUnits getCompilationUnits(
      function Die (line 556) | Die getDieAtOffset(const CompilationUnit& cu, uint64_t offset) {
      function Attribute (line 580) | Attribute readAttribute(
      function forEachAttribute (line 771) | size_t forEachAttribute(
      function getFunctionNameFromDie (line 788) | folly::StringPiece getFunctionNameFromDie(
      function getFunctionName (line 811) | folly::StringPiece getFunctionName(
      function Die (line 820) | Die findDefinitionDie(const CompilationUnit& cu, const Die& die) {

FILE: folly/debugging/symbolizer/DwarfUtil.h
  function namespace (line 31) | namespace folly {
  type Die (line 130) | struct Die {
  type AttributeSpec (line 140) | struct AttributeSpec {
  type Attribute (line 148) | struct Attribute {

FILE: folly/debugging/symbolizer/Elf-inl.h
  function namespace (line 17) | namespace folly {

FILE: folly/debugging/symbolizer/Elf.cpp
  type folly (line 51) | namespace folly {
    type symbolizer (line 52) | namespace symbolizer {
      type stat (line 90) | struct stat
      function ElfFile (line 184) | ElfFile& ElfFile::operator=(ElfFile&& other) noexcept {
      function ElfShdr (line 318) | const ElfShdr* ElfFile::getSectionByIndex(size_t idx) const noexcept {
      function ElfShdr (line 370) | const ElfShdr* ElfFile::getSectionByName(const char* name) const noe...
      function ElfShdr (line 463) | const ElfShdr* ElfFile::getSectionContainingAddress(

FILE: folly/debugging/symbolizer/Elf.h
  function namespace (line 43) | namespace folly {
  function T (line 572) | T* valueAt(const ElfShdr& section, const ElfAddr addr) const noexcept {
  function namespace (line 626) | namespace std {

FILE: folly/debugging/symbolizer/ElfCache.cpp
  type folly (line 27) | namespace folly {
    type symbolizer (line 28) | namespace symbolizer {
      type cmp (line 41) | struct cmp {

FILE: folly/debugging/symbolizer/ElfCache.h
  function class (line 40) | class ElfCacheBase {
  function class (line 56) | class SignalSafeElfCache : public ElfCacheBase {

FILE: folly/debugging/symbolizer/LineReader.cpp
  type folly (line 23) | namespace folly {
    type symbolizer (line 24) | namespace symbolizer {

FILE: folly/debugging/symbolizer/LineReader.h
  function namespace (line 23) | namespace folly {

FILE: folly/debugging/symbolizer/SignalHandler.cpp
  type folly (line 37) | namespace folly {
    type symbolizer (line 38) | namespace symbolizer {
      class FatalSignalCallbackRegistry (line 64) | class FatalSignalCallbackRegistry {
      function FatalSignalCallbackRegistry (line 107) | FatalSignalCallbackRegistry* getFatalSignalCallbackRegistry() {
      function addFatalSignalCallback (line 117) | void addFatalSignalCallback(SignalCallback cb) {
      function installFatalSignalCallbacks (line 121) | void installFatalSignalCallbacks() {
      type FatalSignalInfo (line 129) | struct FatalSignalInfo {
        type sigaction (line 132) | struct sigaction
      function try_async_reraise (line 147) | bool try_async_reraise(int signum, siginfo_t* info) {
      function callPreviousSignalHandler (line 183) | [[maybe_unused]] void callPreviousSignalHandler(int signum, siginfo_...
      function print (line 244) | void print(StringPiece sp) {
      function flush (line 248) | void flush() {
      function printDec (line 252) | void printDec(uint64_t val) {
      function printHex (line 258) | void printHex(uint64_t val) {
      function dumpTimeInfo (line 267) | void dumpTimeInfo() {
      function dumpSignalInfo (line 450) | void dumpSignalInfo(int signum, siginfo_t* siginfo) {
      function innerSignalHandler (line 523) | void innerSignalHandler(int signum, siginfo_t* info, void* /* uctx *...
      function signalHandler (line 564) | void signalHandler(int signum, siginfo_t* info, void* uctx) {
      function isSmallSigAltStackEnabled (line 589) | [[maybe_unused]] bool isSmallSigAltStackEnabled() {
      function installFatalSignalHandler (line 608) | void installFatalSignalHandler(std::bitset<64> signals) {
      function fatalSignalReceived (line 664) | bool fatalSignalReceived() {

FILE: folly/debugging/symbolizer/SignalHandler.h
  function namespace (line 21) | namespace folly {

FILE: folly/debugging/symbolizer/StackTrace.cpp
  type folly (line 36) | namespace folly {
    type symbolizer (line 37) | namespace symbolizer {
      function getStackTrace (line 46) | ssize_t getStackTrace(
      type FrameInfo (line 89) | struct FrameInfo {
        method getAdjustedInstructionPointer (line 94) | inline uintptr_t getAdjustedInstructionPointer(
      function getFrameInfo (line 118) | inline bool getFrameInfo(unw_cursor_t* cursor, FrameInfo& frameInfo) {
      function getStackTraceInPlace (line 139) | ssize_t getStackTraceInPlace(
      function getStackTraceSafe (line 182) | ssize_t getStackTraceSafe(
      function getStackTraceHeap (line 204) | ssize_t getStackTraceHeap(
      type StackFrame (line 226) | struct StackFrame {
      function FOLLY_DISABLE_THREAD_SANITIZER (line 231) | FOLLY_DISABLE_THREAD_SANITIZER size_t walkNormalStack(
      type WalkAsyncStackResult (line 267) | struct WalkAsyncStackResult {
      function WalkAsyncStackResult (line 278) | WalkAsyncStackResult walkAsyncStack(
      function FOLLY_NOINLINE (line 332) | FOLLY_NOINLINE ssize_t

FILE: folly/debugging/symbolizer/StackTrace.h
  function namespace (line 26) | namespace folly {

FILE: folly/debugging/symbolizer/SymbolizePrinter.cpp
  type folly (line 30) | namespace folly {
    type symbolizer (line 31) | namespace symbolizer {
      function getFD (line 183) | int getFD(const std::ios& stream) {
      function isColorfulTty (line 206) | bool isColorfulTty(int options, int fd) {

FILE: folly/debugging/symbolizer/SymbolizePrinter.h
  function namespace (line 25) | namespace folly {

FILE: folly/debugging/symbolizer/SymbolizedFrame.cpp
  type folly (line 19) | namespace folly {
    type symbolizer (line 20) | namespace symbolizer {

FILE: folly/debugging/symbolizer/SymbolizedFrame.h
  function namespace (line 26) | namespace folly {

FILE: folly/debugging/symbolizer/Symbolizer.cpp
  type folly (line 57) | namespace folly {
    type symbolizer (line 58) | namespace symbolizer {
      function printAsyncStackInfo (line 62) | void printAsyncStackInfo(PrintFunc print) {
      function symbolizeAndPrint (line 98) | void symbolizeAndPrint(
      function ElfCache (line 118) | ElfCache* defaultElfCache() {
      function setROARSymbolizedFrame (line 124) | bool setROARSymbolizedFrame(
      function setSymbolizedFrame (line 170) | void setSymbolizedFrame(
      function containedInExecutableSegment (line 206) | bool containedInExecutableSegment(
      type Symbolizer::SymbolCache (line 221) | struct Symbolizer::SymbolCache : public Synchronized<UnsyncSymbolCac...
      function getStackTraceStrImpl (line 546) | std::string getStackTraceStrImpl(
      type detail (line 563) | namespace detail {
        function getStackTraceStr (line 564) | std::string getStackTraceStr(
      function getStackTraceStr (line 586) | std::string getStackTraceStr(bool showFullInfo, size_t skip) {
      function getAsyncStackTraceStr (line 591) | std::string getAsyncStackTraceStr(size_t skip) {
      function getSuspendedStackTraces (line 596) | std::vector<std::string> getSuspendedStackTraces() {
      function MmapPtr (line 620) | MmapPtr getNull() {
      function MmapPtr (line 626) | MmapPtr allocateStack(ucontext_t* oucp, size_t pageSize) {

FILE: folly/debugging/symbolizer/Symbolizer.h
  function namespace (line 37) | namespace folly {

FILE: folly/debugging/symbolizer/detail/Debug.cpp
  type folly (line 33) | namespace folly {
    type symbolizer (line 34) | namespace symbolizer {
      type detail (line 35) | namespace detail {
        function r_debug_cache_init_ (line 68) | [[gnu::constructor(101)]] void r_debug_cache_init_() {
        type r_debug (line 74) | struct r_debug

FILE: folly/debugging/symbolizer/detail/Debug.h
  type r_debug (line 19) | struct r_debug
  function namespace (line 21) | namespace folly {

FILE: folly/debugging/symbolizer/test/Crash.cpp
  function main (line 20) | int main() {

FILE: folly/debugging/symbolizer/test/DwarfBenchmark.cpp
  function FOLLY_NOINLINE (line 33) | FOLLY_NOINLINE void lexicalBlockBar() try {
  function run (line 41) | void run(LocationInfoMode mode, size_t n) {
  function BENCHMARK (line 69) | BENCHMARK(DwarfFindAddressFast, n) {
  function BENCHMARK (line 73) | BENCHMARK(DwarfFindAddressFull, n) {
  function BENCHMARK (line 77) | BENCHMARK(DwarfFindAddressFullWithInline, n) {
  function main (line 83) | int main(int argc, char* argv[]) {

FILE: folly/debugging/symbolizer/test/ElfTest.cpp
  function sum_func (line 37) | [[gnu::noinline, gnu::used, FOLLY_ATTR_GNU_RETAIN]] int sum_func(
  function sub_func (line 41) | [[gnu::noinline, gnu::used, FOLLY_ATTR_GNU_RETAIN]] int sub_func(
  class ElfTest (line 48) | class ElfTest : public ::testing::Test {
  function TEST_F (line 53) | TEST_F(ElfTest, IntegerValue) {
  function TEST_F (line 59) | TEST_F(ElfTest, PointerValue) {
  function TEST_F (line 82) | TEST_F(ElfTest, SymbolByName) {
  function TEST_F (line 101) | TEST_F(ElfTest, SymbolsByNameSuccess) {
  function TEST_F (line 118) | TEST_F(ElfTest, SymbolsByNamePartial) {
  function TEST_F (line 132) | TEST_F(ElfTest, SymbolsByNameEmpty) {
  function TEST_F (line 140) | TEST_F(ElfTest, iterateProgramHeaders) {
  function TEST_F (line 150) | TEST_F(ElfTest, TinyNonElfFile) {
  function TEST_F (line 161) | TEST_F(ElfTest, NonElfScript) {
  function TEST_F (line 173) | TEST_F(ElfTest, FailToOpenLargeFilename) {
  function TEST (line 187) | TEST(TestGetNoteGnuBuildId, SimpleElf) {
  function TEST (line 205) | TEST(TestNoteSectionIteration, SimpleElf) {
  function TEST (line 253) | TEST(TestNoteSegmentIteration, SimpleElf) {
  function TEST (line 278) | TEST(TestNoteMultipleNoteSections, SimpleElf) {
  function TEST (line 298) | TEST(TestNoteParsing, SimpleElf) {
  function TEST (line 330) | TEST(TestFindNote, SimpleElf) {

FILE: folly/debugging/symbolizer/test/LineReaderTest.cpp
  type folly (line 25) | namespace folly {
    type symbolizer (line 26) | namespace symbolizer {
      type test (line 27) | namespace test {
        function writeAll (line 31) | void writeAll(int fd, const char* str) {
        function expect (line 36) | void expect(LineReader& lr, const char* expected) {
        function TEST (line 46) | TEST(LineReader, Simple) {

FILE: folly/debugging/symbolizer/test/SignalHandlerTest.cpp
  type folly (line 33) | namespace folly {
    type symbolizer (line 34) | namespace symbolizer {
      type test (line 35) | namespace test {
        function print (line 39) | void print(StringPiece sp) {
        function callback1 (line 43) | void callback1() {
        function callback2 (line 47) | void callback2() {
        function FOLLY_NOINLINE (line 53) | [[noreturn]] FOLLY_NOINLINE void funcC() {
        function FOLLY_NOINLINE (line 57) | FOLLY_NOINLINE folly::coro::Task<void> co_funcB() {
        function FOLLY_NOINLINE (line 62) | FOLLY_NOINLINE folly::coro::Task<void> co_funcA() {
        function TEST (line 68) | TEST(SignalHandler, Simple) {
        function TEST (line 95) | TEST(SignalHandler, GenericSICode) {
        function TEST (line 122) | TEST(SignalHandler, AsyncStackTraceSimple) {
        function TEST (line 153) | TEST(SignalHandler, AsyncStackTraceSimple2) {
  function main (line 192) | int main(int argc, char** argv) {

FILE: folly/debugging/symbolizer/test/SignalHandlerTest.h
  function namespace (line 19) | namespace folly {

FILE: folly/debugging/symbolizer/test/SimpleElf.cpp
  function main (line 17) | int main() {

FILE: folly/debugging/symbolizer/test/SmallSigAltStackCrash.cpp
  function main (line 26) | int main() {

FILE: folly/debugging/symbolizer/test/StackTraceBenchmark.cpp
  function basic (line 24) | unsigned int basic(size_t nFrames) {
  function Recurse (line 39) | unsigned int Recurse(size_t nFrames, size_t remaining) {
  function SetupStackAndTest (line 48) | unsigned int SetupStackAndTest(int /* iters */, size_t nFrames) {
  function main (line 72) | int main(int argc, char* argv[]) {

FILE: folly/debugging/symbolizer/test/StackTraceSizeLimitTest.cpp
  function fBaseline (line 30) | void fBaseline(FrameArray<kMaxAddresses>& /* unused */) {
  function fStack (line 35) | void fStack(FrameArray<kMaxAddresses>& fa) {
  function fHeap (line 41) | void fHeap(FrameArray<kMaxAddresses>& fa) {
  function TEST (line 49) | TEST(StackTraceSizeLimitTest, FiberLimit) {

FILE: folly/debugging/symbolizer/test/StackTraceTest.cpp
  function verifyStackTraces (line 41) | void verifyStackTraces() {
  function foo1 (line 82) | void foo1() {
  function foo2 (line 86) | void foo2() {
  function handler (line 91) | void handler(int /* num */, siginfo_t* /* info */, void* /* ctx */) {
  function TEST (line 98) | TEST(StackTraceTest, Simple) {
  function TEST (line 102) | TEST(StackTraceTest, Signal) {
  function read_all (line 117) | ssize_t read_all(int fd, uint8_t* buffer, size_t size) {
  function off_t (line 137) | off_t get_stack_trace(int fd, size_t file_pos, uint8_t* buffer, size_t c...
  function testStackTracePrinter (line 149) | void testStackTracePrinter(StackTracePrinter& printer, int fd) {
  function TEST (line 170) | TEST(StackTraceTest, SafeStackTracePrinter) {
  function TEST (line 178) | TEST(StackTraceTest, FastStackTracePrinter) {
  function TEST (line 187) | TEST(StackTraceTest, TerseStackTracePrinter) {
  function TEST (line 196) | TEST(StackTraceTest, TerseFileAndLineStackTracePrinter) {
  function TEST (line 205) | TEST(StackTraceTest, TwoStepFastStackTracePrinter) {
  function TEST (line 214) | TEST(StackTraceTest, TwoStepTerseStackTracePrinter) {
  function TEST (line 223) | TEST(StackTraceTest, TwoStepTerseFileAndLineStackTracePrinter) {
  function FOLLY_NOINLINE (line 234) | FOLLY_NOINLINE void foo(FrameArray<frames>& addresses) {
  function FOLLY_NOINLINE (line 238) | FOLLY_NOINLINE void bar(FrameArray<frames>& addresses) {
  function FOLLY_NOINLINE (line 242) | FOLLY_NOINLINE void baz(FrameArray<frames>& addresses) {
  function TEST (line 247) | TEST(StackTraceTest, TerseFileAndLineStackTracePrinterOutput) {
  function FOLLY_ALWAYS_INLINE (line 269) | FOLLY_ALWAYS_INLINE void verifyAsyncStackTraces() {
  function FOLLY_NOINLINE (line 311) | FOLLY_NOINLINE void funcF() {
  function FOLLY_NOINLINE (line 315) | FOLLY_NOINLINE void funcE() {
  function FOLLY_NOINLINE (line 320) | FOLLY_NOINLINE folly::coro::Task<void> co_funcD() {
  function FOLLY_NOINLINE (line 325) | FOLLY_NOINLINE folly::coro::Task<void> co_funcC() {
  function FOLLY_NOINLINE (line 329) | FOLLY_NOINLINE void funcB2_blocking() {
  function FOLLY_NOINLINE (line 334) | FOLLY_NOINLINE void funcB1() {
  function FOLLY_NOINLINE (line 339) | FOLLY_NOINLINE folly::coro::Task<void> co_funcB0() {
  function FOLLY_NOINLINE (line 344) | FOLLY_NOINLINE folly::coro::Task<void> co_funcA2() {
  function FOLLY_NOINLINE (line 348) | FOLLY_NOINLINE folly::coro::Task<void> co_funcA1() {
  function FOLLY_NOINLINE (line 352) | FOLLY_NOINLINE folly::coro::Task<void> co_funcA0() {
  function TEST (line 357) | TEST(StackTraceTest, AsyncStackTraceSimple) {

FILE: folly/debugging/symbolizer/test/SymbolizedFrameTest.cpp
  function checkPath (line 25) | void checkPath(
  function TEST (line 51) | TEST(SymbolizedFrame, Path) {

FILE: folly/debugging/symbolizer/test/SymbolizerTest.cpp
  type folly (line 39) | namespace folly {
    type symbolizer (line 40) | namespace symbolizer {
      type test (line 41) | namespace test {
        function foo (line 50) | void foo() {}
        function FOLLY_NOINLINE (line 52) | FOLLY_NOINLINE void bar() {
        function TEST (line 60) | TEST(Symbolizer, Single) {
        function TEST (line 80) | TEST(Symbolizer, SingleCustomExePath) {
        class ElfCacheTest (line 123) | class ElfCacheTest : public testing::Test {
        function runElfCacheTest (line 145) | void runElfCacheTest(Symbolizer& symbolizer) {
        function TEST_F (line 159) | TEST_F(ElfCacheTest, ElfCache) {
        function TEST_F (line 167) | TEST_F(ElfCacheTest, SignalSafeElfCache) {
        function TEST (line 175) | TEST(SymbolizerTest, SymbolCache) {
        function expectFrameEq (line 203) | void expectFrameEq(
        function expectFramesEq (line 233) | void expectFramesEq(
        function printFrames (line 243) | void printFrames(const FrameArray<kNumFrames>& frames) {
        function TEST (line 254) | TEST(SymbolizerTest, InlineFunctionBasic) {
        function FOLLY_NOINLINE (line 293) | FOLLY_NOINLINE void call_B_A_lfind() {
        function TEST (line 298) | TEST(SymbolizerTest, InlineFunctionWithoutEnoughFrames) {
        function TEST (line 332) | TEST(SymbolizerTest, InlineFunctionInLexicalBlock) {
        function TEST (line 369) | TEST(SymbolizerTest, InlineFunctionInDifferentCompilationUnit) {
        function TEST (line 391) | TEST(SymbolizerTest, InlineClassMemberFunctionSameFile) {
        function TEST (line 419) | TEST(SymbolizerTest, StaticInlineClassMemberFunctionSameFile) {
        function TEST (line 447) | TEST(SymbolizerTest, InlineClassMemberFunctionInDifferentFile) {
        function TEST (line 475) | TEST(SymbolizerTest, StaticInlineClassMemberFunctionInDifferentFil...
        function TEST (line 504) | TEST(SymbolizerTest, InlineFunctionNoExtraFrames) {
        function TEST (line 528) | TEST(SymbolizerTest, InlineFunctionWithCache) {
        function functionWithTwoParameters (line 564) | int64_t functionWithTwoParameters(size_t a, int32_t b) {
        function TEST (line 568) | TEST(Dwarf, FindParameterNames) {
  function main (line 610) | int main(int argc, char** argv) {

FILE: folly/debugging/symbolizer/test/SymbolizerTestUtils-inl.h
  function namespace (line 34) | namespace folly {

FILE: folly/debugging/symbolizer/test/SymbolizerTestUtils.cpp
  type folly (line 21) | namespace folly {
    type symbolizer (line 22) | namespace symbolizer {
      type test (line 23) | namespace test {
        function testComparator (line 28) | int testComparator(const void* ap, const void* bp) {
        function inlineLTO_inlineA_lfind (line 47) | void inlineLTO_inlineA_lfind() {
        function call_inlineA_lfind (line 52) | void call_inlineA_lfind() {
        function call_inlineB_inlineA_lfind (line 56) | void call_inlineB_inlineA_lfind() {
        function call_inlineLTO_inlineA_lfind (line 60) | void call_inlineLTO_inlineA_lfind() {
        class ClassSameFile (line 64) | class ClassSameFile {
          method memberInline_inlineA_lfind (line 66) | __attribute__((__always_inline__)) void memberInline_inlineA_lfi...
          method staticMemberInline_inlineA_lfind (line 71) | __attribute__((__always_inline__)) static void
          method dummy (line 77) | int dummy() const { return dummy_; }
        function call_same_file_memberInline_inlineA_lfind (line 81) | void call_same_file_memberInline_inlineA_lfind() {
        function call_same_file_staticMemberInline_inlineA_lfind (line 86) | void call_same_file_staticMemberInline_inlineA_lfind() {
        function call_different_file_memberInline_inlineA_lfind (line 90) | void call_different_file_memberInline_inlineA_lfind() {
        function call_different_file_staticMemberInline_inlineA_lfind (line 95) | void call_different_file_staticMemberInline_inlineA_lfind() {
        function lexicalBlock_inlineB_inlineA_lfind (line 99) | void lexicalBlock_inlineB_inlineA_lfind() try {
        function call_lexicalBlock_inlineB_inlineA_lfind (line 105) | void call_lexicalBlock_inlineB_inlineA_lfind() {

FILE: folly/debugging/symbolizer/test/SymbolizerTestUtils.h
  function namespace (line 21) | namespace folly {

FILE: folly/debugging/symbolizer/test/tool/segv.cpp
  function has_opt (line 28) | static bool has_opt(
  function main (line 41) | int main(int const argc, char const* const* const argv) {

FILE: folly/debugging/symbolizer/tool/Addr2Line.cpp
  function shouldDemangle (line 47) | bool shouldDemangle() {
  function addr2line (line 51) | void addr2line(std::shared_ptr<ElfFile> elfFile, uintptr_t address) {
  function main (line 109) | int main(int argc, char* argv[]) {
  function main (line 128) | int main(int, char*[]) {

FILE: folly/debugging/symbolizer/tool/LibSegFault.cpp
  function install_handler (line 41) | static void __attribute__((constructor)) install_handler(void) {

FILE: folly/detail/AsyncTrace.cpp
  type folly (line 19) | namespace folly {
    type async_tracing (line 20) | namespace async_tracing {
      function FOLLY_ATTR_WEAK (line 21) | FOLLY_ATTR_WEAK void logSetGlobalCPUExecutor(Executor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 22) | FOLLY_ATTR_WEAK void logSetGlobalCPUExecutorToImmutable() noexcept {}
      function FOLLY_ATTR_WEAK (line 23) | FOLLY_ATTR_WEAK void logGetGlobalCPUExecutor(Executor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 24) | FOLLY_ATTR_WEAK void logGetImmutableCPUExecutor(Executor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 25) | FOLLY_ATTR_WEAK void logSetGlobalIOExecutor(IOExecutor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 26) | FOLLY_ATTR_WEAK void logGetGlobalIOExecutor(IOExecutor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 27) | FOLLY_ATTR_WEAK void logGetImmutableIOExecutor(IOExecutor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 28) | FOLLY_ATTR_WEAK void logSemiFutureVia(Executor*, Executor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 29) | FOLLY_ATTR_WEAK void logFutureVia(Executor*, Executor*) noexcept {}
      function FOLLY_ATTR_WEAK (line 30) | FOLLY_ATTR_WEAK void logBlockingOperation(std::chrono::milliseconds)...
      function FOLLY_ATTR_WEAK (line 31) | FOLLY_ATTR_WEAK void logSemiFutureDiscard(

FILE: folly/detail/AsyncTrace.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/AtomicHashUtils.h
  function namespace (line 26) | namespace folly {

FILE: folly/detail/AtomicUnorderedMapUtils.h
  function namespace (line 25) | namespace folly {

FILE: folly/detail/Avx2.cpp
  type folly (line 21) | namespace folly {
    type detail (line 22) | namespace detail {
      function FOLLY_DISABLE_SANITIZERS (line 26) | [[FOLLY_ATTR_GNU_FLATTEN]] FOLLY_DISABLE_SANITIZERS __m256i
      function FOLLY_DISABLE_SANITIZERS (line 31) | [[FOLLY_ATTR_GNU_FLATTEN]] FOLLY_DISABLE_SANITIZERS __m256i

FILE: folly/detail/Avx2.h
  function namespace (line 27) | namespace folly {

FILE: folly/detail/BenchmarkAdaptive.cpp
  type folly (line 27) | namespace folly {
    type detail (line 28) | namespace detail {
      function StabilityStats (line 34) | StabilityStats computeStabilityStats(
      function recalibrateIterCount (line 66) | size_t recalibrateIterCount(
      function FOLLY_NOINLINE (line 92) | FOLLY_NOINLINE std::string formatSampleStats(
      type BenchState (line 129) | struct BenchState {
        method timings (line 139) | std::vector<double> timings() const {
        method doRecalibrate (line 148) | void doRecalibrate(nanoseconds dur) {
        method runAndAddSampleRaw (line 160) | double runAndAddSampleRaw(
        method runAndAddSample (line 173) | void runAndAddSample(
        method isStable (line 192) | bool isStable() const {
        method checkDone (line 199) | bool checkDone() {
        method UserCounters (line 217) | UserCounters countersForEstimate(double estimate) const {
        method formatStats (line 230) | std::string formatStats() const {
      function FOLLY_NOINLINE (line 235) | FOLLY_NOINLINE void verboseLogInitial(
      function FOLLY_NOINLINE (line 245) | FOLLY_NOINLINE void verboseLogFinal(
      function FOLLY_NOINLINE (line 291) | FOLLY_NOINLINE std::string formatIntermediateReport(
      type SamplingLoop (line 341) | struct SamplingLoop {
        method FOLLY_NOINLINE (line 368) | FOLLY_NOINLINE void run() {
        method FOLLY_NOINLINE (line 409) | FOLLY_NOINLINE bool checkAllDone() {
      function AdaptiveResult (line 473) | AdaptiveResult runBenchmarksAdaptive(

FILE: folly/detail/BenchmarkAdaptive.h
  function namespace (line 28) | namespace folly {
  function class (line 53) | class SortedSamples {
  type StabilityStats (line 105) | struct StabilityStats {
  type AdaptiveOptions (line 120) | struct AdaptiveOptions {
  type AdaptiveResult (line 139) | struct AdaptiveResult {

FILE: folly/detail/DiscriminatedPtrDetail.h
  function namespace (line 24) | namespace folly {

FILE: folly/detail/FileUtilDetail.cpp
  type folly (line 22) | namespace folly {
    type fileutil_detail (line 23) | namespace fileutil_detail {
      function getTemporaryFilePathString (line 32) | std::string getTemporaryFilePathString(
      function getTemporaryFilePathStringWithoutTempDirectory (line 40) | std::string getTemporaryFilePathStringWithoutTempDirectory(
      function getTemporaryFilePathStringWithTemporaryDirectory (line 45) | std::string getTemporaryFilePathStringWithTemporaryDirectory(

FILE: folly/detail/FileUtilDetail.h
  function namespace (line 31) | namespace folly {

FILE: folly/detail/FileUtilVectorDetail.h
  function namespace (line 30) | namespace folly {

FILE: folly/detail/FingerprintPolynomial.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/Futex-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/detail/Futex.cpp
  type folly (line 33) | namespace folly {
    type detail (line 34) | namespace detail {
      function nativeFutexWake (line 61) | int nativeFutexWake(const void* addr, int count, uint32_t wakeMask) {
      function timeSpecFromTimePoint (line 82) | struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
      function FutexResult (line 101) | FutexResult nativeFutexWaitImpl(
      function emulatedFutexWake (line 169) | int emulatedFutexWake(const void* addr, int count, uint32_t waitMask) {
      function FutexResult (line 186) | FutexResult emulatedFutexWaitImpl(
      function futexWakeImpl (line 232) | int futexWakeImpl(
      function futexWakeImpl (line 241) | int futexWakeImpl(
      function FutexResult (line 246) | FutexResult futexWaitImpl(
      function FutexResult (line 261) | FutexResult futexWaitImpl(

FILE: folly/detail/Futex.h
  function namespace (line 26) | namespace folly {

FILE: folly/detail/GroupVarintDetail.h
  function uint32_t (line 33) | struct GroupVarintTraits<uint32_t> {

FILE: folly/detail/IPAddress.cpp
  type folly (line 23) | namespace folly {
    type detail (line 24) | namespace detail {
      function familyNameStrDefault (line 26) | std::string familyNameStrDefault(sa_family_t family) {
      function getNthMSBitImplThrow (line 30) | [[noreturn]] void getNthMSBitImplThrow(size_t bitCount, sa_family_t ...

FILE: folly/detail/IPAddress.h
  function namespace (line 25) | namespace folly {

FILE: folly/detail/IPAddressSource.h
  function namespace (line 40) | namespace folly {
  function writeIntegerString (line 187) | void writeIntegerString(IntegralType val, char** buffer) {
  function fastIpV4ToBufferUnsafe (line 221) | inline size_t fastIpV4ToBufferUnsafe(const in_addr& inAddr, char* str) {
  function std (line 236) | inline std::string fastIpv4ToString(const in_addr& inAddr) {
  function fastIpv4AppendToString (line 241) | inline void fastIpv4AppendToString(const in_addr& inAddr, std::string& o...
  function fastIpv6ToBufferUnsafe (line 246) | inline size_t fastIpv6ToBufferUnsafe(const in6_addr& in6Addr, char* str) {
  function std (line 269) | inline std::string fastIpv6ToString(const in6_addr& in6Addr) {
  function fastIpv6AppendToString (line 274) | inline void fastIpv6AppendToString(const in6_addr& in6Addr, std::string&...

FILE: folly/detail/Iterators.h
  function namespace (line 49) | namespace folly {

FILE: folly/detail/MPMCPipelineDetail.h
  function namespace (line 21) | namespace folly {
  function blockingRead (line 82) | uint64_t blockingRead(T& elem) noexcept {
  function read (line 88) | bool read(T& elem) noexcept { // only use on last stage, won't track ticket
  function tuple (line 111) | struct AmplificationProduct<std::tuple<>> {

FILE: folly/detail/MemoryIdler.cpp
  type folly (line 45) | namespace folly {
    type detail (line 46) | namespace detail {
      function pageSize (line 120) | static size_t pageSize() {
      function fetchStackLimits (line 125) | static void fetchStackLimits() {
      function FOLLY_NOINLINE (line 184) | FOLLY_NOINLINE static uintptr_t getStackPtr() {

FILE: folly/detail/MemoryIdler.h
  function namespace (line 28) | namespace folly {

FILE: folly/detail/PerfScoped.cpp
  type folly (line 33) | namespace folly {
    type detail (line 34) | namespace detail {
      function prependCommonArgs (line 42) | std::vector<std::string> prependCommonArgs(
      function subprocessOptions (line 56) | Subprocess::Options subprocessOptions() {
      class PerfScoped::PerfScopedImpl (line 64) | class PerfScoped::PerfScopedImpl {
        method PerfScopedImpl (line 66) | PerfScopedImpl(const std::vector<std::string>& args, std::string* ...
        method PerfScopedImpl (line 72) | PerfScopedImpl(const PerfScopedImpl&) = delete;
        method PerfScopedImpl (line 73) | PerfScopedImpl(PerfScopedImpl&&) = delete;
        method PerfScopedImpl (line 74) | PerfScopedImpl& operator=(const PerfScopedImpl&) = delete;
        method PerfScopedImpl (line 75) | PerfScopedImpl& operator=(PerfScopedImpl&&) = delete;
        method waitUntilAttached (line 89) | void waitUntilAttached() {
      class PerfScoped::PerfScopedImpl (line 116) | class PerfScoped::PerfScopedImpl {}
        method PerfScopedImpl (line 66) | PerfScopedImpl(const std::vector<std::string>& args, std::string* ...
        method PerfScopedImpl (line 72) | PerfScopedImpl(const PerfScopedImpl&) = delete;
        method PerfScopedImpl (line 73) | PerfScopedImpl(PerfScopedImpl&&) = delete;
        method PerfScopedImpl (line 74) | PerfScopedImpl& operator=(const PerfScopedImpl&) = delete;
        method PerfScopedImpl (line 75) | PerfScopedImpl& operator=(PerfScopedImpl&&) = delete;
        method waitUntilAttached (line 89) | void waitUntilAttached() {

FILE: folly/detail/PerfScoped.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/PolyDetail.h
  function namespace (line 37) | namespace detail {
  function namespace (line 73) | namespace detail {
  type _ (line 389) | struct _ {
  function ThrowThunk (line 396) | inline constexpr ThrowThunk throw_() noexcept {
  function inSitu (line 401) | constexpr bool inSitu() noexcept {
  function State (line 425) | enum class State : short { eEmpty, eInSitu, eOnHeap };
  function decltype (line 690) | static auto call(This&& _this, As&&... args)
  function Data (line 741) | Data const* data(PolyRoot<I> const& _this) noexcept {
  type MakePolyNode (line 775) | struct MakePolyNode {
  function Fun (line 807) | Fun T::* operator()(Fun T::* t) const
  function F (line 812) | F T::* operator()(F T::* t) const /* nolint */ volatile noexcept {
  function Fun (line 839) | constexpr Fun* operator()(Fun* t) const noexcept { return t; }
  function F (line 841) | F* operator()(F* t) const noexcept {
  function CCFun (line 858) | constexpr CCFun* operator()(CCFun* t) const /* nolint */ volatile noexce...
  type ModelsInterfaceFalse0_ (line 866) | struct ModelsInterfaceFalse0_
  type ModelsInterfaceFalse0_ (line 871) | struct ModelsInterfaceFalse0_

FILE: folly/detail/RangeCommon.cpp
  type folly (line 23) | namespace folly {
    type detail (line 25) | namespace detail {
      function qfind_first_byte_of_bitset (line 27) | size_t qfind_first_byte_of_bitset(
      function qfind_first_byte_of_byteset (line 41) | size_t qfind_first_byte_of_byteset(

FILE: folly/detail/RangeCommon.h
  function namespace (line 25) | namespace folly {

FILE: folly/detail/RangeSimd.cpp
  type folly (line 24) | namespace folly {
    type detail (line 25) | namespace detail {
      function qfind_first_byte_of_simd (line 27) | size_t qfind_first_byte_of_simd(

FILE: folly/detail/RangeSimd.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/RangeSse42.cpp
  type folly (line 29) | namespace folly {
    type detail (line 30) | namespace detail {
      function qfind_first_byte_of_sse42 (line 31) | size_t qfind_first_byte_of_sse42(
      function page_for (line 59) | static inline uintptr_t page_for(T* addr) {
      function nextAlignedIndex (line 63) | static inline size_t nextAlignedIndex(const char* arr) {
      function qfind_first_byte_of_needles16 (line 71) | size_t qfind_first_byte_of_needles16(
      function scanHaystackBlock (line 115) | size_t scanHaystackBlock(
      function qfind_first_byte_of_sse42 (line 162) | size_t qfind_first_byte_of_sse42(
    type detail (line 50) | namespace detail {
      function qfind_first_byte_of_sse42 (line 31) | size_t qfind_first_byte_of_sse42(
      function page_for (line 59) | static inline uintptr_t page_for(T* addr) {
      function nextAlignedIndex (line 63) | static inline size_t nextAlignedIndex(const char* arr) {
      function qfind_first_byte_of_needles16 (line 71) | size_t qfind_first_byte_of_needles16(
      function scanHaystackBlock (line 115) | size_t scanHaystackBlock(
      function qfind_first_byte_of_sse42 (line 162) | size_t qfind_first_byte_of_sse42(
  type folly (line 49) | namespace folly {
    type detail (line 30) | namespace detail {
      function qfind_first_byte_of_sse42 (line 31) | size_t qfind_first_byte_of_sse42(
      function page_for (line 59) | static inline uintptr_t page_for(T* addr) {
      function nextAlignedIndex (line 63) | static inline size_t nextAlignedIndex(const char* arr) {
      function qfind_first_byte_of_needles16 (line 71) | size_t qfind_first_byte_of_needles16(
      function scanHaystackBlock (line 115) | size_t scanHaystackBlock(
      function qfind_first_byte_of_sse42 (line 162) | size_t qfind_first_byte_of_sse42(
    type detail (line 50) | namespace detail {
      function qfind_first_byte_of_sse42 (line 31) | size_t qfind_first_byte_of_sse42(
      function page_for (line 59) | static inline uintptr_t page_for(T* addr) {
      function nextAlignedIndex (line 63) | static inline size_t nextAlignedIndex(const char* arr) {
      function qfind_first_byte_of_needles16 (line 71) | size_t qfind_first_byte_of_needles16(
      function scanHaystackBlock (line 115) | size_t scanHaystackBlock(
      function qfind_first_byte_of_sse42 (line 162) | size_t qfind_first_byte_of_sse42(

FILE: folly/detail/RangeSse42.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/SimpleSimdStringUtils.cpp
  type folly (line 22) | namespace folly {
    type detail (line 23) | namespace detail {
      function simdHasSpaceOrCntrlSymbols (line 25) | bool simdHasSpaceOrCntrlSymbols(folly::StringPiece s) {

FILE: folly/detail/SimpleSimdStringUtils.h
  function namespace (line 21) | namespace folly {

FILE: folly/detail/SimpleSimdStringUtilsImpl.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/Singleton.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/SlowFingerprint.h
  function namespace (line 23) | namespace folly {

FILE: folly/detail/SocketFastOpen.cpp
  type folly (line 25) | namespace folly {
    type detail (line 26) | namespace detail {
      function tfo_sendmsg (line 44) | ssize_t tfo_sendmsg(NetworkSocket sockfd, const struct msghdr* msg, ...
      function tfo_enable (line 49) | int tfo_enable(NetworkSocket sockfd, size_t max_queue_size) {
      function tfo_succeeded (line 54) | bool tfo_succeeded(NetworkSocket sockfd) {
      function PlatformTFOSettings (line 67) | PlatformTFOSettings tfo_platform_availability() {
      function tfo_sendmsg (line 103) | ssize_t tfo_sendmsg(NetworkSocket sockfd, const struct msghdr* msg, ...
      function tfo_enable (line 127) | int tfo_enable(NetworkSocket sockfd, size_t max_queue_size) {
      function tfo_succeeded (line 136) | bool tfo_succeeded(NetworkSocket /* sockfd */) {
      function PlatformTFOSettings (line 141) | PlatformTFOSettings tfo_platform_availability() {
      function tfo_sendmsg (line 149) | ssize_t tfo_sendmsg(
      function tfo_enable (line 157) | int tfo_enable(NetworkSocket /* sockfd */, size_t /* max_queue_size ...
      function tfo_succeeded (line 162) | bool tfo_succeeded(NetworkSocket /* sockfd */) {
      function PlatformTFOSettings (line 167) | PlatformTFOSettings tfo_platform_availability() {

FILE: folly/detail/SocketFastOpen.h
  function namespace (line 31) | namespace folly {

FILE: folly/detail/SplitStringSimd.h
  function namespace (line 22) | namespace folly {

FILE: folly/detail/SplitStringSimdImpl.h
  function namespace (line 35) | namespace folly {
  function emplaceBack (line 70) | static void emplaceBack(
  function outputStringsFoMmask (line 79) | static void outputStringsFoMmask(
  function step (line 105) | bool step(
  function simdSplitByChar (line 116) | static void simdSplitByChar(
  function const (line 141) | void operator()(

FILE: folly/detail/Sse.cpp
  type folly (line 21) | namespace folly {
    type detail (line 22) | namespace detail {
      function FOLLY_DISABLE_SANITIZERS (line 26) | [[FOLLY_ATTR_GNU_FLATTEN]] FOLLY_DISABLE_SANITIZERS __m128i
      function FOLLY_DISABLE_SANITIZERS (line 31) | [[FOLLY_ATTR_GNU_FLATTEN]] FOLLY_DISABLE_SANITIZERS __m128i

FILE: folly/detail/Sse.h
  function namespace (line 27) | namespace folly {

FILE: folly/detail/StaticSingletonManager.cpp
  type folly (line 25) | namespace folly {
    type detail (line 26) | namespace detail {
      class StaticSingletonManagerWithRttiImpl (line 30) | class StaticSingletonManagerWithRttiImpl {
        method Self (line 35) | static Self& instance() {
        type Entry (line 60) | struct Entry {
        method Entry (line 81) | Entry* get_existing_entry(std::type_info const& key) {
        method Entry (line 87) | Entry& create_entry(std::type_info const& key) {

FILE: folly/detail/StaticSingletonManager.h
  function namespace (line 30) | namespace folly {
  function ArgCreate (line 274) | static ArgCreate<noexcept(T())> arg{tag<T, Tag>};

FILE: folly/detail/ThreadLocalDetail.cpp
  type folly (line 35) | namespace folly {
    type threadlocal_detail (line 36) | namespace threadlocal_detail {
      type murmur_hash_fn (line 40) | struct murmur_hash_fn {
      class PthreadKeyUnregister (line 231) | class PthreadKeyUnregister {
        method registerKey (line 246) | static void registerKey(pthread_key_t key) { instance_.registerKey...
        method PthreadKeyUnregister (line 254) | constexpr PthreadKeyUnregister() : lock_(), size_(0), keys_() {}
        method registerKeyImpl (line 256) | void registerKeyImpl(pthread_key_t key) {
      function ThreadEntryList (line 279) | ThreadEntryList* StaticMetaBase::getThreadEntryList() {
      function ThreadEntry (line 316) | ThreadEntry* StaticMetaBase::allocateNewThreadEntry() {
      function ThreadEntrySet (line 523) | ThreadEntrySet StaticMetaBase::popThreadEntrySetAndClearElementPtrs(
      function ElementWrapper (line 612) | ElementWrapper* StaticMetaBase::reallocate(
      function FOLLY_NOINLINE (line 728) | FOLLY_NOINLINE void StaticMetaBase::ensureThreadEntryIsInSet(
      type GlibcThreadLocalInit (line 800) | struct GlibcThreadLocalInit {
        type GlibcThreadLocalInitHelper (line 801) | struct GlibcThreadLocalInitHelper {
          method FOLLY_NOINLINE (line 802) | FOLLY_NOINLINE ~GlibcThreadLocalInitHelper() {
        method GlibcThreadLocalInit (line 806) | GlibcThreadLocalInit() {

FILE: folly/detail/ThreadLocalDetail.h
  function namespace (line 51) | namespace folly {
  function guard (line 184) | auto guard = makeGuard([&] { d(p, TLPDestructionMode::THIS_THREAD); }
  function cleanup (line 193) | void cleanup() noexcept {
  type ThreadEntry (line 215) | struct ThreadEntry {
  function ThreadEntryList (line 218) | ThreadEntryList* list{nullptr};
  type FakeUniqueInstance (line 530) | struct FakeUniqueInstance {
  type LocalCache (line 596) | struct LocalCache {
  function LocalCache (line 603) | static LocalCache& getLocalCache() {
  function FOLLY_ALWAYS_INLINE (line 608) | FOLLY_ALWAYS_INLINE static ElementWrapper& get(EntryID* ent) {
  function FOLLY_ALWAYS_INLINE (line 629) | FOLLY_ALWAYS_INLINE static ThreadEntry* getThreadEntry(EntryID* ent) {
  function FOLLY_NOINLINE (line 651) | FOLLY_NOINLINE static ThreadEntry* getThreadEntrySlowReserve(EntryID* en...
  function ThreadEntry (line 664) | static ThreadEntry* getThreadEntrySlow() {
  function preFork (line 677) | static bool preFork() {
  function onForkParent (line 691) | static void onForkParent() {
  function onForkChild (line 698) | static void onForkChild() {

FILE: folly/detail/TrapOnAvx512.cpp
  type folly::detail (line 24) | namespace folly::detail {
    function detectTrapOnAvx512Helper (line 27) | void detectTrapOnAvx512Helper() {
    function hasTrapOnAvx512 (line 32) | bool hasTrapOnAvx512() {
    function hasTrapOnAvx512 (line 37) | bool hasTrapOnAvx512() {

FILE: folly/detail/TrapOnAvx512.h
  function namespace (line 19) | namespace folly::detail {

FILE: folly/detail/TurnSequencer.h
  function isTurn (line 85) | bool isTurn(const uint32_t turn) const noexcept {
  function TryWaitResult (line 90) | enum class TryWaitResult { SUCCESS, PAST, TIMEDOUT };

FILE: folly/detail/TypeList.h
  function namespace (line 74) | namespace folly {
  function namespace (line 384) | namespace impl {
  function namespace (line 422) | namespace impl {
  function namespace (line 442) | namespace impl {
  type Join_ (line 520) | struct Join_ {

FILE: folly/detail/UniqueInstance.cpp
  type folly (line 29) | namespace folly {
    type detail (line 30) | namespace detail {
      function equal (line 34) | bool equal(std::type_info const& a, std::type_info const& b) {
      type PtrRange (line 45) | struct PtrRange {
      function PtrRange (line 51) | PtrRange ptr_range_key(Value value) {
      function PtrRange (line 57) | PtrRange ptr_range_mapped(Value value) {
      function equal (line 62) | bool equal(PtrRange lhs, PtrRange rhs) {
      function parse_demangled_tag_name (line 67) | std::string_view parse_demangled_tag_name(std::string_view str) {
      function join (line 79) | std::string join(PtrRange types) {
      function fbstring (line 91) | fbstring render_tmpl(Value value) {
      function render (line 96) | std::string render(Value value) {

FILE: folly/detail/UniqueInstance.h
  function namespace (line 25) | namespace folly {

FILE: folly/detail/base64_detail/Base64Api.cpp
  type folly::detail::base64_detail (line 23) | namespace folly::detail::base64_detail {
    function Base64RuntimeImpl (line 24) | Base64RuntimeImpl base64EncodeSelectImplementation() {

FILE: folly/detail/base64_detail/Base64Api.h
  function namespace (line 25) | namespace folly::detail::base64_detail {
  function Base64DecodeResult (line 73) | inline Base64DecodeResult base64DecodeRuntime(
  function Base64DecodeResult (line 78) | inline constexpr Base64DecodeResult base64Decode(
  function Base64DecodeResult (line 87) | inline Base64DecodeResult base64URLDecodeRuntime(
  function Base64DecodeResult (line 92) | inline constexpr Base64DecodeResult base64URLDecode(
  function Base64DecodeResult (line 106) | inline constexpr Base64DecodeResult base64PHPStrictDecode(

FILE: folly/detail/base64_detail/Base64Common.h
  function namespace (line 24) | namespace folly::detail::base64_detail {

FILE: folly/detail/base64_detail/Base64Constants.h
  function namespace (line 22) | namespace folly::detail::base64_detail::constants {

FILE: folly/detail/base64_detail/Base64HiddenConstants.h
  function namespace (line 24) | namespace folly::detail::base64_detail::constants {
  function kValidHighByLowNibble (line 84) | constexpr auto kValidHighByLowNibble = [] {

FILE: folly/detail/base64_detail/Base64SWAR.cpp
  type folly::detail::base64_detail (line 25) | namespace folly::detail::base64_detail {
    function base64DecodeSWARMainLoop (line 104) | std::uint32_t base64DecodeSWARMainLoop(
    function Base64DecodeResult (line 127) | Base64DecodeResult base64DecodeSWAR(
    function Base64DecodeResult (line 144) | Base64DecodeResult base64URLDecodeSWAR(

FILE: folly/detail/base64_detail/Base64SWAR.h
  function namespace (line 21) | namespace folly::detail::base64_detail {

FILE: folly/detail/base64_detail/Base64Scalar.h
  function namespace (line 27) | namespace folly::detail::base64_detail {
  function decodeMainLoop (line 107) | static constexpr std::uint8_t decodeMainLoop(
  function Base64DecodeResult (line 174) | constexpr Base64DecodeResult base64DecodeScalar(
  function base64URLDecodeStripValidPadding (line 197) | constexpr void base64URLDecodeStripValidPadding(const char* f, const cha...
  function Base64DecodeResult (line 240) | constexpr Base64DecodeResult base64URLDecodeScalar(

FILE: folly/detail/base64_detail/Base64Simd.h
  function namespace (line 29) | namespace folly::detail::base64_detail {

FILE: folly/detail/base64_detail/Base64_SSE4_2.cpp
  type folly::detail::base64_detail (line 25) | namespace folly::detail::base64_detail {
    function Base64DecodeResult (line 35) | Base64DecodeResult base64Decode_SSE4_2(

FILE: folly/detail/base64_detail/Base64_SSE4_2.h
  function namespace (line 24) | namespace folly::detail::base64_detail {

FILE: folly/detail/base64_detail/Base64_SSE4_2_Platform.h
  function namespace (line 26) | namespace folly::detail::base64_detail {

FILE: folly/detail/base64_detail/test/Base64AgainstScalarTest.cpp
  type folly::detail::base64_detail (line 29) | namespace folly::detail::base64_detail {
    type Base64RandomTest (line 34) | struct Base64RandomTest : ::testing::Test {
      method generateBytes (line 35) | std::string generateBytes() {
    function callEncode (line 53) | std::string callEncode(std::string_view bytes, Encode encode) {
    function callDecode (line 60) | auto callDecode(std::string_view encoded, Decode decode)
    function TEST_F (line 103) | TEST_F(Base64RandomTest, RandomTest) {
    function TEST_F (line 132) | TEST_F(Base64RandomTest, RandomDecodeTest) {

FILE: folly/detail/base64_detail/test/Base64PlatformTest.cpp
  type folly::detail::base64_detail (line 27) | namespace folly::detail::base64_detail {
    function expectedEncodeToIndexes (line 31) | std::array<std::uint8_t, 16> expectedEncodeToIndexes(
    function expectedPackIndexesToBytes (line 61) | std::array<std::uint8_t, 16> expectedPackIndexesToBytes(
    function expectedLookupByIndex (line 95) | std::array<std::uint8_t, 16> expectedLookupByIndex(
    function expectedSuccessfullDecodeToIndex (line 106) | std::array<std::uint8_t, 16> expectedSuccessfullDecodeToIndex(
    type Base64PlatformTest (line 128) | struct Base64PlatformTest : ::testing::Test {
      method RegBytesArray (line 132) | static RegBytesArray actualEncodeToIndexes(RegBytesArray from) {
      method RegBytesArray (line 139) | static RegBytesArray actualLookupByIndex(RegBytesArray from) {
      method RegBytesArray (line 147) | static RegBytesArray actualSuccesfullDecodeToIndex(RegBytesArray fro...
      method RegBytesArray (line 156) | static RegBytesArray actualPackIndexesToBytes(RegBytesArray from) {
    function TYPED_TEST (line 166) | TYPED_TEST(Base64PlatformTest, EncodeToIndexes) {
    function TYPED_TEST (line 180) | TYPED_TEST(Base64PlatformTest, IndexLookup) {
    function TYPED_TEST (line 195) | TYPED_TEST(Base64PlatformTest, errorDetection) {
    function TYPED_TEST (line 230) | TYPED_TEST(Base64PlatformTest, decodeToIndexSuccess) {
    function TYPED_TEST (line 250) | TYPED_TEST(Base64PlatformTest, packIndexesToBytes) {

FILE: folly/detail/base64_detail/test/Base64SpecialCasesTest.cpp
  type folly::detail::base64_detail (line 29) | namespace folly::detail::base64_detail {
    type TestCase (line 32) | struct TestCase {
    type TestCaseOnStack (line 39) | struct TestCaseOnStack : TestCase {
      method TestCaseOnStack (line 40) | constexpr TestCaseOnStack(
    function byteRangeToString (line 103) | std::string byteRangeToString(std::string_view data) {
    function staticTests (line 120) | constexpr bool staticTests(TestRunner testRunner) {
    function I (line 130) | constexpr I fill_n(I f, N n, V v) {
    function manyZeroesTests (line 138) | constexpr bool manyZeroesTests(TestRunner testRunner) {
    function runEncodeTests (line 181) | constexpr bool runEncodeTests(TestRunner testRunner) {
    type DecoderType (line 194) | enum DecoderType { URLDecoder, RegularDecoder, PHPStrictDecoder }
    type ConstexprTester (line 197) | struct ConstexprTester {
      method encodeTest (line 198) | constexpr bool encodeTest(TestCase test) const {
      method decodeTest (line 217) | constexpr bool decodeTest(TestCase test) const {
      method encodeURLTest (line 238) | constexpr bool encodeURLTest(TestCase test) const {
      method decodeURLTest (line 257) | constexpr bool decodeURLTest(TestCase test) const {
      method decodePHPTest (line 279) | constexpr bool decodePHPTest(TestCase test) const {
      method sizeTests (line 300) | constexpr bool sizeTests(TestCase test) const {
    type SimdTester (line 357) | struct SimdTester {
      method encodeTest (line 366) | bool encodeTest(TestCase test) const {
      method encodeURLTest (line 378) | bool encodeURLTest(TestCase test) const {
      method decodeTest (line 390) | bool decodeTest(TestCase test) const {
      method decodeURLTest (line 410) | bool decodeURLTest(TestCase test) const {
    function TEST (line 436) | TEST(Base64, ConstexprTests) {
    function TEST (line 447) | TEST(Base64, SpecialCases) {
    type DecodingErrorDetectionTest (line 469) | struct DecodingErrorDetectionTest {
    function decodedSize (line 526) | constexpr size_t decodedSize(std::string_view in) {
    function triggerASANOnBadDecode (line 540) | void triggerASANOnBadDecode(std::string_view in, Decoder decoder) {
    function decodingErrorDetectionTest (line 546) | constexpr bool decodingErrorDetectionTest(Decoder decoder) {
    function TEST (line 651) | TEST(Base64, DecodingErrorDetection) {

FILE: folly/detail/test/AsyncTraceTest.cpp
  function TEST (line 21) | TEST(FollyCountersTest, Trivial) {

FILE: folly/detail/test/BenchmarkAdaptiveTest.cpp
  function TEST (line 30) | TEST(SortedSamplesTest, SingleSample) {
  function TEST (line 38) | TEST(SortedSamplesTest, PercentileInterpolation) {
  function TEST (line 54) | TEST(SortedSamplesTest, EmptySamplesDeath) {
  function TEST (line 60) | TEST(SortedSamplesTest, PercentileCIBasic) {
  function TEST (line 80) | TEST(SortedSamplesTest, PercentileCIExtremesCollapse) {
  function TEST (line 95) | TEST(SortedSamplesTest, RelWidthWithZeroEstimate) {
  function TEST (line 103) | TEST(SortedSamplesTest, PercentileCIRelWidthWithTooFewSamples) {
  function TEST (line 109) | TEST(SortedSamplesTest, PercentileCIRequiresTwoSamples) {
  function TEST (line 117) | TEST(StabilityStatsTest, StableWithIdenticalHalves) {
  function TEST (line 125) | TEST(StabilityStatsTest, UnstableWithDisjointHalves) {
  function TEST (line 132) | TEST(StabilityStatsTest, RequiresFourSamples) {
  function TEST (line 139) | TEST(StabilityStatsTest, EpsilonToleranceForSubNsValues) {
  function TEST (line 146) | TEST(StabilityStatsTest, StableWhenDriftBelowTargetPrecision) {
  function AdaptiveOptions (line 166) | AdaptiveOptions defaultTestOptions() {
  function BenchmarkFun (line 179) | BenchmarkFun defaultBaseline() {
  function BenchmarkFun (line 184) | BenchmarkFun noOpSuspenderBaseline() {
  function BenchmarkFun (line 189) | BenchmarkFun simpleBench(std::chrono::nanoseconds nsPerIter) {
  function BenchmarkRegistration (line 196) | BenchmarkRegistration makeReg(
  function toPtrs (line 202) | std::vector<const BenchmarkRegistration*> toPtrs(
  function TEST (line 213) | TEST(AdaptiveTest, EmptyBenchmarks) {
  function TEST (line 220) | TEST(AdaptiveTest, SingleBenchmark) {
  function TEST (line 235) | TEST(AdaptiveTest, MultipleBenchmarks) {
  function TEST (line 249) | TEST(AdaptiveTest, BaselineSubtractionClampsToZero) {
  function TEST (line 264) | TEST(AdaptiveTest, EqualSamplingAcrossBenchmarks) {
  function TEST (line 302) | TEST(AdaptiveTest, ConvergenceWithVariance) {
  function TEST (line 328) | TEST(AdaptiveTest, MinSamplesGuaranteed) {
  function TEST (line 353) | TEST(AdaptiveTest, HighVarianceHitsTimeout) {
  function TEST (line 389) | TEST(AdaptiveTest, UserCountersFromPercentileMatchedSample) {
  function TEST (line 419) | TEST(AdaptiveTest, MinSecsEnforcesMinimumDuration) {
  function TEST (line 436) | TEST(AdaptiveTest, SuspenderOverheadCorrection) {
  function TEST (line 457) | TEST(AdaptiveTest, SuspenderOverheadClampsToZero) {
  function TEST (line 478) | TEST(RecalibrateIterCountTest, Basic) {

FILE: folly/detail/test/FileUtilDetailTest.cpp
  type folly (line 20) | namespace folly {
    type fileutil_detail (line 21) | namespace fileutil_detail {
      class FileUtilDetailTest (line 23) | class FileUtilDetailTest : public ::testing::Test {}
      function TEST_F (line 25) | TEST_F(FileUtilDetailTest, TemporaryPathWithoutTemporaryDirectory) {
      function TEST_F (line 31) | TEST_F(FileUtilDetailTest, TemporaryPathWithoutTemporaryDirectoryRel...
      function TEST_F (line 37) | TEST_F(
      function TEST_F (line 46) | TEST_F(

FILE: folly/detail/test/PerfScopedTest.cpp
  type folly (line 29) | namespace folly {
    type detail (line 30) | namespace detail {
      function retryWithTimeOuts (line 37) | void retryWithTimeOuts(Test test) {
      function TEST (line 47) | TEST(PerfScopedTest, Stat) {
      function TEST (line 63) | TEST(PerfScopedTest, Move) {
      function TEST (line 87) | TEST(PerfScopedTest, Record) {
      function TEST (line 102) | TEST(PerfScopedTest, StatNoOutput) {

FILE: folly/detail/test/SimpleSimdStringUtilsTest.cpp
  type folly (line 23) | namespace folly {
    type detail (line 24) | namespace detail {
      function hasSpaceOrCntrlSymbolsForPlatform (line 28) | bool hasSpaceOrCntrlSymbolsForPlatform(folly::StringPiece s) {
      function testHasSpaceOrCntrlSymbols (line 32) | void testHasSpaceOrCntrlSymbols(folly::StringPiece s, bool r) {
      function TEST (line 59) | TEST(SpaceOrCntrl, One) {
      function TEST (line 63) | TEST(SpaceOrCntrl, EachSymbol) {
      function TEST (line 74) | TEST(SpaceOrCntrl, ExplicitExamples) {

FILE: folly/detail/test/SplitStringSimdTest.cpp
  type folly (line 28) | namespace folly {
    type detail (line 29) | namespace detail {
      function TEST (line 32) | TEST(SplitStringSimdTest, ByCharScalarKeepEmpty) {
      function TEST (line 51) | TEST(SplitStringSimdTest, ByCharScalarIgnoreEmpty) {
      function testContainerSV (line 70) | void testContainerSV(
      function testAllContainersOfSVs (line 85) | void testAllContainersOfSVs(
      function testContainersOfStrings (line 108) | void testContainersOfStrings(
      function testAllContainersOfStrings (line 121) | void testAllContainersOfStrings(
      function runTestStringSplitOneType (line 131) | void runTestStringSplitOneType(folly::StringPiece s) {
      function runTestStringSplit (line 173) | void runTestStringSplit(folly::StringPiece s) {
      function repeat (line 178) | std::string repeat(std::string_view substr, std::size_t n) {
      function TEST (line 187) | TEST(SplitStringSimd, ByChar) {
      function TEST (line 218) | TEST(SplitStringSimd, ByCharTestDifferentOffsets) {

FILE: folly/detail/test/StaticSingletonManagerTest.cpp
  type folly (line 22) | namespace folly {
    type detail (line 23) | namespace detail {
      function FOLLY_ATTR_WEAK (line 25) | FOLLY_ATTR_WEAK void check_doit() {}
      type MayThrow (line 29) | struct MayThrow {
        method FOLLY_NOINLINE (line 30) | FOLLY_NOINLINE MayThrow() noexcept(Noexcept) { check_doit(); }
        method FOLLY_NOINLINE (line 31) | FOLLY_NOINLINE ~MayThrow() { check_doit(); }
      function FOLLY_KEEP (line 35) | FOLLY_KEEP int* check() {
      function FOLLY_KEEP (line 39) | FOLLY_KEEP void* check_throw() {
      function FOLLY_KEEP (line 43) | FOLLY_KEEP void* check_nothrow() {
      type StaticSingletonManagerTest (line 48) | struct StaticSingletonManagerTest : public testing::TestWithParam<Im...
      type Tag (line 52) | struct Tag {}
      function TYPED_TEST_P (line 57) | TYPED_TEST_P(StaticSingletonManagerTest, example) {
      type StaticSingletonManagerTestType (line 99) | struct StaticSingletonManagerTestType : StaticSingletonManager {}
      type CreateGlobalTest (line 103) | struct CreateGlobalTest : testing::Test {}
      function TEST_F (line 105) | TEST_F(CreateGlobalTest, example) {

FILE: folly/detail/test/ThreadLocalBenchmark.cpp
  type folly (line 25) | namespace folly {
    type threadlocal_detail (line 26) | namespace threadlocal_detail {
      type ThreadLocalTestHelper (line 29) | struct ThreadLocalTestHelper {
      function measureAccessAllThreads (line 35) | void measureAccessAllThreads(
  function accessAllThreads (line 99) | void accessAllThreads(
  function main (line 112) | int main(int argc, char* argv[]) {

FILE: folly/detail/test/ThreadLocalDetailTest.cpp
  type folly (line 23) | namespace folly {
    type threadlocal_detail (line 24) | namespace threadlocal_detail {
      class ThreadLocalDetailTest (line 26) | class ThreadLocalDetailTest : public ::testing::Test {}
      type ThreadLocalTestHelper (line 29) | struct ThreadLocalTestHelper {
      function TEST_F (line 35) | TEST_F(ThreadLocalDetailTest, Basic) {
      function TEST_F (line 67) | TEST_F(ThreadLocalDetailTest, MultiThreadedTest) {
      function TEST_F (line 125) | TEST_F(ThreadLocalDetailTest, TLObjectsChurn) {
      function TEST_F (line 192) | TEST_F(ThreadLocalDetailTest, TLResetAndThreadExitRace) {
      function TEST_F (line 242) | TEST_F(ThreadLocalDetailTest, accessAllAndRealloc) {

FILE: folly/detail/test/TrapOnAvx512TestNegative.cpp
  type folly::detail (line 21) | namespace folly::detail {
    function TEST (line 25) | TEST(TrapOnAvx512TestNegative, Basic) {

FILE: folly/detail/test/TypeListTest.cpp
  type IsApplicable_ (line 26) | struct IsApplicable_ : std::false_type {}
  type IsApplicable_<T, TypeList<Ts...>, void_t<MetaApply<T, Ts...>>> (line 28) | struct IsApplicable_<T, TypeList<Ts...>, void_t<MetaApply<T, Ts...>>>
  function TEST (line 34) | TEST(TypeList, Basic) {
  function TEST (line 43) | TEST(TypeList, Defer) {
  function TEST (line 50) | TEST(TypeList, Transform) {
  type Cons (line 62) | struct Cons {}
  function TEST (line 64) | TEST(TypeList, Fold) {
  function TEST (line 90) | TEST(TypeList, Unique) {
  function TEST (line 98) | TEST(TypeList, PushFront) {
  function TEST (line 107) | TEST(TypeList, PushBack) {
  function TEST (line 116) | TEST(TypeList, Join) {

FILE: folly/detail/test/UniqueInstanceTest.cpp
  type Key1 (line 25) | struct Key1
  type Key2 (line 26) | struct Key2
  type TagA (line 27) | struct TagA
  type TagB (line 28) | struct TagB
  type Template0 (line 31) | struct Template0 {}
  type Template1 (line 33) | struct Template1 {}
  type folly (line 35) | namespace folly {
    type detail (line 36) | namespace detail {
      class UniqueInstanceDeathTest (line 38) | class UniqueInstanceDeathTest : public testing::Test {}
      function make (line 41) | static void make(tag_t<Key...> key, tag_t<Mapped...> mapped) {
      function TEST_F (line 45) | TEST_F(UniqueInstanceDeathTest, basic) {

FILE: folly/detail/test/tuple_test.cpp
  function FOLLY_PUSH_WARNING (line 31) | FOLLY_PUSH_WARNING

FILE: folly/detail/thread_local_globals.cpp
  type folly::detail (line 25) | namespace folly::detail {
    type thread_is_dying_global (line 43) | struct thread_is_dying_global {
      method thread_is_dying_global (line 46) | thread_is_dying_global() {
    function thread_is_dying (line 57) | bool thread_is_dying() {
    function thread_is_dying_mark (line 62) | void thread_is_dying_mark() {

FILE: folly/detail/thread_local_globals.h
  function namespace (line 19) | namespace folly::detail {

FILE: folly/detail/tuple.h
  function namespace (line 119) | namespace folly::detail::lite_tuple {
  function FOLLY_ALWAYS_INLINE (line 164) | FOLLY_ALWAYS_INLINE constexpr auto forward_as_tuple(auto&&... a) noexcept {
  function FOLLY_ALWAYS_INLINE (line 168) | FOLLY_ALWAYS_INLINE constexpr decltype(auto) apply(auto&& fn, auto&& tup) {
  function FOLLY_ALWAYS_INLINE (line 176) | FOLLY_ALWAYS_INLINE constexpr decltype(auto) reverse_apply(
  function namespace (line 196) | namespace detail {
  function namespace (line 269) | namespace folly {
  function namespace (line 275) | namespace std {

FILE: folly/docs/examples/folly/CancellationCallback.cpp
  function TEST (line 23) | TEST(CancellationCallback, demo) {

FILE: folly/docs/examples/folly/CancellationSource.cpp
  function TEST (line 23) | TEST(CancellationSource, demo) {

FILE: folly/docs/examples/folly/CancellationToken.cpp
  function TEST (line 23) | TEST(CancellationToken, demo) {

FILE: folly/docs/examples/folly/DynamicConverter.cpp
  function TEST (line 23) | TEST(converter, demo) {

FILE: folly/docs/examples/folly/ExecutorGuide.cpp
  class LoggingExecutor (line 24) | class LoggingExecutor : public folly::Executor {
    method add (line 26) | void add(folly::Func f) override {
    method step (line 31) | void step() { e_.step(); }
  function baz (line 37) | folly::coro::Task<int> baz() {
  function foo (line 41) | folly::coro::Task<int> foo(folly::coro::Baton& b, int x) {
  function bar (line 52) | int bar(int x) {
  function main (line 58) | int main() {

FILE: folly/docs/examples/folly/File.cpp
  function TEST (line 20) | TEST(File, Demo) {

FILE: folly/docs/examples/folly/Format.cpp
  function TEST (line 20) | TEST(Format, demo) {

FILE: folly/docs/examples/folly/Function.cpp
  function TEST (line 20) | TEST(Function, demo) {

FILE: folly/docs/examples/folly/Likely.cpp
  function TEST (line 21) | TEST(likely, demo) {

FILE: folly/docs/examples/folly/MapUtil.cpp
  function TEST (line 24) | TEST(maputil, demo) {

FILE: folly/docs/examples/folly/ScopeGuard.cpp
  function TEST (line 20) | TEST(scopeGuard, demo) {
  function TEST (line 29) | TEST(scopeExit, demo) {

FILE: folly/docs/examples/folly/ScopeGuard2.cpp
  function TEST (line 20) | TEST(scopeGuard, demo) {

FILE: folly/docs/examples/folly/ScopedEventBaseThread.cpp
  function TEST (line 28) | TEST(ScopedEventBaseThread, demo1) {

FILE: folly/docs/examples/folly/ScopedEventBaseThread2.cpp
  function TEST (line 36) | TEST(ScopedEventBaseThread, demo1) {
  function TEST (line 53) | TEST(ScopedEventBaseThread, demo2) {

FILE: folly/docs/examples/folly/Synchronized.cpp
  function TEST (line 21) | TEST(Synchronized, demo) {

FILE: folly/docs/examples/folly/container/Array.cpp
  function TEST (line 22) | TEST(array, fromlist) {

FILE: folly/docs/examples/folly/coro/AsyncScope.cpp
  function CO_TEST (line 22) | CO_TEST(AsyncScope, demo) {

FILE: folly/docs/examples/folly/coro/CancellableAsyncScope.cpp
  function CO_TEST (line 22) | CO_TEST(CancellableAsyncScope, demo) {

FILE: folly/docs/examples/folly/coro/DetachOnCancel.cpp
  function CO_TEST (line 29) | CO_TEST(CodeExamples, demoDetachOnCancel) {

FILE: folly/docs/examples/folly/coro/Promise.cpp
  function sleepAndNotify (line 27) | auto sleepAndNotify(std::function<void(int)>&& cob) {
  function CO_TEST (line 36) | CO_TEST(CodeExamples, promiseFuturePoc) {

FILE: folly/docs/examples/folly/coro/Retry.cpp
  function CO_TEST (line 26) | CO_TEST(CodeExamples, retryTest) {

FILE: folly/docs/examples/folly/coro/Task.cpp
  function co_generateFortyTwo (line 26) | Task<int> co_generateFortyTwo() {
  function co_answerToLife (line 30) | Task<int> co_answerToLife() {
  function TEST (line 35) | TEST(Task, demo) {

FILE: folly/docs/examples/folly/coro/WithCancellation.cpp
  function CO_TEST (line 30) | CO_TEST(CodeExamples, demoTimeoutAndWithCancellationCancel) {

FILE: folly/docs/examples/folly/dynamic.cpp
  function TEST (line 22) | TEST(dynamic, demo) {

FILE: folly/docs/examples/folly/dynamic/array.cpp
  function TEST (line 20) | TEST(dynamic, arrayCtor) {

FILE: folly/docs/examples/folly/dynamic/object.cpp
  function TEST (line 20) | TEST(dynamic, objectCtor) {

FILE: folly/docs/examples/folly/hash/Hash.cpp
  function TEST (line 22) | TEST(hash, demo) {

FILE: folly/docs/examples/folly/io/IOBuf.cpp
  function TEST (line 22) | TEST(IOBuf, demo) {

FILE: folly/docs/examples/folly/ipaddress.cpp
  function TEST (line 22) | TEST(IPAddress, demo) {

FILE: folly/docs/examples/folly/synchronization/Baton.cpp
  function TEST (line 27) | TEST(Baton, demo) {

FILE: folly/docs/examples/folly/test/TestUtils.cpp
  function TEST (line 20) | TEST(TestUtilsDemo, Print) {

FILE: folly/docs/examples/folly/test/common/TestMainDemo.cpp
  function TEST (line 36) | TEST(TestMainDemo, SingletonAccess) {

FILE: folly/executors/Async.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/CPUThreadPoolExecutor.cpp
  type folly (line 46) | namespace folly {
    function WorkerProvider (line 262) | WorkerProvider* CPUThreadPoolExecutor::getThreadIdCollector() {

FILE: folly/executors/CPUThreadPoolExecutor.h
  function namespace (line 28) | namespace folly {

FILE: folly/executors/Codel.cpp
  type folly (line 31) | namespace folly {
    function nanoseconds (line 130) | nanoseconds Codel::getMinDelay() {
    function milliseconds (line 138) | milliseconds Codel::getSloughTimeout(milliseconds delay) const {

FILE: folly/executors/Codel.h
  function namespace (line 22) | namespace folly {

FILE: folly/executors/DrivableExecutor.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/EDFThreadPoolExecutor.cpp
  type folly (line 43) | namespace folly {
    class EDFThreadPoolExecutor::Task (line 45) | class EDFThreadPoolExecutor::Task {
      type Poison (line 47) | struct Poison {}
      method Task (line 49) | explicit Task(Func&& f, uint64_t deadline)
      method Task (line 52) | explicit Task(std::vector<Func>&& fs, uint64_t deadline)
      method Task (line 55) | explicit Task(Poison, int total) : total_(total), deadline_(kLatestD...
      method getDeadline (line 59) | uint64_t getDeadline() const { return deadline_; }
      method getEnqueueOrder (line 60) | uint64_t getEnqueueOrder() const { return enqueueOrder_; }
      method isPoison (line 62) | bool isPoison() const { return !f_ && fs_.empty() && total_ > 0; }
      method isDone (line 64) | bool isDone() const {
      method setEnqueueOrder (line 69) | void setEnqueueOrder(uint64_t enqueueOrder) { enqueueOrder_ = enqueu...
      method next (line 71) | int next() {
      method run (line 80) | void run(int i) {
    class EDFThreadPoolExecutor::TaskQueue (line 106) | class EDFThreadPoolExecutor::TaskQueue {
      type Bucket (line 111) | struct Bucket {
        type Compare (line 114) | struct Compare {
      method push (line 130) | void push(TaskPtr task) {
      method TaskPtr (line 151) | TaskPtr pop() {
      method Bucket (line 203) | Bucket& getBucket(uint64_t deadline) {
        type Compare (line 114) | struct Compare {
      method findNextDeadline (line 207) | uint64_t findNextDeadline(uint64_t prevDeadline) {

FILE: folly/executors/EDFThreadPoolExecutor.h
  function namespace (line 28) | namespace folly {

FILE: folly/executors/ExecutionObserver.cpp
  type folly (line 21) | namespace folly {

FILE: folly/executors/ExecutionObserver.h
  function namespace (line 23) | namespace folly {

FILE: folly/executors/ExecutorWithPriority-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/executors/ExecutorWithPriority.cpp
  type folly (line 19) | namespace folly {

FILE: folly/executors/ExecutorWithPriority.h
  function namespace (line 23) | namespace folly {

FILE: folly/executors/FiberIOExecutor.h
  function namespace (line 22) | namespace folly {

FILE: folly/executors/FunctionScheduler.cpp
  type folly (line 31) | namespace folly {
    type ConsistentDelayFunctor (line 35) | struct ConsistentDelayFunctor {
      method ConsistentDelayFunctor (line 38) | explicit ConsistentDelayFunctor(microseconds interval)
    type ConstIntervalFunctor (line 55) | struct ConstIntervalFunctor {
      method ConstIntervalFunctor (line 58) | explicit ConstIntervalFunctor(microseconds interval)
      method microseconds (line 67) | microseconds operator()() const { return constInterval; }
    type PoissonDistributionFunctor (line 70) | struct PoissonDistributionFunctor {
      method PoissonDistributionFunctor (line 74) | explicit PoissonDistributionFunctor(microseconds meanPoissonUsec)
      method microseconds (line 83) | microseconds operator()() { return microseconds(poissonRandom(genera...
    type UniformDistributionFunctor (line 86) | struct UniformDistributionFunctor {
      method UniformDistributionFunctor (line 90) | UniformDistributionFunctor(microseconds minInterval, microseconds ma...
      method microseconds (line 105) | microseconds operator()() { return microseconds(dist(generator)); }
    function FOLLY_NOINLINE (line 437) | FOLLY_NOINLINE void FunctionScheduler::waitForWork(
    function FOLLY_NOINLINE (line 441) | FOLLY_NOINLINE void FunctionScheduler::waitForWork(

FILE: folly/executors/FunctionScheduler.h
  function namespace (line 30) | namespace folly {
  type RunTimeOrder (line 363) | struct RunTimeOrder {
  function steady_ (line 382) | bool steady_{false};

FILE: folly/executors/FutureExecutor.h
  function namespace (line 22) | namespace folly {

FILE: folly/executors/GlobalExecutor.cpp
  class GlobalTag (line 47) | class GlobalTag {}
  class DefaultCPUExecutor (line 50) | class DefaultCPUExecutor : public InlineLikeExecutor {
    method FOLLY_NOINLINE (line 52) | FOLLY_NOINLINE void add(Func f) override { f(); }
  function getImmutable (line 82) | std::shared_ptr<Executor> getImmutable() {
  function getImmutable (line 90) | std::shared_ptr<IOExecutor> getImmutable() {
  class GlobalExecutor (line 98) | class GlobalExecutor {
    method GlobalExecutor (line 100) | explicit GlobalExecutor(
    method get (line 104) | std::shared_ptr<ExecutorBase> get() {
    method set (line 113) | void set(std::weak_ptr<ExecutorBase> executor) {
    method setFromImmutable (line 120) | void setFromImmutable() {
  type folly (line 151) | namespace folly {
    type detail (line 153) | namespace detail {
      function tryGetImmutableCPUPtr (line 154) | std::shared_ptr<Executor> tryGetImmutableCPUPtr() {
    function getGlobalCPUExecutor (line 159) | Executor::KeepAlive<> getGlobalCPUExecutor() {
    function getGlobalCPUExecutorWeakRef (line 168) | Executor::KeepAlive<> getGlobalCPUExecutorWeakRef() {
    function GlobalCPUExecutorCounters (line 177) | GlobalCPUExecutorCounters getGlobalCPUExecutorCounters() {
    function getGlobalIOExecutor (line 190) | Executor::KeepAlive<IOExecutor> getGlobalIOExecutor() {
    function getUnsafeMutableGlobalCPUExecutor (line 199) | std::shared_ptr<Executor> getUnsafeMutableGlobalCPUExecutor() {
    function getCPUExecutor (line 206) | std::shared_ptr<Executor> getCPUExecutor() {
    function setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor (line 210) | void setUnsafeMutableGlobalCPUExecutorToGlobalCPUExecutor() {
    function setCPUExecutorToGlobalCPUExecutor (line 215) | void setCPUExecutorToGlobalCPUExecutor() {
    function setUnsafeMutableGlobalCPUExecutor (line 219) | void setUnsafeMutableGlobalCPUExecutor(std::weak_ptr<Executor> executo...
    function setCPUExecutor (line 224) | void setCPUExecutor(std::weak_ptr<Executor> executor) {
    function getUnsafeMutableGlobalIOExecutor (line 228) | std::shared_ptr<IOExecutor> getUnsafeMutableGlobalIOExecutor() {
    function getIOExecutor (line 235) | std::shared_ptr<IOExecutor> getIOExecutor() {
    function setUnsafeMutableGlobalIOExecutor (line 239) | void setUnsafeMutableGlobalIOExecutor(std::weak_ptr<IOExecutor> execut...
    function setIOExecutor (line 244) | void setIOExecutor(std::weak_ptr<IOExecutor> executor) {
    function EventBase (line 248) | EventBase* getUnsafeMutableGlobalEventBase() {
    function EventBase (line 257) | EventBase* getEventBase() {

FILE: folly/executors/GlobalExecutor.h
  function namespace (line 34) | namespace folly {

FILE: folly/executors/GlobalThreadPoolList.cpp
  type folly (line 29) | namespace folly {
    type debugger_detail (line 31) | namespace debugger_detail {
      class ThreadListHook (line 33) | class ThreadListHook {
        method ThreadListHook (line 42) | ThreadListHook() = default;
      class GlobalThreadPoolListImpl (line 48) | class GlobalThreadPoolListImpl {
        method GlobalThreadPoolListImpl (line 50) | GlobalThreadPoolListImpl() = default;
        type PoolInfo (line 65) | struct PoolInfo {
        type Pools (line 73) | struct Pools {
          method getPool (line 78) | getPool(void* threadPoolId) {
      class GlobalThreadPoolList (line 94) | class GlobalThreadPoolList {
        method GlobalThreadPoolList (line 96) | GlobalThreadPoolList() noexcept { debug = this; }
        method GlobalThreadPoolList (line 112) | GlobalThreadPoolList(GlobalThreadPoolList const&) = delete;
      function GlobalThreadPoolList (line 125) | GlobalThreadPoolList& GlobalThreadPoolList::instance() {
        method GlobalThreadPoolList (line 96) | GlobalThreadPoolList() noexcept { debug = this; }
        method GlobalThreadPoolList (line 112) | GlobalThreadPoolList(GlobalThreadPoolList const&) = delete;

FILE: folly/executors/GlobalThreadPoolList.h
  function namespace (line 27) | namespace folly {

FILE: folly/executors/IOExecutor.h
  function namespace (line 21) | namespace folly {
  function namespace (line 25) | namespace folly {

FILE: folly/executors/IOObjectCache.h
  function namespace (line 25) | namespace folly {

FILE: folly/executors/IOThreadPoolDeadlockDetectorObserver.cpp
  type folly (line 21) | namespace folly {

FILE: folly/executors/IOThreadPoolDeadlockDetectorObserver.h
  function namespace (line 24) | namespace folly {

FILE: folly/executors/IOThreadPoolExecutor.cpp
  type folly (line 34) | namespace folly {
    class MemoryIdlerTimeout (line 43) | class MemoryIdlerTimeout : public AsyncTimeout, public EventBase::Loop...
      method MemoryIdlerTimeout (line 45) | explicit MemoryIdlerTimeout(EventBase* b) : AsyncTimeout(b), base_(b...
      method timeoutExpired (line 47) | void timeoutExpired() noexcept override {
      method runLoopCallback (line 52) | void runLoopCallback() noexcept override {
    function EventBase (line 93) | EventBase* IOThreadPoolExecutor::getEventBase(
    function EventBase (line 192) | EventBase* IOThreadPoolExecutor::getEventBase() {
    function EventBaseManager (line 214) | EventBaseManager* IOThreadPoolExecutor::getEventBaseManager() {

FILE: folly/executors/IOThreadPoolExecutor.h
  function namespace (line 28) | namespace folly {
  function class (line 83) | class IOThreadPoolExecutor : public IOThreadPoolExecutorBase {
  type alignas (line 153) | struct alignas

FILE: folly/executors/InlineExecutor.cpp
  type folly (line 21) | namespace folly {
    function InlineExecutor (line 23) | InlineExecutor& InlineExecutor::instance_slow() noexcept {

FILE: folly/executors/InlineExecutor.h
  function namespace (line 25) | namespace folly {

FILE: folly/executors/ManualExecutor.cpp
  type folly (line 23) | namespace folly {

FILE: folly/executors/ManualExecutor.h
  function namespace (line 29) | namespace folly {

FILE: folly/executors/MeteredExecutor-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/MeteredExecutor.h
  type Options (line 49) | struct Options {
  function explicit (line 90) | explicit Task(Func&& func, std::shared_ptr<RequestContext>&& rctx)
  function setQueueObserverPayload (line 93) | void setQueueObserverPayload(intptr_t newValue) {
  function RequestContext (line 101) | RequestContext* requestContext() const { return rctx_.get(); }
  function std (line 119) | const std::unique_ptr<folly::QueueObserver> queueObserver_{

FILE: folly/executors/QueueObserver.cpp
  function make_queue_observer_factory_fallback (line 21) | std::unique_ptr<folly::QueueObserverFactory>
  class WorkerKeepAlive (line 27) | class WorkerKeepAlive : public folly::WorkerProvider::KeepAlive {
    method WorkerKeepAlive (line 29) | explicit WorkerKeepAlive(std::shared_lock<folly::SharedMutex> idsLock)
  type folly (line 39) | namespace folly {

FILE: folly/executors/QueueObserver.h
  function namespace (line 32) | namespace folly {

FILE: folly/executors/QueuedImmediateExecutor.cpp
  type folly (line 24) | namespace folly {
    function QueuedImmediateExecutor (line 26) | QueuedImmediateExecutor& QueuedImmediateExecutor::instance() {

FILE: folly/executors/QueuedImmediateExecutor.h
  function namespace (line 27) | namespace folly {

FILE: folly/executors/ScheduledExecutor.h
  function namespace (line 26) | namespace folly {

FILE: folly/executors/SequencedExecutor.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/SerialExecutor-inl.h
  function namespace (line 22) | namespace folly::detail {
  function class (line 159) | class NoopMutex {
  function enqueue (line 201) | void enqueue(Task&& task) {
  function dequeue (line 223) | void dequeue(Task& task) {
  type Segment (line 245) | struct Segment {
  function deleteSegment (line 258) | void deleteSegment(Segment* segment) {

FILE: folly/executors/SerialExecutor.h
  function class (line 74) | class Deleter {
  type Task (line 115) | struct Task {

FILE: folly/executors/SerializedExecutor.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/SoftRealTimeExecutor.cpp
  type folly (line 23) | namespace folly {
    class DeadlineExecutor (line 27) | class DeadlineExecutor : public folly::Executor {
      method create (line 29) | static KeepAlive<> create(
      method add (line 34) | void add(folly::Func f) override { executor_->add(std::move(f), dead...
      method keepAliveAcquire (line 36) | bool keepAliveAcquire() noexcept override {
      method keepAliveRelease (line 42) | void keepAliveRelease() noexcept override {
      method DeadlineExecutor (line 51) | DeadlineExecutor(uint64_t deadline, KeepAlive<SoftRealTimeExecutor> ...

FILE: folly/executors/SoftRealTimeExecutor.h
  function namespace (line 25) | namespace folly {

FILE: folly/executors/StrandExecutor.cpp
  type folly (line 24) | namespace folly {
    class StrandContext::Task (line 28) | class StrandContext::Task {
      method Task (line 30) | explicit Task(std::shared_ptr<StrandContext> ctx) noexcept
      method Task (line 33) | Task(Task&& t) noexcept : context_(std::move(t.context_)) {}
      method Task (line 35) | Task(const Task&) = delete;
      method Task (line 36) | Task& operator=(Task&&) = delete;
      method Task (line 37) | Task& operator=(const Task&) = delete;

FILE: folly/executors/StrandExecutor.h
  function namespace (line 27) | namespace folly {

FILE: folly/executors/StripedEDFThreadPoolExecutor.cpp
  type folly (line 27) | namespace folly {
    class EDFPriorityQueue (line 32) | class EDFPriorityQueue {
      method EDFPriorityQueue (line 34) | EDFPriorityQueue() = default;
      method enqueue (line 42) | void enqueue(T&& item, uint64_t deadline) {
      method T (line 47) | T dequeue() {
      type Node (line 55) | struct Node : IntrusiveHeapNode<> {
        method Node (line 56) | Node(T&& it, uint64_t d) : item(std::move(it)), deadline(d) {}
      method EDFPriorityQueue (line 66) | EDFPriorityQueue(const EDFPriorityQueue&) = delete;
      method EDFPriorityQueue (line 67) | EDFPriorityQueue(EDFPriorityQueue&&) = delete;
      method EDFPriorityQueue (line 68) | EDFPriorityQueue& operator=(const EDFPriorityQueue&) = delete;
      method EDFPriorityQueue (line 69) | EDFPriorityQueue& operator=(EDFPriorityQueue&&) = delete;
    class BlockingQueueWithDeadline (line 76) | class BlockingQueueWithDeadline : public BlockingQueue<T> {
    class StripedEDFPriorityBlockingQueue (line 83) | class StripedEDFPriorityBlockingQueue final
      method StripedEDFPriorityBlockingQueue (line 86) | explicit StripedEDFPriorityBlockingQueue(
      method BlockingQueueAddResult (line 96) | BlockingQueueAddResult addWithDeadline(T&& item, uint64_t deadline) ...
      method BlockingQueueAddResult (line 102) | BlockingQueueAddResult add(T&& item) override {
      method T (line 107) | T take() override {
      method try_take_for (line 113) | folly::Optional<T> try_take_for(std::chrono::milliseconds time) over...
      method size (line 121) | size_t size() override { return sem_.valueGuess(); }
      method getStripeIdx (line 124) | static size_t getStripeIdx() { return LLCAccessSpreader::get().curre...
    class EDFPriorityBlockingQueue (line 132) | class EDFPriorityBlockingQueue final : public BlockingQueueWithDeadlin...
      method EDFPriorityBlockingQueue (line 134) | explicit EDFPriorityBlockingQueue(const ThrottledLifoSem::Options& o...
      method BlockingQueueAddResult (line 137) | BlockingQueueAddResult addWithDeadline(T&& item, uint64_t deadline) ...
      method BlockingQueueAddResult (line 142) | BlockingQueueAddResult add(T&& item) override {
      method T (line 147) | T take() override {
      method try_take_for (line 152) | folly::Optional<T> try_take_for(std::chrono::milliseconds time) over...
      method size (line 159) | size_t size() override { return sem_.valueGuess(); }
    function makeQueue (line 166) | std::unique_ptr<BlockingQueue<CPUThreadPoolExecutor::CPUTask>> makeQueue(

FILE: folly/executors/StripedEDFThreadPoolExecutor.h
  function namespace (line 23) | namespace folly {

FILE: folly/executors/ThreadPoolExecutor.cpp
  type folly (line 29) | namespace folly {
    function SyncVecThreadPoolExecutors (line 34) | SyncVecThreadPoolExecutors& getSyncVecThreadPoolExecutors() {
    class TaskStatsCallbackObserver (line 403) | class TaskStatsCallbackObserver : public TaskObserver {
      method TaskStatsCallbackObserver (line 405) | explicit TaskStatsCallbackObserver(TaskStatsCallback&& cob)
      method taskProcessed (line 408) | void taskProcessed(const ProcessedTaskInfo& info) noexcept override {
    function BlockingQueueAddResult (line 434) | BlockingQueueAddResult ThreadPoolExecutor::StoppedThreadQueue::add(

FILE: folly/executors/ThreadPoolExecutor.h
  function setThreadFactory (line 90) | void setThreadFactory(std::shared_ptr<ThreadFactory> threadFactory) {

FILE: folly/executors/ThreadedExecutor.cpp
  type folly (line 28) | namespace folly {

FILE: folly/executors/ThreadedExecutor.h
  function namespace (line 28) | namespace folly {

FILE: folly/executors/ThreadedRepeatingFunctionRunner.cpp
  type folly (line 25) | namespace folly {

FILE: folly/executors/ThreadedRepeatingFunctionRunner.h
  function namespace (line 25) | namespace folly {

FILE: folly/executors/TimedDrivableExecutor.cpp
  type folly (line 24) | namespace folly {

FILE: folly/executors/TimedDrivableExecutor.h
  function namespace (line 24) | namespace folly {

FILE: folly/executors/TimekeeperScheduledExecutor.cpp
  type folly (line 21) | namespace folly {

FILE: folly/executors/TimekeeperScheduledExecutor.h
  function namespace (line 26) | namespace folly {

FILE: folly/executors/VirtualExecutor.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/task_queue/BlockingQueue.h
  function namespace (line 28) | namespace folly {

FILE: folly/executors/task_queue/LifoSemMPMCQueue.h
  function namespace (line 23) | namespace folly {

FILE: folly/executors/task_queue/PriorityLifoSemMPMCQueue.h
  function namespace (line 27) | namespace folly {
  function getNumPriorities (line 63) | uint8_t getNumPriorities() override { return queues_.size(); }
  function BlockingQueueAddResult (line 66) | BlockingQueueAddResult add(T&& item) override {
  function BlockingQueueAddResult (line 70) | BlockingQueueAddResult addWithPriority(T&& item, int8_t priority) overri...
  function T (line 89) | T take() override {
  function nonBlockingTake (line 111) | bool nonBlockingTake(T& item) {
  function size (line 120) | size_t size() override { return sem_.valueGuess(); }

FILE: folly/executors/task_queue/PriorityUnboundedBlockingQueue.h
  function namespace (line 26) | namespace folly {

FILE: folly/executors/task_queue/StripedPriorityUnboundedBlockingQueue.h
  function namespace (line 29) | namespace folly {

FILE: folly/executors/task_queue/UnboundedBlockingQueue.h
  function namespace (line 23) | namespace folly {

FILE: folly/executors/task_queue/test/PriorityLifoSemMPMCQueueTest.cpp
  function TEST (line 27) | TEST(PriorityLifoSemMPMCQueue, Capacities) {

FILE: folly/executors/task_queue/test/PriorityUnboundedBlockingQueueTest.cpp
  class PriorityUnboundedBlockingQueueTest (line 27) | class PriorityUnboundedBlockingQueueTest : public testing::Test {}
  function TEST_F (line 29) | TEST_F(PriorityUnboundedBlockingQueueTest, push_pop) {
  function TEST_F (line 35) | TEST_F(PriorityUnboundedBlockingQueueTest, multiple_push_pop) {
  function TEST_F (line 43) | TEST_F(PriorityUnboundedBlockingQueueTest, size) {
  function TEST_F (line 52) | TEST_F(PriorityUnboundedBlockingQueueTest, concurrent_push_pop) {
  function TEST_F (line 68) | TEST_F(PriorityUnboundedBlockingQueueTest, priority_order) {
  function TEST_F (line 87) | TEST_F(PriorityUnboundedBlockingQueueTest, invalid_priorities) {
  function TEST_F (line 96) | TEST_F(PriorityUnboundedBlockingQueueTest, invalid_priorities_edge) {

FILE: folly/executors/task_queue/test/StripedPriorityUnboundedBlockingQueueTest.cpp
  type RandomStripe (line 30) | struct RandomStripe {
    method RandomStripe (line 31) | static const RandomStripe& get() {
    method current (line 36) | size_t current() const { return folly::Random::rand64(numStripes()); }
    method numStripes (line 37) | size_t numStripes() const { return 16; }
  function TEST (line 42) | TEST(StripedPriorityUnboundedBlockingQueue, SmokeTest) {

FILE: folly/executors/task_queue/test/UnboundedBlockingQueueBench.cpp
  function BENCHMARK (line 39) | BENCHMARK(drain_full_queue, iters) {
  function main (line 86) | int main(int argc, char** argv) {

FILE: folly/executors/task_queue/test/UnboundedBlockingQueueTest.cpp
  function TEST (line 26) | TEST(UnboundedQueuee, pushPop) {
  function TEST (line 31) | TEST(UnboundedBlockingQueue, size) {
  function TEST (line 40) | TEST(UnboundedBlockingQueue, concurrentPushPop) {

FILE: folly/executors/test/AsyncTest.cpp
  function TEST (line 26) | TEST(AsyncFunc, manualExecutor) {

FILE: folly/executors/test/CodelTest.cpp
  function TEST (line 30) | TEST(CodelTest, Basic) {
  function TEST (line 52) | TEST(CodelTest, highLoad) {
  function TEST (line 58) | TEST(CodelTest, mediumLoad) {
  function TEST (line 68) | TEST(CodelTest, reducingLoad) {
  function TEST (line 75) | TEST(CodelTest, oneRequestNoDrop) {
  function TEST (line 80) | TEST(CodelTest, getLoadSanity) {
  function TEST (line 101) | TEST(CodelTest, updateTargetDelay) {
  function TEST (line 124) | TEST(CodelTest, updateInterval) {
  function TEST (line 149) | TEST(CodelTest, invalidParamUpdates) {

FILE: folly/executors/test/EDFThreadPoolExecutorBenchmark.cpp
  function throughput (line 35) | void throughput(uint32_t n, std::unique_ptr<ThreadPoolExecutor> ex) {
  function saturated (line 47) | void saturated(
  function multiThreaded (line 108) | void multiThreaded(uint32_t n, std::unique_ptr<ThreadPoolExecutor> ex) {
  function main (line 195) | int main(int argc, char* argv[]) {

FILE: folly/executors/test/ExecutorTest.cpp
  function TEST (line 27) | TEST(ManualExecutor, runIsStable) {
  function TEST (line 44) | TEST(ManualExecutor, drainIsNotStable) {
  function TEST (line 57) | TEST(ManualExecutor, scheduleDur) {
  function TEST (line 71) | TEST(ManualExecutor, laterThingsDontBlockEarlierOnes) {
  function TEST (line 82) | TEST(ManualExecutor, orderWillNotBeQuestioned) {
  function TEST (line 99) | TEST(ManualExecutor, evenWhenYouSkipAheadEventsRunInProperOrder) {
  function TEST (line 114) | TEST(ManualExecutor, clockStartsAt0) {
  function TEST (line 119) | TEST(ManualExecutor, scheduleAbs) {
  function TEST (line 128) | TEST(ManualExecutor, advanceTo) {
  function TEST (line 137) | TEST(ManualExecutor, advanceBack) {
  function TEST (line 147) | TEST(ManualExecutor, advanceNeg) {
  function TEST (line 157) | TEST(ManualExecutor, waitForDoesNotDeadlock) {
  function TEST (line 174) | TEST(ManualExecutor, getViaDoesNotDeadlock) {
  function TEST (line 191) | TEST(ManualExecutor, clear) {
  function TEST (line 204) | TEST(ManualExecutor, drainsOnDestruction) {
  function TEST (line 213) | TEST(ManualExecutor, keepAlive) {
  function TEST (line 225) | TEST(Executor, InlineExecutor) {
  function TEST (line 239) | TEST(Executor, QueuedImmediateExecutor) {
  function TEST (line 253) | TEST(Executor, QueuedImmediateExecutorRequestContext) {
  function TEST (line 267) | TEST(Executor, Runnable) {
  function TEST (line 280) | TEST(Executor, ThrowableThen) {
  class CrappyExecutor (line 293) | class CrappyExecutor : public Executor {
    method add (line 295) | void add(Func /* f */) override { throw std::runtime_error("bad"); }
  function TEST (line 298) | TEST(Executor, CrappyExecutor) {
  class DoNothingExecutor (line 309) | class DoNothingExecutor : public Executor {
    method add (line 311) | void add(Func f) override { storedFunc_ = std::move(f); }
  function TEST (line 317) | TEST(Executor, DoNothingExecutor) {

FILE: folly/executors/test/ExecutorWithPriorityTest.cpp
  function TEST (line 25) | TEST(ExecutorWithPriorityTest, addWithCorrectPriorityTest) {
  function TEST (line 55) | TEST(ExecutorWithPriorityTest, updatePriorityUsingCallback) {

FILE: folly/executors/test/FiberIOExecutorTest.cpp
  class FiberIOExecutorTest (line 26) | class FiberIOExecutorTest : public testing::Test {}
  function TEST_F (line 29) | TEST_F(FiberIOExecutorTest, event_base) {
  function TEST_F (line 37) | TEST_F(FiberIOExecutorTest, basic_execution) {

FILE: folly/executors/test/FunctionSchedulerTest.cpp
  function testInterval (line 47) | std::chrono::milliseconds testInterval(int n) {
  function getTicksWithinRange (line 50) | int getTicksWithinRange(int n, int min, int max) {
  function delay (line 56) | void delay(float n) {
  function TEST (line 65) | TEST(FunctionScheduler, StartAndShutdown) {
  function TEST (line 78) | TEST(FunctionScheduler, SimpleAdd) {
  function TEST (line 90) | TEST(FunctionScheduler, AddCancel) {
  function TEST (line 111) | TEST(FunctionScheduler, AddCancel2) {
  function TEST (line 191) | TEST(FunctionScheduler, AddCancelInitialDelayStress) {
  function TEST (line 242) | TEST(FunctionScheduler, AddMultiple) {
  function TEST (line 265) | TEST(FunctionScheduler, AddAfterStart) {
  function TEST (line 278) | TEST(FunctionScheduler, ShutdownStart) {
  function TEST (line 293) | TEST(FunctionScheduler, ResetFunc) {
  function TEST (line 314) | TEST(FunctionScheduler, ResetFunc2) {
  function TEST (line 331) | TEST(FunctionScheduler, ResetFuncWhileRunning) {
  function TEST (line 377) | TEST(FunctionScheduler, AddInvalid) {
  function TEST (line 388) | TEST(FunctionScheduler, NoFunctions) {
  function TEST (line 396) | TEST(FunctionScheduler, AddWhileRunning) {
  function TEST (line 412) | TEST(FunctionScheduler, NoShutdown) {
  function TEST (line 428) | TEST(FunctionScheduler, StartDelay) {
  function TEST (line 459) | TEST(FunctionScheduler, NoSteadyCatchup) {
  function TEST (line 478) | TEST(FunctionScheduler, SteadyCatchup) {
  function TEST (line 498) | TEST(FunctionScheduler, UniformDistribution) {
  function TEST (line 524) | TEST(FunctionScheduler, ConsistentDelay) {
  function TEST (line 559) | TEST(FunctionScheduler, ExponentialBackoff) {
  function TEST (line 587) | TEST(FunctionScheduler, GammaIntervalDistribution) {
  function TEST (line 618) | TEST(FunctionScheduler, PoissonDistribution) {
  function TEST (line 633) | TEST(FunctionScheduler, AddWithRunOnce) {
  function TEST (line 652) | TEST(FunctionScheduler, cancelFunctionAndWait) {
  function TEST (line 674) | TEST(FunctionScheduler, cancelAllFunctionsAndWait) {
  function TEST (line 697) | TEST(FunctionScheduler, CancelAndWaitOnRunningFunc) {
  function TEST (line 712) | TEST(FunctionScheduler, CancelAllAndWaitWithRunningFunc) {
  function TEST (line 727) | TEST(FunctionScheduler, CancelAllAndWaitWithOneRunningAndOneWaiting) {
  function TEST (line 758) | TEST(FunctionScheduler, ConcurrentCancelFunctionAndWait) {

FILE: folly/executors/test/GlobalCPUExecutorTest.cpp
  function TEST (line 23) | TEST(GlobalCPUExecutorTest, CPUThreadCountFlagSet) {

FILE: folly/executors/test/GlobalExecutorAssignmentTest.cpp
  function TEST (line 26) | TEST(GlobalExecutorAssignmentTest, GlobalCPUExecutorAsImmutable) {

FILE: folly/executors/test/GlobalExecutorTest.cpp
  function TEST (line 30) | TEST(GlobalExecutorTest, GlobalImmutableCPUExecutor) {
  function TEST (line 45) | TEST(GlobalExecutorTest, GlobalImmutableIOExecutor) {
  class DummyExecutor (line 61) | class DummyExecutor : public folly::Executor {
    method add (line 63) | void add(Func fn) override {
    method add (line 95) | void add(Func) override { count++; }
  class DummyExecutor (line 93) | class DummyExecutor : public IOExecutor {
    method add (line 63) | void add(Func fn) override {
    method add (line 95) | void add(Func) override { count++; }
  function FOLLY_POP_WARNING (line 118) | FOLLY_POP_WARNING
  function TEST (line 130) | TEST(GlobalExecutorTest, CPUThreadCountFlagUnset) {
  function TEST (line 138) | TEST(GlobalExecutorTest, GetGlobalCPUExecutorCounters) {

FILE: folly/executors/test/GlobalIOExecutorTest.cpp
  function TEST (line 28) | TEST(GlobalExecutorTest, IOThreadCountFlagSet) {

FILE: folly/executors/test/IOThreadPoolDeadlockDetectorObserverTest.cpp
  class DeadlockDetectorMock (line 29) | class DeadlockDetectorMock : public DeadlockDetector {
    method DeadlockDetectorMock (line 31) | DeadlockDetectorMock(std::shared_ptr<std::atomic<int32_t>> counter)
  class DeadlockDetectorFactoryMock (line 41) | class DeadlockDetectorFactoryMock : public DeadlockDetectorFactory {
    method create (line 43) | std::unique_ptr<DeadlockDetector> create(
    method getCounter (line 63) | int32_t getCounter() { return counter_->load(); }
    method getName (line 65) | std::string getName() const { return name_.copy(); }
  function TEST (line 75) | TEST(

FILE: folly/executors/test/IOThreadPoolExecutorBaseTestLib.h
  function namespace (line 33) | namespace test {
  function TypeParam (line 60) | TypeParam ex{kNumThreads};

FILE: folly/executors/test/IOThreadPoolExecutorTest.cpp
  type folly (line 20) | namespace folly {
    type test (line 21) | namespace test {
      function TEST (line 23) | TEST(IOThreadPoolExecutor, MaxReadAtOnce) {

FILE: folly/executors/test/MeteredExecutorTest.cpp
  class MeteredExecutorTest (line 35) | class MeteredExecutorTest : public testing::Test {
    method createAdapter (line 38) | void createAdapter(
    method add (line 53) | void add(Func f, uint8_t level = 0) { executors_[level]->add(std::move...
    method join (line 55) | void join() {
    method getKeepAlive (line 61) | Executor::KeepAlive<> getKeepAlive(int level) { return executors_[leve...
  function TEST_F (line 68) | TEST_F(MeteredExecutorTest, SingleLevel) {
  function TEST_F (line 90) | TEST_F(MeteredExecutorTest, TwoLevels) {
  function TEST_F (line 120) | TEST_F(MeteredExecutorTest, PreemptTest) {
  function TEST_F (line 167) | TEST_F(MeteredExecutorTest, TwoLevelsWithKeepAlives) {
  function TEST_F (line 201) | TEST_F(MeteredExecutorTest, RequestContext) {
  function TEST_F (line 234) | TEST_F(MeteredExecutorTest, ResetJoins) {
  function TEST_F (line 252) | TEST_F(MeteredExecutorTest, ConcurrentShutdown) {
  function TEST_F (line 257) | TEST_F(MeteredExecutorTest, CostOfMeteredExecutors) {
  function TEST_F (line 319) | TEST_F(MeteredExecutorTest, ExceptionHandling) {
  function co_isOnCPUExc (line 342) | coro::Task<bool> co_isOnCPUExc() {
  function co_run (line 349) | coro::Task<bool> co_run(Executor::KeepAlive<> ka, coro::Task<T> f) {
  function TEST_F (line 357) | TEST_F(MeteredExecutorTest, UnderlyingExecutor) {
  function TEST_F (line 366) | TEST_F(MeteredExecutorTest, PauseResume) {
  function TEST_F (line 393) | TEST_F(MeteredExecutorTest, PauseResumeStress) {
  function benchmarkSaturation (line 495) | void benchmarkSaturation(
  function BENCHMARK (line 541) | BENCHMARK(Saturation_no_MeteredExecutor, iters) {
  function BENCHMARK (line 547) | BENCHMARK(Saturation_MeteredExecutor_chain_1_maxInQueue_1, iters) {
  function BENCHMARK (line 550) | BENCHMARK(Saturation_MeteredExecutor_chain_1_maxInQueue_2, iters) {
  function BENCHMARK (line 553) | BENCHMARK(Saturation_MeteredExecutor_chain_1_maxInQueue_4, iters) {
  function BENCHMARK (line 559) | BENCHMARK(Saturation_MeteredExecutor_chain_2_maxInQueue_1, iters) {
  function BENCHMARK (line 562) | BENCHMARK(Saturation_MeteredExecutor_chain_2_maxInQueue_2, iters) {
  function BENCHMARK (line 565) | BENCHMARK(Saturation_MeteredExecutor_chain_2_maxInQueue_4, iters) {
  function BENCHMARK (line 571) | BENCHMARK(Saturation_MeteredExecutor_chain_3_maxInQueue_1, iters) {
  function BENCHMARK (line 574) | BENCHMARK(Saturation_MeteredExecutor_chain_3_maxInQueue_2, iters) {
  function BENCHMARK (line 577) | BENCHMARK(Saturation_MeteredExecutor_chain_3_maxInQueue_4, iters) {
  function main (line 581) | int main(int argc, char** argv) {

FILE: folly/executors/test/SequencedExecutorTest.cpp
  type folly (line 24) | namespace folly {
    function isSequencedExecutor (line 26) | bool isSequencedExecutor(folly::Executor& executor) {
    function testExecutor (line 59) | void testExecutor(folly::Executor& executor) {
    function testExecutor (line 63) | void testExecutor(folly::SequencedExecutor& executor) {
    function TEST (line 67) | TEST(SequencedExecutor, CPUThreadPoolExecutor) {
    function TEST (line 72) | TEST(SequencedExecutor, SerialCPUThreadPoolExecutor) {
    function TEST (line 79) | TEST(SequencedExecutor, EventBase) {

FILE: folly/executors/test/SerialExecutorTest.cpp
  function sleepMs (line 32) | void sleepMs(uint64_t ms) {
  class SerialExecutorTest (line 40) | class SerialExecutorTest : public testing::Test {}
  function TYPED_TEST (line 45) | TYPED_TEST(SerialExecutorTest, Accessors) {
  function simpleTest (line 52) | void simpleTest(folly::Executor& parent) {
  function TYPED_TEST (line 102) | TYPED_TEST(SerialExecutorTest, Simple) {
  function TYPED_TEST (line 106) | TYPED_TEST(SerialExecutorTest, SimpleInline) {
  function TYPED_TEST (line 113) | TYPED_TEST(SerialExecutorTest, Afterlife) {
  function recursiveAddTest (line 150) | void recursiveAddTest(folly::Executor& parent) {
  function TYPED_TEST (line 187) | TYPED_TEST(SerialExecutorTest, RecursiveAdd) {
  function TYPED_TEST (line 191) | TYPED_TEST(SerialExecutorTest, RecursiveAddInline) {
  function TYPED_TEST (line 195) | TYPED_TEST(SerialExecutorTest, ExecutionThrows) {
  function TYPED_TEST (line 203) | TYPED_TEST(SerialExecutorTest, ParentExecutorDiscardsFunc) {
  function TYPED_TEST (line 232) | TYPED_TEST(SerialExecutorTest, Stress) {
  function TEST (line 263) | TEST(SerialExecutorTest2, SerialExecutorMPSCQueue) {
  function TEST (line 297) | TEST(SerialExecutorTest2, SPSerialExecutor) {

FILE: folly/executors/test/StrandExecutorTest.cpp
  function burnTime (line 36) | void burnTime(Duration d) {
  function TEST (line 41) | TEST(StrandExecutor, SimpleTest) {
  function TEST (line 65) | TEST(StrandExecutor, ThreadSafetyTest) {
  function TEST (line 123) | TEST(StrandExecutor, RequestContextPropagation) {

FILE: folly/executors/test/StripedEDFThreadPoolExecutorTest.cpp
  function pinProcessToCurrentCPU (line 29) | void pinProcessToCurrentCPU() {
  function TEST (line 46) | TEST(StripedEDFThreadPoolExecutor, Basic) {
  function TEST (line 68) | TEST(StripedEDFThreadPoolExecutor, Stop) {

FILE: folly/executors/test/ThreadPoolExecutorTest.cpp
  function Func (line 57) | static Func burnMs(uint64_t ms) {
  function thread_clock_now (line 62) | static std::chrono::nanoseconds thread_clock_now() {
  function burnThreadCpu (line 71) | static void burnThreadCpu(milliseconds ms) {
  function idleLoopFor (line 78) | static void idleLoopFor(milliseconds ms) {
  type folly (line 89) | namespace folly {
    function FOLLY_KEEP (line 92) | FOLLY_KEEP std::unique_ptr<QueueObserverFactory> make_queue_observer_f...
  class ThreadPoolExecutorTypedTest (line 102) | class ThreadPoolExecutorTypedTest : public ::testing::Test {}
  function basic (line 110) | static void basic() {
  function TYPED_TEST (line 115) | TYPED_TEST(ThreadPoolExecutorTypedTest, Basic) {
  function resize (line 120) | static void resize() {
  function TYPED_TEST (line 129) | TYPED_TEST(ThreadPoolExecutorTypedTest, Resize) {
  function stop (line 134) | static void stop() {
  function TYPED_TEST (line 166) | TYPED_TEST(ThreadPoolExecutorTypedTest, Stop) {
  function join (line 171) | static void join() {
  function TYPED_TEST (line 185) | TYPED_TEST(ThreadPoolExecutorTypedTest, Join) {
  function destroy (line 190) | static void destroy() {
  function TYPED_TEST (line 222) | TYPED_TEST(ThreadPoolExecutorTypedTest, Destroy) {
  function resizeUnderLoad (line 227) | static void resizeUnderLoad() {
  function TYPED_TEST (line 243) | TYPED_TEST(ThreadPoolExecutorTypedTest, ResizeUnderLoad) {
  function poolStats (line 248) | static void poolStats() {
  function TEST (line 274) | TEST(ThreadPoolExecutorTest, CPUPoolStats) {
  function TEST (line 278) | TEST(ThreadPoolExecutorTest, EDFPoolStats) {
  function TEST (line 282) | TEST(ThreadPoolExecutorTest, IOPoolStats) {
  function taskStats (line 287) | static void taskStats() {
  function TYPED_TEST (line 309) | TYPED_TEST(ThreadPoolExecutorTypedTest, TaskStats) {
  function TYPED_TEST (line 313) | TYPED_TEST(ThreadPoolExecutorTypedTest, TaskObserver) {
  function TEST (line 372) | TEST(ThreadPoolExecutorTest, GetUsedCpuTime) {
  function expiration (line 435) | static void expiration() {
  function TEST (line 457) | TEST(ThreadPoolExecutorTest, CPUExpiration) {
  function TEST (line 461) | TEST(ThreadPoolExecutorTest, IOExpiration) {
  function futureExecutor (line 466) | static void futureExecutor() {
  function TYPED_TEST (line 511) | TYPED_TEST(ThreadPoolExecutorTypedTest, FuturePool) {
  function TEST (line 515) | TEST(ThreadPoolExecutorTest, PriorityPreemptionTest) {
  class TestObserver (line 540) | class TestObserver : public ThreadPoolExecutor::Observer {
    method threadStarted (line 542) | void threadStarted(ThreadPoolExecutor::ThreadHandle*) noexcept override {
    method threadStopped (line 545) | void threadStopped(ThreadPoolExecutor::ThreadHandle*) noexcept override {
    method threadPreviouslyStarted (line 548) | void threadPreviouslyStarted(
    method threadNotYetStopped (line 552) | void threadNotYetStopped(
    method checkCalls (line 556) | void checkCalls() { ASSERT_EQ(threads_, 0); }
  function testObserver (line 563) | static void testObserver() {
  function TYPED_TEST (line 579) | TYPED_TEST(ThreadPoolExecutorTypedTest, Observer) {
  function TEST (line 583) | TEST(ThreadPoolExecutorTest, AddWithPriority) {
  function TEST (line 608) | TEST(ThreadPoolExecutorTest, BlockingQueue) {
  function TEST (line 637) | TEST(ThreadPoolExecutorTest, NoThreadPriorityInheritance) {
  class NoTimeoutBlockingQueue (line 663) | class NoTimeoutBlockingQueue : public UnboundedBlockingQueue<T> {
    method try_take_for (line 665) | folly::Optional<T> try_take_for(std::chrono::milliseconds time) overri...
  function TEST (line 673) | TEST(ThreadPoolExecutorTest, NoTimeoutInNonDynamicPool) {
  function TEST (line 685) | TEST(PriorityThreadFactoryTest, ThreadPriority) {
  function TEST (line 705) | TEST(InitThreadFactoryTest, InitializerCalled) {
  function TEST (line 718) | TEST(InitThreadFactoryTest, InitializerAndFinalizerCalled) {
  class TestData (line 754) | class TestData : public folly::RequestData {
    method TestData (line 756) | explicit TestData(int data) : data_(data) {}
    method hasCallback (line 759) | bool hasCallback() override { return false; }
  function TEST (line 764) | TEST(ThreadPoolExecutorTest, RequestContext) {
  type SlowMover (line 788) | struct SlowMover {
    method SlowMover (line 789) | explicit SlowMover(bool slow_ = false) : slow(slow_) {}
    method SlowMover (line 790) | SlowMover(SlowMover&& other) noexcept { *this = std::move(other); }
    method SlowMover (line 791) | SlowMover& operator=(SlowMover&& other) noexcept {
  function bugD3527722_test (line 805) | void bugD3527722_test() {
  function TEST (line 842) | TEST(ThreadPoolExecutorTest, LifoSemMPMCQueueBugD3527722) {
  type UBQ (line 847) | struct UBQ : public UnboundedBlockingQueue<T> {
    method UBQ (line 848) | explicit UBQ(int) {}
  function TEST (line 851) | TEST(ThreadPoolExecutorTest, UnboundedBlockingQueueBugD3527722) {
  function nothrow_not_full_test (line 856) | void nothrow_not_full_test() {
  function TEST (line 889) | TEST(ThreadPoolExecutorTest, LifoSemMPMCQueueNoThrowNotFull) {
  function removeThreadTest (line 894) | static void removeThreadTest() {
  function TYPED_TEST (line 919) | TYPED_TEST(ThreadPoolExecutorTypedTest, RemoveThread) {
  function resizeThreadWhileExecutingTest (line 924) | static void resizeThreadWhileExecutingTest() {
  function TYPED_TEST (line 946) | TYPED_TEST(ThreadPoolExecutorTypedTest, ResizeThreadWhileExecuting) {
  function keepAliveTest (line 951) | void keepAliveTest() {
  function TYPED_TEST (line 968) | TYPED_TEST(ThreadPoolExecutorTypedTest, KeepAlive) {
  function getNumThreadPoolExecutors (line 972) | int getNumThreadPoolExecutors() {
  function registersToExecutorListTest (line 979) | static void registersToExecutorListTest() {
  function TYPED_TEST (line 993) | TYPED_TEST(ThreadPoolExecutorTypedTest, RegistersToExecutorList) {
  function testUsesNameFromNamedThreadFactory (line 998) | static void testUsesNameFromNamedThreadFactory() {
  function TYPED_TEST (line 1007) | TYPED_TEST(ThreadPoolExecutorTypedTest, UsesNameFromNamedThreadFactory) {
  function TEST (line 1011) | TEST(ThreadPoolExecutorTest, DynamicThreadsTest) {
  function TEST (line 1030) | TEST(ThreadPoolExecutorTest, GetThreadIdCollector) {
  function TEST (line 1064) | TEST(ThreadPoolExecutorTest, DynamicThreadAddRemoveRace) {
  function TEST (line 1080) | TEST(ThreadPoolExecutorTest, AddPerf) {
  class ExecutorWorkerProviderTest (line 1095) | class ExecutorWorkerProviderTest : public ::testing::Test {
    method SetUp (line 1097) | void SetUp() override { kWorkerProviderGlobal = nullptr; }
    method TearDown (line 1098) | void TearDown() override { kWorkerProviderGlobal = nullptr; }
  function TEST_F (line 1101) | TEST_F(ExecutorWorkerProviderTest, ThreadCollectorBasicTest) {
  function TEST_F (line 1126) | TEST_F(ExecutorWorkerProviderTest, ThreadCollectorMultipleInvocationTest) {
  function TEST_F (line 1162) | TEST_F(ExecutorWorkerProviderTest, ThreadCollectorBlocksThreadExitTest) {
  function WeakRefTest (line 1206) | static void WeakRefTest() {
  function virtualExecutorTest (line 1226) | static void virtualExecutorTest() {
  class SingleThreadedCPUThreadPoolExecutor (line 1267) | class SingleThreadedCPUThreadPoolExecutor
    method SingleThreadedCPUThreadPoolExecutor (line 1271) | explicit SingleThreadedCPUThreadPoolExecutor(size_t)
  function TYPED_TEST (line 1276) | TYPED_TEST(ThreadPoolExecutorTypedTest, WeakRef) {
  function TEST (line 1280) | TEST(ThreadPoolExecutorTest, WeakRefTestSingleThreadedCPU) {
  function TEST (line 1284) | TEST(ThreadPoolExecutorTest, WeakRefTestSequential) {
  function TYPED_TEST (line 1292) | TYPED_TEST(ThreadPoolExecutorTypedTest, VirtualExecutor) {
  function currentThreadTest (line 1298) | static void currentThreadTest(folly::StringPiece executorName) {
  function currentThreadTestDisabled (line 1308) | static void currentThreadTestDisabled(folly::StringPiece executorName) {
  function TYPED_TEST (line 1325) | TYPED_TEST(ThreadPoolExecutorTypedTest, CurrentThreadExecutor) {
  function TYPED_TEST (line 1330) | TYPED_TEST(ThreadPoolExecutorTypedTest, ProcessedTasksCountStartsAtZero) {
  function TYPED_TEST (line 1337) | TYPED_TEST(
  class FailingThreadFactory (line 1376) | class FailingThreadFactory : public ThreadFactory {
    method FailingThreadFactory (line 1378) | explicit FailingThreadFactory(
    method newThread (line 1382) | std::thread newThread(Func&& func) override {
  function TEST (line 1399) | TEST(ThreadPoolExecutorTest, AddImplToleratesThreadCreationFailure) {
  function TEST (line 1430) | TEST(ThreadPoolExecutorTest, AddImplNoThreadsAndCreationFails) {

FILE: folly/executors/test/ThreadedExecutorTest.cpp
  class ThreadedExecutorTest (line 28) | class ThreadedExecutorTest : public testing::Test {}
  function TEST_F (line 31) | TEST_F(ThreadedExecutorTest, example) {
  function TEST_F (line 42) | TEST_F(ThreadedExecutorTest, exception) {
  function TEST_F (line 47) | TEST_F(ThreadedExecutorTest, dtor_waits) {
  function TEST_F (line 58) | TEST_F(ThreadedExecutorTest, many) {
  function TEST_F (line 75) | TEST_F(ThreadedExecutorTest, many_sleeping_constant_time) {
  function TEST_F (line 96) | TEST_F(ThreadedExecutorTest, many_sleeping_decreasing_time) {

FILE: folly/executors/test/ThreadedRepeatingFunctionRunnerTest.cpp
  type Foo (line 25) | struct Foo {
    method Foo (line 26) | explicit Foo(std::atomic<int>& d) : data(d) {}
    method start (line 29) | void start() {
  type FooLongSleep (line 40) | struct FooLongSleep {
    method FooLongSleep (line 41) | explicit FooLongSleep(std::atomic<int>& d) : data(d) {}
    method start (line 47) | void start() {
  function TEST (line 58) | TEST(TestThreadedRepeatingFunctionRunner, HandleBackgroundLoop) {
  function TEST (line 74) | TEST(TestThreadedRepeatingFunctionRunner, HandleLongSleepingThread) {

FILE: folly/executors/test/TimedDrivableExecutorTest.cpp
  function TEST (line 25) | TEST(TimedDrivableExecutor, runIsStable) {
  function TEST (line 38) | TEST(TimedDrivableExecutor, drainIsNotStable) {
  function TEST (line 51) | TEST(TimedDrivableExecutor, tryDrive) {
  function TEST (line 62) | TEST(TimedDrivableExecutor, tryDriveFor) {
  function TEST (line 73) | TEST(TimedDrivableExecutor, tryDriveUntil) {

FILE: folly/executors/test/TimekeeperScheduledExecutorTest.cpp
  function simpleTest (line 33) | void simpleTest(std::unique_ptr<folly::Executor> const& parent) {
  function TEST (line 70) | TEST(TimekeeperScheduledExecutor, SimpleThreaded) {
  function TEST (line 74) | TEST(TimekeeperScheduledExecutor, SimpleInline) {
  function TEST (line 78) | TEST(TimekeeperScheduledExecutor, Afterlife) {
  function RecursiveAddTest (line 113) | void RecursiveAddTest(std::unique_ptr<folly::Executor> const& grandparen...
  function TEST (line 146) | TEST(TimekeeperScheduledExecutor, RecursiveAdd) {
  function TEST (line 150) | TEST(TimekeeperScheduledExecutor, RecursiveAddInline) {
  function TEST (line 154) | TEST(TimekeeperScheduledExecutor, ExecutionThrows) {
  function TEST (line 163) | TEST(TimekeeperScheduledExecutor, NoTimekeeper) {

FILE: folly/executors/thread_factory/InitThreadFactory.h
  function namespace (line 25) | namespace folly {

FILE: folly/executors/thread_factory/NamedThreadFactory.h
  function namespace (line 28) | namespace folly {

FILE: folly/executors/thread_factory/PriorityThreadFactory.cpp
  type folly (line 25) | namespace folly {

FILE: folly/executors/thread_factory/PriorityThreadFactory.h
  function namespace (line 21) | namespace folly {

FILE: folly/executors/thread_factory/ThreadFactory.h
  function namespace (line 24) | namespace folly {

FILE: folly/ext/buck2/test_ext.cpp
  type folly (line 28) | namespace folly {
    type ext (line 29) | namespace ext {
      function test_find_resource_buck2 (line 31) | static std::string test_find_resource_buck2(std::string_view resourc...

FILE: folly/ext/test_ext.cpp
  type folly (line 19) | namespace folly {
    type ext (line 20) | namespace ext {

FILE: folly/ext/test_ext.h
  function namespace (line 24) | namespace folly {

FILE: folly/external/farmhash/farmhash.cpp
  type folly (line 202) | namespace folly {
    type external (line 203) | namespace external {
      type farmhash (line 204) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
      type farmhash (line 371) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
    type external (line 370) | namespace external {
      type farmhash (line 204) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
      type farmhash (line 371) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
  function STATIC_INLINE (line 355) | STATIC_INLINE __m128i Fetch128(const char* s) {
  type folly (line 369) | namespace folly {
    type external (line 203) | namespace external {
      type farmhash (line 204) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
      type farmhash (line 371) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
    type external (line 370) | namespace external {
      type farmhash (line 204) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {
      type farmhash (line 371) | namespace farmhash {
        type test (line 206) | namespace test {
        function STATIC_INLINE (line 210) | STATIC_INLINE uint64_t Fetch64(const char *p) {
        function STATIC_INLINE (line 216) | STATIC_INLINE uint32_t Fetch32(const char *p) {
        function STATIC_INLINE (line 222) | STATIC_INLINE uint32_t Bswap32(uint32_t val) { return bswap_32(val...
        function STATIC_INLINE (line 223) | STATIC_INLINE uint64_t Bswap64(uint64_t val) { return bswap_64(val...
        function STATIC_INLINE (line 227) | STATIC_INLINE uint32_t BasicRotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 232) | STATIC_INLINE uint64_t BasicRotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 239) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 245) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 253) | STATIC_INLINE uint32_t Rotate32(uint32_t val, int shift) {
        function STATIC_INLINE (line 256) | STATIC_INLINE uint64_t Rotate64(uint64_t val, int shift) {
        function STATIC_INLINE (line 383) | STATIC_INLINE uint32_t fmix(uint32_t h)
        function STATIC_INLINE (line 393) | STATIC_INLINE uint32_t Mur(uint32_t a, uint32_t h) {
        function STATIC_INLINE (line 403) | STATIC_INLINE T DebugTweak(T x) {
        function uint128_t (line 414) | uint128_t DebugTweak(uint128_t x) {
        type farmhashna (line 427) | namespace farmhashna {
          function STATIC_INLINE (line 437) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 441) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 445) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 455) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 482) | STATIC_INLINE uint64_t HashLen17to32(const char *s, size_t len) {
          function STATIC_INLINE (line 494) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 506) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 517) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function Hash64 (line 533) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 590) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 594) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashuo (line 598) | namespace farmhashuo {
          function STATIC_INLINE (line 605) | STATIC_INLINE uint64_t H(uint64_t x, uint64_t y, uint64_t mul, i...
          function Hash64WithSeeds (line 612) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function Hash64WithSeed (line 703) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64 (line 708) | uint64_t Hash64(const char *s, size_t len) {
        type farmhashxo (line 713) | namespace farmhashxo {
          function STATIC_INLINE (line 720) | STATIC_INLINE uint64_t H32(const char *s, size_t len, uint64_t mul,
          function STATIC_INLINE (line 734) | STATIC_INLINE uint64_t HashLen33to64(const char *s, size_t len) {
          function STATIC_INLINE (line 743) | STATIC_INLINE uint64_t HashLen65to96(const char *s, size_t len) {
          function Hash64 (line 752) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeeds (line 770) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
          function Hash64WithSeed (line 774) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
        type farmhashte (line 778) | namespace farmhashte {
          function Hash64 (line 781) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 786) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 791) | uint64_t Hash64WithSeeds(const char *s, size_t len,
          function STATIC_INLINE (line 809) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 810) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 811) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 812) | STATIC_INLINE __m128i Shuf(__m128i x, __m128i y) { return _mm_sh...
          function STATIC_INLINE (line 816) | STATIC_INLINE uint64_t Hash64Long(const char* s, size_t n,
          function Hash64 (line 993) | uint64_t Hash64(const char *s, size_t len) {
          function Hash64WithSeed (line 998) | uint64_t Hash64WithSeed(const char *s, size_t len, uint64_t seed) {
          function Hash64WithSeeds (line 1003) | uint64_t Hash64WithSeeds(const char *s, size_t len, uint64_t see...
        type farmhashnt (line 1010) | namespace farmhashnt {
          function Hash32 (line 1013) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1018) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function Hash32 (line 1025) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1029) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashmk (line 1035) | namespace farmhashmk {
          function STATIC_INLINE (line 1045) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len...
          function STATIC_INLINE (line 1062) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len, ...
          function STATIC_INLINE (line 1073) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len,...
          function Hash32 (line 1081) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1139) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsu (line 1149) | namespace farmhashsu {
          function Hash32 (line 1152) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1157) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1174) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1175) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1176) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1177) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1178) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1179) | STATIC_INLINE __m128i RotateLeft(__m128i x, int c) {
          function STATIC_INLINE (line 1183) | STATIC_INLINE __m128i Rol17(__m128i x) { return RotateLeft(x, 17...
          function STATIC_INLINE (line 1184) | STATIC_INLINE __m128i Rol19(__m128i x) { return RotateLeft(x, 19...
          function STATIC_INLINE (line 1185) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1189) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1357) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashsa (line 1369) | namespace farmhashsa {
          function Hash32 (line 1372) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1377) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1394) | STATIC_INLINE __m128i Add(__m128i x, __m128i y) { return _mm_add...
          function STATIC_INLINE (line 1395) | STATIC_INLINE __m128i Xor(__m128i x, __m128i y) { return _mm_xor...
          function STATIC_INLINE (line 1396) | STATIC_INLINE __m128i Or(__m128i x, __m128i y) { return _mm_or_s...
          function STATIC_INLINE (line 1397) | STATIC_INLINE __m128i Mul(__m128i x, __m128i y) { return _mm_mul...
          function STATIC_INLINE (line 1398) | STATIC_INLINE __m128i Mul5(__m128i x) { return Add(x, _mm_slli_e...
          function STATIC_INLINE (line 1399) | STATIC_INLINE __m128i Rotate(__m128i x, int c) {
          function STATIC_INLINE (line 1403) | STATIC_INLINE __m128i Rot17(__m128i x) { return Rotate(x, 17); }
          function STATIC_INLINE (line 1404) | STATIC_INLINE __m128i Rot19(__m128i x) { return Rotate(x, 19); }
          function STATIC_INLINE (line 1405) | STATIC_INLINE __m128i Shuffle0321(__m128i x) {
          function Hash32 (line 1409) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1567) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
        type farmhashcc (line 1579) | namespace farmhashcc {
          function STATIC_INLINE (line 1593) | STATIC_INLINE uint32_t Hash32Len13to24(const char *s, size_t len) {
          function STATIC_INLINE (line 1605) | STATIC_INLINE uint32_t Hash32Len0to4(const char *s, size_t len) {
          function STATIC_INLINE (line 1616) | STATIC_INLINE uint32_t Hash32Len5to12(const char *s, size_t len) {
          function Hash32 (line 1624) | uint32_t Hash32(const char *s, size_t len) {
          function Hash32WithSeed (line 1695) | uint32_t Hash32WithSeed(const char *s, size_t len, uint32_t seed) {
          function STATIC_INLINE (line 1714) | STATIC_INLINE uint64_t ShiftMix(uint64_t val) {
          function STATIC_INLINE (line 1718) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v) {
          function STATIC_INLINE (line 1722) | STATIC_INLINE uint64_t HashLen16(uint64_t u, uint64_t v, uint64_...
          function STATIC_INLINE (line 1732) | STATIC_INLINE uint64_t HashLen0to16(const char *s, size_t len) {
          function STATIC_INLINE (line 1759) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1771) | STATIC_INLINE pair<uint64_t, uint64_t> WeakHashLen32WithSeeds(
          function STATIC_INLINE (line 1785) | STATIC_INLINE uint128_t CityMurmur(const char *s, size_t len, ui...
          function uint128_t (line 1815) | uint128_t CityHash128WithSeed(const char *s, size_t len, uint128...
          function STATIC_INLINE (line 1878) | STATIC_INLINE uint128_t CityHash128(const char *s, size_t len) {
          function uint128_t (line 1885) | uint128_t Fingerprint128(const char* s, size_t len) {
        function Hash32 (line 1895) | uint32_t Hash32(const char* s, size_t len) {
        function Hash32WithSeed (line 1907) | uint32_t Hash32WithSeed(const char* s, size_t len, uint32_t seed) {
        function Hash64 (line 1919) | uint64_t Hash64(const char* s, size_t len) {
        function Hash (line 1929) | size_t Hash(const char* s, size_t len) {
        function Hash64WithSeed (line 1937) | uint64_t Hash64WithSeed(const char* s, size_t len, uint64_t seed) {
        function Hash64WithSeeds (line 1945) | uint64_t Hash64WithSeeds(const char* s, size_t len, uint64_t seed0...
        function uint128_t (line 1952) | uint128_t Hash128(const char* s, size_t len) {
        function uint128_t (line 1960) | uint128_t Hash128WithSeed(const char* s, size_t len, uint128_t see...
        function Fingerprint32 (line 1969) | uint32_t Fingerprint32(const char* s, size_t len) {
        function Fingerprint64 (line 1974) | uint64_t Fingerprint64(const char* s, size_t len) {
        function uint128_t (line 1979) | uint128_t Fingerprint128(const char* s, size_t len) {

FILE: folly/external/farmhash/farmhash.h
  function namespace (line 55) | namespace folly {

FILE: folly/external/farmhash/test/farmhash_test.cpp
  function Setup (line 65) | void Setup() {
  function NoteErrors (line 81) | int NoteErrors() {
  function IsNonZero (line 90) | inline bool IsNonZero(T x) {
  type farmhashccTest (line 100) | namespace farmhashccTest {
    function CreateSeed (line 102) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 1582) | bool Test(int offset, int len = 0) {
    function RunTest (line 1611) | int RunTest() {
    function Dump (line 1635) | void Dump(int offset, int len) {
  function TEST (line 1653) | TEST(farmhash, cc) { farmhashccTest::RunTest(); }
  function main (line 1656) | int main(int argc, char** argv) {
  function Setup (line 1694) | void Setup() {
  function NoteErrors (line 1709) | int NoteErrors() {
  function IsNonZero (line 1716) | inline bool IsNonZero(T x) {
  type farmhashmkTest (line 1726) | namespace farmhashmkTest {
    function CreateSeed (line 1728) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 2484) | bool Test(int offset, int len = 0) {
    function RunTest (line 2511) | int RunTest() {
    function Dump (line 2535) | void Dump(int offset, int len) {
  function TEST (line 2551) | TEST(farmhash, mk) { farmhashmkTest::RunTest(); }
  function main (line 2554) | int main(int argc, char** argv) {
  function Setup (line 2591) | void Setup() {
  function NoteErrors (line 2606) | int NoteErrors() {
  function IsNonZero (line 2613) | inline bool IsNonZero(T x) {
  type farmhashnaTest (line 2623) | namespace farmhashnaTest {
    function CreateSeed (line 2625) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 3743) | bool Test(int offset, int len = 0) {
    function RunTest (line 3771) | int RunTest() {
    function Dump (line 3795) | void Dump(int offset, int len) {
  function TEST (line 3812) | TEST(farmhash, na) { farmhashnaTest::RunTest(); }
  function main (line 3815) | int main(int argc, char** argv) {
  function Setup (line 3852) | void Setup() {
  function NoteErrors (line 3867) | int NoteErrors() {
  function IsNonZero (line 3874) | inline bool IsNonZero(T x) {
  type farmhashntTest (line 3884) | namespace farmhashntTest {
    function CreateSeed (line 3886) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 4642) | bool Test(int offset, int len = 0) {
    function RunTest (line 4669) | int RunTest() {
    function Dump (line 4693) | void Dump(int offset, int len) {
  function TEST (line 4709) | TEST(farmhash, nt) { farmhashntTest::RunTest(); }
  function main (line 4712) | int main(int argc, char** argv) {
  function Setup (line 4749) | void Setup() {
  function NoteErrors (line 4764) | int NoteErrors() {
  function IsNonZero (line 4771) | inline bool IsNonZero(T x) {
  type farmhashsaTest (line 4781) | namespace farmhashsaTest {
    function CreateSeed (line 4783) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 5539) | bool Test(int offset, int len = 0) {
    function RunTest (line 5566) | int RunTest() {
    function Dump (line 5590) | void Dump(int offset, int len) {
  function TEST (line 5606) | TEST(farmhash, sa) { farmhashsaTest::RunTest(); }
  function main (line 5609) | int main(int argc, char** argv) {
  function Setup (line 5646) | void Setup() {
  function NoteErrors (line 5661) | int NoteErrors() {
  function IsNonZero (line 5668) | inline bool IsNonZero(T x) {
  type farmhashsuTest (line 5678) | namespace farmhashsuTest {
    function CreateSeed (line 5680) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 6436) | bool Test(int offset, int len = 0) {
    function RunTest (line 6463) | int RunTest() {
    function Dump (line 6487) | void Dump(int offset, int len) {
  function TEST (line 6503) | TEST(farmhash, su) { farmhashsuTest::RunTest(); }
  function main (line 6506) | int main(int argc, char** argv) {
  function Setup (line 6543) | void Setup() {
  function NoteErrors (line 6558) | int NoteErrors() {
  function IsNonZero (line 6565) | inline bool IsNonZero(T x) {
  type farmhashteTest (line 6575) | namespace farmhashteTest {
    function CreateSeed (line 6577) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 7695) | bool Test(int offset, int len = 0) {
    function RunTest (line 7723) | int RunTest() {
    function Dump (line 7747) | void Dump(int offset, int len) {
  function TEST (line 7764) | TEST(farmhash, te) { farmhashteTest::RunTest(); }
  function main (line 7767) | int main(int argc, char** argv) {
  function Setup (line 7804) | void Setup() {
  function NoteErrors (line 7819) | int NoteErrors() {
  function IsNonZero (line 7826) | inline bool IsNonZero(T x) {
  type farmhashuoTest (line 7836) | namespace farmhashuoTest {
    function CreateSeed (line 7838) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 8594) | bool Test(int offset, int len = 0) {
    function RunTest (line 8621) | int RunTest() {
    function Dump (line 8645) | void Dump(int offset, int len) {
  function TEST (line 8661) | TEST(farmhash, uo) { farmhashuoTest::RunTest(); }
  function main (line 8664) | int main(int argc, char** argv) {
  function Setup (line 8701) | void Setup() {
  function NoteErrors (line 8716) | int NoteErrors() {
  function IsNonZero (line 8723) | inline bool IsNonZero(T x) {
  type farmhashxoTest (line 8733) | namespace farmhashxoTest {
    function CreateSeed (line 8735) | uint32_t CreateSeed(int offset, int salt) {
    function Test (line 9853) | bool Test(int offset, int len = 0) {
    function RunTest (line 9881) | int RunTest() {
    function Dump (line 9905) | void Dump(int offset, int len) {
  function TEST (line 9922) | TEST(farmhash, xo) { farmhashxoTest::RunTest(); }
  function main (line 9925) | int main(int argc, char** argv) {

FILE: folly/external/fast-crc32/avx512_crc32c_v8s3x4.cpp
  type folly::detail (line 12) | namespace folly::detail {
    function CRC_EXPORT (line 13) | CRC_EXPORT uint32_t avx512_crc32c_v8s3x4(const uint8_t*, size_t, uint3...
    function CRC_AINLINE (line 34) | CRC_AINLINE __m128i clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 38) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 57) | CRC_AINLINE __m128i crc_shift(uint32_t crc, size_t nbytes) {
    function avx512_crc32c_v8s3x4 (line 62) | uint32_t avx512_crc32c_v8s3x4(const uint8_t* buf, size_t len, uint32_t...
  type folly::detail (line 33) | namespace folly::detail {
    function CRC_EXPORT (line 13) | CRC_EXPORT uint32_t avx512_crc32c_v8s3x4(const uint8_t*, size_t, uint3...
    function CRC_AINLINE (line 34) | CRC_AINLINE __m128i clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 38) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 57) | CRC_AINLINE __m128i crc_shift(uint32_t crc, size_t nbytes) {
    function avx512_crc32c_v8s3x4 (line 62) | uint32_t avx512_crc32c_v8s3x4(const uint8_t* buf, size_t len, uint32_t...

FILE: folly/external/fast-crc32/avx512_crc32c_v8s3x4.h
  function namespace (line 10) | namespace folly::detail {

FILE: folly/external/fast-crc32/neon_crc32c_v3s4x2e_v2.cpp
  type folly::detail (line 14) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 28) | CRC_EXPORT bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_AINLINE (line 45) | CRC_AINLINE uint64x2_t clmul_lo_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_hi_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 57) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 76) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_crc32c_v3s4x2e_v2 (line 81) | bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_EXPORT (line 88) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t* buf, size_t ...
  type folly::detail (line 23) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 28) | CRC_EXPORT bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_AINLINE (line 45) | CRC_AINLINE uint64x2_t clmul_lo_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_hi_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 57) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 76) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_crc32c_v3s4x2e_v2 (line 81) | bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_EXPORT (line 88) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t* buf, size_t ...
  type folly::detail (line 44) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 28) | CRC_EXPORT bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_AINLINE (line 45) | CRC_AINLINE uint64x2_t clmul_lo_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_hi_e(uint64x2_t a, uint64x2_t b, uint64x2...
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 57) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 76) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_crc32c_v3s4x2e_v2 (line 81) | bool has_neon_crc32c_v3s4x2e_v2() {
    function CRC_EXPORT (line 88) | CRC_EXPORT uint32_t neon_crc32c_v3s4x2e_v2(const uint8_t* buf, size_t ...

FILE: folly/external/fast-crc32/neon_crc32c_v3s4x2e_v2.h
  function namespace (line 5) | namespace folly::detail {

FILE: folly/external/fast-crc32/neon_eor3_crc32_v8s2x4e_s1x2.cpp
  type folly::detail (line 14) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t*, size_...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t*, size_t, uint...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32_v8s2x4e_s1x2 (line 85) | bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t* buf, size_t l...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t* buf, s...
  type folly::detail (line 23) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t*, size_...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t*, size_t, uint...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32_v8s2x4e_s1x2 (line 85) | bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t* buf, size_t l...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t* buf, s...
  type folly::detail (line 48) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t*, size_...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t*, size_t, uint...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32_v8s2x4e_s1x2 (line 85) | bool has_neon_eor3_crc32_v8s2x4e_s1x2() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32_small(const uint8_t* buf, size_t l...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32_v8s2x4e_s1x2(const uint8_t* buf, s...

FILE: folly/external/fast-crc32/neon_eor3_crc32_v8s2x4e_s1x2.h
  function namespace (line 5) | namespace folly::detail {

FILE: folly/external/fast-crc32/neon_eor3_crc32c_v8s2x4e_s2x1.cpp
  type folly::detail (line 14) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t*, size...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32c_v8s2x4e_s2x1 (line 85) | bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t* buf, size_t ...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t* buf, ...
  type folly::detail (line 23) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t*, size...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32c_v8s2x4e_s2x1 (line 85) | bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t* buf, size_t ...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t* buf, ...
  type folly::detail (line 48) | namespace folly::detail {
    function ElfHwCaps (line 15) | [[maybe_unused]] static ElfHwCaps hwcaps() {
    function CRC_EXPORT (line 24) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t*, size...
    function CRC_EXPORT (line 28) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t*, size_t, uin...
    function CRC_EXPORT (line 32) | CRC_EXPORT bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_AINLINE (line 49) | CRC_AINLINE uint64x2_t clmul_lo(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 53) | CRC_AINLINE uint64x2_t clmul_hi(uint64x2_t a, uint64x2_t b) {
    function CRC_AINLINE (line 57) | CRC_AINLINE uint64x2_t clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 61) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 80) | CRC_AINLINE uint64x2_t crc_shift(uint32_t crc, size_t nbytes) {
    function has_neon_eor3_crc32c_v8s2x4e_s2x1 (line 85) | bool has_neon_eor3_crc32c_v8s2x4e_s2x1() {
    function CRC_EXPORT (line 93) | CRC_EXPORT uint32_t neon_eor3_crc32c_small(const uint8_t* buf, size_t ...
    function CRC_EXPORT (line 161) | CRC_EXPORT uint32_t neon_eor3_crc32c_v8s2x4e_s2x1(const uint8_t* buf, ...

FILE: folly/external/fast-crc32/neon_eor3_crc32c_v8s2x4e_s2x1.h
  function namespace (line 5) | namespace folly::detail {

FILE: folly/external/fast-crc32/sse_crc32c_v8s3x3.cpp
  type folly::detail (line 12) | namespace folly::detail {
    function CRC_EXPORT (line 13) | CRC_EXPORT uint32_t sse_crc32c_v8s3x3(const uint8_t*, size_t, uint32_t) {
    function CRC_AINLINE (line 33) | CRC_AINLINE __m128i clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 37) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 56) | CRC_AINLINE __m128i crc_shift(uint32_t crc, size_t nbytes) {
    function sse_crc32c_v8s3x3 (line 61) | uint32_t sse_crc32c_v8s3x3(const uint8_t* buf, size_t len, uint32_t cr...
  type folly::detail (line 32) | namespace folly::detail {
    function CRC_EXPORT (line 13) | CRC_EXPORT uint32_t sse_crc32c_v8s3x3(const uint8_t*, size_t, uint32_t) {
    function CRC_AINLINE (line 33) | CRC_AINLINE __m128i clmul_scalar(uint32_t a, uint32_t b) {
    function xnmodp (line 37) | static uint32_t xnmodp(uint64_t n) /* x^n mod P, in log(n) time */ {
    function CRC_AINLINE (line 56) | CRC_AINLINE __m128i crc_shift(uint32_t crc, size_t nbytes) {
    function sse_crc32c_v8s3x3 (line 61) | uint32_t sse_crc32c_v8s3x3(const uint8_t* buf, size_t len, uint32_t cr...

FILE: folly/external/fast-crc32/sse_crc32c_v8s3x3.h
  function namespace (line 10) | namespace folly::detail {

FILE: folly/external/nvidia/detail/RangeSve2.cpp
  type folly (line 22) | namespace folly {
    type detail (line 23) | namespace detail {
      function qfind_first_byte_of_sve2 (line 24) | size_t qfind_first_byte_of_sve2(
      function qfind_first_byte_of_needles16 (line 39) | size_t qfind_first_byte_of_needles16(
      function qfind_first_byte_of_sve2 (line 86) | size_t qfind_first_byte_of_sve2(
    type detail (line 36) | namespace detail {
      function qfind_first_byte_of_sve2 (line 24) | size_t qfind_first_byte_of_sve2(
      function qfind_first_byte_of_needles16 (line 39) | size_t qfind_first_byte_of_needles16(
      function qfind_first_byte_of_sve2 (line 86) | size_t qfind_first_byte_of_sve2(
  type folly (line 35) | namespace folly {
    type detail (line 23) | namespace detail {
      function qfind_first_byte_of_sve2 (line 24) | size_t qfind_first_byte_of_sve2(
      function qfind_first_byte_of_needles16 (line 39) | size_t qfind_first_byte_of_needles16(
      function qfind_first_byte_of_sve2 (line 86) | size_t qfind_first_byte_of_sve2(
    type detail (line 36) | namespace detail {
      function qfind_first_byte_of_sve2 (line 24) | size_t qfind_first_byte_of_sve2(
      function qfind_first_byte_of_needles16 (line 39) | size_t qfind_first_byte_of_needles16(
      function qfind_first_byte_of_sve2 (line 86) | size_t qfind_first_byte_of_sve2(

FILE: folly/external/nvidia/detail/RangeSve2.h
  function namespace (line 23) | namespace folly {

FILE: folly/external/nvidia/hash/Checksum.cpp
  type folly::detail (line 28) | namespace folly::detail {
    function crc32_hw (line 30) | uint32_t crc32_hw(const uint8_t* buf, size_t len, uint32_t crc) {

FILE: folly/external/nvidia/hash/detail/Crc32cCombineDetail.h
  function namespace (line 26) | namespace folly::detail {

FILE: folly/external/nvidia/hash/detail/Crc32cDetail.cpp
  type folly::detail (line 27) | namespace folly::detail {
    function crc32c_hw (line 29) | uint32_t crc32c_hw(const uint8_t* buf, size_t len, uint32_t crc) {

FILE: folly/external/rapidhash/rapidhash.h
  function namespace (line 50) | namespace folly {

FILE: folly/fibers/AddTasks-inl.h
  function namespace (line 20) | namespace folly {
  type invoke_result_t (line 116) | typedef invoke_result_t<
  type TaskIterator (line 119) | typedef TaskIterator<ResultType> IteratorType;

FILE: folly/fibers/AddTasks.h
  function namespace (line 27) | namespace folly {

FILE: folly/fibers/AtomicBatchDispatcher-inl.h
  function namespace (line 17) | namespace folly {
  function fulfillPromises (line 59) | void fulfillPromises() {
  type Entry (line 110) | struct Entry {

FILE: folly/fibers/AtomicBatchDispatcher.h
  function namespace (line 32) | namespace folly {
  type DispatchBaton (line 171) | struct DispatchBaton
  function class (line 178) | class Token {

FILE: folly/fibers/BatchDispatcher.h
  function namespace (line 28) | namespace folly {
  type DispatchState (line 100) | struct DispatchState {
  function dispatchFunctionWrapper (line 109) | static void dispatchFunctionWrapper(DispatchState& state) {

FILE: folly/fibers/BatchSemaphore.cpp
  type folly (line 19) | namespace folly {
    type fibers (line 20) | namespace fibers {

FILE: folly/fibers/BatchSemaphore.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/Baton-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/Baton.cpp
  type folly (line 25) | namespace folly {
    type fibers (line 26) | namespace fibers {

FILE: folly/fibers/Baton.h
  function class (line 38) | class Baton {

FILE: folly/fibers/BoostContextCompatibility.h
  function namespace (line 31) | namespace folly {

FILE: folly/fibers/CallOnce.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/EventBaseLoopController-inl.h
  function namespace (line 19) | namespace folly {
  function scheduleThreadSafe (line 107) | inline void EventBaseLoopController::scheduleThreadSafe() {
  function HHWheelTimer (line 127) | inline HHWheelTimer* EventBaseLoopController::timer() {

FILE: folly/fibers/EventBaseLoopController.h
  function VirtualEventBase (line 41) | VirtualEventBase* getEventBase() { return eventBase_; }
  function setLoopRunner (line 43) | void setLoopRunner(InlineFunctionRunner* loopRunner) {
  function isInLoopThread (line 49) | bool isInLoopThread() override {
  function runLoopCallback (line 59) | void runLoopCallback() noexcept override { controller_.runLoop(); }
  function InlineFunctionRunner (line 71) | InlineFunctionRunner* loopRunner_{nullptr};

FILE: folly/fibers/ExecutorBasedLoopController.h
  function namespace (line 22) | namespace folly {

FILE: folly/fibers/ExecutorLoopController-inl.h
  function namespace (line 22) | namespace folly {
  function runEagerFiber (line 72) | inline void ExecutorLoopController::runEagerFiber(Fiber* fiber) {
  function scheduleThreadSafe (line 83) | inline void ExecutorLoopController::scheduleThreadSafe() {
  function HHWheelTimer (line 92) | inline HHWheelTimer* ExecutorLoopController::timer() {

FILE: folly/fibers/ExecutorLoopController.h
  function namespace (line 26) | namespace folly {

FILE: folly/fibers/Fiber-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/Fiber.cpp
  type folly (line 29) | namespace folly {
    type fibers (line 30) | namespace fibers {
      function nonMagicInBytes (line 36) | size_t nonMagicInBytes(unsigned char* stackLimit, size_t stackSize) {

FILE: folly/fibers/Fiber.h
  type AsyncStackRoot (line 39) | struct AsyncStackRoot
  function namespace (line 41) | namespace fibers {
  type State (line 89) | enum State : char {
  type VTable (line 195) | struct VTable {
  function VTable (line 217) | VTable vtable_{}
  function asanMainStackSize_ (line 230) | size_t asanMainStackSize_{0};

FILE: folly/fibers/FiberManager-inl.h
  function namespace (line 22) | namespace folly {

FILE: folly/fibers/FiberManager.cpp
  type std (line 36) | namespace std {
    type hash<folly::fibers::FiberManager::Options> (line 38) | struct hash<folly::fibers::FiberManager::Options> {
  type folly (line 45) | namespace folly {
    type fibers (line 46) | namespace fibers {
      function FiberManager (line 58) | FiberManager*& FiberManager::getCurrentFiberManager() {
      function LoopController (line 78) | LoopController& FiberManager::loopController() {
      function LoopController (line 82) | const LoopController& FiberManager::loopController() const {
      function Fiber (line 96) | Fiber* FiberManager::getFiber() {
      function hasAlternateStack (line 225) | bool hasAlternateStack() {
      function setAlternateStack (line 231) | int setAlternateStack(char* sp, size_t size) {
      function unsetAlternateStack (line 239) | int unsetAlternateStack() {
      class ScopedAlternateSignalStack (line 245) | class ScopedAlternateSignalStack {
        method ScopedAlternateSignalStack (line 247) | ScopedAlternateSignalStack() {
        method ScopedAlternateSignalStack (line 261) | ScopedAlternateSignalStack(ScopedAlternateSignalStack&&) = default;
        method ScopedAlternateSignalStack (line 262) | ScopedAlternateSignalStack& operator=(ScopedAlternateSignalStack&&...

FILE: folly/fibers/FiberManagerInternal-inl.h
  function namespace (line 33) | namespace folly {
  function recordStackPosition (line 266) | inline size_t FiberManager::recordStackPosition(size_t position) {
  function loopUntilNoReadyImpl (line 272) | inline void FiberManager::loopUntilNoReadyImpl() {
  function runEagerFiber (line 316) | inline void FiberManager::runEagerFiber(Fiber* fiber) {
  function runEagerFiberImpl (line 320) | inline void FiberManager::runEagerFiberImpl(Fiber* fiber) {
  function shouldRunLoopRemote (line 330) | inline bool FiberManager::shouldRunLoopRemote() {
  function class (line 349) | class Func {
  type AddTaskHelper (line 374) | typedef AddTaskHelper<F> Helper;
  type invoke_result_t (line 436) | typedef invoke_result_t<F> Result;
  function class (line 438) | class Finally {
  function class (line 465) | class Func {
  type invoke_result_t (line 491) | typedef invoke_result_t<F> Result;
  type AddTaskFinallyHelper (line 506) | typedef AddTaskFinallyHelper<
  type invoke_result_t (line 551) | typedef invoke_result_t<F> Result;
  function FiberManager (line 569) | inline FiberManager* FiberManager::getFiberManagerUnsafe() {
  function yield (line 582) | inline void FiberManager::yield() {
  function initLocalData (line 603) | inline void FiberManager::initLocalData(Fiber& fiber) {
  function value_type (line 626) | value_type inline await_async(F&& func) {

FILE: folly/fibers/FiberManagerInternal.h
  function namespace (line 51) | namespace fibers {
  type FrozenOptions (line 153) | struct FrozenOptions {
  function LoopController (line 200) | const LoopController& loopController() const;
  function hasReadyTasks (line 240) | bool hasReadyTasks() const;
  type RemoteTask (line 451) | struct RemoteTask {
  function fiberId_ (line 509) | size_t fiberId_{0}
  function maxFibersActiveLastPeriod_ (line 515) | size_t maxFibersActiveLastPeriod_{0}
  function InlineFunctionRunner (line 567) | InlineFunctionRunner* preemptRunner_{nullptr};

FILE: folly/fibers/FiberManagerMap-inl.h
  function namespace (line 30) | namespace folly {

FILE: folly/fibers/FiberManagerMap.h
  function namespace (line 23) | namespace folly {

FILE: folly/fibers/ForEach-inl.h
  function namespace (line 20) | namespace folly {

FILE: folly/fibers/ForEach.h
  function namespace (line 19) | namespace folly {

FILE: folly/fibers/GenericBaton.h
  function namespace (line 23) | namespace folly {

FILE: folly/fibers/GuardPageAllocator.cpp
  type folly (line 35) | namespace folly {
    type fibers (line 36) | namespace fibers {
      class StackCache (line 61) | class StackCache {
        method StackCache (line 63) | explicit StackCache(size_t stackSize, size_t guardPagesPerStack)
        method giveBack (line 121) | bool giveBack(unsigned char* limit, size_t size) {
        method isProtected (line 154) | static bool isProtected(intptr_t addr) {
        method pagesize (line 177) | static size_t pagesize() {
        method allocSize (line 185) | static size_t allocSize(size_t size, size_t guardPages) {
      type sigaction (line 204) | struct sigaction
      function FOLLY_NOINLINE (line 206) | FOLLY_NOINLINE void FOLLY_FIBERS_STACK_OVERFLOW_DETECTED(
      function sigsegvSignalHandler (line 220) | void sigsegvSignalHandler(int signum, siginfo_t* info, void* ucontex...
      function isInJVM (line 246) | bool isInJVM() {
      function maybeInstallGuardPageSignalHandler (line 251) | void maybeInstallGuardPageSignalHandler() {
      function installGuardPageSignalHandler (line 257) | void installGuardPageSignalHandler() {
      class StackCacheEntry (line 283) | class StackCacheEntry {
        method StackCacheEntry (line 285) | explicit StackCacheEntry(size_t stackSize, size_t guardPagesPerStack)
        method StackCache (line 289) | StackCache& cache() const noexcept { return *stackCache_; }
      class CacheManager (line 297) | class CacheManager {
        method CacheManager (line 299) | static CacheManager& instance() {
        method getStackCache (line 304) | std::unique_ptr<StackCacheEntry> getStackCache(
        method giveBack (line 321) | void giveBack(std::unique_ptr<StackCache> /* stackCache_ */) {

FILE: folly/fibers/GuardPageAllocator.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/LoopController.h
  function namespace (line 24) | namespace folly {

FILE: folly/fibers/Promise-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/fibers/Promise.h
  function namespace (line 23) | namespace folly {

FILE: folly/fibers/Semaphore.cpp
  type folly (line 19) | namespace folly {
    type fibers (line 20) | namespace fibers {
      class FutureWaiter (line 194) | class FutureWaiter final : public fibers::Baton::Waiter {
        method FutureWaiter (line 196) | FutureWaiter() { semaphoreWaiter.baton.setWaiter(*this); }
        method post (line 198) | void post() override {

FILE: folly/fibers/Semaphore.h
  function namespace (line 28) | namespace folly {

FILE: folly/fibers/SemaphoreBase.cpp
  type folly (line 19) | namespace folly {
    type fibers (line 20) | namespace fibers {
      class FutureWaiter (line 195) | class FutureWaiter final : public fibers::Baton::Waiter {
        method FutureWaiter (line 197) | explicit FutureWaiter(int64_t tokens) : semaphoreWaiter(tokens) {
        method post (line 201) | void post() override {

FILE: folly/fibers/SemaphoreBase.h
  function namespace (line 29) | namespace folly {

FILE: folly/fibers/SimpleLoopController.cpp
  type folly (line 21) | namespace folly {
    type fibers (line 22) | namespace fibers {
      class SimpleLoopController::SimpleTimeoutManager (line 28) | class SimpleLoopController::SimpleTimeoutManager : public TimeoutMan...
        method SimpleTimeoutManager (line 30) | explicit SimpleTimeoutManager(SimpleLoopController& loopController)
        method attachTimeoutManager (line 33) | void attachTimeoutManager(
        method detachTimeoutManager (line 35) | void detachTimeoutManager(AsyncTimeout* /* unused */) final {}
        method scheduleTimeout (line 37) | bool scheduleTimeout(AsyncTimeout* obj, timeout_type timeout) final {
        method cancelTimeout (line 44) | void cancelTimeout(AsyncTimeout* obj) final {
        method bumpHandlingTime (line 49) | void bumpHandlingTime() final {}
        method isInTimeoutManagerThread (line 51) | bool isInTimeoutManagerThread() final {
        method runTimeouts (line 55) | void runTimeouts() {

FILE: folly/fibers/SimpleLoopController.h
  function namespace (line 26) | namespace folly {

FILE: folly/fibers/TimedMutex-inl.h
  function namespace (line 22) | namespace folly {
  function lock (line 115) | inline void TimedMutex::lock() {
  function try_lock (line 168) | inline bool TimedMutex::try_lock() {
  function unlock (line 177) | inline void TimedMutex::unlock() {
  function tryMutate (line 209) | static bool tryMutate(
  function explicit (line 232) | explicit StateLock(std::atomic<uint64_t>& stateRef) : stateRef_(stateRef) {
  function state (line 248) | uint64_t& state() {
  function unlock (line 253) | void unlock() {
  function StateLock (line 329) | StateLock slock{state_};
  function StateLock (line 369) | StateLock slock2{state_};
  function StateLock (line 390) | StateLock slock{state_};
  function StateLock (line 422) | StateLock slock{state_};
  function StateLock (line 461) | StateLock slock2{state_};
  function StateLock (line 478) | StateLock slock{state_};
  function StateLock (line 490) | StateLock slock{state_};
  function StateLock (line 546) | StateLock slock{state_};

FILE: folly/fibers/TimedMutex.h
  function namespace (line 24) | namespace folly {

FILE: folly/fibers/WhenN-inl.h
  function namespace (line 21) | namespace folly {

FILE: folly/fibers/WhenN.h
  function namespace (line 27) | namespace folly {

FILE: folly/fibers/async/Async.cpp
  type folly (line 21) | namespace folly {
    type fibers (line 22) | namespace fibers {
      type async (line 23) | namespace async {
        type detail (line 24) | namespace detail {
          function onFiber (line 26) | bool onFiber() {

FILE: folly/fibers/async/Async.h
  function namespace (line 28) | namespace folly {

FILE: folly/fibers/async/AsyncStack.h
  function namespace (line 25) | namespace folly::fibers::async {

FILE: folly/fibers/async/Baton.h
  function namespace (line 26) | namespace folly {

FILE: folly/fibers/async/Collect-inl.h
  function namespace (line 17) | namespace folly {

FILE: folly/fibers/async/Collect.h
  function namespace (line 32) | namespace folly {

FILE: folly/fibers/async/FiberManager.h
  function namespace (line 22) | namespace folly {

FILE: folly/fibers/async/Future.h
  function namespace (line 22) | namespace folly {

FILE: folly/fibers/async/Promise.h
  function namespace (line 23) | namespace folly {

FILE: folly/fibers/async/Task.h
  function namespace (line 23) | namespace folly {

FILE: folly/fibers/async/WaitUtils.h
  function namespace (line 24) | namespace folly {

FILE: folly/fibers/async/test/AsyncTest.cpp
  function getString (line 40) | std::string getString() {
  function getAsyncNothing (line 43) | async::Async<void> getAsyncNothing() {
  function getAsyncString (line 46) | async::Async<std::string> getAsyncString() {
  function getOptionalAsyncString (line 49) | async::Async<folly::Optional<std::string>> getOptionalAsyncString() {
  function getTuple (line 54) | async::Async<std::tuple<int, float, std::string>> getTuple() {
  type NonCopyableNonMoveable (line 58) | struct NonCopyableNonMoveable {
    method NonCopyableNonMoveable (line 59) | constexpr NonCopyableNonMoveable() noexcept = default;
    method NonCopyableNonMoveable (line 62) | NonCopyableNonMoveable(const NonCopyableNonMoveable&) = delete;
    method NonCopyableNonMoveable (line 63) | NonCopyableNonMoveable(NonCopyableNonMoveable&&) = delete;
    method NonCopyableNonMoveable (line 64) | NonCopyableNonMoveable& operator=(NonCopyableNonMoveable const&) = del...
    method NonCopyableNonMoveable (line 65) | NonCopyableNonMoveable& operator=(NonCopyableNonMoveable&&) = delete;
  function getReference (line 68) | async::Async<NonCopyableNonMoveable const&> getReference() {
  function TEST (line 76) | TEST(AsyncTest, asyncAwait) {
  function TEST (line 93) | TEST(AsyncTest, asyncBaton) {
  function TEST (line 124) | TEST(AsyncTest, asyncPromise) {
  function TEST (line 136) | TEST(AsyncTest, asyncFuture) {
  function TEST (line 185) | TEST(AsyncTest, asyncTask) {
  function TEST (line 212) | TEST(AsyncTest, asyncTraits) {
  function TEST (line 221) | TEST(AsyncTest, asyncConstructorGuides) {
  function TEST (line 249) | TEST(FiberManager, asyncFiberManager) {
  function TEST (line 304) | TEST(AsyncTest, collect) {
  function TEST (line 353) | TEST(FiberManager, remoteFiberManager) {
  function FOLLY_NOINLINE (line 394) | FOLLY_NOINLINE std::vector<std::uintptr_t> getAsyncStack() {
  function expectStackSize (line 409) | void expectStackSize(size_t size, F&& func) {
  function TEST (line 413) | TEST(AsyncStack, fiberEntryPoint) {
  function TEST (line 437) | TEST(AsyncStack, awaitTry) {
  function TEST (line 471) | TEST(AsyncStack, fiberToFiber) {
  function TEST (line 507) | TEST(AsyncStack, fiberToMainContext) {
  function TEST (line 536) | TEST(AsyncStack, coroToFiber) {

FILE: folly/fibers/detail/AtomicBatchDispatcher.cpp
  type folly (line 23) | namespace folly {
    type fibers (line 24) | namespace fibers {
      type detail (line 25) | namespace detail {
        function createABDTokenNotDispatchedExMsg (line 27) | std::string createABDTokenNotDispatchedExMsg(
        function createUnexpectedNumResultsABDUsageExMsg (line 46) | std::string createUnexpectedNumResultsABDUsageExMsg(

FILE: folly/fibers/detail/AtomicBatchDispatcher.h
  function namespace (line 22) | namespace folly {

FILE: folly/fibers/scripts/gdb.py
  class FiberPrinter (line 32) | class FiberPrinter:
    method __init__ (line 35) | def __init__(self, val):
    method state_to_string (line 43) | def state_to_string(self):
    method backtrace_available (line 60) | def backtrace_available(self):
    method to_string (line 67) | def to_string(self):
  class FiberManagerPrinter (line 73) | class FiberManagerPrinter:
    method __init__ (line 76) | def __init__(self, fm):
    method children (line 79) | def children(self):
    method to_string (line 94) | def to_string(self):
    method display_hint (line 97) | def display_hint(self):
  class GetFiberXMethodWorker (line 106) | class GetFiberXMethodWorker(gdb.xmethod.XMethodWorker):
    method get_arg_types (line 107) | def get_arg_types(self):
    method get_result_type (line 110) | def get_result_type(self):
    method __call__ (line 113) | def __call__(self, *args):
  class GetFiberXMethodMatcher (line 123) | class GetFiberXMethodMatcher(gdb.xmethod.XMethodMatcher):
    method __init__ (line 124) | def __init__(self):
    method match (line 128) | def match(self, class_type, method_name):
  class FiberXMethodWorker (line 137) | class FiberXMethodWorker(gdb.xmethod.XMethodWorker):
    method get_arg_types (line 138) | def get_arg_types(self):
    method get_result_type (line 141) | def get_result_type(self):
    method __call__ (line 144) | def __call__(self, *args):
  class FiberXMethodMatcher (line 148) | class FiberXMethodMatcher(gdb.xmethod.XMethodMatcher):
    method __init__ (line 149) | def __init__(self):
    method match (line 153) | def match(self, class_type, method_name):
  class FrameId (line 164) | class FrameId:
    method __init__ (line 165) | def __init__(self, sp, pc):
  class FiberUnwinder (line 170) | class FiberUnwinder(gdb.unwinder.Unwinder):
    method init (line 174) | def init(cls):
    method get_fiber (line 180) | def get_fiber(cls):
    method set_fiber (line 185) | def set_fiber(cls, fiber):
    method __init__ (line 214) | def __init__(self):
    method __call__ (line 219) | def __call__(self, pending_frame):
  class FiberFrameFilter (line 269) | class FiberFrameFilter:
    method __init__ (line 276) | def __init__(self):
    method filter (line 282) | def filter(self, frames):
  function use_language (line 296) | def use_language(lang):
  class FiberCommand (line 314) | class FiberCommand(gdb.Command):
    method __init__ (line 321) | def __init__(self):
    method invoke (line 325) | def invoke(self, arg, from_tty):
  class FiberNameCommand (line 347) | class FiberNameCommand(gdb.Command):
    method __init__ (line 353) | def __init__(self):
    method invoke (line 356) | def invoke(self, arg, from_tty):
  class FiberInfoCommand (line 364) | class FiberInfoCommand(gdb.Command):
    method __init__ (line 373) | def __init__(self):
    method trace_info (line 376) | def trace_info(self, fiber, skip=()):
    method invoke (line 414) | def invoke(self, arg, to_tty):
  class FiberApplyCommand (line 459) | class FiberApplyCommand(gdb.Command):
    method __init__ (line 468) | def __init__(self):
    method usage (line 471) | def usage(self):
    method invoke (line 475) | def invoke(self, arg, from_tty):
  class FiberDeactivateCommand (line 506) | class FiberDeactivateCommand(gdb.Command):
    method __init__ (line 509) | def __init__(self):
    method invoke (line 512) | def invoke(self, arg, from_tty):
  class SetFiberCommand (line 524) | class SetFiberCommand(gdb.Command):
    method __init__ (line 527) | def __init__(self):
    method invoke (line 530) | def invoke(self, arg, from_tty):
  class ShowFiberCommand (line 535) | class ShowFiberCommand(gdb.Command):
    method __init__ (line 540) | def __init__(self):
    method invoke (line 543) | def invoke(self, arg, from_tty):
  class FiberParameter (line 552) | class FiberParameter(gdb.Parameter):
    method __init__ (line 555) | def __init__(self, name, *args, **kwds):
  class FiberManagerPrintLimitParameter (line 562) | class FiberManagerPrintLimitParameter(FiberParameter):
    method __init__ (line 568) | def __init__(self):
  class FiberInfoFrameSkipWordsParameter (line 575) | class FiberInfoFrameSkipWordsParameter(FiberParameter):
    method __init__ (line 590) | def __init__(self):
  class Shortcut (line 597) | class Shortcut(gdb.Function):
    method __init__ (line 598) | def __init__(self, function_name, value_lambda):
    method invoke (line 602) | def invoke(self, *args):
  class FiberInfo (line 614) | class FiberInfo:
    method __new__ (line 618) | def __new__(cls, fiber):
    method id (line 636) | def id(self):
    method name (line 640) | def name(self):
    method name (line 644) | def name(self, name):
    method by_name (line 658) | def by_name(cls, name):
    method __repr__ (line 661) | def __repr__(self):
    method __str__ (line 666) | def __str__(self):
    method __eq__ (line 673) | def __eq__(self, other):
  function fiber_activate (line 677) | def fiber_activate(fiber):
  function fiber_deactivate (line 681) | def fiber_deactivate():
  function get_fiber (line 685) | def get_fiber(fid):
  function get_fiber_info (line 711) | def get_fiber_info(only=None, managers=False):
  function get_fiber_managers (line 759) | def get_fiber_managers(only=None):
  function fiber_manager_active_fibers (line 834) | def fiber_manager_active_fibers(fm):
  function get_fiber_manager_map (line 854) | def get_fiber_manager_map(evb_type):
  function get_fiber_manager_map_evb (line 888) | def get_fiber_manager_map_evb():
  function get_fiber_manager_map_vevb (line 892) | def get_fiber_manager_map_vevb():
  function clear_fiber_caches (line 897) | def clear_fiber_caches(*args):
  function build_pretty_printer (line 921) | def build_pretty_printer():
  function load (line 930) | def load():
  function info (line 950) | def info():

FILE: folly/fibers/test/BatchSemaphoreTest.cpp
  function TEST (line 20) | TEST(BatchSemaphoreTest, WaitSignalSynchronization) {

FILE: folly/fibers/test/FibersBenchmark.cpp
  function runBenchmark (line 30) | void runBenchmark(size_t numAwaits, size_t toSend, bool logRunningTime) {
  function BENCHMARK (line 75) | BENCHMARK(FiberManagerBasicOneAwait, iters) {
  function BENCHMARK (line 79) | BENCHMARK(FiberManagerBasicOneAwaitLogged, iters) {
  function BENCHMARK (line 83) | BENCHMARK(FiberManagerBasicFiveAwaits, iters) {
  function BENCHMARK (line 87) | BENCHMARK(FiberManagerBasicFiveAwaitsLogged, iters) {
  function BENCHMARK (line 91) | BENCHMARK(FiberManagerGet, iters) {
  function BENCHMARK (line 108) | BENCHMARK(FiberManagerCreateDestroy, iters) {
  function BENCHMARK (line 117) | BENCHMARK(FiberManagerAllocateDeallocatePattern, iters) {
  function BENCHMARK (line 140) | BENCHMARK(FiberManagerAllocateLargeChunk, iters) {
  function runTimeoutsBenchmark (line 164) | void runTimeoutsBenchmark(std::vector<size_t> timeouts) {
  function BENCHMARK (line 196) | BENCHMARK(FiberManagerCancelledTimeouts_Single_300) {
  function BENCHMARK (line 200) | BENCHMARK(FiberManagerCancelledTimeouts_Five) {
  function BENCHMARK (line 204) | BENCHMARK(FiberManagerCancelledTimeouts_TenThousand) {
  function main (line 214) | int main(int argc, char** argv) {

FILE: folly/fibers/test/FibersTest.cpp
  function TEST (line 54) | TEST(FiberManager, batonTimedWaitTimeout) {
  function TEST (line 87) | TEST(FiberManager, batonTimedWaitPost) {
  function TEST (line 122) | TEST(FiberManager, batonTimedWaitTimeoutEvb) {
  function TEST (line 161) | TEST(FiberManager, batonTimedWaitPostEvb) {
  function TEST (line 198) | TEST(FiberManager, fiberTimeLogged) {
  function burnCpu (line 222) | void burnCpu(std::chrono::milliseconds duration) {
  function sleepFor (line 228) | void sleepFor(std::chrono::milliseconds duration) {
  function TEST (line 233) | TEST(FiberManager, fiberTimeWhileRunning) {
  function TEST (line 267) | TEST(FiberManager, fiberTimeWhileAwaiting) {
  function TEST (line 295) | TEST(FiberManager, batonTryWait) {
  function TEST (line 328) | TEST(FiberManager, batonTryWaitConsistent) {
  function TEST (line 357) | TEST(FiberManager, genericBatonFiberWait) {
  function TEST (line 386) | TEST(FiberManager, genericBatonThreadWait) {
  function TEST (line 413) | TEST(FiberManager, addTasksNoncopyable) {
  function TEST (line 457) | TEST(FiberManager, awaitThrow) {
  function TEST (line 481) | TEST(FiberManager, addTasksThrow) {
  function TEST (line 533) | TEST(FiberManager, addTasksVoid) {
  function TEST (line 575) | TEST(FiberManager, addTasksVoidThrow) {
  function TEST (line 625) | TEST(FiberManager, addTasksReserve) {
  function TEST (line 679) | TEST(FiberManager, addTaskDynamic) {
  function TEST (line 715) | TEST(FiberManager, forEach) {
  function TEST (line 758) | TEST(FiberManager, collectN) {
  function TEST (line 798) | TEST(FiberManager, collectNThrow) {
  function TEST (line 837) | TEST(FiberManager, collectNVoid) {
  function TEST (line 873) | TEST(FiberManager, collectNVoidThrow) {
  function TEST (line 912) | TEST(FiberManager, collectAll) {
  function TEST (line 951) | TEST(FiberManager, collectAllVoid) {
  function TEST (line 986) | TEST(FiberManager, collectAny) {
  function expectMainContext (line 1033) | void expectMainContext(bool& ran, int* mainLocation, int* fiberLocation) {
  function TEST (line 1055) | TEST(FiberManager, runInMainContext) {
  function FOLLY_NOINLINE (line 1095) | FOLLY_NOINLINE int runHugeStackInMainContext(bool& checkRan) {
  function TEST (line 1109) | TEST(FiberManager, runInMainContextNoInline) {
  function TEST (line 1126) | TEST(FiberManager, addTaskFinally) {
  function TEST (line 1150) | TEST(FiberManager, fibersPoolWithinLimit) {
  function TEST (line 1179) | TEST(FiberManager, fibersPoolOverLimit) {
  function TEST (line 1204) | TEST(FiberManager, remoteFiberBasic) {
  function TEST (line 1244) | TEST(FiberManager, addTaskRemoteBasic) {
  function TEST (line 1286) | TEST(FiberManager, remoteHasTasks) {
  function TEST (line 1301) | TEST(FiberManager, remoteHasReadyTasks) {
  function testFiberLocal (line 1331) | void testFiberLocal() {
  function TEST (line 1374) | TEST(FiberManager, fiberLocal) {
  function TEST (line 1382) | TEST(FiberManager, fiberLocalHeap) {
  function TEST (line 1391) | TEST(FiberManager, fiberLocalDestructor) {
  function TEST (line 1415) | TEST(FiberManager, yieldTest) {
  function TEST (line 1436) | TEST(FiberManager, RequestContext) {
  function TEST (line 1532) | TEST(FiberManager, resizePeriodically) {
  function TEST (line 1598) | TEST(FiberManager, batonWaitTimeoutHandler) {
  function TEST (line 1630) | TEST(FiberManager, batonWaitTimeoutHandlerExecutor) {
  function TEST (line 1653) | TEST(FiberManager, batonWaitTimeoutMany) {
  function TEST (line 1686) | TEST(FiberManager, remoteFutureTest) {
  function TEST (line 1704) | TEST(FiberManager, remoteFutureVoidUnitTest) {
  function TEST (line 1727) | TEST(FiberManager, nestedFiberManagers) {
  function TEST (line 1755) | TEST(FiberManager, nestedFiberManagersSameEvb) {
  function TEST (line 1800) | TEST(FiberManager, virtualEvbFiberManager) {
  function TEST (line 1825) | TEST(FiberManager, semaphore) {
  function CO_TEST (line 1920) | CO_TEST(FiberManager, SemaphoreCoTryWaitForCanCancelOrTimeout) {
  function CO_TEST (line 1955) | CO_TEST(FiberManager, StressTestSemaphoreCoTryWaitFor) {
  function TEST (line 1997) | TEST(FiberManager, batchSemaphore) {
  function TEST (line 2108) | TEST(FiberManager, batchSemaphoreSignalAll) {
  function singleBatchDispatch (line 2144) | void singleBatchDispatch(ExecutorT& executor, int batchSize, int index) {
  function TEST (line 2160) | TEST(FiberManager, batchDispatchTest) {
  function doubleBatchInnerDispatch (line 2188) | folly::Future<std::vector<std::string>> doubleBatchInnerDispatch(
  function doubleBatchOuterDispatch (line 2218) | void doubleBatchOuterDispatch(
  function TEST (line 2259) | TEST(FiberManager, doubleBatchDispatchTest) {
  function batchDispatchExceptionHandling (line 2276) | void batchDispatchExceptionHandling(ExecutorT& executor, int i) {
  function TEST (line 2285) | TEST(FiberManager, batchDispatchExceptionHandlingTest) {
  type AtomicBatchDispatcherTesting (line 2301) | namespace AtomicBatchDispatcherTesting {
    type DevNullPiper (line 2312) | struct DevNullPiper {
      method DevNullPiper (line 2314) | DevNullPiper& operator<<(const T&) {
      method DevNullPiper (line 2318) | DevNullPiper& operator<<(std::ostream& (*)(std::ostream&)) { return ...
    type Job (line 2323) | struct Job {
      method preprocess (line 2327) | void preprocess(FiberManager& executor, bool die) {
      method Job (line 2340) | Job(AtomicBatchDispatcher<ValueT, ResultT>::Token&& t, ValueT i)
      method Job (line 2343) | Job(Job&&) = default;
      method Job (line 2344) | Job& operator=(Job&&) = default;
    function ResultT (line 2347) | ResultT processSingleInput(ValueT&& input) {
    function userDispatchFunc (line 2351) | std::vector<ResultT> userDispatchFunc(std::vector<ValueT>&& inputs) {
    function createJobs (line 2361) | void createJobs(
    type DispatchProblem (line 2371) | enum class DispatchProblem {
    function dispatchJobs (line 2377) | void dispatchJobs(
  function TEST (line 2473) | TEST(FiberManager, ABDTest) {
  function TEST (line 2489) | TEST(FiberManager, ABDDispatcherdestroyedbeforecallingcommit) {
  function TEST (line 2514) | TEST(FiberManager, ABDPreprocessingfailuretest) {
  function TEST (line 2530) | TEST(FiberManager, ABDMultipledispatchonsametokenerrortest) {
  function TEST (line 2545) | TEST(FiberManager, ABDGettokencalledaftercommittest) {
  function TEST (line 2564) | TEST(FiberManager, ABDUserprovidedbatchdispatchthrowstest) {
  function TEST (line 2583) | TEST(FiberManager, VirtualEventBase) {
  function TEST (line 2617) | TEST(TimedMutex, ThreadsAndFibersDontDeadlock) {
  function TEST (line 2654) | TEST(TimedMutex, ThreadFiberDeadlockOrder) {
  function TEST (line 2683) | TEST(TimedMutex, ThreadFiberDeadlockRace) {
  function testTimedRWMutex (line 2715) | void testTimedRWMutex() {
  function TEST (line 2772) | TEST(TimedRWMutex, MultipleThreadsReadPriority) {
  function TEST (line 2776) | TEST(TimedRWMutex, MultipleThreadsWritePriority) {
  function expectStackHighWatermark (line 2784) | void expectStackHighWatermark(size_t minStackSize, size_t stackHighWater...
  function expectStackHighWatermark (line 2790) | void expectStackHighWatermark(size_t, size_t stackHighWatermark) {
  function TEST (line 2802) | TEST(FiberManager, highWaterMarkViaRecordStackEvery) {
  function TEST (line 2835) | TEST(FiberManager, highWaterMarkViaRecordCurrentPosition) {
  function TEST (line 2863) | TEST(FiberManager, addTaskEager) {
  function TEST (line 2889) | TEST(FiberManager, addTaskEagerFuture) {
  function TEST (line 2913) | TEST(FiberManager, addTaskEagerNested) {
  function TEST (line 2947) | TEST(FiberManager, addTaskEagerNestedFiberManager) {
  function TEST (line 2968) | TEST(FiberManager, swapWithException) {
  function TEST (line 3000) | TEST(FiberManager, loopInCatch) {
  function TEST (line 3026) | TEST(FiberManager, loopInUnwind) {
  function catch (line 3050) | catch (...) {
  function TEST (line 3054) | TEST(FiberManager, addTaskRemoteFutureTry) {
  function TEST (line 3067) | TEST(FiberManager, addTaskEagerKeepAlive) {
  function TEST (line 3080) | TEST(FiberManager, fibersPreserveAsyncStackRoots) {
  function TEST (line 3137) | TEST(FiberManager, EventBaseMigratingThreads) {

FILE: folly/fibers/test/FibersTestApp.cpp
  type Application (line 26) | struct Application {
    method Application (line 28) | Application()
    method loop (line 33) | void loop() {
  function main (line 80) | int main() {

FILE: folly/fibers/test/SemaphoreTest.cpp
  function TEST (line 24) | TEST(SemaphoreTest, MessagePassing) {

FILE: folly/fibers/test/StackOverflow.cpp
  function f (line 23) | void f(int* p) {
  function FOLLY_POP_WARNING (line 37) | FOLLY_POP_WARNING

FILE: folly/fibers/test/TimedMutexBenchmark.cpp
  function concurrentReadersBenchmark (line 29) | void concurrentReadersBenchmark(int iters, size_t numThreads) {
  function BENCHMARK (line 49) | BENCHMARK(TimedRWMutexWritePriority_readers_1, iters) {
  function BENCHMARK (line 53) | BENCHMARK(TimedRWMutexWritePriority_readers_2, iters) {
  function BENCHMARK (line 57) | BENCHMARK(TimedRWMutexWritePriority_readers_4, iters) {
  function BENCHMARK (line 61) | BENCHMARK(TimedRWMutexWritePriority_readers_8, iters) {
  function BENCHMARK (line 65) | BENCHMARK(TimedRWMutexWritePriority_readers_16, iters) {
  function BENCHMARK (line 69) | BENCHMARK(TimedRWMutexWritePriority_readers_32, iters) {
  function main (line 73) | int main(int argc, char** argv) {

FILE: folly/fibers/traits.h
  function namespace (line 21) | namespace folly {

FILE: folly/functional/ApplyTuple.h
  function namespace (line 27) | namespace folly {

FILE: folly/functional/Invoke.h
  function namespace (line 52) | namespace folly {
  function namespace (line 77) | namespace folly {
  function namespace (line 310) | namespace detail {
  type __folly_detail_invoke_obj (line 521) | struct __folly_detail_invoke_obj {                                      ...
  function funcname (line 545) | [[maybe_unused]] inline constexpr funcname##_fn funcname {}
  function namespace (line 650) | namespace folly {
  function namespace (line 792) | namespace folly {

FILE: folly/functional/Partial.h
  type PartialConstructFromCallable (line 32) | struct PartialConstructFromCallable {}

FILE: folly/functional/protocol.h
  function namespace (line 26) | namespace folly {
  function match_empty_function_protocol_fn (line 73) | inline constexpr match_empty_function_protocol_fn
  function namespace (line 106) | namespace detail {

FILE: folly/functional/test/ApplyTupleTest.cpp
  function func (line 30) | void func(int a, int b, double c) {
  type Wat (line 36) | struct Wat {
    method func (line 37) | void func(int a, int b, double c) { ::func(a, b, c); }
    method retVal (line 39) | double retVal(int a, double b) { return a + b; }
    method Wat (line 41) | Wat() {}
    method Wat (line 42) | Wat(Wat const&) = delete;
  type Overloaded (line 47) | struct Overloaded {
    method func (line 48) | int func(int) { return 0; }
    method func (line 49) | bool func(bool) { return true; }
  type CopyCount (line 52) | struct CopyCount {
    method CopyCount (line 53) | CopyCount() {}
    method CopyCount (line 54) | CopyCount(CopyCount const&) { std::cout << "copy count copy ctor\n"; }
  function anotherFunc (line 57) | void anotherFunc(CopyCount const&) {}
  function makeFunc (line 59) | std::function<void(int, int, double)> makeFunc() {
  type GuardObjBase (line 63) | struct GuardObjBase {
    method GuardObjBase (line 64) | GuardObjBase() {}
    method GuardObjBase (line 65) | GuardObjBase(GuardObjBase const&) = delete;
    method GuardObjBase (line 66) | [[maybe_unused]] GuardObjBase(GuardObjBase&&) noexcept {}
    method GuardObjBase (line 67) | GuardObjBase& operator=(GuardObjBase const&) = delete;
    method GuardObjBase (line 68) | [[maybe_unused]] GuardObjBase& operator=(GuardObjBase&&) noexcept {
  type GuardObj (line 74) | struct GuardObj : GuardObjBase {
    method GuardObj (line 75) | explicit GuardObj(F&& f, Tuple&& args)
    method GuardObj (line 77) | GuardObj(GuardObj&& g) noexcept
    method GuardObj (line 84) | GuardObj(const GuardObj&) = delete;
    method GuardObj (line 85) | GuardObj& operator=(const GuardObj&) = delete;
  function guard (line 93) | GuardObj<typename std::decay<F>::type, std::tuple<Args...>> guard(
  type Mover (line 99) | struct Mover {
    method Mover (line 100) | Mover() {}
    method Mover (line 101) | Mover(const Mover&) = delete;
    method Mover (line 102) | [[maybe_unused]] Mover(Mover&&) noexcept {}
    method Mover (line 103) | Mover& operator=(const Mover&) = delete;
    method Mover (line 104) | [[maybe_unused]] Mover& operator=(Mover&&) noexcept { return *this; }
  function move_only_func (line 107) | void move_only_func(Mover&&) {}
  function TEST (line 111) | TEST(ApplyTuple, Test) {
  function TEST (line 155) | TEST(ApplyTuple, Mutable) {
  function TEST (line 162) | TEST(ApplyTuple, ConstOverloads) {
  function TEST (line 183) | TEST(ApplyTuple, RefOverloads) {
  type MemberFunc (line 207) | struct MemberFunc {
    method getX (line 209) | int getX() const { return x; }
    method setX (line 210) | void setX(int xx) { x = xx; }
  function TEST (line 213) | TEST(ApplyTuple, MemberFunction) {
  function TEST (line 226) | TEST(ApplyTuple, MemberFunctionWithRefWrapper) {
  function TEST (line 234) | TEST(ApplyTuple, MemberFunctionWithConstPointer) {
  function TEST (line 245) | TEST(ApplyTuple, MemberFunctionWithSharedPtr) {
  function TEST (line 255) | TEST(ApplyTuple, MemberFunctionWithUniquePtr) {
  function TEST (line 265) | TEST(ApplyTuple, Array) {
  function TEST (line 270) | TEST(ApplyTuple, Pair) {
  function TEST (line 276) | TEST(ApplyTuple, MultipleTuples) {
  function TEST (line 317) | TEST(ApplyTuple, UncurryCopyMove) {
  function TEST (line 335) | TEST(ApplyTuple, Uncurry) {
  function TEST (line 366) | TEST(ApplyTuple, UncurryStdFind) {
  type S (line 375) | struct S {
    method S (line 377) | explicit S(Args&&... args) : tuple_(std::forward<Args>(args)...) {}
  function TEST (line 383) | TEST(MakeIndexSequenceFromTuple, Basic) {
  function TEST (line 403) | TEST(ApplyResult, Basic) {
  function TEST (line 429) | TEST(IsApplicable, Basic) {
  function TEST (line 446) | TEST(IsNothrowApplicable, Basic) {
  function TEST (line 464) | TEST(IsApplicableR, Basic) {
  function TEST (line 483) | TEST(IsNothrowApplicableR, Basic) {
  function TEST (line 504) | TEST(ForwardTuple, Basic) {

FILE: folly/functional/test/InvokeTest.cpp
  class InvokeTest (line 21) | class InvokeTest : public testing::Test {}
  type from_any (line 25) | struct from_any {
    method from_any (line 27) | from_any(T&&) {}
  type Cv (line 30) | struct Cv {
  type ImmCv (line 35) | struct ImmCv : Cv {
    method ImmCv (line 36) | ImmCv(ImmCv const&) = delete;
    method ImmCv (line 37) | ImmCv(ImmCv&&) = delete;
  type Fn (line 42) | struct Fn {
  type invoker (line 51) | namespace invoker {
  type Obj (line 57) | struct Obj {
    method test (line 58) | char test(int, int) noexcept { return 'a'; }
    method test (line 60) | [[maybe_unused]] float test(float, float) { return 3.14; }
  type x (line 64) | namespace x {
    type Obj (line 65) | struct Obj {}
    function go (line 66) | int go(Obj const&, int) noexcept {
  type y (line 71) | namespace y {
    type Obj (line 72) | struct Obj {}
    function go (line 73) | char go(Obj const&, char const*) {
  type z (line 78) | namespace z {
    type Obj (line 79) | struct Obj {}
  function go (line 81) | [[maybe_unused]] float go(z::Obj const&, int) {
  type swappable (line 85) | namespace swappable {
    type Obj (line 86) | struct Obj {
    function swap (line 89) | void swap(Obj&, Obj&) noexcept {}
  type AltSwappable (line 92) | struct AltSwappable {}
  type AltSwappableRet (line 93) | struct AltSwappableRet {}
  type unswappable (line 94) | namespace unswappable {
  type invoker (line 98) | namespace invoker {
  function TEST_F (line 109) | TEST_F(InvokeTest, invoke) {
  function TEST_F (line 124) | TEST_F(InvokeTest, invoke_result) {
  function TEST_F (line 132) | TEST_F(InvokeTest, is_invocable) {
  function TEST_F (line 140) | TEST_F(InvokeTest, is_invocable_r) {
  function TEST_F (line 153) | TEST_F(InvokeTest, is_nothrow_invocable) {
  function TEST_F (line 161) | TEST_F(InvokeTest, is_nothrow_invocable_r) {
  function TEST_F (line 175) | TEST_F(InvokeTest, free_invoke) {
  function TEST_F (line 188) | TEST_F(InvokeTest, free_invoke_result) {
  function TEST_F (line 196) | TEST_F(InvokeTest, free_is_invocable) {
  function TEST_F (line 205) | TEST_F(InvokeTest, free_is_invocable_r) {
  function TEST_F (line 214) | TEST_F(InvokeTest, free_is_nothrow_invocable) {
  function TEST_F (line 223) | TEST_F(InvokeTest, free_is_nothrow_invocable_r) {
  function TEST_F (line 232) | TEST_F(InvokeTest, free_invoke_swap) {
  function TEST_F (line 257) | TEST_F(InvokeTest, qual_invoke_swap) {
  function TEST_F (line 279) | TEST_F(InvokeTest, invoke_qual) {
  function TEST_F (line 291) | TEST_F(InvokeTest, member_invoke) {
  function TEST_F (line 303) | TEST_F(InvokeTest, member_invoke_result) {
  function TEST_F (line 313) | TEST_F(InvokeTest, member_is_invocable) {
  function TEST_F (line 321) | TEST_F(InvokeTest, member_is_invocable_r) {
  function TEST_F (line 329) | TEST_F(InvokeTest, member_is_nothrow_invocable) {
  function TEST_F (line 337) | TEST_F(InvokeTest, member_is_nothrow_invocable_r) {
  function TEST_F (line 345) | TEST_F(InvokeTest, invoke_member) {
  type invoker (line 363) | namespace invoker {
  function TEST_F (line 371) | TEST_F(InvokeTest, static_member_invoke) {
  function TEST_F (line 400) | TEST_F(InvokeTest, static_member_no_invoke) {
  function TEST_F (line 418) | TEST_F(InvokeTest, invoke_first_match) {
  type TestCustomisationPointFn (line 436) | struct TestCustomisationPointFn {
  type TypeA (line 447) | struct TypeA {
    method tag_invoke (line 448) | int tag_invoke(
    method tag_invoke (line 452) | bool tag_invoke(
  function TEST_F (line 482) | TEST_F(InvokeTest, TagInvokeCustomisationPoint) {
  type accessor (line 490) | namespace accessor {
  type DataHolder (line 498) | struct DataHolder {
  type ConstDataHolder (line 504) | struct ConstDataHolder {
  function TEST_F (line 511) | TEST_F(InvokeTest, member_accessor_basic) {
  function TEST_F (line 525) | TEST_F(InvokeTest, member_accessor_forwarding) {
  function TEST_F (line 553) | TEST_F(InvokeTest, member_accessor_noexcept) {

FILE: folly/functional/test/PartialTest.cpp
  function add3 (line 26) | int add3(int x, int y, int z) {
  function TEST (line 30) | TEST(Partial, Simple) {
  type Foo (line 44) | struct Foo {
    method method (line 45) | int method(int& x, int& y, int& z) { return 1000 + 100 * x + 10 * y + ...
    method constMethod (line 46) | int constMethod(int const& x, int const& y, int const& z) const {
    method tempMethod (line 49) | int tempMethod(int&& x, int&& y, int&& z) {
  function TEST (line 54) | TEST(Partial, ReferenceArguments) {
  type RefQualifiers (line 66) | struct RefQualifiers {
  function TEST (line 74) | TEST(Partial, RefQualifiers) {
  type RefQualifiers2 (line 83) | struct RefQualifiers2 {
  function TEST (line 95) | TEST(Partial, RefQualifiers2) {
  function calc_uptr (line 104) | std::unique_ptr<int> calc_uptr(std::unique_ptr<int> x, std::unique_ptr<i...
  function TEST (line 109) | TEST(Partial, MoveOnly) {
  function TEST (line 131) | TEST(Partial, WrapInStdFunction) {
  function TEST (line 137) | TEST(Partial, WrapInFollyFunction) {

FILE: folly/functional/test/protocol_test.cpp
  type ProtocolTest (line 21) | struct ProtocolTest : testing::Test {
    method empty_function (line 23) | static constexpr bool empty_function(F const& f) {
  function TEST_F (line 36) | TEST_F(ProtocolTest, match_empty_function_protocol) {
  function TEST_F (line 58) | TEST_F(ProtocolTest, match_static_lambda_protocol) {
  function TEST_F (line 85) | TEST_F(ProtocolTest, match_safely_invocable_as_protocol) {

FILE: folly/functional/test/traits_test.cpp
  type TraitsTest (line 21) | struct TraitsTest : testing::Test {
  function TEST_F (line 65) | TEST_F(TraitsTest, function_traits) {
  function TEST_F (line 410) | TEST_F(TraitsTest, function_remove_cvref) {
  function TEST_F (line 471) | TEST_F(TraitsTest, function_like_value) {

FILE: folly/functional/traits.h
  function namespace (line 21) | namespace folly {

FILE: folly/futures/Barrier.cpp
  type folly (line 24) | namespace folly {
    type futures (line 25) | namespace futures {

FILE: folly/futures/Barrier.h
  function namespace (line 25) | namespace folly {

FILE: folly/futures/Cleanup.h
  function namespace (line 26) | namespace folly {
  function class (line 95) | class Cleanup {

FILE: folly/futures/Future-inl.h
  function namespace (line 39) | namespace folly {
  function drive (line 482) | void drive() {
  function KeepAlive (line 519) | static KeepAlive<WaitExecutor> create() {
  function keepAliveAcquire (line 526) | bool keepAliveAcquire() noexcept override {
  function keepAliveRelease (line 533) | void keepAliveRelease() noexcept override {
  type Queue (line 542) | struct Queue {
  function const (line 556) | struct WindowFakeVector {
  function work (line 1487) | auto work = [](Try<typename decltype(future)::value_type>&& t) {
  type Context (line 1512) | struct Context {
  function Context (line 1568) | struct Context {
  function work (line 1697) | auto work = [](Try<typename decltype(future)::value_type>&& t) {
  type Context (line 1723) | struct Context {
  type Context (line 1761) | struct Context {
  type Context (line 1809) | struct Context {
  type typename (line 1882) | typedef typename std::iterator_traits<It>::value_type::value_type ItT;
  type typename (line 1883) | typedef typename std::
  type isTry (line 1886) | typedef isTry<Arg> IsTry;
  function f (line 1890) | auto f = std::move(*first).thenTry(
  type WindowContext (line 1928) | struct WindowContext {
  type isTry (line 2010) | typedef isTry<Arg> IsTry;
  type Context (line 2012) | struct Context {
  type Fulfill (line 2029) | struct Fulfill {
  function try (line 2068) | try {
  function namespace (line 2126) | namespace futures {
  function namespace (line 2535) | namespace futures {
  function namespace (line 2617) | namespace futures {
  function namespace (line 2717) | namespace futures {

FILE: folly/futures/Future-pre.h
  function namespace (line 21) | namespace folly {

FILE: folly/futures/Future.cpp
  type folly (line 30) | namespace folly {
    type futures (line 31) | namespace futures {
      type detail (line 33) | namespace detail {
        class FutureBase<Unit> (line 156) | class FutureBase<Unit>
      function sleep (line 63) | SemiFuture<Unit> sleep(HighResDuration dur, Timekeeper* tk) {
      function sleepUnsafe (line 77) | Future<Unit> sleepUnsafe(HighResDuration dur, Timekeeper* tk) {
      class FutureWaiter (line 83) | class FutureWaiter : public fibers::Baton::Waiter {
        method FutureWaiter (line 85) | FutureWaiter(Promise<Unit> promise, Ptr baton)
        method post (line 90) | void post() override {
      function wait (line 101) | SemiFuture<Unit> wait(std::unique_ptr<fibers::Baton> baton) {
      function wait (line 108) | SemiFuture<Unit> wait(std::shared_ptr<fibers::Baton> baton) {
      type detail (line 155) | namespace detail {
        class FutureBase<Unit> (line 156) | class FutureBase<Unit>
    type detail (line 118) | namespace detail {
      function FOLLY_EXPORT (line 120) | FOLLY_EXPORT FOLLY_ALWAYS_INLINE
      class TimekeeperSingletonInstantiator (line 136) | class TimekeeperSingletonInstantiator {
        method TimekeeperSingletonInstantiator (line 138) | TimekeeperSingletonInstantiator() {
      function getTimekeeperSingleton (line 146) | std::shared_ptr<Timekeeper> getTimekeeperSingleton() {
    type futures (line 154) | namespace futures {
      type detail (line 33) | namespace detail {
        class FutureBase<Unit> (line 156) | class FutureBase<Unit>
      function sleep (line 63) | SemiFuture<Unit> sleep(HighResDuration dur, Timekeeper* tk) {
      function sleepUnsafe (line 77) | Future<Unit> sleepUnsafe(HighResDuration dur, Timekeeper* tk) {
      class FutureWaiter (line 83) | class FutureWaiter : public fibers::Baton::Waiter {
        method FutureWaiter (line 85) | FutureWaiter(Promise<Unit> promise, Ptr baton)
        method post (line 90) | void post() override {
      function wait (line 101) | SemiFuture<Unit> wait(std::unique_ptr<fibers::Baton> baton) {
      function wait (line 108) | SemiFuture<Unit> wait(std::shared_ptr<fibers::Baton> baton) {
      type detail (line 155) | namespace detail {
        class FutureBase<Unit> (line 156) | class FutureBase<Unit>
    class Future<Unit> (line 160) | class Future<Unit>
    class SemiFuture<Unit> (line 161) | class SemiFuture<Unit>

FILE: folly/futures/Future.h
  function namespace (line 46) | namespace folly {
  function Base (line 568) | Base(p) {}
  function friend (line 976) | friend Future<T> co_viaIfAsync(
  function Base (line 1098) | Base(p) {}
  function explicit (line 1897) | explicit Future(Core* obj) : Base(obj) {}
  function explicit (line 1899) | explicit Future(futures::detail::EmptyConstruct) noexcept
  function namespace (line 2049) | namespace futures {
  function namespace (line 2627) | namespace folly {

FILE: folly/futures/FutureSplitter.h
  function namespace (line 23) | namespace folly {

FILE: folly/futures/HeapTimekeeper.cpp
  type folly (line 32) | namespace folly {
    class HeapTimekeeper::Timeout (line 34) | class HeapTimekeeper::Timeout : public IntrusiveHeapNode<> {
      type DecRef (line 36) | struct DecRef {
    class HeapTimekeeper::State (line 64) | class HeapTimekeeper::State {
      type Op (line 66) | struct Op {
        type Type (line 67) | enum class Type { kSchedule, kCancel }
      method State (line 73) | State() { clearAndAdjustCapacity(queue_); }

FILE: folly/futures/HeapTimekeeper.h
  function namespace (line 24) | namespace folly {

FILE: folly/futures/ManualTimekeeper.cpp
  type folly (line 21) | namespace folly {

FILE: folly/futures/ManualTimekeeper.h
  function namespace (line 28) | namespace folly {

FILE: folly/futures/Promise-inl.h
  function namespace (line 26) | namespace folly {
  function core_ (line 74) | core_(nullptr) {}

FILE: folly/futures/Promise.cpp
  type folly (line 19) | namespace folly {
    class Promise<Unit> (line 22) | class Promise<Unit>

FILE: folly/futures/Promise.h
  function namespace (line 28) | namespace folly {
  function Core (line 461) | Core const& getCore() const { return getCoreImpl(core_); }

FILE: folly/futures/Retrying.h
  function namespace (line 23) | namespace folly {

FILE: folly/futures/SharedPromise-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/futures/SharedPromise.cpp
  type folly (line 19) | namespace folly {
    class SharedPromise<Unit> (line 22) | class SharedPromise<Unit>

FILE: folly/futures/SharedPromise.h
  function namespace (line 24) | namespace folly {

FILE: folly/futures/ThreadWheelTimekeeper.cpp
  type folly (line 25) | namespace folly {

FILE: folly/futures/ThreadWheelTimekeeper.h
  function namespace (line 25) | namespace folly {

FILE: folly/futures/WTCallback.h
  function namespace (line 26) | namespace folly {

FILE: folly/futures/detail/Core.cpp
  type folly (line 25) | namespace folly {
    type futures (line 26) | namespace futures {
      type detail (line 27) | namespace detail {
        function terminate_unexpected_state (line 32) | void terminate_unexpected_state(fmt::string_view context, Enum sta...
        function KeepAliveOrDeferred (line 68) | KeepAliveOrDeferred& KeepAliveOrDeferred::operator=(
        function DeferredExecutor (line 77) | DeferredExecutor* KeepAliveOrDeferred::getDeferredExecutor() const...
        function Executor (line 87) | Executor* KeepAliveOrDeferred::getKeepAliveExecutor() const noexce...
        function KeepAliveOrDeferred (line 117) | KeepAliveOrDeferred KeepAliveOrDeferred::copy() const {
        function Executor (line 180) | Executor* DeferredExecutor::getExecutor() const {
        function DeferredWrapper (line 260) | DeferredWrapper DeferredExecutor::copy() {
        function DeferredWrapper (line 265) | DeferredWrapper DeferredExecutor::create() {
        function DeferredWrapper (line 310) | DeferredWrapper CoreBase::stealDeferredExecutor() {
        class CoreBase::CoreAndCallbackReference (line 388) | class CoreBase::CoreAndCallbackReference {
          method CoreAndCallbackReference (line 390) | explicit CoreAndCallbackReference(CoreBase* core) noexcept : cor...
          method CoreAndCallbackReference (line 394) | CoreAndCallbackReference(CoreAndCallbackReference const& o) = de...
          method CoreAndCallbackReference (line 395) | CoreAndCallbackReference& operator=(CoreAndCallbackReference con...
          method CoreAndCallbackReference (line 397) | CoreAndCallbackReference& operator=(CoreAndCallbackReference&&) ...
          method CoreAndCallbackReference (line 399) | CoreAndCallbackReference(CoreAndCallbackReference&& o) noexcept
          method CoreBase (line 402) | CoreBase* getCore() const noexcept { return core_; }
          method detach (line 405) | void detach() noexcept {
      class Core<folly::Unit> (line 700) | class Core<folly::Unit>

FILE: folly/futures/detail/Core.h
  function namespace (line 40) | namespace folly {

FILE: folly/futures/detail/Types.h
  function namespace (line 21) | namespace folly {

FILE: folly/futures/test/BarrierTest.cpp
  type folly (line 26) | namespace folly {
    type futures (line 27) | namespace futures {
      type test (line 28) | namespace test {
        function TEST (line 30) | TEST(BarrierTest, Simple) {
        function TEST (line 102) | TEST(BarrierTest, Random) {

FILE: folly/futures/test/Benchmark.cpp
  function T (line 34) | T incr(Try<T>&& t) {
  function thens (line 38) | Future<int> thens(Future<int> f, size_t n, bool runInline = false) {
  function someThens (line 49) | void someThens(size_t n) {
  function someThensOnThread (line 54) | void someThensOnThread(size_t n, bool runInline = false) {
  function BENCHMARK (line 65) | BENCHMARK(constantFuture) {
  function BENCHMARK_RELATIVE (line 69) | BENCHMARK_RELATIVE(promiseAndFuture) {
  function BENCHMARK_RELATIVE (line 76) | BENCHMARK_RELATIVE(withThen) {
  function BENCHMARK (line 86) | BENCHMARK(oneThen) {
  function BENCHMARK_RELATIVE (line 91) | BENCHMARK_RELATIVE(twoThens) {
  function BENCHMARK_RELATIVE (line 96) | BENCHMARK_RELATIVE(fourThens) {
  function BENCHMARK_RELATIVE (line 101) | BENCHMARK_RELATIVE(hundredThens) {
  function BENCHMARK_RELATIVE (line 108) | BENCHMARK_RELATIVE(fourThensOnThread) {
  function BENCHMARK_RELATIVE (line 113) | BENCHMARK_RELATIVE(fourThensOnThreadInline) {
  function BENCHMARK_RELATIVE (line 118) | BENCHMARK_RELATIVE(hundredThensOnThread) {
  function BENCHMARK_RELATIVE (line 123) | BENCHMARK_RELATIVE(hundredThensOnThreadInline) {
  function BENCHMARK (line 132) | BENCHMARK(no_contention) {
  function BENCHMARK_RELATIVE (line 166) | BENCHMARK_RELATIVE(contention) {
  function throwAndCatchImpl (line 217) | void throwAndCatchImpl() {
  function throwAndCatchWrappedImpl (line 237) | void throwAndCatchWrappedImpl() {
  function throwWrappedAndCatchImpl (line 250) | void throwWrappedAndCatchImpl() {
  function throwWrappedAndCatchWrappedImpl (line 267) | void throwWrappedAndCatchWrappedImpl() {
  function contend (line 287) | void contend(void (*func)()) {
  function BENCHMARK (line 312) | BENCHMARK(throwAndCatch) {
  function BENCHMARK_RELATIVE (line 316) | BENCHMARK_RELATIVE(throwAndCatchWrapped) {
  function BENCHMARK_RELATIVE (line 320) | BENCHMARK_RELATIVE(throwWrappedAndCatch) {
  function BENCHMARK_RELATIVE (line 324) | BENCHMARK_RELATIVE(throwWrappedAndCatchWrapped) {
  function BENCHMARK (line 331) | BENCHMARK(throwAndCatchContended) {
  function BENCHMARK_RELATIVE (line 335) | BENCHMARK_RELATIVE(throwAndCatchWrappedContended) {
  function BENCHMARK_RELATIVE (line 339) | BENCHMARK_RELATIVE(throwWrappedAndCatchContended) {
  function BENCHMARK_RELATIVE (line 343) | BENCHMARK_RELATIVE(throwWrappedAndCatchWrappedContended) {
  function Bulky (line 351) | explicit Bulky(std::string message) : message_(message) {}
  function message (line 352) | [[maybe_unused]] std::string message() & { return message_; }
  function BENCHMARK (line 364) | BENCHMARK(lvalue_get) {
  function BENCHMARK_RELATIVE (line 374) | BENCHMARK_RELATIVE(rvalue_get) {
  function fGen (line 387) | Future<T> fGen() {
  function fsGen (line 401) | std::vector<Future<T>> fsGen() {
  function complexBenchmark (line 410) | void complexBenchmark() {
  type Blob (line 421) | struct Blob {
  function BENCHMARK (line 425) | BENCHMARK(complexUnit) {
  function BENCHMARK_RELATIVE (line 429) | BENCHMARK_RELATIVE(complexBlob4) {
  function BENCHMARK_RELATIVE (line 433) | BENCHMARK_RELATIVE(complexBlob8) {
  function BENCHMARK_RELATIVE (line 437) | BENCHMARK_RELATIVE(complexBlob64) {
  function BENCHMARK_RELATIVE (line 441) | BENCHMARK_RELATIVE(complexBlob128) {
  function BENCHMARK_RELATIVE (line 445) | BENCHMARK_RELATIVE(complexBlob256) {
  function BENCHMARK_RELATIVE (line 449) | BENCHMARK_RELATIVE(complexBlob512) {
  function BENCHMARK_RELATIVE (line 453) | BENCHMARK_RELATIVE(complexBlob1024) {
  function BENCHMARK_RELATIVE (line 457) | BENCHMARK_RELATIVE(complexBlob2048) {
  function BENCHMARK_RELATIVE (line 461) | BENCHMARK_RELATIVE(complexBlob4096) {
  function main (line 465) | int main(int argc, char** argv) {

FILE: folly/futures/test/CallbackLifetimeTest.cpp
  class CallbackLifetimeTest (line 41) | class CallbackLifetimeTest : public testing::Test {
    method kRaiseWillThrow (line 45) | static bool kRaiseWillThrow() { return true; }
    method kDelay (line 46) | static constexpr auto kDelay() { return std::chrono::milliseconds(500); }
    method mkC (line 48) | auto mkC() { return std::make_unique<size_t>(0); }
    method mkCGuard (line 49) | auto mkCGuard(CounterPtr& ptr) {
    method raise (line 56) | static void raise(folly::Unit = folly::Unit{}) {
    method raiseFut (line 61) | static Future<Unit> raiseFut() {
  function TEST_F (line 70) | TEST_F(CallbackLifetimeTest, thenReturnsValue) {
  function TEST_F (line 76) | TEST_F(CallbackLifetimeTest, thenReturnsValueThrows) {
  function TEST_F (line 82) | TEST_F(CallbackLifetimeTest, thenReturnsFuture) {
  function TEST_F (line 90) | TEST_F(CallbackLifetimeTest, thenReturnsFutureThrows) {
  function TEST_F (line 98) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsValueMatch) {
  function TEST_F (line 107) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsValueMatchThrows) {
  function TEST_F (line 118) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsValueWrong) {
  function TEST_F (line 127) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsValueWrongThrows) {
  function TEST_F (line 138) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsFutureMatch) {
  function TEST_F (line 149) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsFutureMatchThrows) {
  function TEST_F (line 160) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsFutureWrong) {
  function TEST_F (line 171) | TEST_F(CallbackLifetimeTest, thenErrorTakesExnReturnsFutureWrongThrows) {
  function TEST_F (line 182) | TEST_F(CallbackLifetimeTest, thenErrorTakesWrapReturnsValue) {
  function TEST_F (line 191) | TEST_F(CallbackLifetimeTest, thenErrorTakesWrapReturnsValueThrows) {
  function TEST_F (line 200) | TEST_F(CallbackLifetimeTest, thenErrorTakesWrapReturnsFuture) {
  function TEST_F (line 211) | TEST_F(CallbackLifetimeTest, thenErrorTakesWrapReturnsFutureThrows) {

FILE: folly/futures/test/CleanupTest.cpp
  class Cleaned (line 25) | class Cleaned : public folly::Cleanup {
    method Cleaned (line 29) | Cleaned() : pool_(4) {
  function TEST (line 38) | TEST(CleanupTest, Basic) {
  function TEST (line 67) | TEST(CleanupTest, EnsureCleanupAfterTaskBasic) {
  function TEST (line 95) | TEST(CleanupTest, Errors) {
  function TEST (line 121) | TEST(CleanupTest, Invariants) {

FILE: folly/futures/test/CollectTest.cpp
  function TEST (line 37) | TEST(Collect, collectAll) {
  function TEST (line 118) | TEST(Collect, collectAllUnsafe) {
  function TEST (line 199) | TEST(Collect, collectAllInline) {
  function TEST (line 259) | TEST(Collect, collectInline) {
  function TEST (line 319) | TEST(Collect, collect) {
  type NotDefaultConstructible (line 448) | struct NotDefaultConstructible {
    method NotDefaultConstructible (line 449) | NotDefaultConstructible() = delete;
    method NotDefaultConstructible (line 450) | explicit NotDefaultConstructible(int arg) : i(arg) {}
  function TEST (line 456) | TEST(Collect, collectNotDefaultConstructible) {
  function TEST (line 482) | TEST(Collect, collectAny) {
  function TEST (line 561) | TEST(Collect, collectAnyWithoutException) {
  function TEST (line 654) | TEST(Collect, alreadyCompleted) {
  function TEST (line 688) | TEST(Collect, parallel) {
  function TEST (line 717) | TEST(Collect, parallelWithError) {
  function TEST (line 748) | TEST(Collect, allParallel) {
  function TEST (line 778) | TEST(Collect, allParallelWithError) {
  function TEST (line 816) | TEST(Collect, collectN) {
  function TEST (line 844) | TEST(Collect, collectNParallel) {
  function TEST (line 883) | TEST(Collect, smallVector) {
  function TEST (line 911) | TEST(Collect, collectAllVariadic) {
  function TEST (line 931) | TEST(Collect, collectAllUnsafeVariadic) {
  function TEST (line 951) | TEST(Collect, collectAllVariadicReferences) {
  function TEST (line 970) | TEST(Collect, collectAllVariadicWithException) {
  function TEST (line 990) | TEST(Collect, collectVariadic) {
  function TEST (line 1009) | TEST(Collect, collectUnsafeVariadic) {
  function TEST (line 1027) | TEST(Collect, collectVariadicWithException) {
  function TEST (line 1041) | TEST(Collect, collectAllNone) {
  function TEST (line 1047) | TEST(Collect, noDefaultConstructor) {
  function TEST (line 1058) | TEST(Collect, CollectVariadicWithDestroyedWeakRef) {
  function TEST (line 1083) | TEST(Collect, CollectRangeWithDestroyedWeakRef) {

FILE: folly/futures/test/ContextTest.cpp
  class TestData (line 24) | class TestData : public RequestData {
    method TestData (line 26) | explicit TestData(int data) : data_(data) {}
    method hasCallback (line 29) | bool hasCallback() override { return false; }
  function TEST (line 34) | TEST(Context, basic) {

FILE: folly/futures/test/ConversionOperatorTest.cpp
  type Widget (line 25) | struct Widget {
    method Widget (line 27) | Widget(int v) : v_(v) {}
    method Widget (line 28) | Widget(const Widget& other) = default;
    method Widget (line 29) | Widget(Widget&& other) noexcept = default;
    method Widget (line 30) | Widget& operator=(const Widget& /* other */) {
    method Widget (line 33) | Widget& operator=(Widget&& /* other */) {
  function TEST (line 40) | TEST(ConverstionOperator, DirectInitialization) {
  function TEST (line 47) | TEST(ConverstionOperator, StaticCast) {

FILE: folly/futures/test/CoreTest.cpp
  function TEST (line 24) | TEST(Core, size) {

FILE: folly/futures/test/EnsureTest.cpp
  function TEST (line 25) | TEST(Ensure, basic) {
  function TEST (line 38) | TEST(Ensure, mutableLambda) {

FILE: folly/futures/test/FilterTest.cpp
  function TEST (line 22) | TEST(Filter, alwaysTrye) {
  function TEST (line 26) | TEST(Filter, alwaysFalse) {
  function TEST (line 32) | TEST(Filter, moveOnlyValue) {

FILE: folly/futures/test/FutureSplitterTest.cpp
  function TEST (line 24) | TEST(FutureSplitter, splitFutureSuccess) {
  function TEST (line 38) | TEST(FutureSplitter, splitFutureSuccessSemiFuture) {
  function TEST (line 52) | TEST(FutureSplitter, splitFutureSuccessNullExecutor) {
  function TEST (line 70) | TEST(FutureSplitter, splitFutureCopyable) {
  function TEST (line 89) | TEST(FutureSplitter, splitFutureMovable) {
  function TEST (line 108) | TEST(FutureSplitter, splitFutureCopyAssignable) {
  function TEST (line 128) | TEST(FutureSplitter, splitFutureMoveAssignable) {
  function TEST (line 148) | TEST(FutureSplitter, splitFutureScope) {
  function TEST (line 162) | TEST(FutureSplitter, splitFutureFailure) {
  function TEST (line 176) | TEST(FutureSplitter, lifetime) {

FILE: folly/futures/test/FutureTest.cpp
  function TEST (line 46) | TEST(Future, makeEmpty) {
  function TEST (line 51) | TEST(Future, futureDefaultCtor) {
  function TEST (line 55) | TEST(Future, futureToUnit) {
  function TEST (line 61) | TEST(Future, voidFutureToUnit) {
  function TEST (line 67) | TEST(Future, unitFutureToUnitIdentity) {
  function TEST (line 73) | TEST(Future, toUnitWhileInProgress) {
  function TEST (line 81) | TEST(Future, makeFutureWithUnit) {
  function TEST (line 87) | TEST(Future, getRequiresOnlyMoveCtor) {
  function TEST (line 112) | TEST(Future, makeFutureFromMoveOnlyException) {
  function TEST (line 140) | TEST(Future, makeFutureFromExceptionSpecifyingBothTemplateParams) {
  function makeValid (line 152) | auto makeValid() {
  function makeInvalid (line 157) | auto makeInvalid() {
  function TEST (line 164) | TEST(Future, ctorPostconditionValid) {
  function TEST (line 198) | TEST(Future, ctorPostconditionInvalid) {
  function TEST (line 216) | TEST(Future, lacksPreconditionValid) {
  function TEST (line 251) | TEST(Future, hasPreconditionValid) {
  function TEST (line 278) | TEST(Future, hasPostconditionValid) {
  function TEST (line 304) | TEST(Future, hasPostconditionInvalid) {
  function thenErrorHelperEggs (line 359) | Future<int> thenErrorHelperEggs(const eggs_t&) {
  function thenErrorHelperGeneric (line 362) | Future<int> thenErrorHelperGeneric(const std::exception&) {
  function thenErrorHelperWrapper (line 365) | Future<int> thenErrorHelperWrapper(folly::exception_wrapper&&) {
  function TEST (line 370) | TEST(Future, thenError) {
  function TEST (line 707) | TEST(Future, special) {
  function TEST (line 714) | TEST(Future, then) {
  function doWorkStaticTry (line 739) | static folly::Future<std::string> doWorkStaticTry(Try<std::string>&& t) {
  function TEST (line 743) | TEST(Future, thenTrythenValue) {
  function TEST (line 771) | TEST(Future, thenTry) {
  function TEST (line 806) | TEST(Future, ThenTryWithExecutor) {
  function TEST (line 815) | TEST(Future, thenValue) {
  function TEST (line 842) | TEST(Future, ThenValueWithExecutor) {
  function TEST (line 852) | TEST(Future, thenValueFuture) {
  function doWorkStatic (line 870) | static std::string doWorkStatic(Try<std::string>&& t) {
  function doWorkStaticValue (line 874) | static std::string doWorkStaticValue(std::string&& t) {
  function TEST (line 878) | TEST(Future, thenFunction) {
  function doWorkStaticFuture (line 896) | static Future<std::string> doWorkStaticFuture(Try<std::string>&& t) {
  function TEST (line 900) | TEST(Future, thenFunctionFuture) {
  function TEST (line 919) | TEST(Future, thenStdFunction) {
  function TEST (line 944) | TEST(Future, thenBind) {
  function TEST (line 951) | TEST(Future, thenBindTry) {
  function TEST (line 959) | TEST(Future, value) {
  function TEST (line 967) | TEST(Future, isReady) {
  function TEST (line 975) | TEST(Future, futureNotReady) {
  function TEST (line 981) | TEST(Future, hasException) {
  function TEST (line 986) | TEST(Future, hasValue) {
  function TEST (line 991) | TEST(Future, makeFuture) {
  function TEST (line 1019) | TEST(Future, finish) {
  function TEST (line 1041) | TEST(Future, finishBigLambda) {
  function TEST (line 1074) | TEST(Future, unwrap) {
  function TEST (line 1109) | TEST(Future, throwCaughtInImmediateThen) {
  function TEST (line 1117) | TEST(Future, throwIfFailed) {
  function TEST (line 1133) | TEST(Future, getFutureAfterSetValue) {
  function TEST (line 1139) | TEST(Future, getFutureAfterSetException) {
  function TEST (line 1145) | TEST(Future, detachRace) {
  function TEST (line 1171) | TEST(Future, CircularDependencySharedPtrSelfReset) {
  function TEST (line 1190) | TEST(Future, Constructor) {
  function TEST (line 1197) | TEST(Future, ImplicitConstructor) {
  function TEST (line 1205) | TEST(Future, InPlaceConstructor) {
  function TEST (line 1210) | TEST(Future, thenDynamic) {
  function TEST (line 1221) | TEST(Future, RequestContext) {
  function TEST (line 1285) | TEST(Future, makeFutureNoThrow) {
  function TEST (line 1289) | TEST(Future, invokeCallbackReturningValueAsRvalue) {
  function TEST (line 1307) | TEST(Future, invokeCallbackReturningFutureAsRvalue) {
  function TEST (line 1325) | TEST(Future, futureWithinCtxCleanedUpWhenTaskFinishedInTime) {
  function TEST (line 1346) | TEST(Future, futureWithinNoValueReferenceWhenTimeOut) {
  function TEST (line 1357) | TEST(Future, makePromiseContract) {
  function TEST (line 1384) | TEST(Future, ThenRecursion) {
  type NoThrowTestResult (line 1412) | struct NoThrowTestResult {}
  type folly (line 1413) | namespace folly {
    class Try<NoThrowTestResult> (line 1416) | class Try<NoThrowTestResult> : public Try<void> {
      method Try (line 1422) | explicit Try(const NoThrowTestResult&) : Try<void>() {}
      method NoThrowTestResult (line 1424) | NoThrowTestResult const& value() const& {
      method NoThrowTestResult (line 1428) | NoThrowTestResult const&& value() const&& {
      method NoThrowTestResult (line 1432) | NoThrowTestResult& value() & {
      method NoThrowTestResult (line 1436) | NoThrowTestResult&& value() && {
      method throwIfFailed (line 1442) | inline void throwIfFailed() const {
      method get (line 1449) | typename std::enable_if<isTry, R>::type get() {
      method get (line 1454) | typename std::enable_if<!isTry, R>::type get() {
  function TEST (line 1460) | TEST(Future, NoThrow) {
  function TEST (line 1494) | TEST(Future, DetachTest) {
  function TEST (line 1535) | TEST(Future, SimpleGet) {
  function TEST (line 1543) | TEST(Future, SimpleGetTry) {
  function TEST (line 1551) | TEST(Future, SimpleTimedGet) {
  function TEST (line 1558) | TEST(Future, SimpleTimedGetTry) {
  function TEST (line 1565) | TEST(Future, BatonWait) {

FILE: folly/futures/test/HeaderCompileTest.cpp
  function TEST (line 23) | TEST(Basic, compiles) {

FILE: folly/futures/test/HeapTimekeeperTest.cpp
  type folly (line 20) | namespace folly {
    function TEST (line 25) | TEST(TimekeeperSingletonTest, ExpectedType) {

FILE: folly/futures/test/InterruptTest.cpp
  function TEST (line 25) | TEST(Interrupt, raise) {
  function TEST (line 34) | TEST(Interrupt, cancel) {
  function TEST (line 42) | TEST(Interrupt, handleThenInterrupt) {
  function TEST (line 50) | TEST(Interrupt, interruptThenHandle) {
  function TEST (line 58) | TEST(Interrupt, interruptAfterFulfilNoop) {
  function TEST (line 67) | TEST(Interrupt, secondInterruptNoop) {
  function TEST (line 77) | TEST(Interrupt, futureWithinTimedOut) {
  function TEST (line 86) | TEST(Interrupt, semiFutureWithinTimedOut) {
  function TEST (line 96) | TEST(Interrupt, futureThenValue) {
  function TEST (line 105) | TEST(Interrupt, semiFutureDeferValue) {
  function TEST (line 114) | TEST(Interrupt, futureThenValueFuture) {
  function TEST (line 125) | TEST(Interrupt, semiFutureDeferValueSemiFuture) {
  function TEST (line 136) | TEST(Interrupt, futureThenError) {
  function TEST (line 145) | TEST(Interrupt, semiFutureDeferError) {
  function TEST (line 156) | TEST(Interrupt, futureThenErrorTagged) {
  function TEST (line 169) | TEST(Interrupt, semiFutureDeferErrorTagged) {
  function TEST (line 182) | TEST(Interrupt, futureThenErrorFuture) {
  function TEST (line 193) | TEST(Interrupt, semiFutureDeferErrorSemiFuture) {
  function TEST (line 206) | TEST(Interrupt, futureThenErrorTaggedFuture) {
  function TEST (line 219) | TEST(Interrupt, semiFutureDeferErrorTaggedSemiFuture) {

FILE: folly/futures/test/ManualTimekeeperTest.cpp
  type folly (line 25) | namespace folly {
    class ManualTimekeeperTest (line 27) | class ManualTimekeeperTest : public ::testing::Test {}
    function TEST_F (line 29) | TEST_F(ManualTimekeeperTest, Basic) {
    function TEST_F (line 36) | TEST_F(ManualTimekeeperTest, AdvanceWithoutAnyFutures) {
    function TEST_F (line 45) | TEST_F(ManualTimekeeperTest, advanceToNext) {
    function TEST_F (line 85) | TEST_F(ManualTimekeeperTest, AdvanceWithManyFutures) {
    function TEST_F (line 132) | TEST_F(ManualTimekeeperTest, Cancel) {

FILE: folly/futures/test/MapTest.cpp
  function TEST (line 22) | TEST(Map, basic) {
  function TEST (line 46) | TEST(Map, basicTry) {
  function TEST (line 72) | TEST(Map, executor) {
  function TEST (line 99) | TEST(Map, executorTry) {
  function TEST (line 125) | TEST(Map, semifuture) {

FILE: folly/futures/test/NonCopyableLambdaTest.cpp
  function TEST (line 22) | TEST(NonCopyableLambda, basic) {
  function TEST (line 34) | TEST(NonCopyableLambda, uniquePtr) {
  function TEST (line 52) | TEST(NonCopyableLambda, Function) {
  function TEST (line 66) | TEST(NonCopyableLambda, FunctionConst) {

FILE: folly/futures/test/PollTest.cpp
  function TEST (line 22) | TEST(Poll, ready) {
  function TEST (line 29) | TEST(Poll, notReady) {
  function TEST (line 35) | TEST(Poll, exception) {

FILE: folly/futures/test/PromiseTest.cpp
  function TEST (line 29) | TEST(Promise, makeEmpty) {
  function TEST (line 34) | TEST(Promise, special) {
  function TEST (line 41) | TEST(Promise, getSemiFuture) {
  function TEST (line 47) | TEST(Promise, getFuture) {
  function TEST (line 53) | TEST(Promise, setValueUnit) {
  function makeValid (line 59) | auto makeValid() {
  function makeInvalid (line 64) | auto makeInvalid() {
  function TEST (line 71) | TEST(Promise, ctorPostconditionValid) {
  function TEST (line 92) | TEST(Promise, ctorPostconditionInvalid) {
  function TEST (line 110) | TEST(Promise, lacksPreconditionValid) {
  function TEST (line 146) | TEST(Promise, hasPreconditionValid) {
  function TEST (line 174) | TEST(Promise, hasPostconditionValid) {
  function TEST (line 192) | TEST(Promise, hasPostconditionInvalid) {
  function TEST (line 237) | TEST(Promise, setValueSemiFuture) {
  function TEST (line 275) | TEST(Promise, setValue) {
  function TEST (line 313) | TEST(Promise, setException) {
  function TEST (line 328) | TEST(Promise, setWith) {
  function TEST (line 343) | TEST(Promise, isFulfilled) {
  function TEST (line 351) | TEST(Promise, isFulfilledWithFuture) {
  function TEST (line 360) | TEST(Promise, brokenOnDelete) {
  function TEST (line 375) | TEST(Promise, brokenPromiseHasTypeInfo) {

FILE: folly/futures/test/ReduceTest.cpp
  function TEST (line 22) | TEST(Reduce, basic) {
  function TEST (line 92) | TEST(Reduce, chain) {
  function TEST (line 117) | TEST(Reduce, unorderedReduce) {
  function TEST (line 170) | TEST(Reduce, unorderedReduceException) {
  function TEST (line 211) | TEST(Reduce, unorderedReduceFuture) {

FILE: folly/futures/test/RetryingTest.cpp
  function multiAttemptExpectDurationWithin (line 35) | void multiAttemptExpectDurationWithin(
  function TEST (line 56) | TEST(RetryingTest, hasOpCall) {
  function TEST (line 70) | TEST(RetryingTest, basic) {
  function TEST (line 83) | TEST(RetryingTest, basicUnsafe) {
  function TEST (line 96) | TEST(RetryingTest, futureFactoryThrows) {
  function TEST (line 118) | TEST(RetryingTest, futureFactoryThrowsUnsafe) {
  function TEST (line 140) | TEST(RetryingTest, policyThrows) {
  function TEST (line 148) | TEST(RetryingTest, policyThrowsUnsafe) {
  function TEST (line 156) | TEST(RetryingTest, policyFuture) {
  function TEST (line 175) | TEST(RetryingTest, policyFutureUnsafe) {
  function TEST (line 194) | TEST(RetryingTest, policySemiFuture) {
  function TEST (line 214) | TEST(RetryingTest, policyBasic) {
  function TEST (line 222) | TEST(RetryingTest, policyBasicUnsafe) {
  function TEST (line 230) | TEST(RetryingTest, semifuturePolicyBasic) {
  function TEST (line 239) | TEST(RetryingTest, policyCappedJitteredExponentialBackoff) {
  function TEST (line 261) | TEST(RetryingTest, policyCappedJitteredExponentialBackoffUnsafe) {
  function TEST (line 283) | TEST(RetryingTest, policyCappedJitteredExponentialBackoffManyRetries) {
  function TEST (line 304) | TEST(RetryingTest, policyCappedJitteredExponentialBackoffMinZero) {
  function TEST (line 328) | TEST(RetryingTest, policySleepDefaults) {
  function TEST (line 346) | TEST(RetryingTest, largeRetries) {
  function TEST (line 392) | TEST(RetryingTest, retryingJitteredExponentialBackoffDur) {

FILE: folly/futures/test/SelfDestructTest.cpp
  function TEST (line 23) | TEST(SelfDestruct, then) {
  function TEST (line 33) | TEST(SelfDestruct, ensure) {
  class ThrowingExecutorError (line 40) | class ThrowingExecutorError : public std::runtime_error {
  class ThrowingExecutor (line 45) | class ThrowingExecutor : public folly::Executor {
    method add (line 47) | void add(folly::Func) override {
  function TEST (line 52) | TEST(SelfDestruct, throwingExecutor) {
  function TEST (line 64) | TEST(SelfDestruct, throwingInlineExecutor) {

FILE: folly/futures/test/SemiFutureTest.cpp
  function TEST (line 46) | TEST(SemiFuture, makeEmpty) {
  function TEST (line 51) | TEST(SemiFuture, futureDefaultCtor) {
  function TEST (line 55) | TEST(SemiFuture, semiFutureToUnit) {
  function TEST (line 61) | TEST(SemiFuture, makeSemiFutureWithUnit) {
  function makeValid (line 68) | auto makeValid() {
  function makeInvalid (line 73) | auto makeInvalid() {
  function TEST (line 80) | TEST(SemiFuture, ctorPostconditionValid) {
  function TEST (line 114) | TEST(SemiFuture, ctorPostconditionInvalid) {
  function TEST (line 132) | TEST(SemiFuture, lacksPreconditionValid) {
  function TEST (line 167) | TEST(SemiFuture, hasPreconditionValid) {
  function TEST (line 189) | TEST(SemiFuture, hasPostconditionValid) {
  function TEST (line 215) | TEST(SemiFuture, hasPostconditionInvalid) {
  function onErrorHelperEggs (line 268) | int onErrorHelperEggs(const eggs_t&) {
  function onErrorHelperGeneric (line 271) | int onErrorHelperGeneric(const folly::exception_wrapper&) {
  function TEST (line 276) | TEST(SemiFuture, special) {
  function TEST (line 283) | TEST(SemiFuture, value) {
  function TEST (line 296) | TEST(SemiFuture, hasException) {
  function TEST (line 301) | TEST(SemiFuture, hasValue) {
  function TEST (line 306) | TEST(SemiFuture, makeSemiFuture) {
  function TEST (line 338) | TEST(SemiFuture, Constructor) {
  function TEST (line 345) | TEST(SemiFuture, ImplicitConstructor) {
  function TEST (line 350) | TEST(SemiFuture, InPlaceConstructor) {
  function TEST (line 355) | TEST(SemiFuture, makeSemiFutureNoThrow) {
  function TEST (line 359) | TEST(SemiFuture, ViaThrowOnNull) {
  function TEST (line 363) | TEST(SemiFuture, ConstructSemiFutureFromEmptyFuture) {
  function TEST (line 368) | TEST(SemiFuture, ConstructSemiFutureFromFutureDefaultCtor) {
  function TEST (line 372) | TEST(SemiFuture, MakeSemiFutureFromFutureWithUnit) {
  function TEST (line 378) | TEST(SemiFuture, MakeSemiFutureFromFutureWithValue) {
  function TEST (line 385) | TEST(SemiFuture, MakeSemiFutureFromReadyFuture) {
  function TEST (line 393) | TEST(SemiFuture, MakeSemiFutureFromNotReadyFuture) {
  function TEST (line 399) | TEST(SemiFuture, MakeFutureFromSemiFuture) {
  function TEST (line 418) | TEST(SemiFuture, MakeFutureFromSemiFutureReturnFuture) {
  function TEST (line 437) | TEST(SemiFuture, MakeFutureFromSemiFutureReturnSemiFuture) {
  function TEST (line 462) | TEST(SemiFuture, MakeFutureFromSemiFutureLValue) {
  function TEST (line 481) | TEST(SemiFuture, SimpleGet) {
  function TEST (line 490) | TEST(SemiFuture, SimpleGetTry) {
  function TEST (line 499) | TEST(SemiFuture, SimpleTimedGet) {
  function TEST (line 506) | TEST(SemiFuture, SimpleTimedGetViaFromSemiFuture) {
  function TEST (line 515) | TEST(SemiFuture, SimpleTimedGetTry) {
  function TEST (line 522) | TEST(SemiFuture, SimpleTimedGetTryViaFromSemiFuture) {
  function TEST (line 531) | TEST(SemiFuture, SimpleValue) {
  function TEST (line 539) | TEST(SemiFuture, SimpleValueThrow) {
  function TEST (line 545) | TEST(SemiFuture, SimpleResult) {
  function TEST (line 553) | TEST(SemiFuture, SimpleResultThrow) {
  function TEST (line 559) | TEST(SemiFuture, SimpleDefer) {
  function TEST (line 569) | TEST(SemiFuture, DeferWithDelayedSetValue) {
  function TEST (line 588) | TEST(SemiFuture, DeferWithViaAndDelayedSetValue) {
  function TEST (line 609) | TEST(SemiFuture, DeferWithGetTimedGet) {
  function TEST (line 618) | TEST(SemiFuture, DeferWithVia) {
  function TEST (line 630) | TEST(SemiFuture, ChainingDefertoThen) {
  function TEST (line 644) | TEST(SemiFuture, SimpleDeferWithValue) {
  function deferValueHelper (line 655) | int deferValueHelper(int a) {
  function TEST (line 660) | TEST(SemiFuture, SimpleDeferWithValueFunctionReference) {
  function TEST (line 668) | TEST(SemiFuture, ChainingDefertoThenWithValue) {
  function TEST (line 685) | TEST(SemiFuture, MakeSemiFutureFromFutureWithTry) {
  function deferHelper (line 700) | [[noreturn]] void deferHelper(folly::Try<folly::Unit>&&) {
  function TEST (line 705) | TEST(SemiFuture, DeferWithinContinuation) {
  function TEST (line 729) | TEST(SemiFuture, DeferError) {
  function TEST (line 941) | TEST(SemiFuture, makePromiseContract) {
  function TEST (line 948) | TEST(SemiFuture, invokeCallbackWithOriginalCVRef) {
  function TEST (line 966) | TEST(SemiFuture, semiFutureWithinCtxCleanedUpWhenTaskFinishedInTime) {
  function TEST (line 988) | TEST(SemiFuture, semiFutureWithinNoValueReferenceWhenTimeOut) {
  function TEST (line 999) | TEST(SemiFuture, collectAllDeferredWork) {
  function TEST (line 1076) | TEST(SemiFuture, collectDeferredWork) {
  function TEST (line 1153) | TEST(SemiFuture, collectNDeferredWork) {
  function TEST (line 1181) | TEST(SemiFuture, DeferWithNestedSemiFuture) {
  function TEST (line 1193) | TEST(SemiFuture, DeferWithExecutor) {
  function TEST (line 1202) | TEST(SemiFuture, DeferValueWithExecutor) {
  function TEST (line 1212) | TEST(SemiFuture, within) {
  function TEST (line 1236) | TEST(SemiFuture, ensure) {
  function TEST (line 1304) | TEST(SemiFuture, deferredExecutorInlineTest) {
  function TEST (line 1325) | TEST(Future, makeSemiFutureFromMoveOnlyException) {
  function TEST (line 1354) | TEST(Future, makeSemiFutureFromExceptionSpecifyingBothTemplateParams) {

FILE: folly/futures/test/SharedPromiseTest.cpp
  function TEST (line 23) | TEST(SharedPromise, setGetSemiFuture) {
  function TEST (line 32) | TEST(SharedPromise, setGetMixed) {
  function TEST (line 41) | TEST(SharedPromise, setGet) {
  function TEST (line 49) | TEST(SharedPromise, getSet) {
  function TEST (line 58) | TEST(SharedPromise, getSetGet) {
  function TEST (line 67) | TEST(SharedPromise, reset) {
  function TEST (line 81) | TEST(SharedPromise, getMoveSet) {
  function TEST (line 89) | TEST(SharedPromise, setMoveGet) {
  function TEST (line 97) | TEST(SharedPromise, moveSetGet) {
  function TEST (line 105) | TEST(SharedPromise, moveGetSet) {
  function TEST (line 113) | TEST(SharedPromise, moveMove) {
  function TEST (line 124) | TEST(SharedPromise, setWith) {
  function TEST (line 130) | TEST(SharedPromise, isFulfilled) {
  function TEST (line 142) | TEST(SharedPromise, interruptHandler) {
  function TEST (line 151) | TEST(SharedPromise, ConstMethods) {
  function TEST (line 161) | TEST(SharedPromise, InterruptHandlerSetsException) {

FILE: folly/futures/test/TestExecutor.cpp
  type folly (line 21) | namespace folly {

FILE: folly/futures/test/TestExecutor.h
  function namespace (line 25) | namespace folly {

FILE: folly/futures/test/TestExecutorTest.cpp
  function TEST (line 25) | TEST(TestExecutor, parallelRun) {

FILE: folly/futures/test/ThenCompileTest.cpp
  function TEST (line 7) | TEST(Basic, thenVariants) {

FILE: folly/futures/test/ThenCompileTest.h
  function namespace (line 24) | namespace folly {
  function class (line 64) | class SomeClass {

FILE: folly/futures/test/ThenTest.cpp
  type Widget (line 25) | struct Widget {
    method Widget (line 27) | Widget(int v) : v_(v), copied_(0), moved_(0) {}
    method Widget (line 28) | Widget(const Widget& other)
    method Widget (line 30) | Widget(Widget&& other) noexcept
    method Widget (line 32) | Widget& operator=(const Widget& /* other */) {
    method Widget (line 35) | [[maybe_unused]] Widget& operator=(Widget&& /* other */) {
  type CountedWidget (line 40) | struct CountedWidget : Widget {
    method CountedWidget (line 43) | CountedWidget(int v) : Widget(v) {
    method CountedWidget (line 46) | CountedWidget(const CountedWidget& other) : Widget(other) {
    method CountedWidget (line 49) | CountedWidget(CountedWidget&& other) noexcept(false)
    method CountedWidget (line 62) | CountedWidget& operator=(const CountedWidget&) = delete;
    method CountedWidget (line 63) | CountedWidget& operator=(CountedWidget&&) = delete;
    method remove (line 65) | void remove() {
  function TEST (line 75) | TEST(Then, tryConstructor) {
  function TEST (line 82) | TEST(Then, makeFuture) {
  function TEST (line 89) | TEST(Then, tryConstRValueReference) {
  function TEST (line 98) | TEST(Then, tryRValueReference) {
  function TEST (line 107) | TEST(Then, tryConstLValueReference) {
  function TEST (line 116) | TEST(Then, tryValue) {
  function TEST (line 125) | TEST(Then, tryConstValue) {
  function TEST (line 134) | TEST(Then, constRValueReference) {
  function TEST (line 143) | TEST(Then, rValueReference) {
  function TEST (line 152) | TEST(Then, constLValueReference) {
  function TEST (line 161) | TEST(Then, value) {
  function TEST (line 170) | TEST(Then, constValue) {
  function TEST (line 179) | TEST(Then, objectAliveDuringImmediateNoParamContinuation) {
  function TEST (line 190) | TEST(Then, objectAliveDuringDeferredNoParamContinuation) {
  function TEST (line 202) | TEST(Then, voidThenShouldPropagateExceptions) {

FILE: folly/futures/test/ThreadWheelTimekeeperTest.cpp
  type folly (line 20) | namespace folly {

FILE: folly/futures/test/TimekeeperTest.cpp
  class TimekeeperBase (line 27) | class TimekeeperBase : public testing::Test {
    method TearDown (line 32) | void TearDown() override {
  function TEST_F (line 39) | TEST_F(TimekeeperBase, FutureSleepHandlesNullTimekeeperSingleton) {
  function TEST_F (line 44) | TEST_F(TimekeeperBase, FutureWithinHandlesNullTimekeeperSingleton) {
  function TEST_F (line 51) | TEST_F(TimekeeperBase, SemiFutureWithinHandlesNullTimekeeperSingleton) {
  function TEST_F (line 58) | TEST_F(TimekeeperBase, SemiFutureWithinCancelsTimeout) {
  function TEST_F (line 84) | TEST_F(TimekeeperBase, SemiFutureWithinInlineAfter) {
  function TEST_F (line 98) | TEST_F(TimekeeperBase, SemiFutureWithinReady) {

FILE: folly/futures/test/TimekeeperTestLib.h
  function namespace (line 34) | namespace folly {
  function f (line 334) | auto f = futures::sleep(100ms).deferValue([&](auto&&) { test = true; });
  function class (line 373) | class ExecutorTester : public DefaultKeepAliveExecutor {
  function f (line 426) | auto f = detail::getTimekeeperSingleton()->at(steady_clock::now() - 10s);

FILE: folly/futures/test/TimesTest.cpp
  function makePred (line 54) | inline std::function<bool(void)> makePred(int& i) {
  function TEST (line 98) | TEST(Times, success) {
  function TEST (line 106) | TEST(Times, semiFutureSuccess) {
  function TEST (line 153) | TEST(Times, failure) {
  function TEST (line 161) | TEST(Times, semiFutureFailure) {
  function TEST (line 196) | TEST(Times, interrupt) {
  function TEST (line 204) | TEST(Times, semiFutureInterrupt) {

FILE: folly/futures/test/UnwrapTest.cpp
  function TEST (line 24) | TEST(Unwrap, simpleScenario) {
  function TEST (line 31) | TEST(Unwrap, chainCommands) {
  function TEST (line 42) | TEST(Unwrap, futureNotReady) {

FILE: folly/futures/test/ViaTest.cpp
  type ManualWaiter (line 29) | struct ManualWaiter : public DrivableExecutor {
    method ManualWaiter (line 30) | explicit ManualWaiter(std::shared_ptr<ManualExecutor> ex_) : ex(ex_) {}
    method add (line 32) | void add(Func f) override { ex->add(std::move(f)); }
    method drive (line 34) | void drive() override {
  type ViaFixture (line 42) | struct ViaFixture : public testing::Test {
    method ViaFixture (line 43) | ViaFixture()
    method addAsync (line 62) | void addAsync(int a, int b, std::function<void(int&&)>&& cob) {
  function TEST (line 74) | TEST(Via, exceptionOnLaunch) {
  function TEST (line 79) | TEST(Via, thenValue) {
  function TEST (line 87) | TEST(Via, thenFuture) {
  function doWorkStatic (line 94) | static Future<std::string> doWorkStatic(Try<std::string>&& t) {
  function TEST (line 98) | TEST(Via, thenFunction) {
  function TEST_F (line 117) | TEST_F(ViaFixture, threadHops) {
  function TEST_F (line 133) | TEST_F(ViaFixture, chainVias) {
  function TEST_F (line 166) | TEST_F(ViaFixture, bareViaAssignment) {
  function TEST_F (line 169) | TEST_F(ViaFixture, viaAssignment) {
  type PriorityExecutor (line 176) | struct PriorityExecutor : public Executor {
    method add (line 177) | void add(Func /* f */) override { count1++; }
    method addWithPriority (line 179) | void addWithPriority(Func f, int8_t priority) override {
    method getNumPriorities (line 196) | uint8_t getNumPriorities() const override { return 3; }
  function TEST (line 203) | TEST(Via, priority) {
  function TEST (line 219) | TEST(Via, then2) {
  function TEST (line 243) | TEST(Via, allowInline) {
  class ThreadExecutor (line 351) | class ThreadExecutor : public Executor {
    method work (line 357) | void work() {
    method ThreadExecutor (line 369) | explicit ThreadExecutor(size_t n = 1024) : funcs(n) {
    method add (line 379) | void add(Func fn) override { funcs.blockingWrite(std::move(fn)); }
    method waitForStartup (line 381) | void waitForStartup() { baton.wait(); }
  function TEST (line 384) | TEST(Via, viaThenGetWasRacy) {
  function TEST (line 394) | TEST(Via, callbackRace) {
  class DummyDrivableExecutor (line 419) | class DummyDrivableExecutor : public DrivableExecutor {
    method add (line 421) | void add(Func /* f */) override {}
    method drive (line 422) | void drive() override { ran = true; }
  function TEST (line 426) | TEST(Via, getVia) {
  function TEST (line 449) | TEST(Via, SimpleTimedGetVia) {
  function TEST (line 457) | TEST(Via, getTryVia) {
  function TEST (line 483) | TEST(Via, SimpleTimedGetTryVia) {
  function TEST (line 491) | TEST(Via, waitVia) {
  function TEST (line 514) | TEST(Via, viaRaces) {
  function TEST (line 541) | TEST(Via, viaDummyExecutorFutureSetValueFirst) {
  function TEST (line 559) | TEST(Via, viaDummyExecutorFutureSetCallbackFirst) {
  function TEST (line 579) | TEST(Via, viaExecutorDiscardsTaskFutureSetValueFirst) {
  function TEST (line 605) | TEST(Via, viaExecutorDiscardsTaskFutureSetCallbackFirst) {
  function TEST (line 633) | TEST(ViaFunc, liftsVoid) {
  function TEST (line 643) | TEST(ViaFunc, value) {
  function TEST (line 648) | TEST(ViaFunc, exception) {
  function TEST (line 655) | TEST(ViaFunc, future) {
  function TEST (line 660) | TEST(ViaFunc, semiFuture) {
  function TEST (line 665) | TEST(ViaFunc, voidFuture) {
  function TEST (line 672) | TEST(ViaFunc, isSticky) {
  function TEST (line 685) | TEST(ViaFunc, moveOnly) {
  function TEST (line 692) | TEST(ViaFunc, valueKeepAlive) {
  function TEST (line 697) | TEST(ViaFunc, thenValueKeepAlive) {

FILE: folly/futures/test/WaitTest.cpp
  function TEST (line 30) | TEST(Wait, waitImmediate) {
  function TEST (line 54) | TEST(Wait, wait) {
  type MoveFlag (line 82) | struct MoveFlag {
    method MoveFlag (line 83) | MoveFlag() = default;
    method MoveFlag (line 84) | MoveFlag& operator=(const MoveFlag&) = delete;
    method MoveFlag (line 85) | MoveFlag(const MoveFlag&) = delete;
    method MoveFlag (line 86) | MoveFlag(MoveFlag&& other) noexcept { other.moved = true; }
  function TEST (line 90) | TEST(Wait, waitReplacesSelf) {
  function TEST (line 129) | TEST(Wait, waitWithDuration) {
  function TEST (line 273) | TEST(Wait, multipleWait) {
  function TEST (line 287) | TEST(Wait, WaitPlusThen) {
  function TEST (line 435) | TEST(Wait, cancelAfterWait) {

FILE: folly/futures/test/WhenTest.cpp
  function TEST (line 25) | TEST(When, predicateFalse) {
  function TEST (line 44) | TEST(When, predicateTrue) {

FILE: folly/futures/test/WhileDoTest.cpp
  function makePred (line 54) | inline std::function<bool(void)> makePred(int& i) {
  function TEST (line 99) | TEST(WhileDo, success) {
  function TEST (line 107) | TEST(WhileDo, semiFutureSuccess) {
  function TEST (line 155) | TEST(WhileDo, failure) {
  function TEST (line 163) | TEST(WhileDo, semiFutureFailure) {
  function TEST (line 199) | TEST(WhileDo, interrupt) {
  function TEST (line 207) | TEST(WhileDo, semiFutureInterrupt) {

FILE: folly/futures/test/WillEqualTest.cpp
  function TEST (line 22) | TEST(WillEqual, basic) {

FILE: folly/futures/test/WindowTest.cpp
  function TEST (line 31) | TEST(Window, basic) {
  function TEST (line 142) | TEST(Window, exception) {
  function TEST (line 170) | TEST(Window, stackOverflow) {
  function TEST (line 204) | TEST(Window, parallel) {
  function TEST (line 233) | TEST(Window, parallelWithError) {
  function TEST (line 264) | TEST(Window, allParallelWithError) {
  function TEST (line 303) | TEST(WindowExecutor, basic) {
  function TEST (line 363) | TEST(WindowExecutor, parallel) {
  function TEST (line 396) | TEST(WindowExecutor, parallelWithError) {
  function TEST (line 431) | TEST(WindowExecutor, allParallelWithError) {

FILE: folly/futures/test/then_compile_test.rb
  function test (line 25) | def test(form, *args)
  function retval (line 33) | def retval(ret)
  function doMap (line 57) | def doMap(form, param_types, return_types)
  function doMapMultiArg (line 78) | def doMapMultiArg(form, param_types, return_types)

FILE: folly/gen/Base-inl.h
  function namespace (line 41) | namespace gen {
  function VectorType (line 80) | VectorType operator|(const detail::Collect<VectorType>&) const {
  function VectorType (line 84) | VectorType operator|(const detail::CollectTemplate<std::vector>&) const {
  function copy_ (line 196) | CopiedSource(const SourceContainer& container)
  function explicit (line 200) | explicit CopiedSource(Container&& container)
  function explicit (line 249) | explicit RangeSource(Range<Iterator> range) : range_(std::move(range)) {}
  function test (line 325) | bool test(const Value& current) const { return current < end_; }
  function step (line 326) | void step(Value& current) const { ++current; }
  function test (line 338) | bool test(const Value& current) const { return current < end_; }
  function step (line 339) | void step(Value& current) const { current += step_; }
  function test (line 349) | bool test(const Value& current) const { return current <= end_; }
  function step (line 350) | void step(Value& current) const { ++current; }
  function test (line 362) | bool test(const Value& current) const { return current <= end_; }
  function step (line 363) | void step(Value& current) const { current += step_; }
  function step (line 371) | void step(Value& current) const { ++current; }
  type Break (line 399) | struct Break {}
  function body (line 400) | auto body = [&](Value value) {
  function explicit (line 501) | explicit Map(Predicate pred) : pred_(std::move(pred)) {}
  function explicit (line 565) | explicit Filter(Predicate pred) : pred_(std::move(pred)) {}
  function explicit (line 626) | explicit Until(Predicate pred) : pred_(std::move(pred)) {}
  function explicit (line 742) | explicit Visit(Visitor visitor) : visitor_(std::move(visitor)) {}
  function class (line 791) | class Stride : public Operator<Stride> {
  function explicit (line 1029) | explicit Order(Selector selector) : selector_(std::move(selector)) {}
  type std (line 1048) | typedef std::vector<StorageType> VectorType;
  function VectorType (line 1050) | VectorType asVector() const {
  function VectorType (line 1065) | VectorType operator|(const Collect<VectorType>&) const {
  function VectorType (line 1069) | VectorType operator|(const CollectTemplate<std::vector>&) const {
  function explicit (line 1135) | explicit GroupBy(Selector selector) : selector_(std::move(selector)) {}
  function explicit (line 1211) | explicit GroupByAdjacent(Selector selector)
  function explicit (line 1338) | explicit Distinct(Selector selector) : selector_(std::move(selector)) {}
  type typename (line 1345) | typedef typename std::decay<Value>::type StorageType;
  type StorageType (line 1349) | typedef const StorageType& ParamType;
  type invoke_result_t (line 1351) | typedef invoke_result_t<Selector, ParamType> KeyType;
  type typename (line 1352) | typedef typename std::decay<KeyType>::type KeyStorageType;
  function class (line 1504) | class Window : public Operator<Window> {
  function class (line 1604) | class Concat : public Operator<Concat> {
  function class (line 1665) | class RangeConcat : public Operator<RangeConcat> {
  function class (line 1793) | class Dereference : public Operator<Dereference> {
  function class (line 1846) | class Indirect : public Operator<Indirect> {
  function explicit (line 1912) | explicit Cycle(off_t limit) : limit_(limit) {
  function handler2 (line 1930) | auto handler2 = [&](Value value) {
  function explicit (line 2089) | explicit Reduce(Reducer reducer) : reducer_(std::move(reducer)) {}
  function explicit (line 2210) | explicit Min(Selector selector) : selector_(std::move(selector)) {}
  function explicit (line 2351) | explicit UnwrapOr(const T& value) : value_(value) {}
  function class (line 2443) | class Unwrap {}
  function apply (line 2610) | bool apply(const FunctionRef<bool(Value)>& handler) const final {
  function foreach (line 2614) | void foreach(const FunctionRef<void(Value)>& body) const final {
  function foreach (line 2630) | void foreach(const FunctionRef<void(Value)>& body) const {
  function final (line 2647) | const final {
  function detail (line 2692) | constexpr detail::Sum sum{}
  function detail (line 2694) | constexpr detail::Count count{}
  function detail (line 2696) | constexpr detail::First first{}
  function detail (line 2698) | constexpr detail::IsEmpty<true> isEmpty{}
  function detail (line 2700) | constexpr detail::IsEmpty<false> notEmpty{}
  function detail (line 2706) | constexpr detail::Order<Identity> order{}
  function detail (line 2708) | constexpr detail::Distinct<Identity> distinct{}
  function detail (line 2710) | constexpr detail::Map<Move> move{}
  function detail (line 2712) | constexpr detail::Concat concat{}
  function detail (line 2714) | constexpr detail::RangeConcat rconcat{}
  function detail (line 2716) | constexpr detail::Cycle<true> cycle{}
  function detail (line 2718) | constexpr detail::Dereference dereference{}
  function detail (line 2720) | constexpr detail::Indirect indirect{}
  function detail (line 2722) | constexpr detail::Unwrap unwrap{}
  function detail (line 2724) | constexpr detail::ToVirtualGen virtualize{}
  function detail (line 2734) | inline detail::Stride stride(size_t s) {
  function detail (line 2743) | inline detail::Skip skip(size_t count) {
  function detail (line 2747) | inline detail::Batch batch(size_t batchSize) {
  function detail (line 2751) | inline detail::Window window(size_t windowSize) {

FILE: folly/gen/Base.h
  function namespace (line 81) | namespace folly {
  type MemberType (line 561) | enum MemberType {

FILE: folly/gen/Combine-inl.h
  function namespace (line 26) | namespace folly {

FILE: folly/gen/Combine.h
  function namespace (line 22) | namespace folly {

FILE: folly/gen/Core-inl.h
  function namespace (line 31) | namespace gen {
  type typename (line 154) | typedef typename std::decay<Value>::type StorageType;
  function namespace (line 289) | namespace detail {

FILE: folly/gen/Core.h
  function namespace (line 20) | namespace folly {

FILE: folly/gen/File-inl.h
  function namespace (line 26) | namespace folly {

FILE: folly/gen/File.h
  function namespace (line 24) | namespace folly {

FILE: folly/gen/IStream.h
  function namespace (line 24) | namespace folly {

FILE: folly/gen/Parallel-inl.h
  function namespace (line 29) | namespace folly {

FILE: folly/gen/Parallel.h
  function namespace (line 24) | namespace folly {

FILE: folly/gen/ParallelMap-inl.h
  function namespace (line 34) | namespace folly::gen::detail {

FILE: folly/gen/ParallelMap.h
  function namespace (line 22) | namespace folly {

FILE: folly/gen/String-inl.h
  function namespace (line 25) | namespace folly {
  function namespace (line 209) | namespace detail {
  function eatField (line 388) | auto eatField = [&]() -> StringPiece& { return fields[i++]; }

FILE: folly/gen/String.h
  function namespace (line 24) | namespace folly {

FILE: folly/gen/test/BaseBenchmark.cpp
  function BENCHMARK (line 49) | BENCHMARK(Sum_Basic_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 60) | BENCHMARK_RELATIVE(Sum_Basic_Gen, iters) {
  function BENCHMARK (line 71) | BENCHMARK(Sum_Vector_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 81) | BENCHMARK_RELATIVE(Sum_Vector_Gen, iters) {
  function BENCHMARK (line 91) | BENCHMARK(Member, iters) {
  function BENCHMARK_RELATIVE (line 103) | BENCHMARK_RELATIVE(MapMember, iters) {
  function BENCHMARK (line 117) | BENCHMARK(Count_Vector_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 129) | BENCHMARK_RELATIVE(Count_Vector_Gen, iters) {
  function BENCHMARK (line 145) | BENCHMARK(Fib_Sum_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 165) | BENCHMARK_RELATIVE(Fib_Sum_Gen, iters) {
  function BENCHMARK_RELATIVE (line 182) | BENCHMARK_RELATIVE(Fib_Sum_Gen_Limit, iters) {
  type FibYielder (line 200) | struct FibYielder {
  function BENCHMARK_RELATIVE (line 212) | BENCHMARK_RELATIVE(Fib_Sum_Gen_Static, iters) {
  function BENCHMARK (line 223) | BENCHMARK(VirtualGen_0Virtual, iters) {
  function BENCHMARK_RELATIVE (line 234) | BENCHMARK_RELATIVE(VirtualGen_1Virtual, iters) {
  function BENCHMARK_RELATIVE (line 245) | BENCHMARK_RELATIVE(VirtualGen_2Virtual, iters) {
  function BENCHMARK_RELATIVE (line 256) | BENCHMARK_RELATIVE(VirtualGen_3Virtual, iters) {
  function BENCHMARK (line 269) | BENCHMARK(Concat_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 281) | BENCHMARK_RELATIVE(Concat_Gen, iters) {
  function BENCHMARK (line 291) | BENCHMARK(Composed_NoGen, iters) {
  function BENCHMARK_RELATIVE (line 301) | BENCHMARK_RELATIVE(Composed_Gen, iters) {
  function BENCHMARK_RELATIVE (line 310) | BENCHMARK_RELATIVE(Composed_GenRegular, iters) {
  function BENCHMARK (line 320) | BENCHMARK(Sample, iters) {
  function main (line 364) | int main(int argc, char* argv[]) {

FILE: folly/gen/test/BaseTest.cpp
  function ostream (line 55) | ostream& operator<<(ostream& os, const set<T>& values) {
  function ostream (line 60) | ostream& operator<<(ostream& os, const vector<T>& values) {
  function ostream (line 78) | ostream& operator<<(ostream& os, const pair<A, B>& pair) {
  function TEST (line 82) | TEST(Gen, Count) {
  function TEST (line 88) | TEST(Gen, Sum) {
  function TEST (line 94) | TEST(Gen, Foreach) {
  function TEST (line 104) | TEST(Gen, Map) {
  function TEST (line 111) | TEST(Gen, Member) {
  function TEST (line 146) | TEST(Gen, Field) {
  function TEST (line 185) | TEST(Gen, Seq) {
  function TEST (line 193) | TEST(Gen, SeqWithStep) {
  function TEST (line 197) | TEST(Gen, SeqWithStepArray) {
  function TEST (line 203) | TEST(Gen, Range) {
  function TEST (line 210) | TEST(Gen, RangeWithStep) {
  function TEST (line 214) | TEST(Gen, FromIterators) {
  function TEST (line 220) | TEST(Gen, FromMap) {
  function TEST (line 235) | TEST(Gen, Filter) {
  function TEST (line 242) | TEST(Gen, FilterDefault) {
  function TEST (line 276) | TEST(Gen, FilterSink) {
  function TEST (line 286) | TEST(Gen, Contains) {
  function TEST (line 301) | TEST(Gen, Take) {
  function TEST (line 346) | TEST(Gen, Stride) {
  function TEST (line 377) | TEST(Gen, Sample) {
  function TEST (line 407) | TEST(Gen, Skip) {
  function TEST (line 413) | TEST(Gen, Until) {
  function TEST (line 455) | TEST(Gen, Visit) {
  function TEST (line 483) | TEST(Gen, Composed) {
  function TEST (line 497) | TEST(Gen, Chain) {
  function TEST (line 506) | TEST(Gen, Concat) {
  function TEST (line 513) | TEST(Gen, ConcatGen) {
  function TEST (line 519) | TEST(Gen, ConcatAlt) {
  function TEST (line 532) | TEST(Gen, Order) {
  function TEST (line 538) | TEST(Gen, OrderMoved) {
  function TEST (line 551) | TEST(Gen, OrderTake) {
  function TEST (line 563) | TEST(Gen, Distinct) {
  function TEST (line 569) | TEST(Gen, DistinctBy) { //  0  1  4  9  6  5  6  9  4  1  0
  function TEST (line 576) | TEST(Gen, DistinctMove) { //  0  1  4  9  6  5  6  9  4  1  0
  function TEST (line 596) | TEST(Gen, DistinctInfinite) {
  function TEST (line 610) | TEST(Gen, DistinctByInfinite) {
  function TEST (line 625) | TEST(Gen, MinBy) {
  function TEST (line 638) | TEST(Gen, MaxBy) {
  function TEST (line 644) | TEST(Gen, Min) {
  function TEST (line 650) | TEST(Gen, Max) {
  function TEST (line 656) | TEST(Gen, Append) {
  function TEST (line 663) | TEST(Gen, FromRValue) {
  function TEST (line 702) | TEST(Gen, OrderBy) {
  function TEST (line 723) | TEST(Gen, Foldl) {
  function TEST (line 729) | TEST(Gen, Reduce) {
  function TEST (line 735) | TEST(Gen, ReduceBad) {
  function TEST (line 741) | TEST(Gen, Moves) {
  function TEST (line 750) | TEST(Gen, First) {
  function TEST (line 755) | TEST(Gen, FromCopy) {
  function TEST (line 766) | TEST(Gen, Get) {
  function TEST (line 791) | TEST(Gen, notEmpty) {
  function TEST (line 798) | TEST(Gen, isEmpty) {
  function TEST (line 805) | TEST(Gen, Any) {
  function TEST (line 810) | TEST(Gen, All) {
  function TEST (line 820) | TEST(Gen, Yielders) {
  function TEST (line 834) | TEST(Gen, NestedYield) {
  function TEST (line 847) | TEST(Gen, MapYielders) {

FILE: folly/gen/test/CombineTest.cpp
  function initVectorUniquePtr (line 41) | auto initVectorUniquePtr(int value) {
  function TEST (line 49) | TEST(CombineGen, Interleave) {
  function TEST (line 64) | TEST(CombineGen, InterleaveMoveOnly) {
  function TEST (line 78) | TEST(CombineGen, Zip) {
  function TEST (line 112) | TEST(CombineGen, ZipMoveOnly) {
  function TEST (line 126) | TEST(CombineGen, TupleFlatten) {

FILE: folly/gen/test/FileBenchmark.cpp
  function BENCHMARK (line 28) | BENCHMARK(ByLine_Pipes, iters) {
  function main (line 69) | int main(int argc, char* argv[]) {

FILE: folly/gen/test/FileTest.cpp
  function TEST (line 33) | TEST(FileGen, ByLine) {
  function TEST (line 62) | TEST(FileGen, ByLineFull) {
  class FileGenBufferedTest (line 91) | class FileGenBufferedTest : public ::testing::TestWithParam<int> {}
  function TEST_P (line 93) | TEST_P(FileGenBufferedTest, FileWriter) {
  function TEST (line 114) | TEST(FileGenBufferedTest, FileWriterSimple) {

FILE: folly/gen/test/IStreamTest.cpp
  type folly (line 28) | namespace folly {
    type gen (line 29) | namespace gen {
      function TEST (line 33) | TEST(IStream, ByLine) {

FILE: folly/gen/test/ParallelBenchmark.cpp
  function fib (line 37) | size_t fib(int n) {
  function stopc (line 57) | static auto stopc(int n) {
  function divides (line 60) | static auto divides(int n) {

FILE: folly/gen/test/ParallelMapBenchmark.cpp
  function fib (line 35) | size_t fib(int n) {
  function BENCHMARK (line 39) | BENCHMARK(FibSumMap, n) {
  function BENCHMARK_RELATIVE (line 44) | BENCHMARK_RELATIVE(FibSumPmap, n) {
  function BENCHMARK_RELATIVE (line 57) | BENCHMARK_RELATIVE(FibSumThreads, n) {
  function main (line 88) | int main(int argc, char* argv[]) {

FILE: folly/gen/test/ParallelMapTest.cpp
  function TEST (line 30) | TEST(Pmap, InfiniteEquivalent) {
  function TEST (line 68) | TEST(Pmap, Empty) {
  function TEST (line 108) | TEST(Pmap, Rvalues) {
  function TEST (line 158) | TEST(Pmap, Exception) {

FILE: folly/gen/test/ParallelTest.cpp
  function TEST (line 66) | TEST(ParallelTest, Serial) {
  function TEST (line 74) | TEST(ParallelTest, ComputeBound64) {
  function TEST (line 81) | TEST(ParallelTest, Take) {
  function TEST (line 89) | TEST(ParallelTest, Unique) {
  function TEST (line 102) | TEST(ParallelTest, PSum) {

FILE: folly/gen/test/StringBenchmark.cpp
  function initStringResplitterBenchmark (line 44) | void initStringResplitterBenchmark() {
  function len (line 59) | size_t len(folly::StringPiece s) {
  function BENCHMARK (line 65) | BENCHMARK(StringResplitter_Big, iters) {
  function BENCHMARK_RELATIVE (line 73) | BENCHMARK_RELATIVE(StringResplitter_Small, iters) {
  function BENCHMARK (line 83) | BENCHMARK(StringSplit_Old, iters) {
  function BENCHMARK_RELATIVE (line 94) | BENCHMARK_RELATIVE(StringSplit_Gen_Vector, iters) {
  function BENCHMARK (line 105) | BENCHMARK(StringSplit_Old_ReuseVector, iters) {
  function BENCHMARK_RELATIVE (line 117) | BENCHMARK_RELATIVE(StringSplit_Gen_ReuseVector, iters) {
  function BENCHMARK_RELATIVE (line 129) | BENCHMARK_RELATIVE(StringSplit_Gen, iters) {
  function BENCHMARK_RELATIVE (line 138) | BENCHMARK_RELATIVE(StringSplit_Gen_Take, iters) {
  function BENCHMARK (line 149) | BENCHMARK(StringUnsplit_Old, iters) {
  function BENCHMARK_RELATIVE (line 159) | BENCHMARK_RELATIVE(StringUnsplit_Old_ReusedBuffer, iters) {
  function BENCHMARK_RELATIVE (line 170) | BENCHMARK_RELATIVE(StringUnsplit_Gen, iters) {
  function BENCHMARK_RELATIVE (line 179) | BENCHMARK_RELATIVE(StringUnsplit_Gen_ReusedBuffer, iters) {
  function StringUnsplit_Gen (line 192) | void StringUnsplit_Gen(size_t iters, size_t joinSize) {
  function Lines_Gen (line 215) | void Lines_Gen(size_t iters, int joinSize) {
  function BENCHMARK (line 238) | BENCHMARK(Records_EachToTuple, iters) {
  function BENCHMARK_RELATIVE (line 251) | BENCHMARK_RELATIVE(Records_VectorStringPieceReused, iters) {
  function BENCHMARK_RELATIVE (line 273) | BENCHMARK_RELATIVE(Records_VectorStringPiece, iters) {
  function BENCHMARK_RELATIVE (line 294) | BENCHMARK_RELATIVE(Records_VectorString, iters) {
  function main (line 346) | int main(int argc, char* argv[]) {

FILE: folly/gen/test/StringTest.cpp
  function TEST (line 37) | TEST(StringGen, EmptySplit) {
  function TEST (line 64) | TEST(StringGen, Split) {
  function TEST (line 90) | TEST(StringGen, SplitByNewLine) {
  function TEST (line 98) | TEST(StringGen, EmptyResplit) {
  function TEST (line 119) | TEST(StringGen, Resplit) {
  function TEST (line 133) | TEST(StringGen, ResplitKeepDelimiter) {
  function TEST (line 147) | TEST(StringGen, EachToTuple) {
  function TEST (line 245) | TEST(StringGen, EachToPair) {
  function checkResplitMaxLength (line 278) | void checkResplitMaxLength(
  function TEST (line 304) | TEST(StringGen, ResplitMaxLength) {
  function runUnsplitSuite (line 323) | void runUnsplitSuite(F fn) {
  function TEST (line 332) | TEST(StringGen, Unsplit) {
  function TEST (line 364) | TEST(StringGen, Batch) {
  function TEST (line 383) | TEST(StringGen, UncurryTuple) {
  function TEST (line 391) | TEST(StringGen, UncurryPair) {

FILE: folly/hash/Checksum.cpp
  type folly (line 37) | namespace folly {
    type detail (line 39) | namespace detail {
      function crc32_hw (line 49) | uint32_t crc32_hw(
      function crc32c_hw_supported (line 75) | bool crc32c_hw_supported() {
      function crc32c_hw_supported_sse42 (line 79) | bool crc32c_hw_supported_sse42() {
      function crc32c_hw_supported_avx512 (line 84) | bool crc32c_hw_supported_avx512() {
      function crc32_hw_supported (line 90) | bool crc32_hw_supported() {
      function crc32c_hw_supported_neon (line 95) | bool crc32c_hw_supported_neon() {
      function crc32c_hw_supported_neon_eor3_sha3 (line 99) | bool crc32c_hw_supported_neon_eor3_sha3() {
      function crc32_hw_supported_neon_eor3_sha3 (line 103) | bool crc32_hw_supported_neon_eor3_sha3() {
      function crc32c_hw_supported (line 111) | bool crc32c_hw_supported() {
      function crc32c_hw_supported_sse42 (line 115) | bool crc32c_hw_supported_sse42() {
      function crc32c_hw_supported_avx512 (line 119) | bool crc32c_hw_supported_avx512() {
      function crc32c_hw_supported_neon (line 123) | bool crc32c_hw_supported_neon() {
      function crc32_hw_supported_neon_eor3_sha3 (line 128) | bool crc32_hw_supported_neon_eor3_sha3() {
      function crc32c_hw_supported_neon_eor3_sha3 (line 133) | bool crc32c_hw_supported_neon_eor3_sha3() {
      function crc32_hw_supported (line 138) | bool crc32_hw_supported() {
      function crc32_hw (line 144) | uint32_t crc32_hw(
      function crc32c_hw_supported (line 151) | bool crc32c_hw_supported() {
      function crc32c_hw_supported_sse42 (line 155) | bool crc32c_hw_supported_sse42() {
      function crc32c_hw_supported_avx512 (line 159) | bool crc32c_hw_supported_avx512() {
      function crc32_hw_supported (line 163) | bool crc32_hw_supported() {
      function crc32c_hw_supported_neon (line 167) | bool crc32c_hw_supported_neon() {
      function crc32_hw_supported_neon_eor3_sha3 (line 171) | bool crc32_hw_supported_neon_eor3_sha3() {
      function crc32c_hw_supported_neon_eor3_sha3 (line 175) | bool crc32c_hw_supported_neon_eor3_sha3() {
      function crc_sw (line 181) | uint32_t crc_sw(const uint8_t* data, size_t nbytes, uint32_t startin...
      function crc32c_sw (line 202) | uint32_t crc32c_sw(
      function crc32_sw (line 208) | uint32_t crc32_sw(
    function crc32c (line 216) | uint32_t crc32c(const uint8_t* data, size_t nbytes, uint32_t startingC...
    function crc32 (line 250) | uint32_t crc32(const uint8_t* data, size_t nbytes, uint32_t startingCh...
    function crc32_type (line 269) | uint32_t crc32_type(
    function crc32_combine (line 274) | uint32_t crc32_combine(uint32_t crc1, uint32_t crc2, size_t crc2len) {
    function crc32c_combine (line 289) | uint32_t crc32c_combine(uint32_t crc1, uint32_t crc2, size_t crc2len) {
    function crc32c_combine_seed (line 304) | uint32_t crc32c_combine_seed(

FILE: folly/hash/Checksum.h
  function namespace (line 27) | namespace folly {

FILE: folly/hash/FarmHash.h
  function namespace (line 21) | namespace folly {

FILE: folly/hash/FnvHash.h
  function namespace (line 25) | namespace folly {

FILE: folly/hash/Hash.h
  function namespace (line 56) | namespace folly {
  function const (line 350) | constexpr size_t operator()(bool key) const noexcept {
  type hasher (line 359) | struct hasher
  type hasher (line 363) | struct hasher
  type hasher (line 366) | struct hasher
  type hasher (line 369) | struct hasher
  type hasher (line 372) | struct hasher
  type hasher (line 375) | struct hasher
  type hasher (line 378) | struct hasher
  type hasher (line 381) | struct hasher
  type hasher (line 384) | struct hasher
  type hasher (line 387) | struct hasher
  type hasher (line 394) | struct hasher
  type hasher (line 397) | struct hasher
  type hasher (line 402) | struct hasher
  type hasher (line 405) | struct hasher
  function string (line 408) | struct hasher<std::string> {
  function string_view (line 420) | struct hasher<std::string_view> {
  function string_view (line 432) | struct hasher<cstring_view> : hasher<std::string_view> {}
  function const (line 438) | size_t operator()(T key) const noexcept {
  function namespace (line 449) | namespace detail {
  function hash_one_fn (line 458) | inline constexpr hash_one_fn hash_one{}
  function const (line 465) | size_t operator()(const std::pair<T1, T2>& key) const {
  function const (line 481) | size_t operator()(T* key) const {
  function const (line 491) | size_t operator()(const std::unique_ptr<T>& key) const {
  function const (line 500) | size_t operator()(const std::shared_ptr<T>& key) const {
  function namespace (line 513) | namespace hash {
  function hash_combine (line 685) | [[nodiscard]] size_t hash_combine(const T& t, const Ts&... ts) noexcept(
  function const (line 703) | size_t operator()(std::tuple<Ts...> const& key) const {
  function namespace (line 722) | namespace std {
  function namespace (line 756) | namespace folly {

FILE: folly/hash/HsiehHash.h
  function namespace (line 26) | namespace folly {

FILE: folly/hash/MurmurHash.h
  function namespace (line 25) | namespace folly {

FILE: folly/hash/SpookyHashV1.cpp
  type folly (line 33) | namespace folly {
    type hash (line 34) | namespace hash {

FILE: folly/hash/SpookyHashV1.h
  function namespace (line 50) | namespace folly {

FILE: folly/hash/SpookyHashV2.cpp
  type folly (line 35) | namespace folly {
    type hash (line 36) | namespace hash {

FILE: folly/hash/SpookyHashV2.h
  function namespace (line 56) | namespace folly {

FILE: folly/hash/UniqueHashKey.cpp
  type folly (line 34) | namespace folly {
    type detail (line 36) | namespace detail {
      function unique_hash_key_init_process_key_sha256 (line 48) | void unique_hash_key_init_process_key_sha256(
      type unique_hash_key_algo_strong_sha256_init_t (line 69) | struct unique_hash_key_algo_strong_sha256_init_t { // NOLINT
      function unique_hash_key_algo_strong_sha256_init_t (line 73) | static unique_hash_key_algo_strong_sha256_init_t
      function unique_hash_key_algo_strong_sha256_init_t (line 81) | static unique_hash_key_algo_strong_sha256_init_t const&
      function unique_hash_key_init_process_key_blake3 (line 95) | void unique_hash_key_init_process_key_blake3(
      type unique_hash_key_algo_strong_blake3_init_t (line 113) | struct unique_hash_key_algo_strong_blake3_init_t { // NOLINT
      function unique_hash_key_algo_strong_blake3_init_t (line 117) | static unique_hash_key_algo_strong_blake3_init_t
      function unique_hash_key_algo_strong_blake3_init_t (line 125) | static unique_hash_key_algo_strong_blake3_init_t const&
      type unique_hash_key_algo_fast_xxh3_init_t (line 133) | struct unique_hash_key_algo_fast_xxh3_init_t { // NOLINT
      function unique_hash_key_algo_fast_xxh3_init_t (line 138) | static unique_hash_key_algo_fast_xxh3_init_t
      function unique_hash_key_algo_fast_xxh3_init_t (line 147) | static unique_hash_key_algo_fast_xxh3_init_t const&
      type unique_hash_key_algo_fast_xxh3_ops (line 154) | struct unique_hash_key_algo_fast_xxh3_ops
      type unique_hash_key_algo_fast_xxh3_ops<8> (line 156) | struct unique_hash_key_algo_fast_xxh3_ops<8> {
      type unique_hash_key_algo_fast_xxh3_ops<16> (line 162) | struct unique_hash_key_algo_fast_xxh3_ops<16> {
      function FOLLY_ALWAYS_INLINE (line 173) | FOLLY_ALWAYS_INLINE static void unique_hash_key_hash_items(

FILE: folly/hash/UniqueHashKey.h
  function namespace (line 29) | namespace folly {

FILE: folly/hash/detail/ChecksumDetail.cpp
  type folly (line 115) | namespace folly {
    type detail (line 116) | namespace detail {
      function __m128i (line 120) | static __m128i crc32MulAdd(__m128i x, __m128i a, __m128i multiplier) {
      function crc32_hw_aligned (line 132) | uint32_t crc32_hw_aligned(

FILE: folly/hash/detail/ChecksumDetail.h
  function namespace (line 29) | namespace folly {

FILE: folly/hash/detail/Crc32CombineDetail.cpp
  type folly (line 24) | namespace folly {
    function gf_multiply_sw_1 (line 30) | static constexpr uint32_t gf_multiply_sw_1(
    function gf_multiply_sw (line 41) | static constexpr uint32_t gf_multiply_sw(uint32_t a, uint32_t b, uint3...
    function gf_square_sw (line 45) | static constexpr uint32_t gf_square_sw(uint32_t a, uint32_t m) {
    type gf_powers_memo (line 52) | struct gf_powers_memo {
    type gf_powers_memo<0, m> (line 57) | struct gf_powers_memo<0, m> {
    type gf_powers_make (line 62) | struct gf_powers_make {
    function gf_multiply_crc32c_hw (line 77) | static uint32_t gf_multiply_crc32c_hw(uint64_t crc1, uint64_t crc2, ui...
    function gf_multiply_crc32_hw (line 91) | static uint32_t gf_multiply_crc32_hw(uint64_t crc1, uint64_t crc2, uin...
    function gf_multiply_crc32c_hw (line 116) | static uint32_t gf_multiply_crc32c_hw(uint64_t, uint64_t, uint32_t) {
    function gf_multiply_crc32_hw (line 119) | static uint32_t gf_multiply_crc32_hw(uint64_t, uint64_t, uint32_t) {
    function crc32_append_zeroes (line 137) | static uint32_t crc32_append_zeroes(
    type detail (line 164) | namespace detail {
      function crc32_combine_sw (line 166) | uint32_t crc32_combine_sw(uint32_t crc1, uint32_t crc2, size_t crc2l...
      function crc32_combine_hw (line 171) | uint32_t crc32_combine_hw(uint32_t crc1, uint32_t crc2, size_t crc2l...
      function crc32c_combine_sw (line 177) | uint32_t crc32c_combine_sw(uint32_t crc1, uint32_t crc2, size_t crc2...
      function crc32c_combine_hw (line 183) | uint32_t crc32c_combine_hw(uint32_t crc1, uint32_t crc2, size_t crc2...

FILE: folly/hash/detail/Crc32cDetail.cpp
  type folly (line 41) | namespace folly {
    type detail (line 42) | namespace detail {
      type crc32_detail (line 46) | namespace crc32_detail {
        function CombineCRC (line 145) | uint64_t CombineCRC(
        function FOLLY_ALWAYS_INLINE (line 166) | FOLLY_ALWAYS_INLINE void align_to_8(
        function triplet_loop (line 188) | void triplet_loop(
      function crc32c_hw (line 242) | uint32_t crc32c_hw(const uint8_t* buf, size_t len, uint32_t crc) {
      function crc32c_hw (line 295) | uint32_t crc32c_hw(

FILE: folly/hash/detail/RandomSeed.h
  function namespace (line 24) | namespace folly {

FILE: folly/hash/detail/test/RandomSeedTest.cpp
  function TEST (line 23) | TEST(RandomSeedTest, Seed) {

FILE: folly/hash/rapidhash.h
  function namespace (line 21) | namespace folly {

FILE: folly/hash/test/ChecksumBenchmark.cpp
  function main (line 60) | int main(int argc, char** argv) {

FILE: folly/hash/test/ChecksumTest.cpp
  type ExpectedResult (line 37) | struct ExpectedResult {
  function testCRC32C (line 78) | void testCRC32C(
  function testCRC32CContinuation (line 86) | void testCRC32CContinuation(
  function testMatchesBoost32Type (line 100) | void testMatchesBoost32Type() {
  function TEST (line 113) | TEST(Checksum, crc32cSoftware) {
  function TEST (line 117) | TEST(Checksum, crc32cContinuationSoftware) {
  function TEST (line 121) | TEST(Checksum, crc32cHardware) {
  function TEST (line 132) | TEST(Checksum, crc32cHardwareEq) {
  function TEST (line 147) | TEST(Checksum, crc32cContinuationHardware) {
  function TEST (line 158) | TEST(Checksum, crc32cHardwareSse42) {
  function TEST (line 169) | TEST(Checksum, crc32cHardwareEqSse42) {
  function TEST (line 184) | TEST(Checksum, crc32cContinuationHardwareSse42) {
  function TEST (line 195) | TEST(Checksum, crc32cHardwareAvx512) {
  function TEST (line 206) | TEST(Checksum, crc32cHardwareEqAvx512) {
  function TEST (line 221) | TEST(Checksum, crc32cContinuationHardwareAvx512) {
  function TEST (line 232) | TEST(Checksum, crc32cHardwareNeon) {
  function TEST (line 243) | TEST(Checksum, crc32cHardwareEqNeon) {
  function TEST (line 258) | TEST(Checksum, crc32cContinuationHardwareNeon) {
  function TEST (line 269) | TEST(Checksum, crc32cHardwareNeonEor3Sha3) {
  function TEST (line 280) | TEST(Checksum, crc32cHardwareEqNeonEor3Sha3) {
  function TEST (line 295) | TEST(Checksum, crc32cContinuationHardwareNeonEor3Sha3) {
  function TEST (line 309) | TEST(Checksum, crc32clargeBuffers) {
  function TEST (line 340) | TEST(Checksum, crc32cAutodetect) {
  function TEST (line 344) | TEST(Checksum, crc32cContinuationAutodetect) {
  function TEST (line 348) | TEST(Checksum, crc32) {
  function TEST (line 364) | TEST(Checksum, crc32Continuation) {
  function TEST (line 391) | TEST(Checksum, crc32Type) {
  function TEST (line 396) | TEST(Checksum, crc32Combine) {
  function TEST (line 407) | TEST(Checksum, crc32cCombine) {
  function TEST (line 418) | TEST(Checksum, crc32cCombineSeed_explicit_starting_checksum) {
  function benchmarkHardwareCRC32C (line 438) | void benchmarkHardwareCRC32C(unsigned long iters, size_t blockSize) {
  function benchmarkSoftwareCRC32C (line 451) | void benchmarkSoftwareCRC32C(unsigned long iters, size_t blockSize) {
  function benchmarkHardwareCRC32 (line 459) | void benchmarkHardwareCRC32(unsigned long iters, size_t blockSize) {
  function benchmarkSoftwareCRC32 (line 472) | void benchmarkSoftwareCRC32(unsigned long iters, size_t blockSize) {
  function benchmarkCombineHardwareCrc32 (line 480) | void benchmarkCombineHardwareCrc32(unsigned long iters, size_t blockSize) {
  function benchmarkCombineSoftwareLinear (line 491) | void benchmarkCombineSoftwareLinear(unsigned long iters, size_t blockSiz...
  function benchmarkCombineHardwareCrc32c (line 506) | void benchmarkCombineHardwareCrc32c(unsigned long iters, size_t blockSiz...
  function BENCHMARK (line 519) | BENCHMARK(crc32c_hardware_1KB_block, iters) {
  function BENCHMARK (line 523) | BENCHMARK(crc32c_software_1KB_block, iters) {
  function BENCHMARK (line 527) | BENCHMARK(crc32_hardware_1KB_block, iters) {
  function BENCHMARK (line 531) | BENCHMARK(crc32_software_1KB_block, iters) {
  function BENCHMARK (line 538) | BENCHMARK(crc32c_hardware_64KB_block, iters) {
  function BENCHMARK (line 542) | BENCHMARK(crc32c_software_64KB_block, iters) {
  function BENCHMARK (line 546) | BENCHMARK(crc32_hardware_64KB_block, iters) {
  function BENCHMARK (line 550) | BENCHMARK(crc32_software_64KB_block, iters) {
  function BENCHMARK (line 557) | BENCHMARK(crc32c_hardware_512KB_block, iters) {
  function BENCHMARK (line 561) | BENCHMARK(crc32c_software_512KB_block, iters) {
  function BENCHMARK (line 565) | BENCHMARK(crc32_hardware_512KB_block, iters) {
  function BENCHMARK (line 569) | BENCHMARK(crc32_software_512KB_block, iters) {
  function BENCHMARK (line 575) | BENCHMARK(crc32_combine_linear_512KB_block, iters) {
  function BENCHMARK (line 579) | BENCHMARK(crc32_combine_512KB_block, iters) {
  function BENCHMARK (line 583) | BENCHMARK(crc32c_combine_512KB_block, iters) {
  function main (line 587) | int main(int argc, char** argv) {

FILE: folly/hash/test/FarmHashTest.cpp
  function TEST (line 21) | TEST(farmhash, simple) {

FILE: folly/hash/test/FnvHashTest.cpp
  function TEST (line 23) | TEST(FnvHash, Fnv32_BROKEN) {
  function TEST (line 46) | TEST(FnvHash, Fnv64_BROKEN) {
  function TEST (line 90) | TEST(FnvHash, Fnv32_FIXED) {
  function TEST (line 113) | TEST(FnvHash, Fnv64_FIXED) {

FILE: folly/hash/test/HashBenchmark.cpp
  function FOLLY_KEEP (line 36) | FOLLY_KEEP uint64_t
  function FOLLY_KEEP (line 41) | FOLLY_KEEP uint64_t
  function FOLLY_KEEP (line 46) | FOLLY_KEEP uint64_t check_folly_twang_mix64(uint64_t key) {
  function FOLLY_KEEP (line 50) | FOLLY_KEEP uint64_t check_folly_twang_unmix64(uint64_t key) {
  function FOLLY_KEEP (line 54) | FOLLY_KEEP uint32_t check_folly_twang_32from64(uint64_t key) {
  function FOLLY_KEEP (line 58) | FOLLY_KEEP uint32_t check_folly_jenkins_rev_mix32(uint32_t key) {
  function FOLLY_KEEP (line 62) | FOLLY_KEEP uint32_t check_folly_jenkins_rev_unmix32(uint32_t key) {
  function FOLLY_KEEP (line 66) | FOLLY_KEEP uint64_t
  function FOLLY_KEEP (line 71) | FOLLY_KEEP uint64_t
  type detail (line 76) | namespace detail {
    function randomBytes (line 78) | std::vector<uint8_t> randomBytes(size_t n) {
    function bmHasher (line 89) | void bmHasher(Hasher hasher, size_t k, size_t iters) {
    function addHashBenchmark (line 100) | void addHashBenchmark(const std::string& hasherName) {
    type SpookyHashV2 (line 124) | struct SpookyHashV2 {
    type FNV64 (line 130) | struct FNV64 {
    type MurmurHash (line 136) | struct MurmurHash {
    type RapidHash (line 143) | struct RapidHash {
    type RapidHashMicro (line 149) | struct RapidHashMicro {
    type RapidHashNano (line 156) | struct RapidHashNano {
  function main (line 165) | int main(int argc, char** argv) {

FILE: folly/hash/test/HashTest.cpp
  function TEST (line 36) | TEST(Hash, Test128To64) {
  function TEST (line 45) | TEST(Hash, TWangMix64) {
  function checkTWang (line 58) | void checkTWang(uint64_t r) {
  function TEST (line 64) | TEST(Hash, TWangUnmix64) {
  function TEST (line 73) | TEST(Hash, TWang32From64) {
  function TEST (line 83) | TEST(Hash, JenkinsRevMix32) {
  function checkJenkins (line 96) | void checkJenkins(uint32_t r) {
  function TEST (line 102) | TEST(Hash, JenkinsRevUnmix32) {
  function TEST (line 111) | TEST(Hash, hasher) {
  function TEST (line 118) | TEST(Hash, integralTypes) {
  type TestEnum (line 157) | enum class TestEnum {
  type TestBigEnum (line 163) | enum class TestBigEnum : uint64_t {
  type TestStruct (line 167) | struct TestStruct {}
  type std (line 170) | namespace std {
    type hash<TestEnum> (line 172) | struct hash<TestEnum> {
    type hash<TestStruct> (line 179) | struct hash<TestStruct> {
  class TestAlloc (line 190) | class TestAlloc {
    method TestAlloc (line 206) | TestAlloc() {}
    method TestAlloc (line 209) | TestAlloc(TestAlloc<T2> const& other) noexcept : a_(other.a_) {}
    method TestAlloc (line 212) | TestAlloc& operator=(TestAlloc<T2> const& other) noexcept {
    method TestAlloc (line 218) | TestAlloc(TestAlloc<T2>&& other) noexcept : a_(std::move(other.a_)) {}
    method TestAlloc (line 221) | TestAlloc& operator=(TestAlloc<T2>&& other) noexcept {
    method getAllocatedMemorySize (line 226) | static size_t getAllocatedMemorySize() { return allocatedMemorySize; }
    method resetTracking (line 228) | static void resetTracking() { allocatedMemorySize = 0; }
    method T (line 230) | T* allocate(size_t n) {
    method deallocate (line 234) | void deallocate(T* p, size_t n) {
  function getStats (line 257) | std::vector<size_t> getStats(size_t iter) {
  function testNoCachedHashCode (line 273) | void testNoCachedHashCode() {
  function TEST (line 287) | TEST(Hash, noCachedHashCode) {
  function TEST (line 299) | TEST(Hash, integerConversion) {
  function TEST (line 306) | TEST(Hash, int128StdHash) {
  function TEST (line 319) | TEST(Hash, floatTypes) {
  class TestHasher (line 338) | class TestHasher {
  function hash_combine_test (line 346) | size_t hash_combine_test(const T& t, const Ts&... ts) {
  function TEST (line 350) | TEST(Hash, pair) {
  function TEST (line 378) | TEST(Hash, hashCombine) {
  function TEST (line 383) | TEST(Hash, hashBool) {
  function TEST (line 388) | TEST(Hash, hashBool10) {
  function TEST (line 416) | TEST(Hash, stdTuple) {
  function TEST (line 425) | TEST(Hash, stdEmptyTuple) {
  function TEST (line 434) | TEST(Hash, enumType) {
  function TEST (line 456) | TEST(Hash, pairFollyHash) {
  function TEST (line 465) | TEST(Hash, tupleFollyHash) {
  function hash_vector (line 476) | size_t hash_vector(const std::vector<T>& v) {
  function TEST (line 481) | TEST(Hash, hashRange) {
  function TEST (line 487) | TEST(Hash, commutativeHashCombine) {
  function TEST (line 517) | TEST(Hash, stdTupleDifferentHash) {
  function TEST (line 527) | TEST(Hash, Strings) {
  function deletePointer (line 562) | void deletePointer(const std::unique_ptr<std::string>&) {}
  function deletePointer (line 563) | void deletePointer(const std::shared_ptr<std::string>&) {}
  function deletePointer (line 564) | void deletePointer(std::string* pointer) {
  function pointerTestWithFollyHash (line 569) | void pointerTestWithFollyHash() {
  function TEST (line 588) | TEST(Hash, UniquePtr) {
  function TEST (line 592) | TEST(Hash, SharedPtr) {
  function TEST (line 596) | TEST(Hash, Pointer) {
  type FNVTestParam (line 613) | struct FNVTestParam {
  class FNV32Test (line 620) | class FNV32Test : public ::testing::TestWithParam<FNV32TestParam> {}
  class FNV64Test (line 621) | class FNV64Test : public ::testing::TestWithParam<FNV64TestParam> {}
  function TEST_P (line 623) | TEST_P(FNV32Test, Fnva32Buf) {
  function TEST_P (line 628) | TEST_P(FNV64Test, Fnva64Buf) {
  function TEST_P (line 633) | TEST_P(FNV32Test, Fnva32) {
  function TEST_P (line 637) | TEST_P(FNV64Test, Fnva64) {
  function TEST_P (line 641) | TEST_P(FNV32Test, Fnva32Partial) {
  function TEST_P (line 651) | TEST_P(FNV64Test, Fnva64Partial) {
  function verifyAvalanching (line 843) | void verifyAvalanching(T initialValue, F const& advance) {
  function TEST (line 898) | TEST(Traits, stdHashPairAvalances) {
  function TEST (line 903) | TEST(Traits, stdHashTuple2Avalances) {
  function TEST (line 909) | TEST(Traits, stdHashStringAvalances) {
  function TEST (line 921) | TEST(Traits, stdHashStringViewAvalances) {
  function TEST (line 933) | TEST(Traits, follyHashUint64Avalances) {
  function TEST (line 937) | TEST(Traits, follyHasherInt64Avalances) {
  function TEST (line 943) | TEST(Traits, follyHasherFloatAvalanches) {
  function TEST (line 947) | TEST(Traits, follyHasherDoubleAvalanches) {
  function TEST (line 951) | TEST(HashSequence, Fold) {
  function TEST (line 968) | TEST(HashSequence, TypeMix) {
  function TEST (line 979) | TEST(HashTuple, Empty) {
  function TEST (line 986) | TEST(HashTuple, Basic) {
  function TEST (line 997) | TEST(Hash, cstring_view_hasher_basic) {
  function TEST (line 1007) | TEST(Hash, cstring_view_hasher_different_strings) {
  function TEST (line 1016) | TEST(Hash, cstring_view_hasher_empty_string) {
  function TEST (line 1026) | TEST(Hash, cstring_view_hasher_after_remove_prefix) {
  function TEST (line 1038) | TEST(Hash, cstring_view_hasher_consistency) {

FILE: folly/hash/test/HsiehHashTest.cpp
  function TEST (line 23) | TEST(HsiehHash, Hsieh32) {

FILE: folly/hash/test/MurmurHashTest.cpp
  function murmurHash64 (line 55) | constexpr std::uint64_t murmurHash64(std::string_view input) {
  function TEST (line 61) | TEST(MurmurHash, Runtime) {
  function TEST (line 67) | TEST(MurmurHash, Constexpr) {

FILE: folly/hash/test/RapidHashTest.cpp
  function TEST (line 58) | TEST(RapidHash, Runtime) {
  function TEST (line 64) | TEST(RapidHashMicro, Runtime) {
  function TEST (line 70) | TEST(RapidHashNano, Runtime) {
  function TEST (line 76) | TEST(RapidHash, Constexpr) {
  function TEST (line 110) | TEST(RapidHashMicro, Constexpr) {
  function TEST (line 144) | TEST(RapidHashNano, Constexpr) {

FILE: folly/hash/test/SpookyHashV1Test.cpp
  function GetClockTickCount (line 43) | static uint64_t GetClockTickCount() {
  class Random (line 49) | class Random
    method Value (line 52) | inline uint64_t Value()
    method Init (line 62) | inline void Init( uint64_t seed)
    method Rot64 (line 72) | static inline uint64_t Rot64(uint64_t x, int k)
  function Add (line 84) | static void Add(const void *data, size_t length,
  function TestResults (line 100) | void TestResults()
  function DoTimingBig (line 270) | void DoTimingBig(int seed)
  function DoTimingSmall (line 331) | void DoTimingSmall(int seed)
  function TestAlignment (line 359) | void TestAlignment()
  function TestDeltas (line 393) | void TestDeltas(int seed)
  function TestPieces (line 484) | void TestPieces()
  function TEST (line 546) | TEST(SpookyHashV1, Main) {

FILE: folly/hash/test/SpookyHashV2Test.cpp
  function GetClockTickCount (line 43) | static uint64_t GetClockTickCount() {
  class Random (line 49) | class Random
    method Value (line 52) | inline uint64_t Value()
    method Init (line 62) | inline void Init( uint64_t seed)
    method Rot64 (line 72) | static inline uint64_t Rot64(uint64_t x, int k)
  function Add (line 84) | static void Add(const void *data, size_t length,
  function TestResults (line 100) | void TestResults()
  function DoTimingBig (line 260) | void DoTimingBig(int seed)
  function DoTimingSmall (line 321) | void DoTimingSmall(int seed)
  function TestAlignment (line 349) | void TestAlignment()
  function TestDeltas (line 383) | void TestDeltas(int seed)
  function TestPieces (line 474) | void TestPieces()
  function TEST (line 536) | TEST(SpookyHashV2, Main) {

FILE: folly/hash/test/StdCompatibleHashTest.cpp
  function randomBytes (line 32) | std::vector<uint8_t> randomBytes(
  function TEST (line 43) | TEST(StdCompatibleHashTest, Stress) {

FILE: folly/hash/test/UniqueHashKeyTest.cpp
  type UniqueHashKeyTest (line 24) | struct UniqueHashKeyTest : testing::TestWithParam<Algo> {}
  function TYPED_TEST_P (line 27) | TYPED_TEST_P(UniqueHashKeyTest, Example) {

FILE: folly/hash/test/traits_test.cpp
  type HashableStruct1 (line 25) | struct HashableStruct1 {}
  type HashableStruct2 (line 26) | struct HashableStruct2 {}
  type UnhashableStruct (line 27) | struct UnhashableStruct {}
  type CompositeStruct (line 30) | struct CompositeStruct {
  type std (line 37) | namespace std {
    type hash<HashableStruct1> (line 40) | struct hash<HashableStruct1> {
    type hash<HashableStruct2> (line 47) | struct hash<HashableStruct2> {
    type hash<enable_std_hash_helper<CompositeStruct<X, Y>, X, Y>> (line 54) | struct hash<enable_std_hash_helper<CompositeStruct<X, Y>, X, Y>> {

FILE: folly/hash/traits.h
  function namespace (line 24) | namespace folly {

FILE: folly/init/Init.cpp
  type folly (line 33) | namespace folly {
    function wrapped_abort (line 48) | __attribute__((noreturn))
    function initImpl (line 57) | void initImpl(int* argc, char*** argv, InitOptions options) {
    function unsafe_unscoped_init (line 114) | void unsafe_unscoped_init(int* argc, char*** argv, bool removeFlags) {
    function unsafe_unscoped_init (line 118) | void unsafe_unscoped_init(int* argc, char*** argv, InitOptions options) {

FILE: folly/init/Init.h
  function remove_flags (line 30) | bool remove_flags{true};

FILE: folly/init/Phase.cpp
  type folly (line 23) | namespace folly {
    function set_process_phase (line 29) | void set_process_phase(ProcessPhase newphase) {
    function set_process_phases (line 39) | void set_process_phases() {
    function ProcessPhase (line 44) | ProcessPhase get_process_phase() noexcept {

FILE: folly/init/Phase.h
  function namespace (line 21) | namespace folly {

FILE: folly/init/test/PhaseTest.cpp
  type Global (line 28) | struct Global {
    method Global (line 29) | Global() { CHECK(folly::get_process_phase() == folly::ProcessPhase::In...
  function TEST (line 40) | TEST(InitTest, basic) {
  function TEST (line 44) | TEST(InitTest, fork) {

FILE: folly/io/Cursor-inl.h
  function namespace (line 19) | namespace folly {

FILE: folly/io/Cursor.cpp
  type folly (line 23) | namespace folly {
    type io (line 24) | namespace io {

FILE: folly/io/Cursor.h
  function namespace (line 55) | namespace folly {
  function getPositionInCurrentBuffer (line 161) | size_t getPositionInCurrentBuffer() const noexcept {
  function folly (line 190) | const folly::IOBuf* currentBuffer() const noexcept { return crtBuf_; }
  function length (line 202) | size_t length() const noexcept {
  function canAdvance (line 234) | bool canAdvance(size_t amount) const noexcept {
  function isAtEnd (line 256) | bool isAtEnd() const noexcept {
  function advanceToEnd (line 286) | void advanceToEnd() {
  function skipAtMost (line 547) | size_t skipAtMost(size_t len) {
  function skip (line 563) | void skip(size_t len) {
  function skipNoAdvance (line 579) | void skipNoAdvance(size_t len) {
  function retreatAtMost (line 589) | size_t retreatAtMost(size_t len) {
  function retreat (line 604) | void retreat(size_t len) {
  function pullAtMost (line 622) | size_t pullAtMost(void* buf, size_t len) {
  function pull (line 646) | void pull(void* buf, size_t len) {
  function ByteRange (line 671) | ByteRange peekBytes() {
  function CursorAccess (line 1273) | enum class CursorAccess { PRIVATE, UNSHARE };
  function class (line 1481) | class Appender : public Writable<Appender> {
  function class (line 1624) | class QueueAppender : public Writable<QueueAppender> {
  function pushAtMost (line 1729) | size_t pushAtMost(const uint8_t* buf, size_t len) {
  function growth_ (line 1798) | size_t growth_{0};

FILE: folly/io/FsUtil.cpp
  type folly (line 33) | namespace folly {
    type fs (line 34) | namespace fs {
      function skipPrefix (line 37) | bool skipPrefix(const path& pth, const path& prefix, path::const_ite...
      function starts_with (line 55) | bool starts_with(const path& pth, const path& prefix) {
      function path (line 60) | path remove_prefix(const path& pth, const path& prefix) {
      function path (line 78) | path canonical_parent(const path& pth, const path& base) {
      function path (line 82) | path executable_path() {
      function wchar_t (line 102) | [[maybe_unused]] static constexpr wchar_t const* hex_(wchar_t) {

FILE: folly/io/FsUtil.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/GlobalShutdownSocketSet.cpp
  type folly (line 21) | namespace folly {
    type PrivateTag (line 24) | struct PrivateTag {}
    function tryGetShutdownSocketSet (line 29) | std::shared_ptr<ShutdownSocketSet> tryGetShutdownSocketSet() {
    function tryGetShutdownSocketSetFast (line 32) | ReadMostlySharedPtr<ShutdownSocketSet> tryGetShutdownSocketSetFast() {

FILE: folly/io/GlobalShutdownSocketSet.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/HugePages.cpp
  type folly (line 42) | namespace folly {
    function getDefaultHugePageSize (line 47) | size_t getDefaultHugePageSize() {
    function HugePageSizeVec (line 70) | HugePageSizeVec readRawHugePageSizes() {
    function parsePageSizeValue (line 92) | size_t parsePageSizeValue(StringPiece value) {
    function HugePageSizeVec (line 125) | HugePageSizeVec readHugePageSizes() {
    function HugePageSizeVec (line 201) | const HugePageSizeVec& getHugePageSizes() {
    function HugePageSize (line 206) | const HugePageSize* getHugePageSize(size_t size) {
    function HugePageSize (line 219) | const HugePageSize* getHugePageSizeForDevice(dev_t device) {

FILE: folly/io/HugePages.h
  function namespace (line 32) | namespace folly {

FILE: folly/io/IOBuf.cpp
  function takeOwnershipError (line 87) | void takeOwnershipError(
  type folly (line 104) | namespace folly {
    type IOBuf::HeapPrefix (line 108) | struct IOBuf::HeapPrefix {
      method HeapPrefix (line 109) | HeapPrefix(uint8_t rc, uint32_t sz, bool hmr)
    type IOBuf::HeapStorage (line 126) | struct IOBuf::HeapStorage {
      method checkInvariants (line 138) | static void checkInvariants() {
    type IOBuf::HeapFullStorage (line 146) | struct alignas(folly::max_align_v) IOBuf::HeapFullStorage {
      method checkInvariants (line 154) | static void checkInvariants() {
    function IOBuf (line 610) | IOBuf IOBuf::wrapBufferAsValue(const void* buf, std::size_t capacity) ...
    function IOBuf (line 686) | IOBuf& IOBuf::operator=(IOBuf&& other) noexcept {
    function IOBuf (line 733) | IOBuf& IOBuf::operator=(const IOBuf& other) {
    function IOBuf (line 823) | IOBuf IOBuf::cloneAsValue() const {
    function IOBuf (line 833) | IOBuf IOBuf::cloneOneAsValue() const {
    function IOBuf (line 841) | IOBuf IOBuf::cloneCoalescedAsValue() const {
    function IOBuf (line 847) | IOBuf IOBuf::cloneCoalescedAsValueWithHeadroomTailroom(
    type SplitTailStorage (line 904) | struct SplitTailStorage : HeapFullStorage {
    function fbstring (line 1329) | fbstring IOBuf::moveToFbString() {
    type iovec (line 1405) | struct iovec
    type iovec (line 1406) | struct iovec
    type iovec (line 1412) | struct iovec
    type iovec (line 1461) | struct iovec
    function ordering (line 1506) | ordering IOBufCompare::impl(const IOBuf& a, const IOBuf& b) const noex...

FILE: folly/io/IOBuf.h
  function namespace (line 62) | namespace folly {
  function std (line 649) | static std::unique_ptr<IOBuf> wrapBuffer(ByteRange br) {
  function IOBuf (line 666) | static IOBuf wrapBufferAsValue(ByteRange br) noexcept {
  function destroy (line 757) | static void destroy(std::unique_ptr<IOBuf>&& data) {
  function empty (line 784) | bool empty() const noexcept;
  function IOBuf (line 898) | IOBuf* next() noexcept { return next_; }
  function IOBuf (line 900) | const IOBuf* next() const noexcept { return next_; }
  function IOBuf (line 907) | IOBuf* prev() noexcept { return prev_; }
  function IOBuf (line 909) | const IOBuf* prev() const noexcept { return prev_; }
  function advance (line 931) | void advance(std::size_t amount) noexcept {
  function retreat (line 960) | void retreat(std::size_t amount) noexcept {
  function prepend (line 985) | void prepend(std::size_t amount) noexcept {
  function append (line 1006) | void append(std::size_t amount) noexcept {
  function trimStart (line 1025) | void trimStart(std::size_t amount) noexcept {
  function trimEnd (line 1045) | void trimEnd(std::size_t amount) noexcept {
  function trimWritableTail (line 1061) | void trimWritableTail(std::size_t amount) noexcept {
  function clear (line 1072) | void clear() noexcept {
  function reserve (line 1095) | void reserve(std::size_t minHeadroom, std::size_t minTailroom) {
  function countChainElements (line 1135) | size_t countChainElements() const noexcept;
  function prependChain (line 1197) | void prependChain(std::unique_ptr<IOBuf>&& iobuf) {
  function appendChain (line 1209) | void appendChain(std::unique_ptr<IOBuf>&& iobuf) {
  function isShared (line 1314) | bool isShared() const noexcept {
  function isManaged (line 1397) | bool isManaged() const noexcept {
  function approximateShareCountOne (line 1441) | uint32_t approximateShareCountOne() const noexcept;
  function unshare (line 1500) | void unshare() {
  function unshareOne (line 1519) | void unshareOne() {
  function markExternallySharedOne (line 1549) | void markExternallySharedOne() {
  function makeManaged (line 1568) | void makeManaged() {
  function makeManagedOne (line 1589) | void makeManagedOne() {
  function ByteRange (line 1617) | ByteRange coalesce() {
  function ByteRange (line 1635) | ByteRange coalesceWithHeadroomTailroom(
  function gather (line 1664) | void gather(std::size_t contiguousLength) {
  function IOBuf (line 1743) | IOBuf cloneCoalescedAsValue() const;
  function std (line 1823) | static std::unique_ptr<IOBuf> fromString(std::string s) {
  type FillIovResult (line 1855) | struct FillIovResult {
  type iovec (line 1878) | struct iovec
  function Iterator (line 2019) | Iterator cbegin() const;
  function IOBufCompare (line 2300) | struct IOBufEqualTo : compare_equal_to<IOBufCompare> {}
  function IOBufCompare (line 2305) | struct IOBufNotEqualTo : compare_not_equal_to<IOBufCompare> {}
  function IOBufCompare (line 2310) | struct IOBufLess : compare_less<IOBufCompare> {}
  function IOBufCompare (line 2315) | struct IOBufLessEqual : compare_less_equal<IOBufCompare> {}
  function IOBufCompare (line 2320) | struct IOBufGreater : compare_greater<IOBufCompare> {}
  function IOBufCompare (line 2325) | struct IOBufGreaterEqual : compare_greater_equal<IOBufCompare> {}
  function std (line 2338) | inline std::unique_ptr<IOBuf> IOBuf::copyBuffer(
  function std (line 2356) | inline std::unique_ptr<IOBuf> IOBuf::copyBuffer(
  function std (line 2361) | inline std::unique_ptr<IOBuf> IOBuf::maybeCopyBuffer(
  function Iterator (line 2389) | Iterator(Iterator const& rhs) : Iterator(rhs.pos_, rhs.end_) {}
  function equal (line 2402) | bool equal(const Iterator& other) const {
  function increment (line 2409) | void increment() {
  function adjustForEnd (line 2417) | void adjustForEnd() {
  function IOBuf (line 2427) | const IOBuf* end_{nullptr};

FILE: folly/io/IOBufIovecBuilder.cpp
  type folly (line 20) | namespace folly {
    type iovec (line 34) | struct iovec

FILE: folly/io/IOBufIovecBuilder.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/IOBufQueue.cpp
  function packInto (line 37) | void packInto(IOBuf* tail, Src& src, Next next) {
  function appendToChain (line 57) | void appendToChain(unique_ptr<IOBuf>& dst, unique_ptr<IOBuf>&& src, bool...
  type folly (line 73) | namespace folly {
    function IOBufQueue (line 98) | IOBufQueue& IOBufQueue::operator=(IOBufQueue&& other) noexcept {

FILE: folly/io/IOBufQueue.h
  function namespace (line 25) | namespace folly {
  type Options (line 90) | struct Options {
  function Options (line 102) | static Options cacheChainLength() {
  function class (line 120) | class WritableRangeCache {
  function append (line 356) | void append(StringPiece sp) { append(sp.data(), sp.size()); }
  function postallocate (line 425) | void postallocate(std::size_t n) noexcept {
  function folly (line 554) | const folly::IOBuf* front() const {
  function reset (line 604) | void reset() { move(); }
  function IOBufFactory (line 665) | IOBufFactory* factory_{nullptr};

FILE: folly/io/RecordIO-inl.h
  function namespace (line 24) | namespace folly {
  function RecordIOReader (line 57) | inline auto RecordIOReader::cbegin() const -> Iterator {
  function RecordIOReader (line 63) | inline auto RecordIOReader::cend() const -> Iterator {
  function RecordIOReader (line 69) | inline auto RecordIOReader::seek(off_t pos) const -> Iterator {
  function namespace (line 73) | namespace recordio_helpers {

FILE: folly/io/RecordIO.cpp
  type folly (line 25) | namespace folly {
    type stat (line 38) | struct stat
    type recordio_helpers (line 99) | namespace recordio_helpers {
      function headerHash (line 107) | uint32_t headerHash(const Header& header) {
      function dataLengthAndHash (line 112) | std::pair<size_t, std::size_t> dataLengthAndHash(const IOBuf* buf) {
      function dataHash (line 129) | std::size_t dataHash(ByteRange range) {
      function prependHeader (line 135) | size_t prependHeader(std::unique_ptr<IOBuf>& buf, uint32_t fileId) {
      function validateRecordHeader (line 166) | bool validateRecordHeader(ByteRange range, uint32_t fileId) {
      function RecordInfo (line 182) | RecordInfo validateRecordData(ByteRange range) {
      function RecordInfo (line 198) | RecordInfo validateRecord(ByteRange range, uint32_t fileId) {
      function RecordInfo (line 205) | RecordInfo findRecord(

FILE: folly/io/RecordIO.h
  function namespace (line 38) | namespace folly {

FILE: folly/io/ShutdownSocketSet.cpp
  type folly (line 28) | namespace folly {
    function cap_ (line 35) | static size_t cap_(std::false_type, Cap) {
    function cap_ (line 39) | static size_t cap_(std::true_type, Cap cap) {
    function cap (line 44) | static size_t cap(size_t capacity) {
    function pos_ (line 49) | static size_t pos_(std::false_type, Data) {
    function pos_ (line 53) | static size_t pos_(std::true_type, Data data) {
    function pos (line 56) | static size_t pos(NetworkSocket fd) {
    function NetworkSocket (line 63) | static NetworkSocket at_(std::false_type, Pos) {
    function NetworkSocket (line 67) | static NetworkSocket at_(std::true_type, Pos p) {
    function NetworkSocket (line 70) | static NetworkSocket at(size_t p) {
    type linger (line 198) | struct linger

FILE: folly/io/ShutdownSocketSet.h
  function namespace (line 26) | namespace folly {

FILE: folly/io/SocketOptionMap.cpp
  type folly (line 23) | namespace folly {
    function applySocketOptions (line 38) | int applySocketOptions(
    function SocketOptionMap (line 53) | SocketOptionMap validateSocketOptions(

FILE: folly/io/SocketOptionMap.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/SocketOptionValue.cpp
  type folly (line 21) | namespace folly {
    function toAppend (line 91) | void toAppend(const SocketOptionValue& val, std::string* result) {

FILE: folly/io/SocketOptionValue.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/TypedIOBuf.h
  function namespace (line 26) | namespace folly {

FILE: folly/io/async/AsyncBase.cpp
  type folly (line 31) | namespace folly {

FILE: folly/io/async/AsyncBase.h
  type class (line 55) | enum class
  function pread (line 67) | void pread(int fd, Range<unsigned char*> range, off_t start) {
  function virtual (line 71) | virtual void pread(
  function pwrite (line 80) | void pwrite(int fd, Range<const unsigned char*> range, off_t start) {
  function virtual (line 84) | virtual void pwrite(
  function setUserData (line 106) | void setUserData(void* userData) { userData_ = userData; }
  function setNotificationCallback (line 114) | void setNotificationCallback(NotificationCallback cb) { cb_ = std::move(...
  function NotificationCallback (line 123) | NotificationCallback getNotificationCallback() { return std::move(cb_); }
  type PollMode (line 161) | enum PollMode {
  function complete (line 249) | void complete(Op* op, ssize_t result) { op->complete(result); }
  function cancel (line 251) | void cancel(Op* op) { op->cancel(); }
  function WaitType (line 259) | enum class WaitType { COMPLETE, CANCEL };

FILE: folly/io/async/AsyncIO.cpp
  function toStream (line 63) | void toStream(std::ostream& os, const iocb& cb) {
  type folly (line 93) | namespace folly {

FILE: folly/io/async/AsyncIO.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/AsyncIoUringSocket.cpp
  type ShutdownFlags (line 34) | enum ShutdownFlags {
  function AsyncSocket (line 40) | AsyncSocket* getAsyncSocket(AsyncTransport::UniquePtr const& o) {
  function ensureSocketReturnCode (line 48) | int ensureSocketReturnCode(int x, char const* message) {
  function NetworkSocket (line 57) | NetworkSocket makeConnectSocket(SocketAddress const& peerAddress) {
  function IoUringBackend (line 74) | IoUringBackend* getBackendFromEventBase(EventBase* evb) {
  type sockaddr_storage (line 251) | struct sockaddr_storage
  type sockaddr (line 255) | struct sockaddr
  type io_uring_sqe (line 388) | struct io_uring_sqe
  type sockaddr (line 390) | struct sockaddr
  type pollfd (line 559) | struct pollfd
  type io_uring_sqe (line 771) | struct io_uring_sqe
  type io_uring_sqe (line 958) | struct io_uring_sqe
  type DetachFdState (line 978) | struct DetachFdState : AsyncReader::ReadCallback {
    method DetachFdState (line 979) | DetachFdState(
    method done (line 988) | void done() {
    method getReadBuffer (line 995) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
    method readErr (line 1003) | void readErr(const AsyncSocketException&) noexcept override { done(); }
    method readEOF (line 1004) | void readEOF() noexcept override { done(); }
    method readBufferAvailable (line 1005) | void readBufferAvailable(std::unique_ptr<IOBuf> buf) noexcept override {
    method readDataAvailable (line 1016) | void readDataAvailable(size_t len) noexcept override {
    method isBufferMovable (line 1020) | bool isBufferMovable() noexcept override { return true; }
  type CancelSqe (line 1023) | struct CancelSqe : IoSqeBase {
    method CancelSqe (line 1024) | explicit CancelSqe(IoSqeBase* sqe, folly::Function<void()> fn = {})
    method processSubmit (line 1026) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
    method callback (line 1029) | void callback(const io_uring_cqe*) noexcept override {
    method callbackCancelled (line 1036) | void callbackCancelled(const io_uring_cqe*) noexcept override {
  type DetachReadCallback (line 1155) | struct DetachReadCallback : AsyncReader::ReadCallback {
    method DetachReadCallback (line 1156) | explicit DetachReadCallback() { buf_ = folly::IOBuf::create(2048); }
    method getReadBuffer (line 1158) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
    method readDataAvailable (line 1163) | void readDataAvailable(size_t len) noexcept override {
    method readErr (line 1168) | void readErr(const AsyncSocketException&) noexcept override { done(); }
    method readEOF (line 1169) | void readEOF() noexcept override { done(); }
    method done (line 1170) | void done() noexcept {
  type io_uring_sqe (line 1318) | struct io_uring_sqe
  type NullWriteCallback (line 1575) | struct NullWriteCallback : AsyncWriter::WriteCallback {
    method writeSuccess (line 1576) | void writeSuccess() noexcept override {}
    method writeErr (line 1577) | void writeErr(size_t, const AsyncSocketException&) noexcept override {}
  class UnregisterFdSqe (line 1622) | class UnregisterFdSqe : public IoSqeBase {
    method UnregisterFdSqe (line 1624) | UnregisterFdSqe(IoUringBackend* b, IoUringFdRegistrationRecord* f)
    method processSubmit (line 1627) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
    method callback (line 1631) | void callback(const io_uring_cqe*) noexcept override {
    method callbackCancelled (line 1647) | void callbackCancelled(const io_uring_cqe* cqe) noexcept override {
  function NetworkSocket (line 1671) | NetworkSocket AsyncIoUringSocket::takeFd() {
  type io_uring_sqe (line 1698) | struct io_uring_sqe
  type linger (line 1715) | struct linger

FILE: folly/io/async/AsyncIoUringSocket.h
  function namespace (line 43) | namespace folly {
  function class (line 59) | class AsyncIoUringSocket : public AsyncSocketTransport {

FILE: folly/io/async/AsyncIoUringSocketFactory.cpp
  type folly (line 24) | namespace folly {
    function NetworkSocket (line 26) | NetworkSocket AsyncIoUringSocketFactory::createBoundSocketForZcRx(

FILE: folly/io/async/AsyncIoUringSocketFactory.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/AsyncPipe.cpp
  type folly (line 27) | namespace folly {
    function recv_internal (line 59) | static int recv_internal(NetworkSocket s, void* buf, size_t count) {
    function send_internal (line 243) | static int send_internal(NetworkSocket s, const void* buf, size_t coun...

FILE: folly/io/async/AsyncPipe.h
  function namespace (line 27) | namespace folly {
  function writev (line 153) | void writev(
  function closeOnEmpty_ (line 172) | bool closeOnEmpty_{false};

FILE: folly/io/async/AsyncSSLSocket.cpp
  function setup_SSL_CTX (line 64) | void setup_SSL_CTX(SSL_CTX* ctx) {
  function BIO_METHOD (line 84) | BIO_METHOD* getSSLBioMethod() {
  type folly (line 107) | namespace folly {
    class AsyncSSLSocketConnector (line 109) | class AsyncSSLSocketConnector
      method AsyncSSLSocketConnector (line 119) | AsyncSSLSocketConnector(
      method preConnect (line 130) | void preConnect(folly::NetworkSocket fd) override {
      method connectSuccess (line 137) | void connectSuccess() noexcept override {
      method connectErr (line 158) | void connectErr(const AsyncSocketException& ex) noexcept override {
      method handshakeSuc (line 164) | void handshakeSuc(AsyncSSLSocket* /* sock */) noexcept override {
      method handshakeErr (line 172) | void handshakeErr(
      method fail (line 180) | void fail(const AsyncSocketException& ex) {
    function AsyncSSLSocket (line 729) | AsyncSSLSocket* AsyncSSLSocket::getFromSSL(const SSL* ssl) {
    function SSL (line 951) | const SSL* AsyncSSLSocket::getSSL() const {
    function AsyncTransportCertificate (line 1045) | const AsyncTransportCertificate* AsyncSSLSocket::getPeerCertificate() ...
    function AsyncTransportCertificate (line 1062) | const AsyncTransportCertificate* AsyncSSLSocket::getSelfCertificate() ...
    type ::msghdr (line 1543) | struct ::msghdr
    type iovec (line 1884) | struct iovec

FILE: folly/io/async/AsyncSSLSocket.h
  function namespace (line 42) | namespace folly {
  function closeNow (line 391) | void closeNow() override;
  function enableByteEvents (line 426) | void enableByteEvents() override;
  function virtual (line 613) | virtual bool getSSLSessionReused() const;
  function getSSLVersion (line 653) | int getSSLVersion() const;
  function detachEventBase (line 672) | void detachEventBase() override {
  function isDetachable (line 678) | bool isDetachable() const override {
  function isServerNameMatch (line 729) | bool isServerNameMatch() const;
  function setMinWriteSize (line 830) | void setMinWriteSize(size_t minWriteSize) { minWriteSize_ = minWriteSize; }
  function forceCacheAddrOnFailure (line 844) | void forceCacheAddrOnFailure(bool force) { cacheAddrOnFailure_ = force; }
  function setSessionKey (line 848) | void setSessionKey(std::string sessionKey) {
  function setCertCacheHit (line 852) | void setCertCacheHit(bool hit) { certCacheHit_ = hit; }
  function setAsyncOperationFinishCallback (line 871) | void setAsyncOperationFinishCallback(std::unique_ptr<ReadCallback> cb) {
  function setZeroCopy (line 877) | bool setZeroCopy(bool enable) override {
  function handleRead (line 913) | void handleRead() noexcept override;
  type msghdr (line 928) | struct ::msghdr
  function virtual (line 945) | virtual int sslWriteImpl(SSL* ssl, const void* buf, int n) {
  function virtual (line 950) | virtual int sslGetErrorImpl(const SSL* s, int ret_code) {
  function WriteFlags (line 1008) | WriteFlags currWriteFlags_{}
  function sessionIDResumed_ (line 1048) | bool sessionIDResumed_{false};

FILE: folly/io/async/AsyncServerSocket.cpp
  type folly (line 40) | namespace folly {
    function AtomicNotificationQueueTaskStatus (line 83) | AtomicNotificationQueueTaskStatus AsyncServerSocket::NewConnMessage::o...
    function AtomicNotificationQueueTaskStatus (line 107) | AtomicNotificationQueueTaskStatus AsyncServerSocket::ErrorMessage::ope...
    class AsyncServerSocket::BackoffTimeout (line 117) | class AsyncServerSocket::BackoffTimeout : public AsyncTimeout {
      method BackoffTimeout (line 120) | BackoffTimeout(BackoffTimeout&&) = delete;
      method BackoffTimeout (line 121) | explicit BackoffTimeout(AsyncServerSocket* socket)
      method timeoutExpired (line 124) | void timeoutExpired() noexcept override { socket_->backoffTimeoutExp...
    type addrinfo (line 458) | struct addrinfo
    type addrinfo (line 480) | struct addrinfo
    type addrinfo (line 536) | struct addrinfo
    type addrinfo (line 553) | struct addrinfo
    function NetworkSocket (line 827) | NetworkSocket AsyncServerSocket::createSocket(int family) {
    type sockaddr_un (line 1032) | struct sockaddr_un

FILE: folly/io/async/AsyncServerSocket.h
  function namespace (line 58) | namespace folly {
  function setCallbackAssignFunction (line 373) | void setCallbackAssignFunction(CallbackAssignFunction func) {
  function setMaxAcceptAtOnce (line 616) | void setMaxAcceptAtOnce(uint32_t numConns) { maxAcceptAtOnce_ = numConns; }
  function setQueueTimeout (line 637) | void setQueueTimeout(
  function setQueueTimeout (line 641) | void setQueueTimeout(std::chrono::nanoseconds duration) {
  function setMaxNumMessagesInQueue (line 656) | void setMaxNumMessagesInQueue(uint32_t num) { maxNumMsgsInQueue_ = num; }
  function setAcceptRateAdjustSpeed (line 666) | void setAcceptRateAdjustSpeed(double speed) {
  function getTosReflect (line 677) | bool getTosReflect() { return tosReflect_; }
  function setKeepAliveEnabled (line 726) | void setKeepAliveEnabled(bool enabled) {
  function setReusePortEnabled (line 753) | void setReusePortEnabled(bool enabled) {
  function setCloseOnExec (line 804) | void setCloseOnExec(bool closeOnExec) { closeOnExec_ = closeOnExec; }
  function setTFOEnabled (line 814) | void setTFOEnabled(bool enabled, uint32_t maxTFOQueueSize) {
  function disableTransparentTls (line 822) | void disableTransparentTls() { noTransparentTls_ = true; }
  function setConnectionEventCallback (line 832) | void setConnectionEventCallback(
  function ConnectionEventCallback (line 840) | ConnectionEventCallback* getConnectionEventCallback() const {
  type NewConnMessage (line 861) | struct NewConnMessage {
  type ErrorMessage (line 876) | struct ErrorMessage {
  function class (line 895) | class RemoteAcceptor {
  function explicit (line 903) | explicit Consumer(RemoteAcceptor& acceptor) : acceptor_(acceptor) {}
  type CallbackInfo (line 935) | struct CallbackInfo {
  function CallbackInfo (line 963) | CallbackInfo* nextCallback(NetworkSocket socket = NetworkSocket()) {
  function EventHandler (line 984) | struct ServerEventHandler : public EventHandler {
  function tfoMaxQueueSize_ (line 1052) | uint32_t tfoMaxQueueSize_{0}
  function listenerTos_ (line 1056) | uint32_t listenerTos_{0}
  function zeroCopyVal_ (line 1057) | bool zeroCopyVal_{false};

FILE: folly/io/async/AsyncSignalHandler.cpp
  type folly (line 26) | namespace folly {

FILE: folly/io/async/AsyncSignalHandler.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/async/AsyncSocket.cpp
  class ZeroCopyMMapMemStoreFallback (line 53) | class ZeroCopyMMapMemStoreFallback : public ZeroCopyMemStore {
    method ZeroCopyMMapMemStoreFallback (line 55) | ZeroCopyMMapMemStoreFallback(size_t /*entries*/, size_t /*size*/) {}
    method get (line 57) | ZeroCopyMemStore::EntryPtr get() override { return nullptr; }
    method put (line 59) | void put(ZeroCopyMemStore::Entry* /*entry*/) override {}
  function getRXZeroCopyIOBuf (line 63) | std::unique_ptr<folly::IOBuf> getRXZeroCopyIOBuf(
  class ZeroCopyMMapMemStoreReal (line 76) | class ZeroCopyMMapMemStoreReal : public ZeroCopyMemStore {
    method ZeroCopyMMapMemStoreReal (line 78) | ZeroCopyMMapMemStoreReal(size_t entries, size_t size) {
    method get (line 108) | ZeroCopyMemStore::EntryPtr get() override {
    method put (line 124) | void put(ZeroCopyMemStore::Entry* entry) override {
  function checkIoUringBackend (line 153) | bool checkIoUringBackend(folly::EventBase* evb) {
  function checkIoUringBackend (line 158) | bool checkIoUringBackend(folly::EventBase*) {
  type folly (line 175) | namespace folly {
    function AsyncSocketException (line 189) | static AsyncSocketException const& getSocketClosedLocallyEx() {
    function AsyncSocketException (line 195) | static AsyncSocketException const& getSocketShutdownForWritesEx() {
    function sock_extended_err (line 203) | const sock_extended_err* FOLLY_NULLABLE
    function sock_extended_err (line 215) | const sock_extended_err* FOLLY_NULLABLE
    function scm_timestamping (line 226) | const scm_timestamping* FOLLY_NULLABLE
    class AsyncSocket::BytesWriteRequest (line 252) | class AsyncSocket::BytesWriteRequest : public AsyncSocket::WriteRequest {
      method BytesWriteRequest (line 254) | static BytesWriteRequest* newRequest(
      method destroy (line 290) | void destroy() override {
      method WriteResult (line 296) | WriteResult performWrite() override {
      method isComplete (line 331) | bool isComplete() override { return opsWritten_ == getOpCount(); }
      method consume (line 333) | void consume() override {
      method BytesWriteRequest (line 369) | BytesWriteRequest(
      type iovec (line 393) | struct iovec
      method getOpCount (line 398) | uint32_t getOpCount() const {
      type iovec (line 415) | struct iovec
    type cmsghdr (line 478) | struct cmsghdr
    function disableTransparentFunctions (line 654) | void disableTransparentFunctions(
    function NetworkSocket (line 833) | NetworkSocket AsyncSocket::detachNetworkSocket() {
    type sockaddr_storage (line 930) | struct sockaddr_storage
    type sockaddr (line 934) | struct sockaddr
    function catch (line 1104) | catch (const AsyncSocketException& ex) {
    function catch (line 1106) | catch (const std::exception& ex) {
    type sockaddr (line 1139) | struct sockaddr
    type linger (line 1558) | struct linger
    type sock_extended_err (line 1607) | struct sock_extended_err
    type sock_extended_err (line 1619) | struct sock_extended_err
    type linger (line 2257) | struct linger
    type ::msghdr (line 2847) | struct ::msghdr
    type iovec (line 2985) | struct iovec
    type msghdr (line 2989) | struct msghdr
    type msghdr (line 3019) | struct msghdr
    type cmsghdr (line 3054) | struct cmsghdr
    type ::msghdr (line 3417) | struct ::msghdr
    type ::iovec (line 3421) | struct ::iovec
    type msghdr (line 3853) | struct msghdr
    type msghdr (line 3917) | struct msghdr
    type iovec (line 3920) | struct iovec
    type msghdr (line 4027) | struct msghdr

FILE: folly/io/async/AsyncSocket.h
  function namespace (line 50) | namespace folly {
  function destroy (line 599) | void destroy() override;
  function cancelConnect (line 663) | void cancelConnect() override;
  function setMaxReadsPerEvent (line 700) | void setMaxReadsPerEvent(uint16_t maxReads) { maxReadsPerEvent_ = maxRea...
  function virtual (line 767) | virtual void setOverrideNetOpsDispatcher(
  function virtual (line 790) | virtual void setOverrideTcpInfoDispatcher(
  type ZeroCopyDrainConfig (line 851) | struct ZeroCopyDrainConfig {
  function writeRequestReady (line 875) | void writeRequestReady() { handleWrite(); }
  function close (line 878) | void close() override;
  function setEorTracking (line 899) | void setEorTracking(bool track) override { trackEor_ = track; }
  function getRawBytesReceived (line 921) | size_t getRawBytesReceived() const override { return getAppBytesReceived...
  function getRawBytesBuffered (line 926) | size_t getRawBytesBuffered() const override { return getAppBytesBuffered...
  function getTFOSucceeded (line 993) | bool getTFOSucceeded() const override;
  function setSockOpt (line 1103) | int setSockOpt(
  function virtual (line 1119) | virtual int getSockOptVirtual(
  function virtual (line 1135) | virtual int setSockOptVirtual(
  function setPreReceivedData (line 1144) | void setPreReceivedData(std::unique_ptr<IOBuf> data) override {
  function enableTFO (line 1160) | void enableTFO() override {
  function setBindAddressNoPort (line 1176) | void setBindAddressNoPort(bool flag) { bindAddressNoPort_ = flag; }
  function disableTransparentTls (line 1178) | void disableTransparentTls() override { noTransparentTls_ = true; }
  function disableTSocks (line 1180) | void disableTSocks() { noTSocks_ = true; }
  function StateEnum (line 1182) | enum class StateEnum : uint8_t {
  function exception (line 1256) | struct ReadResult {
  function class (line 1270) | class WriteCallbackWithState {
  function virtual (line 1479) | [[nodiscard]] virtual std::vector<LegacyLifecycleObserver*>
  function virtual (line 1520) | virtual bool removeObserver(Observer* observer) {
  function virtual (line 1533) | virtual bool removeObserver(std::shared_ptr<Observer> observer) {
  function virtual (line 1545) | [[nodiscard]] virtual size_t numObservers() {
  type ReadResultEnum (line 1590) | enum ReadResultEnum {
  type WriteResultEnum (line 1598) | enum WriteResultEnum {
  type ShutdownFlags (line 1613) | enum ShutdownFlags {
  function class (line 1636) | class WriteTimeout : public AsyncTimeout {
  function class (line 1647) | class IoHandler : public EventHandler {
  function class (line 1664) | class ImmediateReadCB : public folly::EventBase::LoopCallback {
  function scheduleImmediateRead (line 1680) | void scheduleImmediateRead() noexcept {
  function scheduleInitialReadWrite (line 1689) | void scheduleInitialReadWrite() noexcept {
  function drainErrorQueue (line 1700) | void drainErrorQueue() noexcept;
  type IOBufInfo (line 1963) | struct IOBufInfo {
  function shutdownFlags_ (line 1973) | uint8_t shutdownFlags_{0}
  function appBytesWritten_ (line 2000) | size_t appBytesWritten_{0}
  function rawBytesWritten_ (line 2001) | size_t rawBytesWritten_{0}
  function allocatedBytesBuffered_ (line 2006) | size_t allocatedBytesBuffered_{0}
  type TCPFastOpenInfo (line 2045) | struct TCPFastOpenInfo {
  function finished (line 2048) | bool finished{false};
  function zeroCopyReenableThreshold_ (line 2065) | size_t zeroCopyReenableThreshold_{0}
  function zeroCopyReenableCounter_ (line 2066) | size_t zeroCopyReenableCounter_{0}
  function zerocopyReadErr_ (line 2070) | int zerocopyReadErr_{0}
  function useIoUring_ (line 2074) | bool useIoUring_{false};
  function WriteRequestTag (line 2105) | struct std::hash<folly::AsyncSocket::WriteRequestTag> {

FILE: folly/io/async/AsyncSocketBase.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/AsyncSocketException.cpp
  type folly (line 22) | namespace folly {
    function StringPiece (line 24) | StringPiece AsyncSocketException::getExceptionTypeString(

FILE: folly/io/async/AsyncSocketException.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/AsyncSocketTransport.cpp
  type folly (line 19) | namespace folly {
    function SocketAddress (line 21) | const SocketAddress& AsyncSocketTransport::anyAddress() {

FILE: folly/io/async/AsyncSocketTransport.h
  function class (line 40) | class ConnectCallback {
  function setPeerCertificate (line 96) | void setPeerCertificate(
  function AsyncTransportCertificate (line 101) | const AsyncTransportCertificate* getPeerCertificate() const override {
  function dropPeerCertificate (line 105) | void dropPeerCertificate() noexcept override { peerCertData_.reset(); }
  function setSelfCertificate (line 107) | void setSelfCertificate(
  function dropSelfCertificate (line 112) | void dropSelfCertificate() noexcept override { selfCertData_.reset(); }
  function AsyncTransportCertificate (line 114) | const AsyncTransportCertificate* getSelfCertificate() const override {
  function getNapiId (line 118) | int getNapiId() const override;
  function mutable (line 129) | mutable std::unique_ptr<const AsyncTransportCertificate> peerCertData_{

FILE: folly/io/async/AsyncTimeout.cpp
  type folly (line 27) | namespace folly {

FILE: folly/io/async/AsyncTimeout.h
  function namespace (line 27) | namespace folly {

FILE: folly/io/async/AsyncTransport.h
  function namespace (line 34) | namespace folly {
  function class (line 286) | class AsyncWriter {
  function virtual (line 394) | [[nodiscard]] virtual bool setRXZeroCopy(RXZerocopyParams /*params*/) {
  function virtual (line 403) | virtual void setZeroCopyEnableFunc(ZeroCopyEnableFunc /*func*/) {}
  function virtual (line 405) | virtual void setZeroCopyEnableThreshold(size_t /*threshold*/) {}
  function virtual (line 482) | virtual void closeWithReset() { closeNow(); }
  function SocketAddress (line 634) | SocketAddress getLocalAddress() const {
  function SocketAddress (line 663) | SocketAddress getPeerAddress() const {
  function virtual (line 684) | virtual void dropPeerCertificate() noexcept {}
  function virtual (line 694) | virtual void dropSelfCertificate() noexcept {}
  function virtual (line 699) | virtual const AsyncTransportCertificate* getSelfCertificate() const {
  function virtual (line 722) | virtual std::unique_ptr<IOBuf> getExportedKeyingMaterial(
  function virtual (line 732) | virtual bool isEorTrackingEnabled() const = 0;
  function class (line 752) | class BufferCallback {
  function class (line 774) | class ReplaySafetyCallback {
  function virtual (line 795) | virtual void setReplaySafetyCallback(ReplaySafetyCallback* callback) {
  function virtual (line 843) | virtual AsyncTransport::UniquePtr tryExchangeWrappedTransport(
  function AsyncTransport (line 913) | AsyncTransport* decoratingTransport_{nullptr};

FILE: folly/io/async/AsyncTransportCertificate.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/AsyncUDPServerSocket.h
  function namespace (line 24) | namespace folly {
  function setReusePort (line 141) | void setReusePort(bool reusePort) { reusePort_ = reusePort; }
  function setReuseAddr (line 143) | void setReuseAddr(bool reuseAddr) { reuseAddr_ = reuseAddr; }
  function setRecvTos (line 145) | void setRecvTos(bool recvTos) { recvTos_ = recvTos; }
  function setTosOrTrafficClass (line 147) | void setTosOrTrafficClass(uint8_t tosOrTclass) {
  function getAddress (line 157) | void getAddress(SocketAddress* a) const override { *a = address(); }
  function addListener (line 162) | void addListener(EventBase* evb, Callback* callback) {
  function listen (line 166) | void listen() {
  function close (line 187) | void close() {
  function EventBase (line 193) | EventBase* getEventBase() const override { return evb_; }
  function pauseAccepting (line 203) | void pauseAccepting() {
  function pauseAcceptingNewPeer (line 218) | void pauseAcceptingNewPeer() {
  function resumeAccepting (line 231) | void resumeAccepting() {
  function resumeAcceptingNewPeer (line 246) | void resumeAcceptingNewPeer() {
  function setTimestamping (line 256) | bool setTimestamping(int val) { return socket_->setTimestamping(val); }
  function onDataAvailable (line 264) | void onDataAvailable(
  function onReadError (line 318) | void onReadError(const AsyncSocketException& ex) noexcept override {
  function onReadClosed (line 325) | void onReadClosed() noexcept override {
  function reusePort_ (line 352) | bool reusePort_{false};

FILE: folly/io/async/AsyncUDPSocket.cpp
  type folly (line 60) | namespace folly {
    type msghdr (line 64) | struct msghdr
    type cmsghdr (line 66) | struct cmsghdr
    type timespec (line 81) | struct timespec
    type msghdr (line 570) | struct msghdr
    type iovec (line 582) | struct iovec
    type cmsghdr (line 594) | struct cmsghdr
    type timespec (line 618) | struct timespec
    type iovec (line 663) | struct iovec
    type timespec (line 779) | struct timespec
    type iovec (line 798) | struct iovec
    type iovec (line 927) | struct iovec
    type mmsghdr (line 946) | struct mmsghdr
    type iovec (line 947) | struct iovec
    type cmsghdr (line 976) | struct cmsghdr
    type mmsghdr (line 1052) | struct mmsghdr
    type iovec (line 1089) | struct iovec
    type mmsghdr (line 1091) | struct mmsghdr
    type msghdr (line 1109) | struct msghdr
    type mmsghdr (line 1114) | struct mmsghdr
    type timespec (line 1117) | struct timespec
    type sock_extended_err (line 1189) | struct sock_extended_err
    type sock_extended_err (line 1200) | struct sock_extended_err
    type msghdr (line 1224) | struct msghdr
    type cmsghdr (line 1257) | struct cmsghdr
    type sockaddr_storage (line 1318) | struct sockaddr_storage
    type msghdr (line 1333) | struct msghdr
    type iovec (line 1334) | struct iovec

FILE: folly/io/async/AsyncUDPSocket.h
  type class (line 42) | enum class
  function class (line 47) | class ReadCallback {
  function class (line 117) | class ErrMessageCallback {
  type msghdr (line 142) | struct msghdr
  function BindOptions (line 148) | struct WriteOptions {
  function virtual (line 386) | virtual void setFreeBind(bool freeBind) { freeBind_ = freeBind; }
  function virtual (line 391) | virtual void setTransparent(bool transparent) { transparent_ = transpare...
  function virtual (line 397) | virtual void setRecvTos(bool recvTos) { recvTos_ = recvTos; }
  function virtual (line 404) | virtual bool getRecvTos() { return recvTos_; }
  function virtual (line 409) | virtual void setReusePort(bool reusePort) { reusePort_ = reusePort; }
  function virtual (line 414) | virtual void setReuseAddr(bool reuseAddr) { reuseAddr_ = reuseAddr; }
  function virtual (line 419) | virtual void setRcvBuf(int rcvBuf) { rcvBuf_ = rcvBuf; }
  function virtual (line 424) | virtual void setSndBuf(int sndBuf) { sndBuf_ = sndBuf; }
  function virtual (line 430) | virtual void setBusyPoll(int busyPollUs) { busyPollUs_ = busyPollUs; }
  function EventBase (line 432) | EventBase* getEventBase() const { return eventBase_; }
  function setMaxReadsPerEvent (line 473) | void setMaxReadsPerEvent(uint16_t maxReads) { maxReadsPerEvent_ = maxRea...
  function setIOBufFreeFunc (line 495) | void setIOBufFreeFunc(IOBufFreeFunc&& ioBufFreeFunc) {
  function virtual (line 533) | virtual void setOverrideNetOpsDispatcher(
  type full_sockaddr_storage (line 556) | struct full_sockaddr_storage {
  function virtual (line 561) | virtual ssize_t sendmsg(
  function virtual (line 566) | virtual int sendmmsg(
  type iovec (line 576) | struct iovec
  type mmsghdr (line 585) | struct mmsghdr
  type iovec (line 586) | struct iovec
  function rcvBuf_ (line 647) | int rcvBuf_{0}
  function sndBuf_ (line 648) | int sndBuf_{0}
  function busyPollUs_ (line 649) | int busyPollUs_{0}
  function zeroCopyVal_ (line 669) | bool zeroCopyVal_{false};

FILE: folly/io/async/AtomicNotificationQueue-inl.h
  function namespace (line 22) | namespace folly {
  function Node (line 80) | Node* head{nullptr};
  function namespace (line 250) | namespace detail {

FILE: folly/io/async/AtomicNotificationQueue.h
  function getMaxReadAtOnce (line 43) | uint32_t getMaxReadAtOnce() const;
  function class (line 194) | class AtomicQueue {
  function maxReadAtOnce_ (line 260) | uint32_t maxReadAtOnce_{10};
  function AtomicNotificationQueueTaskStatus (line 268) | enum class AtomicNotificationQueueTaskStatus : uint8_t {

FILE: folly/io/async/CertificateIdentityVerifier.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/async/DecoratedAsyncTransportWrapper.h
  function namespace (line 21) | namespace folly {
  function attachEventBase (line 79) | void attachEventBase(folly::EventBase* eventBase) override {
  function close (line 83) | void close() override { transport_->close(); }
  function closeNow (line 85) | void closeNow() override { transport_->closeNow(); }
  function closeWithReset (line 87) | void closeWithReset() override {
  function detachEventBase (line 97) | void detachEventBase() override { transport_->detachEventBase(); }
  function getLocalAddress (line 109) | void getLocalAddress(folly::SocketAddress* address) const override {
  function getPeerAddress (line 113) | void getPeerAddress(folly::SocketAddress* address) const override {
  function setEorTracking (line 141) | void setEorTracking(bool track) override {
  function setSendTimeout (line 145) | void setSendTimeout(uint32_t timeoutInMs) override {
  function shutdownWrite (line 149) | void shutdownWrite() override { transport_->shutdownWrite(); }
  function shutdownWriteNow (line 151) | void shutdownWriteNow() override { transport_->shutdownWriteNow(); }
  function override (line 164) | const override {
  function setReplaySafetyCallback (line 171) | void setReplaySafetyCallback(
  function AsyncTransportCertificate (line 176) | const AsyncTransportCertificate* getPeerCertificate() const override {
  function dropPeerCertificate (line 180) | void dropPeerCertificate() noexcept override {
  function AsyncTransportCertificate (line 184) | const AsyncTransportCertificate* getSelfCertificate() const override {
  function dropSelfCertificate (line 188) | void dropSelfCertificate() noexcept override {
  function setZeroCopy (line 192) | bool setZeroCopy(bool enable) override {
  function setZeroCopyEnableFunc (line 198) | void setZeroCopyEnableFunc(ZeroCopyEnableFunc func) override {
  function setZeroCopyEnableThreshold (line 202) | void setZeroCopyEnableThreshold(size_t threshold) override {
  function destroy (line 217) | void destroy() override {

FILE: folly/io/async/DelayedDestruction.cpp
  type folly (line 19) | namespace folly {

FILE: folly/io/async/DelayedDestruction.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/DelayedDestructionBase.h
  function namespace (line 30) | namespace folly {
  function explicit (line 141) | explicit IntrusivePtr(AliasType* dd) : DestructorGuard(dd) {}
  function AliasType (line 173) | AliasType* get() const {

FILE: folly/io/async/DestructorCheck.h
  function namespace (line 19) | namespace folly {

FILE: folly/io/async/EpollBackend.cpp
  type folly (line 36) | namespace folly {
    type EventInfo (line 39) | struct EventInfo {
      method freeFunction (line 40) | static void freeFunction(void* v) { delete static_cast<EventInfo*>(v...
      method resetEvent (line 42) | void resetEvent() {
      type event (line 48) | struct event
    type SignalRegistry (line 54) | struct SignalRegistry {
      type SigInfo (line 55) | struct SigInfo {
        type sigaction (line 56) | struct sigaction
      method SignalRegistry (line 61) | SignalRegistry() {}
    function SignalRegistry (line 74) | SignalRegistry& getSignalRegistry() {
      type SigInfo (line 55) | struct SigInfo {
        type sigaction (line 56) | struct sigaction
      method SignalRegistry (line 61) | SignalRegistry() {}
    function evSigHandler (line 79) | void evSigHandler(int sig) {
    type sigaction (line 106) | struct sigaction
    function getPollFlags (line 127) | uint32_t getPollFlags(short events) {
    type EpollBackend::TimerInfo (line 142) | struct EpollBackend::TimerInfo : public IntrusiveHeapNode<> {
      method freeFunction (line 148) | static void freeFunction(void* v) { delete static_cast<TimerInfo*>(v...
      type event (line 153) | struct event
    type epoll_event (line 190) | struct epoll_event
    type epoll_event (line 200) | struct epoll_event
    type event (line 307) | struct event
    type timeval (line 357) | struct timeval
    type epoll_event (line 388) | struct epoll_event
    type epoll_event (line 455) | struct epoll_event
    type timeval (line 463) | struct timeval
    type itimerspec (line 506) | struct itimerspec
    type itimerspec (line 515) | struct itimerspec

FILE: folly/io/async/EpollBackend.h
  type Options (line 36) | struct Options {
  function event_base (line 52) | event_base* getEventBase() override { return nullptr; }
  function eb_event_base_loopbreak (line 57) | int eb_event_base_loopbreak() override;
  type TimerInfo (line 67) | struct TimerInfo
  function class (line 69) | class SocketPair {
  type timeval (line 87) | struct timeval
  function numInsertedEvents_ (line 100) | size_t numInsertedEvents_{0}
  function numInternalEvents_ (line 101) | size_t numInternalEvents_{0}
  function loopBreak_ (line 103) | bool loopBreak_{false};

FILE: folly/io/async/EventBase.cpp
  type event_base (line 49) | struct event_base {
  type epollop (line 54) | struct epollop {
  class EventBaseBackend (line 65) | class EventBaseBackend : public folly::EventBaseBackendBase {
    method event_base (line 71) | event_base* getEventBase() override { return evb_; }
    type timeval (line 76) | struct timeval
  type timeval (line 107) | struct timeval
  class TestEventBaseBackend (line 158) | class TestEventBaseBackend : public EventBaseBackend {
    method TestEventBaseBackend (line 160) | explicit TestEventBaseBackend(int napiId) : napiId_(napiId) {}
    method getNapiId (line 162) | int getNapiId() const override { return napiId_; }
  type folly (line 170) | namespace folly {
    class EventBase::LoopCallbacksDeadline (line 172) | class EventBase::LoopCallbacksDeadline {
      method reset (line 174) | void reset(EventBase& evb) {
      method expired (line 184) | bool expired() const {
    class EventBase::FuncRunner (line 194) | class EventBase::FuncRunner {
      method FuncRunner (line 196) | explicit FuncRunner(EventBase& eventBase)
      method AtomicNotificationQueueTaskStatus (line 199) | AtomicNotificationQueueTaskStatus operator()(Func&& func) noexcept {
    class EventBase::ThreadIdCollector (line 223) | class EventBase::ThreadIdCollector : public WorkerProvider {
      method ThreadIdCollector (line 225) | explicit ThreadIdCollector(EventBase& parent) : parent_(parent) {}
      method IdsWithKeepAlive (line 227) | IdsWithKeepAlive collectThreadIds() override {
      method awaitOutstandingKeepAlives (line 237) | void awaitOutstandingKeepAlives() {
      class Guard (line 244) | class Guard : public KeepAlive {
        method Guard (line 246) | Guard(ThreadIdCollector& parent) : parent_(parent) {}
    function getTimeDelta (line 481) | static std::chrono::milliseconds getTimeDelta(
  type timeval (line 1132) | struct timeval
  function event_base (line 1181) | event_base* EventBase::getLibeventBase() const {
  type op (line 1190) | struct op {
  type base (line 1193) | struct base {
  function VirtualEventBase (line 1200) | VirtualEventBase& EventBase::getVirtualEventBase() {
  function VirtualEventBase (line 1208) | VirtualEventBase* EventBase::tryGetVirtualEventBase() {
  function EventBase (line 1215) | EventBase* EventBase::getEventBase() {
  function WorkerProvider (line 1219) | WorkerProvider* EventBase::getThreadIdCollector() {

FILE: folly/io/async/EventBase.h
  function namespace (line 68) | namespace detail {
  function class (line 75) | class EventBaseObserver {
  function explicit (line 110) | explicit RequestEventBase(EventBase* eb) : eb_(eb) {}
  function class (line 158) | class LoopCallback
  function class (line 182) | class FunctionLoopCallback : public LoopCallback {
  function class (line 200) | class StackFunctionLoopCallback : public LoopCallback {
  function class (line 258) | class FunctionOnDestructionCallback : public OnDestructionCallback {
  type Options (line 275) | struct Options {
  function EventBase (line 345) | EventBase(true) {}
  type LoopPollOptions (line 414) | struct LoopPollOptions {
  function LoopStatus (line 471) | enum class LoopStatus { kDone, kError, kSuspended };
  function getAvgLoopTime (line 736) | double getAvgLoopTime() const {
  function getNotificationQueueSize (line 756) | size_t getNotificationQueueSize() const;
  function EventBaseBackendBase (line 818) | EventBaseBackendBase* getBackend() { return evb_.get(); }
  function class (line 838) | class SmoothLoopTime {

FILE: folly/io/async/EventBaseAtomicNotificationQueue-inl.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/EventBaseAtomicNotificationQueue.h
  function EventBaseAtomicNotificationQueue (line 53) | EventBaseAtomicNotificationQueue(Consumer()) {}
  function successfulArmCount_ (line 189) | ssize_t successfulArmCount_{0}
  function consumerDisarmedCount_ (line 190) | ssize_t consumerDisarmedCount_{0}
  function writesObserved_ (line 191) | ssize_t writesObserved_{0}
  function writesLocal_ (line 192) | ssize_t writesLocal_{0}
  function armed_ (line 193) | bool armed_{false};

FILE: folly/io/async/EventBaseBackendBase.cpp
  type folly (line 21) | namespace folly {
    type timeval (line 36) | struct timeval
    function EventBaseBackendBase (line 64) | EventBaseBackendBase* EventBaseEvent::getBackend() const {

FILE: folly/io/async/EventBaseBackendBase.h
  type event (line 46) | struct event
  type event (line 48) | struct event
  function isEventRegistered (line 50) | bool isEventRegistered() const {
  function setUserData (line 63) | void setUserData(void* userData) { userData_ = userData; }
  function setUserData (line 65) | void setUserData(void* userData, FreeFunction freeFn) {
  function eb_event_set (line 70) | void eb_event_set(
  function eb_signal_set (line 78) | void eb_signal_set(
  function eb_timer_set (line 83) | void eb_timer_set(void (*callback)(libevent_fd_t, short, void*), void* a...
  function EventBase (line 88) | EventBase* eb_ev_base() const { return evb_; }
  type timeval (line 92) | struct timeval
  type event (line 101) | struct event
  function FreeFunction (line 107) | FreeFunction freeFn_{nullptr};
  type PollLoopHook (line 128) | struct PollLoopHook {
  function virtual (line 143) | virtual void queueRecvZc(
  function setPollLoopHook (line 149) | void setPollLoopHook(PollLoopHook pollLoopHook) {

FILE: folly/io/async/EventBaseLocal.cpp
  type folly (line 24) | namespace folly {
    type detail (line 25) | namespace detail {

FILE: folly/io/async/EventBaseLocal.h
  function namespace (line 32) | namespace folly {

FILE: folly/io/async/EventBaseManager.cpp
  type folly (line 19) | namespace folly {
    function EventBaseManager (line 23) | EventBaseManager* EventBaseManager::get() {
    function EventBase (line 66) | EventBase* EventBaseManager::getEventBase() const {

FILE: folly/io/async/EventBaseManager.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/EventBasePoller.cpp
  type folly::detail (line 77) | namespace folly::detail {
    class Queue (line 82) | class Queue {
      method insert (line 84) | bool insert(T* t) {
      method T (line 96) | T* arm() {
      method T (line 118) | static T* kQueueArmedTag() { return reinterpret_cast<T*>(1); }
    class EventBasePollerImpl (line 125) | class EventBasePollerImpl : public EventBasePoller {
      class FdGroupImpl (line 126) | class FdGroupImpl
      method EventBasePollerImpl (line 129) | explicit EventBasePollerImpl(bool rearmInline)
      method startLoop (line 145) | void startLoop() {
      method stopLoop (line 153) | void stopLoop() {
      type Event (line 159) | struct Event final : public Handle {
        type NotificationFd (line 160) | struct NotificationFd {}
        method Event (line 162) | Event(FdGroupImpl& group_, int fd_, void* userData)
        method Event (line 165) | Event(NotificationFd, int fd_) : Handle(nullptr), group(nullptr), ...
        method isNotificationFd (line 172) | bool isNotificationFd() const { return group == nullptr; }
        method FOLLY_ALWAYS_INLINE (line 177) | FOLLY_ALWAYS_INLINE void markReady() {
        method FOLLY_ALWAYS_INLINE (line 182) | FOLLY_ALWAYS_INLINE void markProcessed() {
    class EventBasePollerImpl::FdGroupImpl (line 235) | class EventBasePollerImpl::FdGroupImpl final : public FdGroup {
      method FdGroupImpl (line 237) | FdGroupImpl(EventBasePollerImpl& parent_, ReadyCallback readyCallback_)
      method add (line 248) | std::unique_ptr<Handle> add(int fd, void* userData) override {
      method reclaim (line 257) | void reclaim(std::unique_ptr<Handle> handle) override {
    class EventBasePollerEpoll (line 384) | class EventBasePollerEpoll final : public EventBasePollerImpl {
      method EventBasePollerEpoll (line 386) | EventBasePollerEpoll()
      method setup (line 393) | void setup() override {
      method teardown (line 398) | void teardown() override { fileops::close(epFd_); }
      method addEvent (line 400) | void addEvent(Event* event) override {
      method delEvent (line 427) | void delEvent(Event* event) override {
      method waitForEvents (line 437) | bool waitForEvents(std::chrono::steady_clock::time_point loopStart) ...
      type epoll_event (line 468) | struct epoll_event
    function enableFlagsIfSupported (line 475) | void enableFlagsIfSupported(
    class EventBasePollerIoUring (line 498) | class EventBasePollerIoUring final : public EventBasePollerImpl {
      method EventBasePollerIoUring (line 500) | EventBasePollerIoUring()
      method setup (line 508) | void setup() override {
      method teardown (line 522) | void teardown() override { ::io_uring_queue_exit(&ring_); }
      method addEvent (line 524) | void addEvent(Event* event) override {
      method delEvent (line 544) | void delEvent(Event* /* event */) override {
      method waitForEvents (line 548) | bool waitForEvents(std::chrono::steady_clock::time_point loopStart) ...
      method submitPendingSqes (line 603) | void submitPendingSqes() {
      type io_uring (line 609) | struct io_uring
    function EventBasePoller (line 642) | EventBasePoller& EventBasePoller::get() {

FILE: folly/io/async/EventBasePoller.h
  function namespace (line 26) | namespace folly::detail {

FILE: folly/io/async/EventBaseThread.cpp
  type folly (line 21) | namespace folly {
    function EventBase (line 49) | EventBase* EventBaseThread::getEventBase() const {

FILE: folly/io/async/EventBaseThread.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/async/EventHandler.cpp
  type folly (line 24) | namespace folly {

FILE: folly/io/async/EventHandler.h
  function namespace (line 28) | namespace folly {

FILE: folly/io/async/EventUtil.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/HHWheelTimer-fwd.h
  function namespace (line 20) | namespace folly {

FILE: folly/io/async/HHWheelTimer.cpp
  type folly (line 26) | namespace folly {
    class HHWheelTimerBase<std::chrono::milliseconds> (line 395) | class HHWheelTimerBase<std::chrono::milliseconds>
    class HHWheelTimerBase<std::chrono::microseconds> (line 398) | class HHWheelTimerBase<std::chrono::microseconds>

FILE: folly/io/async/HHWheelTimer.h
  function namespace (line 34) | namespace folly {

FILE: folly/io/async/IoUring.cpp
  function roundUpToNextPowerOfTwo (line 35) | uint32_t roundUpToNextPowerOfTwo(uint32_t num) {
  function toStream (line 72) | void toStream(std::ostream& os, const struct io_uring_sqe& sqe) {
  type folly (line 111) | namespace folly {
    type iovec (line 241) | struct iovec
    type io_uring_cqe (line 339) | struct io_uring_cqe

FILE: folly/io/async/IoUring.h
  function namespace (line 27) | namespace folly {
  type io_uring_cqe (line 98) | struct io_uring_cqe
  function setCqe (line 101) | void setCqe(const struct io_uring_cqe* cqe) {
  type io_uring_sqe (line 113) | struct io_uring_sqe
  type iovec (line 124) | struct iovec
  function class (line 132) | class IoUring : public AsyncBase {

FILE: folly/io/async/IoUringBackend.cpp
  type folly (line 47) | namespace folly {
    type SignalRegistry (line 51) | struct SignalRegistry {
      type SigInfo (line 52) | struct SigInfo {
        type sigaction (line 53) | struct sigaction
      method SignalRegistry (line 58) | constexpr SignalRegistry() {}
    function SignalRegistry (line 69) | SignalRegistry& getSignalRegistry() {
      type SigInfo (line 52) | struct SigInfo {
        type sigaction (line 53) | struct sigaction
      method SignalRegistry (line 58) | constexpr SignalRegistry() {}
    function evSigHandler (line 74) | void evSigHandler(int sig) {
    type sigaction (line 105) | struct sigaction
    function checkLogOverflow (line 129) | void checkLogOverflow([[maybe_unused]] io_uring* ring) {
    class SQGroupInfoRegistry (line 136) | class SQGroupInfoRegistry {
      type SQGroupInfo (line 140) | struct SQGroupInfo {
        type SQSubGroupInfo (line 141) | struct SQSubGroupInfo {
          method add (line 145) | void add(int fd) {
          method remove (line 151) | size_t remove(int fd) {
        method SQGroupInfo (line 161) | SQGroupInfo(size_t num, std::set<uint32_t> const& cpus)
        method SQSubGroupInfo (line 165) | SQSubGroupInfo* getNextSubgroup() {
          method add (line 145) | void add(int fd) {
          method remove (line 151) | size_t remove(int fd) {
        method add (line 180) | size_t add(int fd, SQSubGroupInfo* sg) {
        method remove (line 189) | size_t remove(int fd) {
      method SQGroupInfoRegistry (line 215) | SQGroupInfoRegistry() = default;
      type io_uring_params (line 217) | struct io_uring_params
      method addTo (line 220) | size_t addTo(
      method removeFrom (line 257) | size_t removeFrom(const std::string& groupName, int fd, FDCloseFunc&...
    function validateZeroCopyRxOptions (line 282) | bool validateZeroCopyRxOptions(IoUringOptions& options) {
    function IoUringFdRegistrationRecord (line 347) | IoUringFdRegistrationRecord* IoUringBackend::FdRegistry::alloc(
    function FOLLY_ALWAYS_INLINE (line 389) | FOLLY_ALWAYS_INLINE io_uring_sqe* IoUringBackend::getUntrackedSqe() {
    function FOLLY_ALWAYS_INLINE (line 409) | FOLLY_ALWAYS_INLINE io_uring_sqe* IoUringBackend::getSqe() {
    function FOLLY_ALWAYS_INLINE (line 439) | FOLLY_ALWAYS_INLINE void IoUringBackend::setProcessTimers() {
    function FOLLY_ALWAYS_INLINE (line 444) | FOLLY_ALWAYS_INLINE void IoUringBackend::setProcessSignals() {
    type TimerUserData (line 731) | struct TimerUserData {
    function timerUserDataFreeFunction (line 736) | void timerUserDataFreeFunction(void* v) {
    type __kernel_timespec (line 1430) | struct __kernel_timespec
    type __kernel_timespec (line 1623) | struct __kernel_timespec
    type statx (line 1800) | struct statx
    function doKernelSupportsRecvmsgMultishot (line 1924) | static bool doKernelSupportsRecvmsgMultishot() {
    function doKernelSupportsDeferTaskrun (line 1977) | static bool doKernelSupportsDeferTaskrun() {
    function doKernelSupportsSendZC (line 1990) | static bool doKernelSupportsSendZC() {

FILE: folly/io/async/IoUringBackend.h
  function namespace (line 59) | namespace folly {
  function processSubmit (line 390) | void processSubmit(io_uring_sqe* sqe) noexcept override {
  function virtual (line 397) | virtual void processActive() {}
  function prepPollAdd (line 399) | void prepPollAdd(io_uring_sqe* sqe, int fd, uint32_t events) noexcept {
  function prepRead (line 405) | void prepRead(
  function prepWrite (line 421) | void prepWrite(
  function prepRecvmsgMultishot (line 455) | void prepRecvmsgMultishot(io_uring_sqe* sqe, int fd, msghdr* msg) noexce...
  function FOLLY_ALWAYS_INLINE (line 465) | FOLLY_ALWAYS_INLINE void prepCancel(io_uring_sqe* sqe, IoSqe* cancel_sqe) {
  type FileOpIoSqe (line 477) | struct FileOpIoSqe
  function processActive (line 481) | void processActive() override { cb_(res_); }
  function fd_ (line 483) | int fd_{-1};
  function FileOpIoSqe (line 488) | struct ReadWriteIoSqe : public FileOpIoSqe {
  function ReadWriteIoSqe (line 511) | struct ReadIoSqe : public ReadWriteIoSqe {
  function ReadWriteIoSqe (line 519) | struct WriteIoSqe : public ReadWriteIoSqe {
  function ReadWriteIoSqe (line 527) | struct ReadvIoSqe : public ReadWriteIoSqe {
  function ReadWriteIoSqe (line 541) | struct WritevIoSqe : public ReadWriteIoSqe {
  type class (line 555) | enum class
  function FileOpIoSqe (line 560) | struct FSyncIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 583) | struct FOpenAtIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 606) | struct FOpenAt2IoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 624) | struct FCloseIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 633) | struct FStatxIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 659) | struct FRenameIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 678) | struct FUnlinkIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 698) | struct FAllocateIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 721) | struct SendmsgIoSqe : public FileOpIoSqe {
  function FileOpIoSqe (line 739) | struct RecvmsgIoSqe : public FileOpIoSqe {
  function ReadWriteIoSqe (line 757) | struct RecvzcIoSqe : public ReadWriteIoSqe {
  function processFileOpCB (line 782) | static void processFileOpCB(
  function processRecvZcCB (line 787) | static void processRecvZcCB(
  function bufferProviderGidNext_ (line 839) | uint16_t bufferProviderGidNext_{0}
  function bufferProviderIdx_ (line 841) | uint64_t bufferProviderIdx_{0}
  function waitingToSubmit_ (line 850) | size_t waitingToSubmit_{0}
  function numInsertedEvents_ (line 851) | size_t numInsertedEvents_{0}
  function numInternalEvents_ (line 852) | size_t numInternalEvents_{0}
  function numSendEvents_ (line 853) | size_t numSendEvents_{0}
  function numPooledIoSqeInUse_ (line 856) | size_t numPooledIoSqeInUse_{0}
  function needsDelayedInit_ (line 868) | bool needsDelayedInit_{true};

FILE: folly/io/async/IoUringBase.h
  type io_uring_sqe (line 24) | struct io_uring_sqe
  type io_uring_cqe (line 25) | struct io_uring_cqe
  function namespace (line 27) | namespace folly {

FILE: folly/io/async/IoUringBufferPoolSharing.cpp
  type folly (line 30) | namespace folly {
    function setupIoUringBufferPoolSharingImpl (line 34) | bool setupIoUringBufferPoolSharingImpl(
    function setupIoUringBufferPoolSharing (line 85) | bool setupIoUringBufferPoolSharing(
    function setupIoUringBufferPoolSharing (line 94) | bool setupIoUringBufferPoolSharing(

FILE: folly/io/async/IoUringBufferPoolSharing.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/async/IoUringConnect.cpp
  type folly (line 22) | namespace folly {
    type io_uring_sqe (line 59) | struct io_uring_sqe
    type io_uring_cqe (line 64) | struct io_uring_cqe
    type io_uring_sqe (line 118) | struct io_uring_sqe
    type io_uring_cqe (line 123) | struct io_uring_cqe

FILE: folly/io/async/IoUringConnect.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/IoUringEvent.cpp
  type folly (line 23) | namespace folly {

FILE: folly/io/async/IoUringEvent.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/IoUringEventBaseLocal.cpp
  type folly (line 24) | namespace folly {
    type Tag (line 27) | struct Tag {}
    function detach (line 30) | void detach(EventBase* evb) {
    function IoUringBackend (line 40) | IoUringBackend* IoUringEventBaseLocal::try_get(EventBase* evb) {

FILE: folly/io/async/IoUringEventBaseLocal.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/IoUringOptions.h
  function setMinCapacity (line 48) | struct IoUringOptions {
  function isPow2 (line 152) | constexpr bool isPow2(uint64_t n) noexcept { return n > 0 && !((n - 1) &...
  function minCapacity (line 273) | size_t minCapacity{0}
  function registeredFds (line 276) | size_t registeredFds{0}
  function sqGroupNumThreads (line 277) | size_t sqGroupNumThreads{1}
  function initialProvidedBuffersCount (line 278) | size_t initialProvidedBuffersCount{0}
  function initialProvidedBuffersEachSize (line 279) | size_t initialProvidedBuffersEachSize{0}
  function providedBufRings (line 280) | size_t providedBufRings{1}
  function flags (line 282) | uint32_t flags{0}
  function useHugePages (line 315) | bool useHugePages{false};

FILE: folly/io/async/IoUringProvidedBufferRing.cpp
  type folly (line 33) | namespace folly {
    type io_uring_buf (line 68) | struct io_uring_buf
    type io_uring_buf_ring (line 105) | struct io_uring_buf_ring
    type io_uring_cqe (line 295) | struct io_uring_cqe
    type io_uring_buf_reg (line 303) | struct io_uring_buf_reg

FILE: folly/io/async/IoUringProvidedBufferRing.h
  function FOLLY_POP_WARNING (line 30) | FOLLY_POP_WARNING
  type Options (line 53) | struct Options {
  function bufferCount (line 55) | uint32_t bufferCount{0}
  function bufferSize (line 56) | uint32_t bufferSize{0}
  function useIncrementalBuffers (line 58) | bool useIncrementalBuffers{false};
  function tryPublish (line 108) | bool tryPublish(uint16_t expected, uint16_t value) noexcept {
  type io_uring_buf (line 118) | struct io_uring_buf
  type BufferState (line 122) | struct BufferState {
  function offset (line 127) | unsigned int offset{0}
  function IoUringProvidedBufferRing (line 128) | IoUringProvidedBufferRing* parent{nullptr};
  type io_uring_buf_ring (line 136) | struct io_uring_buf_ring
  function sizePerBuffer_ (line 139) | uint32_t sizePerBuffer_{0}
  function ringMask_ (line 140) | int ringMask_{0}
  function gottenBuffers_ (line 141) | uint32_t gottenBuffers_{0}
  function ringReturnedBuffers_ (line 142) | uint32_t ringReturnedBuffers_{0}
  function returnedBuffers_ (line 143) | uint32_t returnedBuffers_{0}
  function bufferCount_ (line 144) | uint32_t bufferCount_{0}
  function shutdownReferences_ (line 152) | uint32_t shutdownReferences_{0}
  function gid_ (line 153) | uint16_t const gid_{0}
  function ringCount_ (line 154) | uint32_t ringCount_{0}
  function allSize_ (line 155) | uint32_t allSize_{0}
  function ringMemSize_ (line 157) | uint32_t ringMemSize_{0}
  function bufferSize_ (line 158) | uint32_t bufferSize_{0}

FILE: folly/io/async/IoUringRecv.cpp
  type folly (line 24) | namespace folly {
    class DetachedReadCallback (line 33) | class DetachedReadCallback : public IoUringRecvCallback {
      method recvSuccess (line 35) | void recvSuccess(std::unique_ptr<IOBuf> data) override {
      method recvEOF (line 43) | void recvEOF() noexcept override { done(); }
      method recvErr (line 44) | void recvErr(
      method done (line 51) | void done() {
    class IoUringRecvHandle::RecvRequest (line 67) | class IoUringRecvHandle::RecvRequest
      method RecvRequest (line 73) | explicit RecvRequest(
      method setRecvLen (line 89) | void setRecvLen(size_t len) { recvLen_ = len; }
      method prepRecvNormal (line 91) | void prepRecvNormal(struct io_uring_sqe* sqe) {
      method prepRecvFallback (line 101) | void prepRecvFallback(struct io_uring_sqe* sqe) {
      method processSubmit (line 115) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
      method callback (line 137) | void callback(const struct io_uring_cqe* cqe) noexcept override {
      method callbackCancelled (line 160) | void callbackCancelled(const io_uring_cqe* cqe) noexcept override {
      method getData (line 174) | std::unique_ptr<IOBuf> getData(const struct io_uring_cqe* cqe) {
      method isEOF (line 188) | bool isEOF(const struct io_uring_cqe* cqe) {
    class IoUringRecvHandle::RecvRequest (line 449) | class IoUringRecvHandle::RecvRequest : public DelayedDestruction {}
      method RecvRequest (line 73) | explicit RecvRequest(
      method setRecvLen (line 89) | void setRecvLen(size_t len) { recvLen_ = len; }
      method prepRecvNormal (line 91) | void prepRecvNormal(struct io_uring_sqe* sqe) {
      method prepRecvFallback (line 101) | void prepRecvFallback(struct io_uring_sqe* sqe) {
      method processSubmit (line 115) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
      method callback (line 137) | void callback(const struct io_uring_cqe* cqe) noexcept override {
      method callbackCancelled (line 160) | void callbackCancelled(const io_uring_cqe* cqe) noexcept override {
      method getData (line 174) | std::unique_ptr<IOBuf> getData(const struct io_uring_cqe* cqe) {
      method isEOF (line 188) | bool isEOF(const struct io_uring_cqe* cqe) {

FILE: folly/io/async/IoUringRecv.h
  function class (line 33) | class IoUringRecvCallback {
  function readEnabled_ (line 103) | bool readEnabled_{false};

FILE: folly/io/async/IoUringSend.cpp
  type folly (line 22) | namespace folly {
    class IoUringSendHandle::SendRequest (line 30) | class IoUringSendHandle::SendRequest : public IoSqeBase {
      type iovec (line 35) | struct iovec
      method SendRequest (line 45) | explicit SendRequest(
      method destroy (line 73) | void destroy() {
      method setHandle (line 82) | void setHandle(IoUringSendHandle* handle) {
      method SendRequest (line 86) | SendRequest* getNext() { return next_; }
      method append (line 87) | void append(SendRequest* request) { next_ = request; }
      method getTotalBytesWritten (line 89) | size_t getTotalBytesWritten() { return bytesWritten_; }
      method releaseIOBuf (line 91) | void releaseIOBuf(IoUringSendHandle* handle) {
      method detachEventBase (line 97) | folly::SemiFuture<int> detachEventBase() {
      method SendRequest (line 108) | SendRequest* clone(IoUringSendHandle* newHandle) {
      method processSubmit (line 131) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
      method callback (line 136) | void callback(const struct io_uring_cqe* cqe) noexcept override {
      method callbackCancelled (line 161) | void callbackCancelled(const io_uring_cqe*) noexcept override { dest...
      method flags (line 164) | int flags() {
      method consumeBytes (line 182) | void consumeBytes(size_t bytes) {
      type msghdr (line 219) | struct msghdr
      type iovec (line 222) | struct iovec
    type io_uring_cqe (line 285) | struct io_uring_cqe
    type iovec (line 321) | struct iovec
    type iovec (line 479) | struct iovec

FILE: folly/io/async/IoUringSend.h
  function class (line 27) | class IoUringSendCallback {
  type iovec (line 58) | struct iovec
  function empty (line 68) | bool empty() { return requestHead_ == nullptr; }
  function SendRequest (line 98) | SendRequest* requestTail_{nullptr};

FILE: folly/io/async/IoUringZeroCopyBufferPool.cpp
  type folly (line 30) | namespace folly {
    class IoUringZeroCopyBufferPoolImpl (line 32) | class IoUringZeroCopyBufferPoolImpl {
      type Buffer (line 36) | struct Buffer {
      method IoUringZeroCopyBufferPoolImpl (line 47) | IoUringZeroCopyBufferPoolImpl(IoUringZeroCopyBufferPoolImpl&&) = del...
      method IoUringZeroCopyBufferPoolImpl (line 48) | IoUringZeroCopyBufferPoolImpl(IoUringZeroCopyBufferPoolImpl const&) ...
      method IoUringZeroCopyBufferPoolImpl (line 49) | IoUringZeroCopyBufferPoolImpl& operator=(IoUringZeroCopyBufferPoolIm...
      method IoUringZeroCopyBufferPoolImpl (line 51) | IoUringZeroCopyBufferPoolImpl& operator=(
      type io_uring_cqe (line 57) | struct io_uring_cqe
      type io_uring_zcrx_cqe (line 58) | struct io_uring_zcrx_cqe
      method getRingUsedCount (line 63) | uint32_t getRingUsedCount() const noexcept {
      method getRingFreeCount (line 66) | uint32_t getRingFreeCount() const noexcept {
      method getPendingBuffersSize (line 69) | size_t getPendingBuffersSize() const noexcept {
      method getFlushThreshold (line 72) | uint32_t getFlushThreshold() const noexcept { return flushThreshold_; }
      method getAndResetFlushFailures (line 73) | uint16_t getAndResetFlushFailures() noexcept {
      method getAndResetFlushCount (line 76) | uint16_t getAndResetFlushCount() noexcept {
      type io_uring (line 88) | struct io_uring
      type io_uring_zcrx_rq (line 97) | struct io_uring_zcrx_rq
    type ImplDeleter (line 113) | struct ImplDeleter {
    type RingQueue (line 122) | struct RingQueue {
    function getRefillRingSize (line 127) | size_t getRefillRingSize(size_t rqEntries) {
    type io_uring_zcrx_rqe (line 179) | struct io_uring_zcrx_rqe
    type io_uring_cqe (line 203) | struct io_uring_cqe
    type io_uring_zcrx_cqe (line 204) | struct io_uring_zcrx_cqe
    type io_uring_region_desc (line 257) | struct io_uring_region_desc
    type io_uring_zcrx_area_reg (line 262) | struct io_uring_zcrx_area_reg
    type io_uring_zcrx_ifq_reg (line 266) | struct io_uring_zcrx_ifq_reg
    type io_uring_zcrx_rqe (line 287) | struct io_uring_zcrx_rqe
    type io_uring_zcrx_rqe (line 304) | struct io_uring_zcrx_rqe
    type zcrx_ctrl (line 358) | struct zcrx_ctrl
    type io_uring (line 384) | struct io_uring
    type io_uring (line 400) | struct io_uring
    type io_uring_zcrx_ifq_reg (line 402) | struct io_uring_zcrx_ifq_reg
    type zcrx_ctrl (line 433) | struct zcrx_ctrl
    type io_uring_cqe (line 443) | struct io_uring_cqe
    type io_uring_zcrx_cqe (line 444) | struct io_uring_zcrx_cqe

FILE: folly/io/async/IoUringZeroCopyBufferPool.h
  type Params (line 37) | struct Params {
  type ExportHandle (line 46) | struct ExportHandle {
  type io_uring (line 67) | struct io_uring
  type TestTag (line 80) | struct TestTag {}
  type io_uring (line 84) | struct io_uring
  type io_uring (line 102) | struct io_uring
  function zcrxId_ (line 104) | int zcrxId_{-1};

FILE: folly/io/async/MuxIOThreadPoolExecutor.cpp
  type folly (line 27) | namespace folly {
    function throttledLifoSemOptions (line 31) | ThrottledLifoSem::Options throttledLifoSemOptions(
    type MuxIOThreadPoolExecutor::EvbState (line 40) | struct MuxIOThreadPoolExecutor::EvbState {
      method EvbState (line 41) | EvbState() : evb(evbOptions()) {}
    function EventBase (line 239) | EventBase* MuxIOThreadPoolExecutor::getEventBase() {

FILE: folly/io/async/MuxIOThreadPoolExecutor.h
  function namespace (line 33) | namespace folly {

FILE: folly/io/async/NotificationQueue.h
  function namespace (line 48) | namespace folly {
  function tryConsume (line 419) | bool tryConsume(MessageT& result) {
  function drainSignalsLocked (line 525) | void drainSignalsLocked() {
  function syncSignalAndQueue (line 557) | void syncSignalAndQueue() {
  function mutable (line 631) | mutable bool signal_{false};
  function namespace (line 871) | namespace detail {

FILE: folly/io/async/PasswordInFile.cpp
  type folly (line 24) | namespace folly {

FILE: folly/io/async/PasswordInFile.h
  function namespace (line 21) | namespace folly {

FILE: folly/io/async/Request.cpp
  type folly (line 23) | namespace folly {
    function RequestContext (line 29) | RequestContext* getCachedRequestContext() {
    function FOLLY_ALWAYS_INLINE (line 71) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 98) | FOLLY_ALWAYS_INLINE
    function FOLLY_NOINLINE (line 109) | FOLLY_NOINLINE
    type RequestContext::State::Combined (line 118) | struct RequestContext::State::Combined : hazptr_obj_base<Combined> {
      method Combined (line 130) | Combined()
      method Combined (line 133) | Combined(const Combined& o)
      method Combined (line 136) | Combined(size_t dataCapacity, size_t callbackCapacity, const Combine...
      method Combined (line 140) | Combined(Combined&&) = delete;
      method Combined (line 141) | Combined& operator=(const Combined&) = delete;
      method Combined (line 142) | Combined& operator=(Combined&&) = delete;
      method acquireDataRefs (line 147) | void acquireDataRefs() {
      method releaseDataRefs (line 157) | void releaseDataRefs() {
      method debugCheckConsistency (line 172) | void debugCheckConsistency() {
      method needExpand (line 196) | bool needExpand() {
      method needExpandRequestData (line 201) | bool needExpandRequestData() {
      method needExpandCallbackData (line 207) | bool needExpandCallbackData() {
    function FOLLY_ALWAYS_INLINE (line 215) | FOLLY_ALWAYS_INLINE
    class RequestContext::State::LockGuard (line 238) | class [[nodiscard]] RequestContext::State::LockGuard {
      method LockGuard (line 240) | explicit LockGuard(RequestContext::State& state)
      method LockGuard (line 253) | LockGuard(const LockGuard&) = delete;
      method LockGuard (line 254) | LockGuard(LockGuard&&) = delete;
      method LockGuard (line 255) | LockGuard& operator=(const LockGuard&) = delete;
      method LockGuard (line 256) | LockGuard& operator=(LockGuard&&) = delete;
    function FOLLY_ALWAYS_INLINE (line 262) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 267) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 277) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 283) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 306) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 426) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 459) | FOLLY_ALWAYS_INLINE
    function FOLLY_ALWAYS_INLINE (line 473) | FOLLY_ALWAYS_INLINE
    function RequestData (line 585) | const RequestData* FOLLY_NULLABLE
    function RequestContext (line 738) | RequestContext* RequestContext::get() {
    function RequestContext (line 749) | RequestContext* RequestContext::try_get() {

FILE: folly/io/async/Request.h
  function namespace (line 33) | namespace folly {
  function namespace (line 65) | namespace std {
  function namespace (line 74) | namespace folly {
  type Tag (line 356) | struct Tag {}
  type StaticContext (line 364) | struct StaticContext {
  function explicit (line 396) | explicit StaticContextAccessor(Inner&& inner) noexcept
  function DoSetBehaviour (line 460) | enum class DoSetBehaviour {
  type State (line 482) | struct State {
  type SetContextDataResult (line 507) | struct SetContextDataResult {
  function class (line 567) | class RequestContextSaverScopeGuard {
  function class (line 595) | class RequestContextScopeGuard : private RequestContextSaverScopeGuard {
  function ShallowCopyRequestContextScopeGuard (line 618) | struct ShallowCopyRequestContextScopeGuard {
  function first (line 649) | first, rest...) {}
  type MultiTag (line 665) | struct MultiTag {}
  function go (line 670) | auto go = [&](RequestDataItem& i) {
  function class (line 682) | class [[maybe_unused]] DCheckRequestContextRestoredGuard {

FILE: folly/io/async/SSLContext.cpp
  type folly (line 30) | namespace folly {
    function getExDataIndex (line 34) | int getExDataIndex() {
    function configureProtocolVersion (line 43) | void configureProtocolVersion(SSL_CTX* ctx, SSLContext::SSLVersion ver...
    function dispatchTicketCrypto (line 76) | static int dispatchTicketCrypto(
    function SSL (line 703) | SSL* SSLContext::createSSL() const {
    function SSLContext (line 831) | SSLContext* SSLContext::getFromSSLCtx(const SSL_CTX* ctx) {

FILE: folly/io/async/SSLContext.h
  function namespace (line 41) | namespace ssl {
  function class (line 48) | class SSLAcceptRunner {
  type SessionLifecycleCallbacks (line 68) | struct SessionLifecycleCallbacks {
  type SSLVersion (line 73) | enum SSLVersion {
  type SSLVerifyPeerEnum (line 85) | enum SSLVerifyPeerEnum {
  function VerifyClientCertificate (line 101) | enum class VerifyClientCertificate {
  function virtual (line 378) | virtual bool isCertKeyPairValid() const;
  function virtual (line 456) | virtual std::shared_ptr<ssl::PasswordCollector> passwordCollector() {
  type ServerNameCallbackResult (line 463) | enum ServerNameCallbackResult {
  type std (line 503) | typedef std::function<ServerNameCallbackResult(SSL* ssl)> ServerNameCall...
  type std (line 510) | typedef std::function<void(SSL* ssl)> ClientHelloCallback;
  function setAlpnAllowMismatch (line 578) | void setAlpnAllowMismatch(bool allowMismatch) {
  function SSL_CTX (line 585) | SSL_CTX* getSSLCtx() const { return ctx_; }
  function sslAcceptRunner (line 611) | void sslAcceptRunner(std::unique_ptr<SSLAcceptRunner> runner) {
  function SSLAcceptRunner (line 619) | const SSLAcceptRunner* sslAcceptRunner() const {
  function OpenSSLTicketHandler (line 625) | OpenSSLTicketHandler* getTicketHandler() const {
  type AdvertisedNextProtocolsItem (line 688) | struct AdvertisedNextProtocolsItem {
  function alpnAllowMismatch_ (line 713) | bool alpnAllowMismatch_{true};

FILE: folly/io/async/SSLOptions.cpp
  type folly (line 23) | namespace folly {
    type ssl (line 24) | namespace ssl {
      type ssl_options_detail (line 26) | namespace ssl_options_detail {
        function logDfatal (line 27) | void logDfatal(std::exception const& e) {

FILE: folly/io/async/SSLOptions.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/STTimerFDTimeoutManager.cpp
  type folly (line 20) | namespace folly {

FILE: folly/io/async/STTimerFDTimeoutManager.h
  function namespace (line 21) | namespace folly {

FILE: folly/io/async/ScopedEventBaseThread.cpp
  type folly (line 28) | namespace folly {
    function run (line 30) | static void run(

FILE: folly/io/async/ScopedEventBaseThread.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/SimpleAsyncIO.h
  function namespace (line 28) | namespace folly {

FILE: folly/io/async/TerminateCancellationToken.cpp
  type folly (line 25) | namespace folly {
    class ScopedTerminateSignalHandler (line 32) | class ScopedTerminateSignalHandler : private AsyncSignalHandler {
      method ScopedTerminateSignalHandler (line 34) | ScopedTerminateSignalHandler() : AsyncSignalHandler(nullptr) {
      method CancellationToken (line 43) | CancellationToken getCancellationToken() {
      method signalReceived (line 48) | void signalReceived(int) noexcept override {
    function CancellationToken (line 63) | CancellationToken getTerminateCancellationToken() {

FILE: folly/io/async/TerminateCancellationToken.h
  function namespace (line 21) | namespace folly {

FILE: folly/io/async/TimeoutManager.cpp
  type folly (line 27) | namespace folly {
    type TimeoutManager::CobTimeouts (line 29) | struct TimeoutManager::CobTimeouts {
      class CobTimeout (line 32) | class CobTimeout : public AsyncTimeout {
        method CobTimeout (line 34) | CobTimeout(TimeoutManager* timeoutManager, Func cob, InternalEnum ...
        method timeoutExpired (line 37) | void timeoutExpired() noexcept override {

FILE: folly/io/async/TimeoutManager.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/TimerFD.cpp
  type folly (line 25) | namespace folly {
    type itimerspec (line 68) | struct itimerspec

FILE: folly/io/async/TimerFD.h
  function fd_ (line 56) | int fd_{-1};
  function class (line 60) | class TimerFD {

FILE: folly/io/async/TimerFDTimeoutManager.cpp
  type folly (line 19) | namespace folly {

FILE: folly/io/async/TimerFDTimeoutManager.h
  function namespace (line 24) | namespace folly {
  function processingExpired_ (line 127) | bool processingExpired_{false};

FILE: folly/io/async/VirtualEventBase.cpp
  type folly (line 19) | namespace folly {

FILE: folly/io/async/VirtualEventBase.h
  function namespace (line 28) | namespace folly {
  function keepAliveRelease (line 124) | void keepAliveRelease() noexcept override {
  function keepAliveCount (line 140) | size_t keepAliveCount() {
  function destroyImpl (line 145) | void destroyImpl() noexcept;

FILE: folly/io/async/WriteChainAsyncTransportWrapper.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/WriteFlags.h
  function namespace (line 21) | namespace folly {

FILE: folly/io/async/fdsock/AsyncFdSocket.cpp
  type folly (line 22) | namespace folly {
    type ::cmsghdr (line 208) | struct ::cmsghdr
    function receiveFdsFromCMSG (line 273) | bool receiveFdsFromCMSG(
    function receiveFds (line 309) | bool receiveFds(struct ::msghdr& msg, std::vector<folly::File>* fds) n...
    type ::msghdr (line 330) | struct ::msghdr
    function SocketFds (line 371) | SocketFds AsyncFdSocket::popNextReceivedFds() {

FILE: folly/io/async/fdsock/AsyncFdSocket.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/fdsock/SocketFds.cpp
  type folly (line 19) | namespace folly {

FILE: folly/io/async/fdsock/SocketFds.h
  function namespace (line 26) | namespace folly {
  function namespace (line 142) | namespace detail {

FILE: folly/io/async/fdsock/test/AsyncFdSocketTest.cpp
  type folly (line 22) | namespace folly { // required for FRIEND_TEST to work
    function getFdProcMagic (line 27) | std::string getFdProcMagic(int fd) {
    function checkFdsMatch (line 38) | void checkFdsMatch(
    function makeFdsToSend (line 62) | folly::SocketFds::ToSend makeFdsToSend(size_t n) {
    type AsyncFdSocketTest (line 81) | struct AsyncFdSocketTest : public testing::Test {
      method AsyncFdSocketTest (line 82) | AsyncFdSocketTest()
      method AsyncFdSocketTest (line 92) | explicit AsyncFdSocketTest(std::array<NetworkSocket, 2> fds)
    function TEST_F (line 107) | TEST_F(AsyncFdSocketTest, TestAddSeqNum) {
    function TEST_F (line 138) | TEST_F(AsyncFdSocketTest, FailNoData) {
    function TEST_F (line 145) | TEST_F(AsyncFdSocketTest, FailSendReceivedFds) {
    function TEST_F (line 155) | TEST_F(AsyncFdSocketTest, FailTooManyFds) {
    type AsyncFdSocketSimpleRoundtripTest (line 164) | struct AsyncFdSocketSimpleRoundtripTest
    function TEST_P (line 168) | TEST_P(AsyncFdSocketSimpleRoundtripTest, WithNumFds) {
    type WriteCountedAsyncFdSocket (line 194) | struct WriteCountedAsyncFdSocket : public AsyncFdSocket {
      method sendSocketMessage (line 196) | AsyncSocket::WriteResult sendSocketMessage(
    function TEST_F (line 211) | TEST_F(AsyncFdSocketTest, MultiPartSend) {
    type AsyncFdSocketSequenceRoundtripTest (line 256) | struct AsyncFdSocketSequenceRoundtripTest
    function TEST_P (line 260) | TEST_P(AsyncFdSocketSequenceRoundtripTest, WithDataSize) {

FILE: folly/io/async/observer/AsyncSocketObserverContainer.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/observer/AsyncSocketObserverInterface.h
  function namespace (line 25) | namespace folly {

FILE: folly/io/async/ssl/BasicTransportCertificate.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/ssl/OpenSSLTransportCertificate.h
  function namespace (line 23) | namespace folly {

FILE: folly/io/async/ssl/OpenSSLUtils.cpp
  type folly (line 38) | namespace folly {
    type ssl (line 39) | namespace ssl {
      function getOpenSSLCipherNames (line 146) | static std::unordered_map<uint16_t, std::string> getOpenSSLCipherNam...
      function SSL_CTX (line 199) | SSL_CTX* OpenSSLUtils::getSSLInitialCtx(SSL* ssl) {
      function BioMethodUniquePtr (line 204) | BioMethodUniquePtr OpenSSLUtils::newSocketBioMethod() {
      function NetworkSocket (line 262) | NetworkSocket OpenSSLUtils::getBioFd(BIO* b) {
      function forEachX509 (line 325) | static void forEachX509(BIO* source, Callback cb) {
      function getSubjectNamesFromBIO (line 337) | static std::vector<X509NameUniquePtr> getSubjectNamesFromBIO(BIO* b) {
  function boringssl_bio_fd_non_fatal_error (line 373) | static int boringssl_bio_fd_non_fatal_error(int err) {
  function boringssl_bio_fd_should_retry (line 407) | int boringssl_bio_fd_should_retry(int i) {
  function boringssl_bio_fd_should_retry (line 416) | int boringssl_bio_fd_should_retry(int i) {

FILE: folly/io/async/ssl/OpenSSLUtils.h
  function namespace (line 27) | namespace folly {

FILE: folly/io/async/ssl/SSLErrors.cpp
  function decodeOpenSSLError (line 26) | std::string decodeOpenSSLError(
  function StringPiece (line 46) | StringPiece getSSLErrorString(SSLError error) {
  function exTypefromSSLErrInfo (line 71) | AsyncSocketException::AsyncSocketExceptionType exTypefromSSLErrInfo(
  function exTypefromSSLErr (line 87) | AsyncSocketException::AsyncSocketExceptionType exTypefromSSLErr(SSLError...
  type folly (line 104) | namespace folly {

FILE: folly/io/async/ssl/SSLErrors.h
  function namespace (line 21) | namespace folly {

FILE: folly/io/async/ssl/TLSDefinitions.h
  type class (line 29) | enum class
  function HashAlgorithm (line 63) | enum class HashAlgorithm : uint8_t {

FILE: folly/io/async/ssl/test/BasicTransportCertificateTest.cpp
  function TEST (line 30) | TEST(BasicTransportCertificateTest, TestCerts) {

FILE: folly/io/async/ssl/test/OpenSSLUtilsTest.cpp
  type folly (line 26) | namespace folly {
    function X509UniquePtr (line 36) | X509UniquePtr createMinimalX509(const std::string& commonName) {
    function TEST (line 55) | TEST(OpenSSLUtilsTest, getCommonName) {
    function TEST (line 63) | TEST(OpenSSLUtilsTest, getCommonNameMaxLength) {
    function TEST (line 72) | TEST(OpenSSLUtilsTest, getCommonNameNullX509) {
    function TEST (line 78) | TEST(OpenSSLUtilsTest, getCommonNameEmpty) {
    function TEST (line 85) | TEST(OpenSSLUtilsTest, encodeALPNString) {

FILE: folly/io/async/ssl/test/SSLErrorsTest.cpp
  function TEST (line 24) | TEST(SSLErrorsTest, TestMessage) {

FILE: folly/io/async/test/AsyncBaseTestLib.cpp
  type folly (line 19) | namespace folly {
    type test (line 20) | namespace test {
      type async_base_test_lib_detail (line 21) | namespace async_base_test_lib_detail {

FILE: folly/io/async/test/AsyncBaseTestLib.h
  function namespace (line 43) | namespace test {
  function schedule (line 446) | const auto schedule = [&](size_t n) {

FILE: folly/io/async/test/AsyncIOTest.cpp
  type folly (line 22) | namespace folly {
    type test (line 23) | namespace test {
      type async_base_test_lib_detail (line 24) | namespace async_base_test_lib_detail {
        class BatchAsyncIO (line 43) | class BatchAsyncIO : public AsyncIO {
          method BatchAsyncIO (line 45) | BatchAsyncIO() : AsyncIO(kBatchNumEntries, folly::AsyncBase::NOT...

FILE: folly/io/async/test/AsyncIoUringSocketTest.cpp
  type folly (line 40) | namespace folly {
    function toString (line 47) | std::string toString(std::unique_ptr<IOBuf> const& buf) {
    class NullWriteCallback (line 55) | class NullWriteCallback : public AsyncWriter::WriteCallback {
      method writeSuccess (line 57) | void writeSuccess() noexcept override {}
      method writeErr (line 59) | void writeErr(
    class FutureWriteCallback (line 67) | class FutureWriteCallback : public AsyncWriter::WriteCallback {
      method writeSuccess (line 69) | void writeSuccess() noexcept override {
      method writeErr (line 74) | void writeErr(
    class EchoTransport (line 86) | class EchoTransport
      method EchoTransport (line 90) | explicit EchoTransport(AsyncSocketTransport::UniquePtr s, bool bm)
      method start (line 93) | void start() { transport->setReadCB(this); }
      method getReadBuffer (line 95) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
      method writeSuccess (line 100) | void writeSuccess() noexcept override {}
      method writeErr (line 102) | void writeErr(
      method readEOF (line 108) | void readEOF() noexcept override {
      method readErr (line 113) | void readErr(const AsyncSocketException& ex) noexcept override {
      method readDataAvailable (line 118) | void readDataAvailable(size_t len) noexcept override {
      method isBufferMovable (line 124) | bool isBufferMovable() noexcept override { return bufferMovable; }
      method readBufferAvailable (line 126) | void readBufferAvailable(std::unique_ptr<IOBuf> readBuf) noexcept ov...
    class CollectCallback (line 136) | class CollectCallback : public AsyncReader::ReadCallback {
      method getReadBuffer (line 138) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
      method readEOF (line 143) | void readEOF() noexcept override { clear(); }
      method readErr (line 145) | void readErr(const AsyncSocketException& ex) noexcept override {
      method readDataAvailable (line 152) | void readDataAvailable(size_t len) noexcept override {
      method waitFor (line 162) | SemiFuture<std::string> waitFor(size_t n) {
      method readBufferAvailable (line 168) | void readBufferAvailable(std::unique_ptr<IOBuf> readBuf) noexcept ov...
      method clear (line 188) | void clear() {
      method dataAvailable (line 194) | void dataAvailable() {
      method isBufferMovable (line 205) | bool isBufferMovable() noexcept override { return true; }
      method setHoldData (line 207) | void setHoldData(bool b) { holdData = b; }
    type TestParams (line 218) | struct TestParams {
      method testName (line 225) | std::string testName() const {
    type ConnectedOptions (line 240) | struct ConnectedOptions {
      method ConnectedOptions (line 244) | ConnectedOptions withNoServerShouldRead() {
      method ConnectedOptions (line 250) | ConnectedOptions withFastOpen(std::string i) {
    class AsyncIoUringSocketTest (line 257) | class AsyncIoUringSocketTest
      method ioOptions (line 262) | static IoUringBackend::Options ioOptions(TestParams const& p) {
      method ioUringEbOptions (line 274) | EventBase::Options ioUringEbOptions() {
      method ebOptions (line 281) | EventBase::Options ebOptions() { return ioUringEbOptions(); }
      method maybeSkip (line 283) | void maybeSkip() {
      method AsyncIoUringSocketTest (line 289) | AsyncIoUringSocketTest() {
      method connectionAccepted (line 310) | void connectionAccepted(
      method connectSuccess (line 315) | void connectSuccess() noexcept override {}
      method connectErr (line 316) | void connectErr(const AsyncSocketException& ex) noexcept override {
      type Connected (line 321) | struct Connected {
      method ioUringSocketOptions (line 335) | AsyncIoUringSocket::Options ioUringSocketOptions() const {
      method makeConnected (line 344) | Connected<ServerReadCallback> makeConnected(
    function TEST_P (line 401) | TEST_P(AsyncIoUringSocketTest, ConnectTimeout) {
    function TEST_P (line 445) | TEST_P(AsyncIoUringSocketTest, EoF) {
    type DetachCB (line 501) | struct DetachCB : folly::AsyncDetachFdCallback {
      method fdDetached (line 502) | void fdDetached(
      method fdDetachFail (line 507) | void fdDetachFail(const AsyncSocketException& ex) noexcept override {
    function TEST_P (line 514) | TEST_P(AsyncIoUringSocketTest, Detach) {
    function TEST_P (line 556) | TEST_P(AsyncIoUringSocketTest, DetachEventBase) {
    function TEST_P (line 599) | TEST_P(AsyncIoUringSocketTest, DetachEventBaseClear) {
    function TEST_P (line 614) | TEST_P(AsyncIoUringSocketTest, FastOpen) {
    function TEST_P (line 658) | TEST_P(AsyncIoUringSocketTest, BindAddressNoPort) {
    function TEST_P (line 679) | TEST_P(AsyncIoUringSocketTest, ConnectSuccessStateEstablished) {
    function TEST_P (line 711) | TEST_P(AsyncIoUringSocketTest, ConnectWithBoundFd) {
    function TEST_P (line 783) | TEST_P(AsyncIoUringSocketTest, ConnectWithUnboundFd) {
    function TEST_P (line 827) | TEST_P(AsyncIoUringSocketTest, ConnectWithAlreadyConnectedFd) {
    function TEST_P (line 875) | TEST_P(AsyncIoUringSocketTest, ReadCallbackSetDuringConnect) {
    class AsyncIoUringSocketTestAll (line 918) | class AsyncIoUringSocketTestAll : public AsyncIoUringSocketTest {}
    function TEST_P (line 920) | TEST_P(AsyncIoUringSocketTestAll, WriteChain2) {
    function TEST_P (line 929) | TEST_P(AsyncIoUringSocketTestAll, WriteChainOrder) {
    function TEST_P (line 940) | TEST_P(AsyncIoUringSocketTestAll, WriteChainLong) {
    function TEST_P (line 954) | TEST_P(AsyncIoUringSocketTestAll, Write) {
    function TEST_P (line 961) | TEST_P(AsyncIoUringSocketTestAll, WriteAfterWait) {
    function randomString (line 977) | std::string randomString(size_t n) {
    function TEST_P (line 992) | TEST_P(AsyncIoUringSocketTestAll, WriteBig) {
    function TEST_P (line 1002) | TEST_P(AsyncIoUringSocketTestAll, WriteBigChunked) {
    function TEST_P (line 1018) | TEST_P(AsyncIoUringSocketTestAll, WriteBigDrop) {
    function TEST_P (line 1027) | TEST_P(AsyncIoUringSocketTestAll, Writev) {
    function TEST_P (line 1035) | TEST_P(AsyncIoUringSocketTestAll, SendTimeout) {
    function mkAllTestParams (line 1060) | auto mkAllTestParams() {
    function TestParams (line 1110) | TestParams mkBasicTestParams() {
      method testName (line 225) | std::string testName() const {
    class AsyncIoUringSocketTakeoverTest (line 1124) | class AsyncIoUringSocketTakeoverTest : public AsyncIoUringSocketTest {}
    class AsyncSocketWithPreRead (line 1126) | class AsyncSocketWithPreRead : public AsyncSocket {
      method AsyncSocketWithPreRead (line 1128) | AsyncSocketWithPreRead(AsyncSocket::UniquePtr a, std::string const& ...
    function TEST_P (line 1134) | TEST_P(AsyncIoUringSocketTakeoverTest, PreRead) {
    function TestParams (line 1150) | TestParams mkTakeoverParams() {
      method testName (line 225) | std::string testName() const {
    function TEST (line 1164) | TEST(AsyncIoUringSocketTest, RemoveNonBlockFlag) {

FILE: folly/io/async/test/AsyncPipeTest.cpp
  class TestReadCallback (line 29) | class TestReadCallback : public folly::AsyncReader::ReadCallback {
    method isBufferMovable (line 31) | bool isBufferMovable() noexcept override { return movable_; }
    method setMovable (line 32) | void setMovable(bool movable) { movable_ = movable; }
    method readBufferAvailable (line 34) | void readBufferAvailable(
    method readDataAvailable (line 39) | void readDataAvailable(size_t len) noexcept override {
    method getReadBuffer (line 43) | void getReadBuffer(void** bufReturn, size_t* lenReturn) noexcept overr...
    method readEOF (line 49) | void readEOF() noexcept override {}
    method readErr (line 51) | void readErr(const folly::AsyncSocketException&) noexcept override {
    method getData (line 55) | std::string getData() {
    method reset (line 61) | void reset() {
  class TestWriteCallback (line 72) | class TestWriteCallback : public folly::AsyncWriter::WriteCallback {
    method writeSuccess (line 74) | void writeSuccess() noexcept override { writes_++; }
    method writeErr (line 76) | void writeErr(size_t, const folly::AsyncSocketException&) noexcept ove...
    method reset (line 80) | void reset() {
  class AsyncPipeTest (line 89) | class AsyncPipeTest : public Test {
    method reset (line 91) | void reset(bool movable) {
  function getBuf (line 119) | std::unique_ptr<folly::IOBuf> getBuf(const std::string& data) {
  function TEST_F (line 126) | TEST_F(AsyncPipeTest, simple) {
  function TEST_F (line 140) | TEST_F(AsyncPipeTest, blocked_writes) {
  function TEST_F (line 165) | TEST_F(AsyncPipeTest, writeOnClose) {

FILE: folly/io/async/test/AsyncSSLSocketTest.cpp
  type GlobalStatic (line 72) | struct GlobalStatic {
    method GlobalStatic (line 73) | GlobalStatic() {
    method reset (line 76) | void reset() noexcept { ttlsDisabledSet.clear(); }
  function setsockopt (line 88) | int setsockopt(
  function getfds (line 111) | void getfds(NetworkSocket fds[2]) {
  function getctx (line 123) | void getctx(
  function getFileAsBuf (line 133) | std::string getFileAsBuf(const char* fileName) {
  function readCertFromFile (line 139) | folly::ssl::X509UniquePtr readCertFromFile(const std::string& filename) {
  function connectWriteReadClose (line 153) | void connectWriteReadClose(
  function TEST (line 197) | TEST(AsyncSSLSocketTest, ConnectWriteReadClose) {
  function TEST (line 201) | TEST(AsyncSSLSocketTest, ConnectWriteReadvClose) {
  function TEST (line 205) | TEST(AsyncSSLSocketTest, ConnectWriteReadCloseReadable) {
  function TEST (line 257) | TEST(AsyncSSLSocketTest, ZeroCopy) {
  function TEST (line 271) | TEST(AsyncSSLSocketTest, ConnectWriteReadLargeClose) {
  function TEST (line 319) | TEST(AsyncSSLSocketTest, ReadAfterClose) {
  function TEST (line 347) | TEST(AsyncSSLSocketTest, Renegotiate) {
  function TEST (line 402) | TEST(AsyncSSLSocketTest, HandshakeError) {
  function TEST (line 438) | TEST(AsyncSSLSocketTest, ReadError) {
  function TEST (line 467) | TEST(AsyncSSLSocketTest, WriteError) {
  function TEST (line 496) | TEST(AsyncSSLSocketTest, SocketWithDelay) {
  class NextProtocolTest (line 530) | class NextProtocolTest : public Test {
    method SetUp (line 533) | void SetUp() override { getctx(clientCtx, serverCtx); }
    method connect (line 535) | void connect(bool unset = false) {
    method expectProtocol (line 554) | void expectProtocol(const std::string& proto) {
    method expectNoProtocol (line 565) | void expectNoProtocol() {
    method expectHandshakeSuccess (line 573) | void expectHandshakeSuccess() {
    method expectHandshakeError (line 580) | void expectHandshakeError() {
  function TEST_F (line 595) | TEST_F(NextProtocolTest, AlpnTestOverlap) {
  function TEST_F (line 604) | TEST_F(NextProtocolTest, AlpnTestUnset) {
  function TEST_F (line 615) | TEST_F(NextProtocolTest, AlpnTestNoOverlap) {
  function TEST_F (line 623) | TEST_F(NextProtocolTest, RandomizedAlpnTest) {
  function TEST_F (line 647) | TEST_F(NextProtocolTest, AlpnNotAllowMismatchNoClientProtocol) {
  function TEST_F (line 659) | TEST_F(NextProtocolTest, AlpnNotAllowMismatchWithOverlap) {
  function TEST_F (line 671) | TEST_F(NextProtocolTest, AlpnNotAllowMismatchWithoutOverlap) {
  function TEST (line 688) | TEST(AsyncSSLSocketTest, SNITestMatch) {
  function TEST (line 720) | TEST(AsyncSSLSocketTest, SNITestNotMatch) {
  function TEST (line 756) | TEST(AsyncSSLSocketTest, SNITestChangeServerName) {
  function TEST (line 788) | TEST(AsyncSSLSocketTest, SNITestClientHelloNoHostname) {
  function TEST (line 823) | TEST(AsyncSSLSocketTest, SetSupportedApplicationProtocols) {
  function TEST (line 864) | TEST(AsyncSSLSocketTest, SSLClientTest) {
  function TEST (line 890) | TEST(AsyncSSLSocketTest, SSLClientTestReuse) {
  function TEST (line 917) | TEST(AsyncSSLSocketTest, SSLClientTimeoutTest) {
  class PerLoopReadCallback (line 946) | class PerLoopReadCallback : public AsyncTransport::ReadCallback {
    method getReadBuffer (line 948) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
    method readDataAvailable (line 953) | void readDataAvailable(size_t len) noexcept override {
    method readErr (line 959) | void readErr(const AsyncSocketException&) noexcept override {}
    method readEOF (line 961) | void readEOF() noexcept override {}
    method setSocket (line 963) | void setSocket(AsyncSocket* s) { s_ = s; }
  class CloseNotifyConnector (line 970) | class CloseNotifyConnector : public AsyncSocket::ConnectCallback {
    method CloseNotifyConnector (line 972) | CloseNotifyConnector(EventBase* evb, const SocketAddress& addr) {
    method connectSuccess (line 978) | void connectSuccess() noexcept override {
    method connectErr (line 993) | void connectErr(const AsyncSocketException& ex) noexcept override {
  class ErrorCheckingWriteCallback (line 1004) | class ErrorCheckingWriteCallback : public AsyncSocket::WriteCallback {
    method writeSuccess (line 1006) | void writeSuccess() noexcept override {}
    method writeErr (line 1008) | void writeErr(size_t, const AsyncSocketException& ex) noexcept override {
  class WriteOnEofReadCallback (line 1016) | class WriteOnEofReadCallback : public ReadCallback {
    method readEOF (line 1020) | void readEOF() noexcept override {
    method readErr (line 1032) | void readErr(const AsyncSocketException& ex) noexcept override {
  function TEST (line 1040) | TEST(AsyncSSLSocketTest, EarlyCloseNotify) {
  function TEST (line 1055) | TEST(AsyncSSLSocketTest, SSLParseClientHelloSuccess) {
  function TEST (line 1112) | TEST(AsyncSSLSocketTest, SSLGetEKM) {
  function TEST (line 1150) | TEST(AsyncSSLSocketTest, SSLGetEKMFailsOnTLS10) {
  function TEST (line 1176) | TEST(AsyncSSLSocketTest, GetClientCertificate) {
  function TEST (line 1235) | TEST(AsyncSSLSocketTest, SSLParseClientHelloOnePacket) {
  function TEST (line 1277) | TEST(AsyncSSLSocketTest, SSLParseClientHelloTwoPackets) {
  function TEST (line 1336) | TEST(AsyncSSLSocketTest, SSLParseClientHelloMultiplePackets) {
  function TEST (line 1392) | TEST(AsyncSSLSocketTest, SSLHandshakeValidationSuccess) {
  function TEST (line 1430) | TEST(AsyncSSLSocketTest, SSLHandshakeValidationFailure) {
  function TEST (line 1468) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierReturns) {
  function TEST (line 1527) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierFailsToConnect) {
  function TEST (line 1583) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierContextFailure) {
  function TEST (line 1627) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierContextInspectsCh...
  function TEST (line 1695) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierNotInvokedX509Fai...
  function TEST (line 1734) | TEST(
  function TEST (line 1802) | TEST(AsyncSSLSocketTest, SSLCertificateIdentityVerifierSucceedsOnServer) {
  function TEST (line 1883) | TEST(AsyncSSLSocketTest, OverrideSSLCtxDisableVerify) {
  function TEST (line 1922) | TEST(AsyncSSLSocketTest, OverrideSSLCtxEnableVerify) {
  function TEST (line 1967) | TEST(AsyncSSLSocketTest, SSLHandshakeValidationOverride) {
  function TEST (line 2004) | TEST(AsyncSSLSocketTest, SSLHandshakeValidationSkip) {
  function TEST (line 2039) | TEST(AsyncSSLSocketTest, ClientCertHandshakeSuccess) {
  function TEST (line 2101) | TEST(AsyncSSLSocketTest, NoClientCertHandshakeError) {
  function makeNonBlockingPipe (line 2136) | static void makeNonBlockingPipe(int pipefds[2]) {
  function customRsaPrivEnc (line 2154) | static int customRsaPrivEnc(
  function rsaFree (line 2216) | void rsaFree(void*, void* ptr, CRYPTO_EX_DATA*, int, long, void*) {
  type RSAPointers (line 2232) | struct RSAPointers {
  function RSAPointersFree (line 2238) | inline void RSAPointersFree(RSAPointers* p) {
  function setupCustomRSA (line 2264) | std::unique_ptr<RSAPointers, RSAPointersDeleter> setupCustomRSA(
  function TEST (line 2316) | TEST(AsyncSSLSocketTest, OpenSSL110AsyncTest) {
  function TEST (line 2356) | TEST(AsyncSSLSocketTest, OpenSSL110AsyncTestFailure) {
  function TEST (line 2395) | TEST(AsyncSSLSocketTest, OpenSSL110AsyncTestClosedWithCallbackPending) {
  function TEST (line 2440) | TEST(AsyncSSLSocketTest, LoadCertFromMemory) {
  function TEST (line 2482) | TEST(AsyncSSLSocketTest, MinWriteSizeTest) {
  class ReadCallbackTerminator (line 2500) | class ReadCallbackTerminator : public ReadCallback {
    method ReadCallbackTerminator (line 2502) | ReadCallbackTerminator(EventBase* base, WriteCallbackBase* wcb)
    method readDataAvailable (line 2506) | void readDataAvailable(size_t len) noexcept override {
  function TEST (line 2526) | TEST(AsyncSSLSocketTest, UnencryptedTest) {
  function TEST (line 2579) | TEST(AsyncSSLSocketTest, ConnectUnencryptedTest) {
  function TEST (line 2617) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerBasic) {
  function TEST (line 2652) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerAcceptError) {
  function TEST (line 2686) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerAcceptClose) {
  function TEST (line 2720) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerAcceptDestroy) {
  function TEST (line 2754) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerFiber) {
  function TEST (line 2789) | TEST(AsyncSSLSocketTest, SSLClientHelloRetryCallback) {
  function newCloseCb (line 2853) | static int newCloseCb(SSL* ssl, SSL_SESSION*) {
  function SSL_SESSION (line 2861) | static SSL_SESSION* getCloseCb(SSL* ssl, const unsigned char*, int, int*) {
  function TEST (line 2866) | TEST(AsyncSSLSocketTest, SSLAcceptRunnerFiberCloseSessionCb) {
  function TEST (line 2907) | TEST(AsyncSSLSocketTest, ConnResetErrorString) {
  function TEST (line 2928) | TEST(AsyncSSLSocketTest, ConnEOFErrorString) {
  function TEST (line 2948) | TEST(AsyncSSLSocketTest, ConnOpenSSLErrorString) {
  function TEST (line 2978) | TEST(AsyncSSLSocketTest, TestSSLCipherCodeToNameMap) {
  function TEST (line 2992) | TEST(AsyncSSLSocketTest, TTLSDisabled) {
  class MockAsyncTFOSSLSocket (line 3031) | class MockAsyncTFOSSLSocket : public AsyncSSLSocket {
    method MockAsyncTFOSSLSocket (line 3035) | explicit MockAsyncTFOSSLSocket(
    type msghdr (line 3042) | struct msghdr
  function TEST (line 3049) | TEST(AsyncSSLSocketTest, TTLSDisabledWithTFO) {
  function TEST (line 3091) | TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFO) {
  function TEST (line 3127) | TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFOWithTFOServerDisabled) {
  class ConnCallback (line 3159) | class ConnCallback : public AsyncSocket::ConnectCallback {
    method connectSuccess (line 3161) | void connectSuccess() noexcept override { state = State::SUCCESS; }
    method connectErr (line 3163) | void connectErr(const AsyncSocketException& ex) noexcept override {
    type State (line 3168) | enum class State { WAITING, SUCCESS, ERROR }
  function setupSocketWithFallback (line 3175) | MockAsyncTFOSSLSocket::UniquePtr setupSocketWithFallback(
  function TEST (line 3195) | TEST(AsyncSSLSocketTest, ConnectWriteReadCloseTFOFallback) {
  function TEST (line 3236) | TEST(AsyncSSLSocketTest, ConnectTFOTimeout) {
  function TEST (line 3254) | TEST(AsyncSSLSocketTest, ConnectTFOFallbackTimeout) {
  function TEST (line 3271) | TEST(AsyncSSLSocketTest, HandshakeTFOFallbackTimeout) {
  function TEST (line 3290) | TEST(AsyncSSLSocketTest, HandshakeTFORefused) {
  function TEST (line 3305) | TEST(AsyncSSLSocketTest, TestPreReceivedData) {
  function TEST (line 3343) | TEST(AsyncSSLSocketTest, TestMoveFromAsyncSocket) {
  function TEST (line 3383) | TEST(AsyncSSLSocketTest, TestNullConnectCallbackError) {
  function TEST (line 3412) | TEST(AsyncSSLSocketTest, TestSSLSetClientOptionsP256) {
  function TEST (line 3446) | TEST(AsyncSSLSocketTest, TestSSLSetClientOptionsX25519) {
  function TEST (line 3484) | TEST(AsyncSSLSocketTest, SendMsgParamsCallback) {
  class AsyncSSLSocketByteEventTest (line 3518) | class AsyncSSLSocketByteEventTest : public ::testing::Test {
    class ClientConn (line 3530) | class ClientConn {
      method ClientConn (line 3532) | explicit ClientConn(
      method connect (line 3549) | void connect() {
      method waitForHandshake (line 3558) | void waitForHandshake() {
      method setReadCb (line 3564) | void setReadCb() {
      method attachObserver (line 3574) | std::shared_ptr<NiceMock<TestObserver>> attachObserver(
      method writeAndReflect (line 3588) | void writeAndReflect(
      method getRawSocket (line 3611) | std::shared_ptr<AsyncSSLSocket> getRawSocket() { return socket_; }
      method getSslContext (line 3613) | std::shared_ptr<SSLContext> getSslContext() {
      method EventBase (line 3618) | EventBase& getEventBase() {
      method netOpsExpectTimestampingSetSockOpt (line 3623) | void netOpsExpectTimestampingSetSockOpt() {
      method netOpsExpectNoTimestampingSetSockOpt (line 3632) | void netOpsExpectNoTimestampingSetSockOpt() {
      method netOpsExpectWriteWithFlags (line 3641) | void netOpsExpectWriteWithFlags(WriteFlags writeFlags) {
      method netOpsVerifyAndClearExpectations (line 3652) | void netOpsVerifyAndClearExpectations() {
      method initSslContext (line 3659) | static std::shared_ptr<SSLContext> initSslContext() {
    method ClientConn (line 3680) | ClientConn getClientConn() { return ClientConn(server_); }
      method ClientConn (line 3532) | explicit ClientConn(
      method connect (line 3549) | void connect() {
      method waitForHandshake (line 3558) | void waitForHandshake() {
      method setReadCb (line 3564) | void setReadCb() {
      method attachObserver (line 3574) | std::shared_ptr<NiceMock<TestObserver>> attachObserver(
      method writeAndReflect (line 3588) | void writeAndReflect(
      method getRawSocket (line 3611) | std::shared_ptr<AsyncSSLSocket> getRawSocket() { return socket_; }
      method getSslContext (line 3613) | std::shared_ptr<SSLContext> getSslContext() {
      method EventBase (line 3618) | EventBase& getEventBase() {
      method netOpsExpectTimestampingSetSockOpt (line 3623) | void netOpsExpectTimestampingSetSockOpt() {
      method netOpsExpectNoTimestampingSetSockOpt (line 3632) | void netOpsExpectNoTimestampingSetSockOpt() {
      method netOpsExpectWriteWithFlags (line 3641) | void netOpsExpectWriteWithFlags(WriteFlags writeFlags) {
      method netOpsVerifyAndClearExpectations (line 3652) | void netOpsVerifyAndClearExpectations() {
      method initSslContext (line 3659) | static std::shared_ptr<SSLContext> initSslContext() {
    method SetUp (line 3682) | void SetUp() override {
    method attachObserver (line 3696) | static std::shared_ptr<NiceMock<TestObserver>> attachObserver(
    method WriteFlags (line 3703) | static WriteFlags getMsgWriteFlags(const struct msghdr& msg) {
    method WriteFlags (line 3727) | static WriteFlags dropWriteFromFlags(WriteFlags writeFlags) {
  function TEST_F (line 3739) | TEST_F(AsyncSSLSocketByteEventTest, ObserverAttachedBeforeConnect) {
  function TEST_F (line 3804) | TEST_F(AsyncSSLSocketByteEventTest, ObserverAttachedAfterConnect) {
  function TEST_F (line 3904) | TEST_F(AsyncSSLSocketByteEventTest, MultiByteWrites) {
  function TEST_F (line 3973) | TEST_F(AsyncSSLSocketByteEventTest, MultiByteWritesEnableSecondWrite) {
  class SimpleSessionLifecycleCallback (line 4034) | class SimpleSessionLifecycleCallback
    method onNewSession (line 4037) | void onNewSession(SSL*, ssl::SSLSessionUniquePtr session) override {
  function TEST (line 4053) | TEST(AsyncSSLSocketTest, TestSNIClientHelloBehavior) {
  function TEST (line 4147) | TEST(AsyncSSLSocketTest, BytesWrittenWithMove) {
  type Initializer (line 4197) | struct Initializer {
    method Initializer (line 4198) | Initializer() { signal(SIGPIPE, SIG_IGN); }

FILE: folly/io/async/test/AsyncSSLSocketTest.h
  function namespace (line 48) | namespace folly::test {
  function connAccepted (line 617) | void connAccepted(
  function class (line 630) | class SSLServerAcceptCallbackDelay : public SSLServerAcceptCallback {
  function class (line 669) | class HandshakeErrorCallback : public SSLServerAcceptCallbackBase {
  function class (line 701) | class HandshakeTimeoutCallback : public SSLServerAcceptCallbackBase {
  function class (line 729) | class ConnectTimeoutCallback : public SSLServerAcceptCallbackBase {
  type iovec (line 774) | struct iovec
  function handshakeErr (line 781) | void handshakeErr(
  function writeSuccess (line 785) | void writeSuccess() noexcept override { socket_->close(); }
  function writeErr (line 786) | void writeErr(
  function checkBuffer (line 809) | void checkBuffer(struct iovec* iov, uint32_t count) const {
  function handshakeErr (line 841) | void handshakeErr(
  function getReadBuffer (line 845) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
  function readDataAvailable (line 849) | void readDataAvailable(size_t len) noexcept override {
  function readEOF (line 855) | void readEOF() noexcept override { socket_->close(); }
  function readErr (line 856) | void readErr(const AsyncSocketException& ex) noexcept override {
  function handshakeErr (line 883) | void handshakeErr(
  function writeSuccess (line 887) | void writeSuccess() noexcept override { socket_->close(); }
  function writeErr (line 888) | void writeErr(
  function handshakeErr (line 918) | void handshakeErr(
  function getReadBuffer (line 922) | void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
  function readDataAvailable (line 925) | void readDataAvailable(size_t /* len */) noexcept override {}
  function readEOF (line 926) | void readEOF() noexcept override { socket_->close(); }
  function readErr (line 927) | void readErr(const AsyncSocketException& ex) noexcept override {
  function handshakeSuc (line 945) | void handshakeSuc(AsyncSSLSocket* /* socket */) noexcept override {
  function handshakeErr (line 949) | void handshakeErr(
  function getReadBuffer (line 953) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
  function readDataAvailable (line 957) | void readDataAvailable(size_t /* len */) noexcept override {}
  function readEOF (line 958) | void readEOF() noexcept override {}
  function readErr (line 959) | void readErr(const AsyncSocketException& ex) noexcept override {
  function renegotiationError_ (line 971) | bool renegotiationError_{false};
  function handshakeErr (line 993) | void handshakeErr(
  function writeSuccess (line 997) | void writeSuccess() noexcept override { socket_->close(); }
  function writeErr (line 998) | void writeErr(
  function handshakeErr (line 1033) | void handshakeErr(
  function getReadBuffer (line 1037) | void getReadBuffer(void** /* bufReturn */, size_t* lenReturn) override {
  function readDataAvailable (line 1040) | void readDataAvailable(size_t /* len */) noexcept override {}
  function readEOF (line 1041) | void readEOF() noexcept override { socket_->close(); }
  function readErr (line 1042) | void readErr(const AsyncSocketException& ex) noexcept override {
  function setSSLOptions (line 1129) | void setSSLOptions(long options) { ctx_->setOptions(options); }
  function connectSuccess (line 1144) | void connectSuccess() noexcept override {
  function connectErr (line 1161) | void connectErr(const AsyncSocketException& ex) noexcept override {
  function writeSuccess (line 1167) | void writeSuccess() noexcept override {
  function writeErr (line 1171) | void writeErr(
  function getReadBuffer (line 1180) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
  function readEOF (line 1185) | void readEOF() noexcept override {
  function readErr (line 1189) | void readErr(const AsyncSocketException& ex) noexcept override {
  function readDataAvailable (line 1193) | void readDataAvailable(size_t len) noexcept override {
  function handshakeVerifyInvocations_ (line 1225) | int handshakeVerifyInvocations_{}
  function handshakeVer (line 1234) | bool handshakeVer(
  function handshakeSuc (line 1247) | void handshakeSuc(AsyncSSLSocket*) noexcept override {
  function handshakeErr (line 1255) | void handshakeErr(
  function writeSuccess (line 1265) | void writeSuccess() noexcept override {
  function writeErr (line 1271) | void writeErr(
  function class (line 1278) | class SSLHandshakeClient : public SSLHandshakeBase {
  function class (line 1287) | class SSLHandshakeClientNoVerify : public SSLHandshakeBase {
  function class (line 1299) | class SSLHandshakeClientDoVerify : public SSLHandshakeBase {
  function class (line 1311) | class SSLHandshakeServer : public SSLHandshakeBase {
  function class (line 1320) | class SSLHandshakeServerParseClientHello : public SSLHandshakeBase {
  function class (line 1341) | class SSLHandshakeServerNoVerify : public SSLHandshakeBase {
  function class (line 1353) | class SSLHandshakeServerDoVerify : public SSLHandshakeBase {
  function class (line 1365) | class EventBaseAborter : public AsyncTimeout {
  function class (line 1382) | class SSLAcceptEvbRunner : public SSLAcceptRunner {
  function class (line 1399) | class SSLAcceptErrorRunner : public SSLAcceptEvbRunner {
  function class (line 1412) | class SSLAcceptCloseRunner : public SSLAcceptEvbRunner {
  function class (line 1434) | class SSLAcceptDestroyRunner : public SSLAcceptEvbRunner {
  function class (line 1456) | class SSLAcceptFiberRunner : public SSLAcceptEvbRunner {

FILE: folly/io/async/test/AsyncSSLSocketTest2.cpp
  type EvbAndContext (line 34) | struct EvbAndContext {
    method EvbAndContext (line 35) | EvbAndContext() {
    method createSocket (line 41) | std::shared_ptr<AsyncSSLSocket> createSocket() {
    method EventBase (line 45) | EventBase* getEventBase() { return evb_.getEventBase(); }
    method attach (line 47) | void attach(AsyncSSLSocket& socket) {
  class AttachDetachClient (line 56) | class AttachDetachClient
    method detach (line 73) | void detach() {
    method AttachDetachClient (line 79) | explicit AttachDetachClient(const folly::SocketAddress& address)
    method getFuture (line 82) | Future<bool> getFuture() { return promise_.getFuture(); }
    method connect (line 84) | void connect() {
    method connectSuccess (line 104) | void connectSuccess() noexcept override {
    method connectErr (line 127) | void connectErr(const AsyncSocketException& ex) noexcept override {
    method writeSuccess (line 132) | void writeSuccess() noexcept override {
    method writeErr (line 136) | void writeErr(
    method getReadBuffer (line 142) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
    method readEOF (line 146) | void readEOF() noexcept override { cerr << "client readEOF" << endl; }
    method readErr (line 148) | void readErr(const AsyncSocketException& ex) noexcept override {
    method readDataAvailable (line 153) | void readDataAvailable(size_t len) noexcept override {
  function TEST (line 170) | TEST(AsyncSSLSocketTest2, AttachDetachSSLContext) {
  class ConnectClient (line 186) | class ConnectClient : public AsyncSocket::ConnectCallback {
    method ConnectClient (line 188) | ConnectClient() = default;
    method getFuture (line 190) | Future<bool> getFuture() { return promise_.getFuture(); }
    method connect (line 192) | void connect(const folly::SocketAddress& addr) {
    method connectSuccess (line 199) | void connectSuccess() noexcept override {
    method connectErr (line 204) | void connectErr(const AsyncSocketException& /* ex */) noexcept override {
    method setCtx (line 209) | void setCtx(std::shared_ptr<SSLContext> ctx) { t1_.ctx_ = ctx; }
  class NoopReadCallback (line 218) | class NoopReadCallback : public ReadCallbackBase {
    method NoopReadCallback (line 220) | NoopReadCallback() : ReadCallbackBase(nullptr) { state = STATE_SUCCEED...
    method getReadBuffer (line 222) | void getReadBuffer(void** buf, size_t* lenReturn) override {
    method readDataAvailable (line 226) | void readDataAvailable(size_t) noexcept override {}
  function TEST (line 231) | TEST(AsyncSSLSocketTest2, TestTLS12DefaultClient) {
  function TEST (line 249) | TEST(AsyncSSLSocketTest2, TestLegacyClientCannotConnectToTLS12Server) {
  function main (line 270) | int main(int argc, char* argv[]) {

FILE: folly/io/async/test/AsyncSSLSocketWriteTest.cpp
  type folly (line 29) | namespace folly {
    class MockAsyncSSLSocket (line 31) | class MockAsyncSSLSocket : public AsyncSSLSocket {
      method newSocket (line 33) | static std::shared_ptr<MockAsyncSSLSocket> newSocket(
      method MockAsyncSSLSocket (line 46) | MockAsyncSSLSocket(const std::shared_ptr<SSLContext>& ctx, EventBase...
      type msghdr (line 62) | struct msghdr
      method WriteResult (line 68) | WriteResult testPerformWrite(
      method getCurrBytesToFinalByte (line 87) | folly::Optional<size_t> getCurrBytesToFinalByte() const {
      type MySendMsgParamsCallback (line 91) | struct MySendMsgParamsCallback : public SendMsgParamsCallback {
        method getAncillaryDataSize (line 92) | uint32_t getAncillaryDataSize(
    class AsyncSSLSocketWriteTest (line 110) | class AsyncSSLSocketWriteTest : public testing::Test {
      method AsyncSSLSocketWriteTest (line 112) | AsyncSSLSocketWriteTest()
      method makeVec (line 122) | std::unique_ptr<iovec[]> makeVec(std::vector<uint32_t> sizes) {
      method verifyVec (line 135) | void verifyVec(const void* buf, int n, int pos) {
      method consumeVec (line 140) | void consumeVec(iovec* vec, uint32_t countWritten, uint32_t partialW...
    function TEST_F (line 152) | TEST_F(AsyncSSLSocketWriteTest, CompleteSSLWriteUpdatesAppBytesWritten) {
    function TEST_F (line 174) | TEST_F(AsyncSSLSocketWriteTest, NoSSLWriteUpdatesAppBytesWritten) {
    function TEST_F (line 199) | TEST_F(AsyncSSLSocketWriteTest, PartialSSLWriteUpdatesAppBytesWritten) {
    function TEST_F (line 222) | TEST_F(AsyncSSLSocketWriteTest, SslErrorWantWrite) {
    function TEST_F (line 282) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing1) {
    function TEST_F (line 310) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing2) {
    function TEST_F (line 350) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing3) {
    function TEST_F (line 372) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing4) {
    function TEST_F (line 424) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing5) {
    function TEST_F (line 463) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescing6) {
    function TEST_F (line 516) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescingWithEoRTracking1) {
    function TEST_F (line 564) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescingWithEoRTracking2) {
    function TEST_F (line 611) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescingWithEoRTracking3) {
    function TEST_F (line 670) | TEST_F(AsyncSSLSocketWriteTest, WriteCoalescingWithEoRTrackingErrorWan...

FILE: folly/io/async/test/AsyncSignalHandlerTestLib.h
  function class (line 25) | class TestSignalHandler : public AsyncSignalHandler {
  function TestSignalHandler (line 55) | TestSignalHandler handler{&evb};
  function TestSignalHandler (line 69) | TestSignalHandler handler{nullptr};

FILE: folly/io/async/test/AsyncSocketExceptionTest.cpp
  type folly (line 27) | namespace folly {
    function TEST (line 29) | TEST(AsyncSocketException, SimpleTest) {
    function TEST (line 56) | TEST(AsyncSocketException, SSLExceptionType) {

FILE: folly/io/async/test/AsyncSocketObserverTest.cpp
  function TEST (line 26) | TEST(AsyncSocketObserver, ConstructorCallback) {
  function TEST (line 45) | TEST(AsyncSocketObserver, AttachObserverThenDetachAndAttachEvb) {
  function TEST (line 81) | TEST(AsyncSocketObserver, AttachObserverThenConnectAndCloseSocket) {
  function TEST (line 107) | TEST(AsyncSocketObserver, AttachObserverThenConnectError) {
  function TEST (line 132) | TEST(AsyncSocketObserver, AttachMultipleObserversThenConnectAndCloseSock...
  function TEST (line 170) | TEST(AsyncSocketObserver, AttachThenRemoveObserver) {
  function TEST (line 192) | TEST(AsyncSocketObserver, AttachThenRemoveSharedPtrObserver) {
  function TEST (line 214) | TEST(AsyncSocketObserver, AttachThenRemoveMultipleObservers) {
  function TEST (line 243) | TEST(AsyncSocketObserver, AttachThenRemoveMultipleObserversReverse) {
  function TEST (line 272) | TEST(AsyncSocketObserver, RemoveMissingObserver) {
  function TEST (line 282) | TEST(AsyncSocketObserver, RemoveMissingSharedPtrObserver) {
  function TEST (line 292) | TEST(AsyncSocketObserver, AttachObserverThenRemoveThenConnect) {
  function TEST (line 316) | TEST(AsyncSocketObserver, AttachObserverThenConnectThenRemoveObserver) {
  function TEST (line 346) | TEST(AsyncSocketObserver, AttachObserverThenDestroySocket) {
  function TEST (line 363) | TEST(AsyncSocketObserver, AttachSharedPtrObserverThenDestroySocket) {
  function TEST (line 380) | TEST(
  function TEST (line 410) | TEST(AsyncSocketObserver, AttachObserverThenConnectThenDestroySocket) {
  function TEST (line 436) | TEST(
  function TEST (line 471) | TEST(
  function TEST (line 504) | TEST(AsyncSocketObserver, AttachObserverThenConnectAndDetachFd) {
  function TEST (line 538) | TEST(AsyncSocketObserver, AttachObserverThenConnectAndMoveSocket) {

FILE: folly/io/async/test/AsyncSocketTest.cpp
  function TEST (line 32) | TEST(AsyncSocketTest, getSockOpt) {
  function TEST (line 47) | TEST(AsyncSocketTest, REUSEPORT) {
  function TEST (line 72) | TEST(AsyncSocketTest, DisableReuseAddr) {
  function TEST (line 95) | TEST(AsyncSocketTest, EnableThenDisableReuseAddr) {
  function TEST (line 115) | TEST(AsyncSocketTest, IPFreebind) {
  function TEST (line 137) | TEST(AsyncSocketTest, v4v6samePort) {
  function TEST (line 149) | TEST(AsyncSocketTest, duplicateBind) {
  function TEST (line 162) | TEST(AsyncSocketTest, tosReflect) {
  function TEST (line 190) | TEST(AsyncSocketTest, listenerTosV6) {
  function TEST (line 216) | TEST(AsyncSocketTest, listenerTosV4) {

FILE: folly/io/async/test/AsyncSocketTest.h
  function namespace (line 30) | namespace folly::test {
  function writeErr (line 51) | void writeErr(
  function writeStarting (line 63) | void writeStarting() noexcept override { writeStartingInvocations++; }
  function releaseIOBuf (line 70) | void releaseIOBuf(std::unique_ptr<folly::IOBuf> ioBuf) noexcept override {
  function writeStartingInvocations (line 84) | size_t writeStartingInvocations{0}
  function releaseIOBufCallbackCalled (line 85) | bool releaseIOBufCallbackCalled{false};
  function class (line 88) | class ReadCallback : public folly::AsyncTransport::ReadCallback {
  function getReadBuffer (line 103) | void getReadBuffer(void** bufReturn, size_t* lenReturn) override {
  function readDataAvailable (line 111) | void readDataAvailable(size_t len) noexcept override {
  function isBufferMovable (line 121) | bool isBufferMovable() noexcept override { return true; }
  function readBufferAvailable (line 122) | void readBufferAvailable(std::unique_ptr<IOBuf> readBuf) noexcept overri...
  function readEOF (line 139) | void readEOF() noexcept override { state = STATE_SUCCEEDED; }
  function readErr (line 141) | void readErr(const folly::AsyncSocketException& ex) noexcept override {
  function verifyData (line 146) | void verifyData(const char* expected, size_t expectedLen) const {
  function verifyData (line 150) | void verifyData(const unsigned char* expected, size_t expectedLen) const {
  function clearData (line 162) | void clearData() {
  function class (line 239) | class TestEventBaseBackend : public folly::EventBaseBackendBase {
  function class (line 345) | class BufferCallback : public folly::AsyncTransport::BufferCallback {

FILE: folly/io/async/test/AsyncSocketTest2.cpp
  function WriteFlags (line 73) | WriteFlags msgFlagsToWriteFlags(const int msg_flags) {
  function WriteFlags (line 95) | WriteFlags getMsgAncillaryTsFlags(const struct msghdr& msg) {
  function WriteFlags (line 119) | WriteFlags getMsgAncillaryTsFlags(const struct msghdr* msg) {
  class DelayedWrite (line 177) | class DelayedWrite : public AsyncTimeout {
    method DelayedWrite (line 179) | DelayedWrite(
    method timeoutExpired (line 193) | void timeoutExpired() noexcept override {
  type BackendType (line 208) | enum class BackendType {
  type TFOState (line 213) | enum class TFOState {
  function getBackendTestingValues (line 218) | std::vector<BackendType> getBackendTestingValues() {
  function getBackendTFOTestingValues (line 226) | std::vector<ConnectTestParam> getBackendTFOTestingValues() {
  class AsyncSocketTest (line 242) | class AsyncSocketTest : public ::testing::TestWithParam<BackendType> {
    method SetUp (line 244) | void SetUp() override {
    method EventBase (line 263) | EventBase& getEventBase() { return *evb_; }
    method makeEventBase (line 265) | std::unique_ptr<EventBase> makeEventBase() {
  function TEST_P (line 296) | TEST_P(AsyncSocketTest, ConstructWithFd) {
  function TEST_P (line 325) | TEST_P(AsyncSocketTest, ConstructWithFdAndTimestamp) {
  function TEST_P (line 358) | TEST_P(AsyncSocketTest, ConstructWithFdThenMove) {
  function TEST_P (line 399) | TEST_P(AsyncSocketTest, ConstructWithFdAndTimestampThenMove) {
  class AsyncSocketConnectTFOTest (line 447) | class AsyncSocketConnectTFOTest
    method SetUp (line 450) | void SetUp() override {
    method EventBase (line 469) | EventBase& getEventBase() { return *evb_; }
    method BackendType (line 471) | BackendType getBackendType() const { return std::get<0>(GetParam()); }
    method TFOState (line 472) | TFOState getTFOState() const { return std::get<1>(GetParam()); }
  function TEST_P (line 495) | TEST_P(AsyncSocketTest, Connect) {
  function TEST_P (line 529) | TEST_P(AsyncSocketTest, ConnectWithBoundFd) {
  function TEST_P (line 578) | TEST_P(AsyncSocketTest, ConnectWithUnboundFd) {
  function TEST_P (line 602) | TEST_P(AsyncSocketTest, ConnectWithAlreadyConnectedFd) {
  function TEST_P (line 636) | TEST_P(AsyncSocketTest, ConnectThenMove) {
  function TEST_P (line 684) | TEST_P(AsyncSocketTest, ConnectRefused) {
  function TEST_P (line 718) | TEST_P(AsyncSocketTest, ConnectTimeout) {
  class AsyncSocketToSTest (line 771) | class AsyncSocketToSTest : public ::testing::TestWithParam<BackendType> {
    method SetUp (line 777) | void SetUp() override {
    method setupDefaultReturn (line 804) | void setupDefaultReturn() {
    method expectNoCallsToTOS (line 810) | void expectNoCallsToTOS() {
  function TEST_P (line 836) | TEST_P(AsyncSocketToSTest, SetTosOrTrafficClassBeforeConnect) {
  function TEST_P (line 847) | TEST_P(AsyncSocketToSTest, SetTosOrTrafficClassAfterConnect) {
  function TEST_P (line 859) | TEST_P(AsyncSocketToSTest, SetTosOrTrafficClassIPV4) {
  function TEST_P (line 870) | TEST_P(AsyncSocketToSTest, SetTosOrTrafficClassError) {
  function TEST_P (line 887) | TEST_P(AsyncSocketConnectTFOTest, ConnectAndWrite) {
  function TEST_P (line 929) | TEST_P(AsyncSocketConnectTFOTest, ConnectNullCallback) {
  function TEST_P (line 966) | TEST_P(AsyncSocketConnectTFOTest, ConnectWriteAndClose) {
  function TEST_P (line 1003) | TEST_P(AsyncSocketTest, ConnectAndClose) {
  function TEST_P (line 1037) | TEST_P(AsyncSocketTest, ConnectAndCloseNow) {
  function TEST_P (line 1072) | TEST_P(AsyncSocketTest, ConnectWriteAndCloseNow) {
  function TEST_P (line 1111) | TEST_P(AsyncSocketConnectTFOTest, ConnectAndRead) {
  function TEST_P (line 1153) | TEST_P(AsyncSocketConnectTFOTest, ConnectAndReadZC) {
  function TEST_P (line 1209) | TEST_P(AsyncSocketConnectTFOTest, ConnectAndReadv) {
  function TEST_P (line 1253) | TEST_P(AsyncSocketConnectTFOTest, ConnectAndZeroCopyRead) {
  function TEST_P (line 1319) | TEST_P(AsyncSocketTest, ConnectReadAndClose) {
  function TEST_P (line 1357) | TEST_P(AsyncSocketConnectTFOTest, ConnectWriteAndRead) {
  function TEST_P (line 1421) | TEST_P(AsyncSocketTest, ConnectWriteAndShutdownWrite) {
  function TEST_P (line 1509) | TEST_P(AsyncSocketTest, ConnectReadWriteAndShutdownWrite) {
  function TEST_P (line 1597) | TEST_P(AsyncSocketTest, ConnectReadWriteAndShutdownWriteNow) {
  function tmpDisableReads (line 1686) | void tmpDisableReads(AsyncSocket* socket, ReadCallback* rcb) {
  function testConnectOptWrite (line 1700) | void testConnectOptWrite(size_t size1, size_t size2, bool close = false) {
  function TEST (line 1794) | TEST(AsyncSocketTest, ConnectCallbackWrite) {
  function TEST_P (line 1832) | TEST_P(AsyncSocketTest, WriteNullCallback) {
  function TEST_P (line 1859) | TEST_P(AsyncSocketTest, WriteTimeout) {
  function TEST_P (line 1917) | TEST_P(AsyncSocketTest, GetAddressesNoFd) {
  function TEST_P (line 1937) | TEST_P(AsyncSocketTest, GetAddressesAfterConnectGetwhileopenandonclose) {
  function TEST_P (line 1993) | TEST_P(AsyncSocketTest, GetAddressesAfterConnectGetonlyafterclose) {
  function TEST_P (line 2030) | TEST_P(AsyncSocketTest, GetAddressesAfterInitFromFdGetoninitandonclose) {
  function TEST_P (line 2087) | TEST_P(AsyncSocketTest, WritePipeError) {
  function TEST_P (line 2135) | TEST_P(AsyncSocketTest, WriteAfterReadEOF) {
  function TEST_P (line 2173) | TEST_P(AsyncSocketTest, WriteErrorCallbackBytesWritten) {
  function TEST_P (line 2255) | TEST_P(AsyncSocketTest, WriteIOBuf) {
  function TEST_P (line 2343) | TEST_P(AsyncSocketTest, WriteIOBufCorked) {
  function TEST_P (line 2407) | TEST_P(AsyncSocketTest, ZeroLengthWrite) {
  function TEST_P (line 2448) | TEST_P(AsyncSocketTest, ZeroLengthWritev) {
  function TEST_P (line 2497) | TEST_P(AsyncSocketTest, ClosePendingWritesWhileClosing) {
  class AsyncSocketImmediateRead (line 2554) | class AsyncSocketImmediateRead : public folly::AsyncSocket {
    method AsyncSocketImmediateRead (line 2557) | explicit AsyncSocketImmediateRead(folly::EventBase* evb) : AsyncSocket...
    method checkForImmediateRead (line 2560) | void checkForImmediateRead() noexcept override {
  function TEST (line 2566) | TEST(AsyncSocket, ConnectReadImmediateRead) {
  function TEST (line 2612) | TEST(AsyncSocket, ConnectReadUninstallRead) {
  function TEST_P (line 2685) | TEST_P(AsyncSocketTest, ServerAcceptOptions) {
  function TEST (line 2743) | TEST(AsyncSocketTest, NapiDispatch) {
  function TEST_P (line 2876) | TEST_P(AsyncSocketTest, RemoveAcceptCallback) {
  function TEST_P (line 3019) | TEST_P(AsyncSocketTest, OtherThreadAcceptCallback) {
  function serverSocketSanityTest (line 3072) | void serverSocketSanityTest(
  function TEST_P (line 3119) | TEST_P(AsyncSocketTest, DestroyCloseTest) {
  function TEST_P (line 3160) | TEST_P(AsyncSocketTest, ServerExistingSocket) {
  function TEST_P (line 3253) | TEST_P(AsyncSocketTest, UnixDomainSocketTest) {
  function TEST (line 3304) | TEST(AsyncSocketTest, VsockSocketLocal) {
  function TEST (line 3328) | TEST(AsyncSocketTest, VsockSocketAny) {
  function TEST (line 3356) | TEST(AsyncSocketTest, VsockSocketPortAny) {
  function TEST_P (line 3383) | TEST_P(AsyncSocketTest, ConnectionEventCallbackDefault) {
  function TEST_P (line 3426) | TEST_P(AsyncSocketTest, CallbackInPrimaryEventBase) {
  function TEST_P (line 3479) | TEST_P(AsyncSocketTest, CallbackInSecondaryEventBase) {
  function TEST_P (line 3536) | TEST_P(AsyncSocketTest, NumPendingMessagesInQueue) {
  function TEST_P (line 3585) | TEST_P(AsyncSocketTest, BufferTest) {
  function TEST_P (line 3618) | TEST_P(AsyncSocketTest, BufferTestChain) {
  function TEST_P (line 3662) | TEST_P(AsyncSocketTest, BufferCallbackKill) {
  function TEST_P (line 3698) | TEST_P(AsyncSocketTest, BufferCallbackKillWithIOBuf) {
  function TEST_P (line 3731) | TEST_P(AsyncSocketTest, ConnectTFO) {
  function TEST_P (line 3785) | TEST_P(AsyncSocketTest, ConnectTFOSupplyEarlyReadCB) {
  function TEST_P (line 3842) | TEST_P(AsyncSocketTest, ConnectRefusedImmediatelyTFO) {
  function TEST_P (line 3881) | TEST_P(AsyncSocketTest, ConnectWriteAndCloseNowTFO) {
  function TEST_P (line 3911) | TEST_P(AsyncSocketTest, ConnectAndCloseTFO) {
  class MockAsyncTFOSocket (line 3934) | class MockAsyncTFOSocket : public AsyncSocket {
    method MockAsyncTFOSocket (line 3938) | explicit MockAsyncTFOSocket(EventBase* evb) : AsyncSocket(evb) {}
    type msghdr (line 3943) | struct msghdr
  function TEST_P (line 3946) | TEST_P(AsyncSocketTest, TestTFOUnsupported) {
  function TEST_P (line 3995) | TEST_P(AsyncSocketTest, ConnectRefusedDelayedTFO) {
  function TEST_P (line 4040) | TEST_P(AsyncSocketTest, TestTFOUnsupportedTimeout) {
  function TEST_P (line 4077) | TEST_P(AsyncSocketTest, TestTFOFallbackToConnect) {
  function TEST_P (line 4130) | TEST_P(AsyncSocketTest, TestTFOFallbackTimeout) {
  function TEST_P (line 4171) | TEST_P(AsyncSocketTest, TestTFOEagain) {
  function TEST_P (line 4195) | TEST_P(AsyncSocketTest, ConnectTFOWithBigData) {
  class MockEvbChangeCallback (line 4253) | class MockEvbChangeCallback : public AsyncSocket::EvbChangeCallback {
  function TEST_P (line 4259) | TEST_P(AsyncSocketTest, EvbCallbacks) {
  function TEST_P (line 4273) | TEST_P(AsyncSocketTest, TestEvbDetachWtRegisteredIOHandlers) {
  function TEST_P (line 4306) | TEST_P(AsyncSocketTest, TestEvbDetachThenClose) {
  function TEST_P (line 4341) | TEST_P(AsyncSocketTest, BytesWrittenWithMove) {
  type AsyncSocketErrMessageCallbackTestParams (line 4365) | struct AsyncSocketErrMessageCallbackTestParams {
  class AsyncSocketErrMessageCallbackTest (line 4373) | class AsyncSocketErrMessageCallbackTest
    method getTestingValues (line 4376) | static std::vector<AsyncSocketErrMessageCallbackTestParams>
  class TestErrMessageCallback (line 4454) | class TestErrMessageCallback : public folly::AsyncSocket::ErrMessageCall...
    method TestErrMessageCallback (line 4456) | TestErrMessageCallback()
    method errMessage (line 4459) | void errMessage(const cmsghdr& cmsg) noexcept override {
    method errMessageError (line 4473) | void errMessageError(
    method checkResetCallback (line 4478) | void checkResetCallback() noexcept {
    method checkCloseSocket (line 4485) | void checkCloseSocket() noexcept {
  function TEST_P (line 4500) | TEST_P(AsyncSocketErrMessageCallbackTest, ErrMessageCallback) {
  function TEST (line 4584) | TEST(
  class AsyncSocketByteEventTest (line 4607) | class AsyncSocketByteEventTest : public ::testing::Test {
    class ClientConn (line 4618) | class ClientConn {
      type SendmsgInvocation (line 4623) | struct SendmsgInvocation {
      method ClientConn (line 4634) | explicit ClientConn(
      method connect (line 4650) | void connect() {
      method setReadCb (line 4662) | void setReadCb() {
      method setMockTcpInfoDispatcher (line 4671) | void setMockTcpInfoDispatcher(
      method attachObserver (line 4676) | std::shared_ptr<NiceMock<TestObserver>> attachObserver(
      method writeAtClientReadAtServer (line 4687) | void writeAtClientReadAtServer(
      method writeAtClientReadAtServer (line 4717) | void writeAtClientReadAtServer(
      method writeAtClientReadAtServerReflectReadAtClient (line 4731) | void writeAtClientReadAtServerReflectReadAtClient(
      method writeAtServerReadAtClient (line 4748) | void writeAtServerReadAtClient(const iovec* iov, const size_t count) {
      method writeAtClientReadAtServerReflectReadAtClient (line 4764) | void writeAtClientReadAtServerReflectReadAtClient(
      method writeAtClientDirectlyToNetworkSocket (line 4775) | void writeAtClientDirectlyToNetworkSocket(
      method getRawSocket (line 4795) | std::shared_ptr<AsyncSocket> getRawSocket() { return socket_; }
      method getAcceptedSocket (line 4797) | std::shared_ptr<BlockingSocket> getAcceptedSocket() {
      method EventBase (line 4801) | EventBase& getEventBase() {
      method getNetOpsDispatcher (line 4806) | std::shared_ptr<MockDispatcher> getNetOpsDispatcher() const {
      method getErrorQueueReads (line 4820) | int getErrorQueueReads() { return errorQueueReads_; }
      method netOpsExpectTimestampingSetSockOpt (line 4825) | void netOpsExpectTimestampingSetSockOpt() {
      method netOpsExpectNoTimestampingSetSockOpt (line 4837) | void netOpsExpectNoTimestampingSetSockOpt() {
      method netOpsExpectSendmsgWithAncillaryTsFlags (line 4848) | void netOpsExpectSendmsgWithAncillaryTsFlags(WriteFlags writeFlags) {
      method netOpsOnSendmsgRecordIovecsAndFlagsAndFwd (line 4863) | void netOpsOnSendmsgRecordIovecsAndFlagsAndFwd() {
      method netOpsOnRecvmsg (line 4880) | void netOpsOnRecvmsg() {
      method netOpsVerifyAndClearExpectations (line 4892) | void netOpsVerifyAndClearExpectations() {
      method recordSendmsgInvocation (line 4897) | void recordSendmsgInvocation(
      method recordRecvmsgInvocation (line 4906) | void recordRecvmsgInvocation(
    method ClientConn (line 4939) | ClientConn getClientConn() { return ClientConn(server_); }
      type SendmsgInvocation (line 4623) | struct SendmsgInvocation {
      method ClientConn (line 4634) | explicit ClientConn(
      method connect (line 4650) | void connect() {
      method setReadCb (line 4662) | void setReadCb() {
      method setMockTcpInfoDispatcher (line 4671) | void setMockTcpInfoDispatcher(
      method attachObserver (line 4676) | std::shared_ptr<NiceMock<TestObserver>> attachObserver(
      method writeAtClientReadAtServer (line 4687) | void writeAtClientReadAtServer(
      method writeAtClientReadAtServer (line 4717) | void writeAtClientReadAtServer(
      method writeAtClientReadAtServerReflectReadAtClient (line 4731) | void writeAtClientReadAtServerReflectReadAtClient(
      method writeAtServerReadAtClient (line 4748) | void writeAtServerReadAtClient(const iovec* iov, const size_t count) {
      method writeAtClientReadAtServerReflectReadAtClient (line 4764) | void writeAtClientReadAtServerReflectReadAtClient(
      method writeAtClientDirectlyToNetworkSocket (line 4775) | void writeAtClientDirectlyToNetworkSocket(
      method getRawSocket (line 4795) | std::shared_ptr<AsyncSocket> getRawSocket() { return socket_; }
      method getAcceptedSocket (line 4797) | std::shared_ptr<BlockingSocket> getAcceptedSocket() {
      method EventBase (line 4801) | EventBase& getEventBase() {
      method getNetOpsDispatcher (line 4806) | std::shared_ptr<MockDispatcher> getNetOpsDispatcher() const {
      method getErrorQueueReads (line 4820) | int getErrorQueueReads() { return errorQueueReads_; }
      method netOpsExpectTimestampingSetSockOpt (line 4825) | void netOpsExpectTimestampingSetSockOpt() {
      method netOpsExpectNoTimestampingSetSockOpt (line 4837) | void netOpsExpectNoTimestampingSetSockOpt() {
      method netOpsExpectSendmsgWithAncillaryTsFlags (line 4848) | void netOpsExpectSendmsgWithAncillaryTsFlags(WriteFlags writeFlags) {
      method netOpsOnSendmsgRecordIovecsAndFlagsAndFwd (line 4863) | void netOpsOnSendmsgRecordIovecsAndFlagsAndFwd() {
      method netOpsOnRecvmsg (line 4880) | void netOpsOnRecvmsg() {
      method netOpsVerifyAndClearExpectations (line 4892) | void netOpsVerifyAndClearExpectations() {
      method recordSendmsgInvocation (line 4897) | void recordSendmsgInvocation(
      method recordRecvmsgInvocation (line 4906) | void recordRecvmsgInvocation(
    method attachObserver (line 4945) | static std::shared_ptr<NiceMock<TestObserver>> attachObserver(
    method getHundredBytesOfData (line 4953) | static std::vector<uint8_t> getHundredBytesOfData() {
    method get10KBOfData (line 4958) | static std::vector<uint8_t> get10KBOfData() {
    method get1000KBOfData (line 4971) | static std::vector<uint8_t> get1000KBOfData() {
    method WriteFlags (line 4984) | static WriteFlags dropWriteFromFlags(WriteFlags writeFlags) {
    method getMsgIovecs (line 4988) | static std::vector<iovec> getMsgIovecs(const struct msghdr& msg) {
    method getMsgIovecs (line 4996) | static std::vector<iovec> getMsgIovecs(const struct msghdr* msg) {
    method iovsToVector (line 5000) | static std::vector<uint8_t> iovsToVector(
    method iovsToNumBytes (line 5013) | static size_t iovsToNumBytes(const iovec* iov, const size_t count) {
    method filterToWriteEvents (line 5021) | std::vector<AsyncSocket::ByteEvent> filterToWriteEvents(
  function TEST_F (line 5038) | TEST_F(AsyncSocketByteEventTest, MsgFlagsToWriteFlags) {
  function TEST_F (line 5058) | TEST_F(AsyncSocketByteEventTest, GetMsgAncillaryTsFlags) {
  function TEST_F (line 5115) | TEST_F(AsyncSocketByteEventTest, ObserverAttachedBeforeConnect) {
  function TEST_F (line 5149) | TEST_F(AsyncSocketByteEventTest, ObserverAttachedAfterConnect) {
  function TEST_F (line 5186) | TEST_F(
  function TEST_F (line 5232) | TEST_F(
  function TEST_F (line 5279) | TEST_F(AsyncSocketByteEventTest, ObserverAttachedAfterWrite) {
  function TEST_F (line 5312) | TEST_F(AsyncSocketByteEventTest, ObserverAttachedAfterClose) {
  function TEST_F (line 5324) | TEST_F(AsyncSocketByteEventTest, MultipleObserverAttached) {
  function TEST_F (line 5370) | TEST_F(AsyncSocketByteEventTest, KernelOffsetWrap) {
  function TEST_F (line 5443) | TEST_F(AsyncSocketByteEventTest, ErrMessageCallbackStillTriggered) {
  function TEST_F (line 5493) | TEST_F(AsyncSocketByteEventTest, FailUnixSocket) {
  function TEST_F (line 5543) | TEST_F(AsyncSocketByteEventTest, FailTimestampsAlreadyEnabled) {
  function TEST_F (line 5578) | TEST_F(AsyncSocketByteEventTest, MoveByteEventsEnabled) {
  function TEST_F (line 5647) | TEST_F(AsyncSocketByteEventTest, WriteThenDetachThenEnableByteEvents) {
  function TEST_F (line 5699) | TEST_F(AsyncSocketByteEventTest, WriteThenDetachThenDoNotEnableByteEvent...
  function TEST_F (line 5744) | TEST_F(AsyncSocketByteEventTest, WriteThenMoveByteEventsEnabled) {
  function TEST_F (line 5835) | TEST_F(AsyncSocketByteEventTest, MoveThenEnableByteEvents) {
  function TEST_F (line 5904) | TEST_F(AsyncSocketByteEventTest, WriteThenMoveThenEnableByteEvents) {
  function TEST_F (line 5979) | TEST_F(AsyncSocketByteEventTest, NoObserverMoveThenEnableByteEvents) {
  function TEST_F (line 6050) | TEST_F(AsyncSocketByteEventTest, CheckByteEventDetails) {
  function TEST_F (line 6123) | TEST_F(
  function TEST_F (line 6320) | TEST_F(AsyncSocketByteEventTest, SplitIoVecArraySingleIoVec) {
  function TEST_F (line 6383) | TEST_F(AsyncSocketByteEventTest, SplitIoVecArrayMultiIoVecInvalid) {
  function TEST_F (line 6408) | TEST_F(AsyncSocketByteEventTest, SplitIoVecArrayMultiIoVec) {
  function TEST_F (line 6796) | TEST_F(AsyncSocketByteEventTest, SendmsgMatchers) {
  function TEST_F (line 7041) | TEST_F(AsyncSocketByteEventTest, SendmsgInvocMsgFlagsEq) {
  function TEST_F (line 7062) | TEST_F(AsyncSocketByteEventTest, SendmsgInvocAncillaryFlagsEq) {
  function TEST_F (line 7088) | TEST_F(AsyncSocketByteEventTest, ByteEventMatching) {
  function TEST_F (line 7118) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserver) {
  function TEST_F (line 7188) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverCorkIfSplitMiddle) {
  function TEST_F (line 7240) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverNoCorkIfSplitAtEn...
  function TEST_F (line 7287) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverNoSplitFlagsIfNoS...
  function TEST_F (line 7325) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverFlagsOnAll) {
  function TEST_F (line 7411) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverFlagsOnWrite) {
  function TEST_F (line 7473) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverInvalidOffset) {
  function TEST_F (line 7507) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverTwoIovec) {
  function TEST_F (line 7589) | TEST_F(AsyncSocketByteEventTest, PrewriteSingleObserverManyIovec) {
  function TEST_F (line 7670) | TEST_F(AsyncSocketByteEventTest, PrewriteMultipleObservers) {
  function TEST_F (line 7821) | TEST_F(AsyncSocketByteEventTest, PrewriteTimestampedByteEvents) {
  function TEST_F (line 7903) | TEST_F(AsyncSocketByteEventTest, PrewriteRawBytesWrittenAndTriedToWrite) {
  function TEST_F (line 8142) | TEST_F(AsyncSocketByteEventTest, GetTcpInfo_SocketStates) {
  function TEST_F (line 8168) | TEST_F(
  function TEST_F (line 8219) | TEST_F(
  function TEST_F (line 8276) | TEST_F(
  function TEST_F (line 8333) | TEST_F(
  function TEST_F (line 8413) | TEST_F(
  function TEST_F (line 8486) | TEST_F(AsyncSocketByteEventTest, EnableByteEventsThrowsWithIoUringBacken...
  class AsyncSocketByteEventRawOffsetTest (line 8512) | class AsyncSocketByteEventRawOffsetTest
    method getTestingValues (line 8525) | static std::vector<size_t> getTestingValues() {
  function TEST_P (line 8557) | TEST_P(AsyncSocketByteEventRawOffsetTest, EnableByteEvents_CheckRawByteO...
  type AsyncSocketByteEventDetailsTestParams (line 8658) | struct AsyncSocketByteEventDetailsTestParams {
    type WriteParams (line 8659) | struct WriteParams {
      method WriteParams (line 8660) | WriteParams(uint64_t bufferSize, WriteFlags writeFlags)
  class AsyncSocketByteEventDetailsTest (line 8669) | class AsyncSocketByteEventDetailsTest
    method getTestingValues (line 8674) | static std::vector<AsyncSocketByteEventDetailsTestParams> getTestingVa...
  function TEST_P (line 8743) | TEST_P(AsyncSocketByteEventDetailsTest, CheckByteEventDetails) {
  class AsyncSocketByteEventHelperTest (line 8847) | class AsyncSocketByteEventHelperTest : public ::testing::Test {
    class WrappedCMsg (line 8854) | class WrappedCMsg {
      method WrappedCMsg (line 8856) | explicit WrappedCMsg(std::vector<char>&& data) : data_(std::move(dat...
      type cmsghdr (line 8858) | struct cmsghdr
      type cmsghdr (line 8859) | struct cmsghdr
    class WrappedSockExtendedErrTsCMsg (line 8869) | class WrappedSockExtendedErrTsCMsg : public WrappedCMsg {
      method setSoftwareTimestamp (line 8877) | void setSoftwareTimestamp(
      method setHardwareTimestamp (line 8887) | void setHardwareTimestamp(
    method cmsgData (line 8898) | static std::vector<char> cmsgData(int level, int type, size_t len) {
    method WrappedSockExtendedErrTsCMsg (line 8907) | static WrappedSockExtendedErrTsCMsg cmsgForSockExtendedErrTimestamping...
      method setSoftwareTimestamp (line 8877) | void setSoftwareTimestamp(
      method setHardwareTimestamp (line 8887) | void setHardwareTimestamp(
    method WrappedCMsg (line 8912) | static WrappedCMsg cmsgForScmTimestamping(
      method WrappedCMsg (line 8856) | explicit WrappedCMsg(std::vector<char>&& data) : data_(std::move(dat...
      type cmsghdr (line 8858) | struct cmsghdr
      type cmsghdr (line 8859) | struct cmsghdr
  function TEST_F (line 8926) | TEST_F(AsyncSocketByteEventHelperTest, ByteOffsetThenTs) {
  function TEST_F (line 8941) | TEST_F(AsyncSocketByteEventHelperTest, TsThenByteOffset) {
  function TEST_F (line 8956) | TEST_F(AsyncSocketByteEventHelperTest, ByteEventsDisabled) {
  function TEST_F (line 8977) | TEST_F(AsyncSocketByteEventHelperTest, IgnoreUnsupportedEvent) {
  function TEST_F (line 9000) | TEST_F(AsyncSocketByteEventHelperTest, ErrorDoubleScmCmsg) {
  function TEST_F (line 9012) | TEST_F(AsyncSocketByteEventHelperTest, ErrorDoubleSerrCmsg) {
  function TEST_F (line 9027) | TEST_F(AsyncSocketByteEventHelperTest, ErrorExceptionSet) {
  type AsyncSocketByteEventHelperTimestampTestParams (line 9050) | struct AsyncSocketByteEventHelperTimestampTestParams {
    method AsyncSocketByteEventHelperTimestampTestParams (line 9051) | AsyncSocketByteEventHelperTimestampTestParams(
  class AsyncSocketByteEventHelperTimestampTest (line 9066) | class AsyncSocketByteEventHelperTimestampTest
    method getTestingValues (line 9071) | static std::vector<AsyncSocketByteEventHelperTimestampTestParams>
  function TEST_P (line 9118) | TEST_P(AsyncSocketByteEventHelperTimestampTest, CheckEventTimestamps) {
  type AsyncSocketByteEventHelperOffsetTestParams (line 9157) | struct AsyncSocketByteEventHelperOffsetTestParams {
  class AsyncSocketByteEventHelperOffsetTest (line 9163) | class AsyncSocketByteEventHelperOffsetTest
    method getTestingValues (line 9168) | static std::vector<AsyncSocketByteEventHelperOffsetTestParams>
  function TEST_P (line 9390) | TEST_P(AsyncSocketByteEventHelperOffsetTest, CheckCalculatedOffset) {
  function TEST (line 9434) | TEST(AsyncSocket, LifecycleCtorCallback) {
  function TEST_P (line 9459) | TEST_P(AsyncSocketTest, LifecycleObserverDetachAndAttachEvb) {
  function TEST_P (line 9497) | TEST_P(AsyncSocketTest, LifecycleObserverAttachThenDestroySocket) {
  function TEST_P (line 9522) | TEST_P(AsyncSocketTest, LifecycleObserverAttachThenConnectError) {
  function TEST_P (line 9549) | TEST_P(AsyncSocketTest, LifecycleObserverMultipleAttachThenDestroySocket) {
  function TEST_P (line 9591) | TEST_P(AsyncSocketTest, LifecycleObserverAttachRemove) {
  function TEST_P (line 9607) | TEST_P(AsyncSocketTest, LifecycleObserverAttachRemoveMultiple) {
  function TEST_P (line 9636) | TEST_P(AsyncSocketTest, LifecycleObserverAttachRemoveMultipleReverse) {
  function TEST_P (line 9665) | TEST_P(AsyncSocketTest, LifecycleObserverRemoveMissing) {
  function TEST_P (line 9672) | TEST_P(AsyncSocketTest, LifecycleObserverMultipleAttachThenRemove) {
  function TEST_P (line 9706) | TEST_P(AsyncSocketTest, LifecycleObserverDetach) {
  function TEST_P (line 9739) | TEST_P(AsyncSocketTest, LifecycleObserverMoveResubscribe) {
  function TEST_P (line 9787) | TEST_P(AsyncSocketTest, LifecycleObserverMoveDoNotResubscribe) {
  function TEST_P (line 9820) | TEST_P(AsyncSocketTest, LifecycleObserverDetachCallbackImmediately) {
  function TEST_P (line 9841) | TEST_P(AsyncSocketTest, LifecycleObserverDetachCallbackAfterConnect) {
  function TEST_P (line 9863) | TEST_P(AsyncSocketTest, LifecycleObserverDetachCallbackAfterClose) {
  function TEST_P (line 9889) | TEST_P(AsyncSocketTest, LifecycleObserverDetachCallbackcloseDuringDestro...
  function TEST_P (line 9916) | TEST_P(AsyncSocketTest, PreReceivedData) {
  function TEST_P (line 9950) | TEST_P(AsyncSocketTest, PreReceivedDataOnly) {
  function TEST_P (line 9981) | TEST_P(AsyncSocketTest, PreReceivedDataPartial) {
  function TEST_P (line 10016) | TEST_P(AsyncSocketTest, PreReceivedDataTakeover) {
  function TEST (line 10060) | TEST(AsyncSocketTest, SendMessageFlags) {
  function TEST (line 10114) | TEST(AsyncSocketTest, SendMessageAncillaryData) {
  type FailableSocket (line 10229) | struct FailableSocket : public AsyncSocket {
    method FailableSocket (line 10230) | FailableSocket(EventBase* evb, NetworkSocket fd) : AsyncSocket(evb, fd...
    method testFailRead (line 10231) | void testFailRead() {
  class TruncateAncillaryDataAndCallFn (line 10238) | class TruncateAncillaryDataAndCallFn
    method TruncateAncillaryDataAndCallFn (line 10241) | explicit TruncateAncillaryDataAndCallFn(VoidCallback cob)
    method ancillaryData (line 10244) | folly::Expected<folly::Unit, AsyncSocketException> ancillaryData(
    method getAncillaryDataCtrlBuffer (line 10251) | folly::MutableByteRange getAncillaryDataCtrlBuffer() override {
  function testTruncateAncillaryDataAndCall (line 10264) | std::string testTruncateAncillaryDataAndCall(
  function TEST (line 10318) | TEST(AsyncSocketTest, ReceiveTruncatedAncillaryDataAndFail) {
  function TEST (line 10326) | TEST(AsyncSocketTest, ReceiveTruncatedAncillaryDataAndClose) {
  function TEST (line 10334) | TEST(AsyncSocketTest, ReceiveTruncatedAncillaryDataUnhandled) {
  function TEST (line 10344) | TEST(AsyncSocketTest, UnixDomainSocketErrMessageCB) {
  function TEST_P (line 10413) | TEST_P(AsyncSocketTest, V6TosReflectTest) {
  function TEST_P (line 10498) | TEST_P(AsyncSocketTest, V4TosReflectTest) {
  function TEST_P (line 10558) | TEST_P(AsyncSocketTest, V6AcceptedTosTest) {
  function TEST_P (line 10622) | TEST_P(AsyncSocketTest, V4AcceptedTosTest) {
  function TEST (line 10687) | TEST(AsyncSocketTest, getBufInUse) {
  function TEST (line 10737) | TEST(AsyncSocketTest, QueueTimeout) {
  class TestRXTimestampsCallback (line 10788) | class TestRXTimestampsCallback
    method TestRXTimestampsCallback (line 10791) | explicit TestRXTimestampsCallback(AsyncSocket* sock) : socket_(sock) {}
    method ancillaryData (line 10793) | folly::Expected<folly::Unit, AsyncSocketException> ancillaryData(
    method getAncillaryDataCtrlBuffer (line 10813) | folly::MutableByteRange getAncillaryDataCtrlBuffer() override {
  function TEST (line 10829) | TEST(AsyncSocketTest, readAncillaryData) {
  class AsyncSocketWriteCallbackTest (line 10901) | class AsyncSocketWriteCallbackTest : public ::testing::Test {
    method SetUp (line 10904) | void SetUp() override {
    method netOpsOnSendmsg (line 10912) | void netOpsOnSendmsg() {
    method netOpsOnSendmsgPartial (line 10925) | void netOpsOnSendmsgPartial() {
    method netOpsOnSendmsgFail (line 10945) | void netOpsOnSendmsgFail() {
  function TEST_F (line 10971) | TEST_F(AsyncSocketWriteCallbackTest, WriteStartingTests_WriteOnceSuccess) {
  function TEST_F (line 10997) | TEST_F(AsyncSocketWriteCallbackTest, WriteStartingTests_WriteOnceIncompl...
  function TEST_F (line 11024) | TEST_F(AsyncSocketWriteCallbackTest, WriteStartingTests_WriteTwiceSucces...
  function TEST_F (line 11048) | TEST_F(
  function TEST_F (line 11088) | TEST_F(
  function TEST_F (line 11139) | TEST_F(
  function TEST_F (line 11158) | TEST_F(AsyncSocketWriteCallbackTest, WriteStartingTests_WriteOnceFail) {
  function TEST (line 11177) | TEST(AsyncSocketTest, BindAddressNoPort) {

FILE: folly/io/async/test/AsyncSocketTest2.h
  function namespace (line 28) | namespace folly {

FILE: folly/io/async/test/AsyncTimeoutTest.cpp
  type folly (line 22) | namespace folly {
    function TEST (line 24) | TEST(AsyncTimeout, destroy) {
    function TEST (line 33) | TEST(AsyncTimeout, make) {
    function TEST (line 49) | TEST(AsyncTimeout, schedule) {
    function TEST (line 64) | TEST(AsyncTimeout, scheduleImmediate) {
    function TEST (line 78) | TEST(AsyncTimeout, cancelMake) {
    function TEST (line 105) | TEST(AsyncTimeout, cancelSchedule) {

FILE: folly/io/async/test/AsyncTransportTest.cpp
  type folly (line 25) | namespace folly {
    function TEST (line 27) | TEST(AsyncTransportTest, getSocketFromSocket) {
    function TEST (line 33) | TEST(AsyncTransportTest, getSocketFromWrappedTransport) {

FILE: folly/io/async/test/AsyncUDPSocketGSOGROTest.cpp
  type TestData (line 38) | struct TestData {
    method TestData (line 39) | TestData(
    method TestData (line 55) | TestData(
    method checkIn (line 67) | bool checkIn() const {
    method checkOut (line 75) | bool checkOut() const {
    method appendOut (line 88) | bool appendOut(int num) {
    method isMulti (line 95) | bool isMulti() const { return (in_.size() > 1); }
    method getInBuf (line 101) | std::unique_ptr<folly::IOBuf> getInBuf() {
    method getInBufs (line 120) | std::vector<std::unique_ptr<folly::IOBuf>> getInBufs() {
  class UDPAcceptor (line 154) | class UDPAcceptor : public AsyncUDPServerSocket::Callback {
    method UDPAcceptor (line 156) | UDPAcceptor(EventBase* /* evb */) {}
    method onListenStarted (line 158) | void onListenStarted() noexcept override {}
    method onListenStopped (line 160) | void onListenStopped() noexcept override {}
    method onDataAvailable (line 162) | void onDataAvailable(
  class UDPServer (line 185) | class UDPServer {
    method UDPServer (line 187) | UDPServer(EventBase* evb, folly::SocketAddress addr, int n)
    method start (line 190) | void start() {
    method address (line 225) | folly::SocketAddress address() const { return socket_->address(); }
    method shutdown (line 227) | void shutdown() {
    method pauseAccepting (line 241) | void pauseAccepting() { socket_->pauseAccepting(); }
    method resumeAccepting (line 243) | void resumeAccepting() { socket_->resumeAccepting(); }
  class UDPClient (line 255) | class UDPClient : private AsyncUDPSocket::ReadCallback, private AsyncTim...
    method UDPClient (line 257) | explicit UDPClient(EventBase* evb, TestData& testData)
    method start (line 260) | void start(const folly::SocketAddress& server) {
    method connect (line 295) | void connect() {
    method shutdown (line 300) | void shutdown() {
    method sendPing (line 308) | void sendPing() {
    method writePing (line 320) | virtual void writePing(std::unique_ptr<folly::IOBuf> buf, int gso) {
    method writePing (line 328) | virtual void writePing(
    method getReadBuffer (line 335) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onDataAvailable (line 340) | void onDataAvailable(
    method onReadError (line 353) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 360) | void onReadClosed() noexcept override {
    method timeoutExpired (line 364) | void timeoutExpired() noexcept override {
    method AsyncUDPSocket (line 369) | AsyncUDPSocket& getSocket() { return *socket_; }
    method setShouldConnect (line 371) | void setShouldConnect(const folly::SocketAddress& connectAddr) {
  class AsyncSocketGSOIntegrationTest (line 387) | class AsyncSocketGSOIntegrationTest : public Test {
    method SetUp (line 389) | void SetUp() override {
    method startServer (line 402) | void startServer() {
    method TearDown (line 408) | void TearDown() override {
  function TEST_F (line 455) | TEST_F(AsyncSocketGSOIntegrationTest, PingPongGlobalGSO) {
  function TEST_F (line 472) | TEST_F(AsyncSocketGSOIntegrationTest, PingPongRequestGSO) {
  function TEST_F (line 489) | TEST_F(AsyncSocketGSOIntegrationTest, MultiPingPongGlobalGSO) {
  function TEST_F (line 524) | TEST_F(AsyncSocketGSOIntegrationTest, MultiPingPongRequestGSO) {
  class GSOBuf (line 565) | class GSOBuf {
    method GSOBuf (line 567) | explicit GSOBuf(size_t size1, size_t size2 = 0) {
  class GSOSendTest (line 584) | class GSOSendTest {
    method GSOSendTest (line 586) | explicit GSOSendTest(
    method get (line 601) | ssize_t get() const { return ret_; }
  function TEST (line 607) | TEST(AsyncSocketGSOTest, send) {

FILE: folly/io/async/test/AsyncUDPSocketSendmmsgTest.cpp
  type TestData (line 39) | struct TestData {
    method TestData (line 40) | explicit TestData(const SizeVec& in) : in_(in) {}
    method checkOut (line 42) | bool checkOut() const { return (outNum_ == in_.size()); }
    method getCharAt (line 44) | char getCharAt(size_t pos) {
    method appendOut (line 52) | bool appendOut(const char* data, size_t len) {
    method IOBufVec (line 69) | IOBufVec getInBufs() {
  class UDPAcceptor (line 91) | class UDPAcceptor : public AsyncUDPServerSocket::Callback {
    method UDPAcceptor (line 93) | UDPAcceptor(EventBase* /* evb */) {}
    method onListenStarted (line 95) | void onListenStarted() noexcept override {}
    method onListenStopped (line 97) | void onListenStopped() noexcept override {}
    method onDataAvailable (line 99) | void onDataAvailable(
  class UDPServer (line 110) | class UDPServer {
    method UDPServer (line 112) | UDPServer(EventBase* evb, folly::SocketAddress addr, int n)
    method start (line 115) | void start() {
    method address (line 147) | folly::SocketAddress address() const { return socket_->address(); }
    method shutdown (line 149) | void shutdown() {
    method pauseAccepting (line 163) | void pauseAccepting() { socket_->pauseAccepting(); }
    method resumeAccepting (line 165) | void resumeAccepting() { socket_->resumeAccepting(); }
  class UDPClient (line 177) | class UDPClient : private AsyncUDPSocket::ReadCallback, private AsyncTim...
    method UDPClient (line 179) | explicit UDPClient(EventBase* evb, TestData& testData)
    method start (line 182) | void start(const folly::SocketAddress& server) {
    method connect (line 203) | void connect() {
    method shutdown (line 208) | void shutdown() {
    method sendPing (line 216) | void sendPing() {
    method writePing (line 222) | virtual void writePing(IOBufVec& bufs) {
    method getReadBuffer (line 227) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onDataAvailable (line 232) | void onDataAvailable(
    method onReadError (line 243) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 250) | void onReadClosed() noexcept override {
    method timeoutExpired (line 254) | void timeoutExpired() noexcept override {
    method AsyncUDPSocket (line 259) | AsyncUDPSocket& getSocket() { return *socket_; }
    method setShouldConnect (line 261) | void setShouldConnect(const folly::SocketAddress& connectAddr) {
  class AsyncSocketSendmmsgIntegrationTest (line 277) | class AsyncSocketSendmmsgIntegrationTest : public Test {
    method SetUp (line 279) | void SetUp() override {
    method startServer (line 292) | void startServer() {
    method TearDown (line 298) | void TearDown() override {
  function TEST_F (line 346) | TEST_F(AsyncSocketSendmmsgIntegrationTest, PingPongRequest) {

FILE: folly/io/async/test/AsyncUDPSocketTest.cpp
  class UDPAcceptor (line 46) | class UDPAcceptor : public AsyncUDPServerSocket::Callback {
    method UDPAcceptor (line 48) | UDPAcceptor(
    method onListenStarted (line 58) | void onListenStarted() noexcept override {}
    method onListenStopped (line 60) | void onListenStopped() noexcept override {}
    method onDataAvailable (line 62) | void onDataAvailable(
    method sendPong (line 78) | void sendPong() noexcept {
  class UDPServer (line 106) | class UDPServer {
    method UDPServer (line 108) | UDPServer(EventBase* evb, folly::SocketAddress addr, int n)
    method start (line 111) | void start() {
    method address (line 145) | folly::SocketAddress address() const { return socket_->address(); }
    method shutdown (line 147) | void shutdown() {
    method pauseAccepting (line 161) | void pauseAccepting() { socket_->pauseAccepting(); }
    method resumeAccepting (line 163) | void resumeAccepting() { socket_->resumeAccepting(); }
    method isAccepting (line 165) | bool isAccepting() { return socket_->isAccepting(); }
    method setChangePortForWrites (line 168) | void setChangePortForWrites(bool changePortForWrites) {
  type BindSocket (line 185) | enum class BindSocket { YES, NO }
  class UDPClient (line 187) | class UDPClient : private AsyncUDPSocket::ReadCallback, private AsyncTim...
    method UDPClient (line 193) | explicit UDPClient(EventBase* evb) : AsyncTimeout(evb), evb_(evb) {}
    method start (line 195) | void start(
    method shutdown (line 228) | void shutdown() {
    method sendPing (line 238) | void sendPing() {
    method sendPingsClustered (line 249) | void sendPingsClustered() {
    method writePing (line 258) | virtual void writePing(std::unique_ptr<folly::IOBuf> buf) {
    method getReadBuffer (line 265) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onDataAvailable (line 270) | void onDataAvailable(
    method onReadError (line 288) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 295) | void onReadClosed() noexcept override {
    method timeoutExpired (line 299) | void timeoutExpired() noexcept override {
    method pongRecvd (line 304) | int pongRecvd() const { return pongRecvd_; }
    method tosMessagesRecvd (line 306) | int tosMessagesRecvd() const { return tosMessagesRecvd_; }
    method AsyncUDPSocket (line 308) | AsyncUDPSocket& getSocket() { return *socket_; }
    method setShouldConnect (line 310) | void setShouldConnect(
    method setRecvTos (line 316) | void setRecvTos(bool recvTos) { recvTos_ = recvTos; }
    method error (line 318) | bool error() const { return error_; }
    method incrementPongCount (line 320) | void incrementPongCount(int n) { pongRecvd_ += n; }
  class UDPNotifyClient (line 340) | class UDPNotifyClient : public UDPClient {
    method UDPNotifyClient (line 344) | explicit UDPNotifyClient(
    method shouldOnlyNotify (line 348) | bool shouldOnlyNotify() override { return true; }
    method onRecvMsg (line 350) | void onRecvMsg(AsyncUDPSocket& sock) {
    method onRecvMmsg (line 392) | void onRecvMmsg(AsyncUDPSocket& sock) {
    method onNotifyDataAvailable (line 436) | void onNotifyDataAvailable(AsyncUDPSocket& sock) noexcept override {
  class AsyncSocketIntegrationTest (line 450) | class AsyncSocketIntegrationTest : public Test {
    method SetUp (line 452) | void SetUp() override {
    method startServer (line 465) | void startServer() {
    method TearDown (line 471) | void TearDown() override {
  function TEST_F (line 606) | TEST_F(AsyncSocketIntegrationTest, PingPong) {
  function TEST_F (line 613) | TEST_F(AsyncSocketIntegrationTest, PingPongNotify) {
  function TEST_F (line 621) | TEST_F(AsyncSocketIntegrationTest, PingPongNotifyMmsg) {
  function TEST_F (line 630) | TEST_F(AsyncSocketIntegrationTest, PingPongRecvTosDisabled) {
  function TEST_F (line 638) | TEST_F(AsyncSocketIntegrationTest, PingPongRecvTos) {
  class ConnectedAsyncSocketIntegrationTest (line 646) | class ConnectedAsyncSocketIntegrationTest
  function TEST_P (line 650) | TEST_P(ConnectedAsyncSocketIntegrationTest, ConnectedPingPong) {
  function TEST_P (line 659) | TEST_P(
  function TEST_P (line 669) | TEST_P(
  function TEST_P (line 682) | TEST_P(
  function TEST_F (line 701) | TEST_F(AsyncSocketIntegrationTest, PingPongPauseResumeListening) {
  class MockErrMessageCallback (line 717) | class MockErrMessageCallback : public AsyncUDPSocket::ErrMessageCallback {
    method errMessage (line 722) | void errMessage(const cmsghdr& cmsg) noexcept override { errMessage_(c...
    method errMessageError (line 725) | void errMessageError(
  class MockUDPReadCallback (line 731) | class MockUDPReadCallback : public AsyncUDPSocket::ReadCallback {
    method getReadBuffer (line 736) | void getReadBuffer(void** buf, size_t* len) noexcept override {
    method onNotifyDataAvailable (line 742) | void onNotifyDataAvailable(folly::AsyncUDPSocket& sock) noexcept overr...
    method onDataAvailable (line 750) | void onDataAvailable(
    method onReadError (line 759) | void onReadError(const folly::AsyncSocketException& ex) noexcept overr...
    method onReadClosed (line 764) | void onReadClosed() noexcept override { onReadClosed_(); }
  class AsyncUDPSocketTest (line 767) | class AsyncUDPSocketTest : public Test {
    method SetUp (line 769) | void SetUp() override {
  function TEST_F (line 782) | TEST_F(AsyncUDPSocketTest, TestConnectAfterBind) {
  function TEST_F (line 786) | TEST_F(AsyncUDPSocketTest, TestConnect) {
  function TEST_F (line 798) | TEST_F(AsyncUDPSocketTest, TestErrToNonExistentServer) {
  function TEST_F (line 823) | TEST_F(AsyncUDPSocketTest, TestUnsetErrCallback) {
  function TEST_F (line 835) | TEST_F(AsyncUDPSocketTest, CloseInErrorCallback) {
  function TEST_F (line 851) | TEST_F(AsyncUDPSocketTest, TestNonExistentServerNoErrCb) {
  function TEST_F (line 873) | TEST_F(AsyncUDPSocketTest, TestBound) {
  function TEST_F (line 881) | TEST_F(AsyncUDPSocketTest, TestBoundUnixSocket) {
  function TEST_F (line 891) | TEST_F(AsyncUDPSocketTest, TestAttachAfterDetachEvbWithReadCallback) {
  function TEST_F (line 900) | TEST_F(AsyncUDPSocketTest, TestAttachAfterDetachEvbNoReadCallback) {
  function TEST_F (line 908) | TEST_F(AsyncUDPSocketTest, TestDetachAttach) {
  type msghdr (line 952) | struct msghdr
  type msghdr (line 952) | struct msghdr
  type cmsghdr (line 959) | struct cmsghdr
  type timespec (line 967) | struct timespec
  type timespec (line 977) | struct timespec
  type timespec (line 987) | struct timespec
  type timespec (line 995) | struct timespec
  type msghdr (line 1008) | struct msghdr
  type msghdr (line 1008) | struct msghdr
  type cmsghdr (line 1015) | struct cmsghdr
  type linger (line 1020) | struct linger
  type linger (line 1026) | struct linger
  function TEST_F (line 1038) | TEST_F(AsyncUDPSocketTest, TestWriteCmsg) {
  function TEST_F (line 1109) | TEST_F(AsyncUDPSocketTest, TestWriteDynamicCmsg) {
  function TEST (line 1235) | TEST(MatcherTest, AllHaveCmsgsTest) {
  function TEST_F (line 1284) | TEST_F(AsyncUDPSocketTest, TestWritemCmsg) {
  function TEST_F (line 1331) | TEST_F(AsyncUDPSocketTest, TestWritemDynamicCmsg) {
  function TEST_F (line 1394) | TEST_F(AsyncUDPSocketTest, TestApplyStringOptionsPostBind) {
  function TEST_F (line 1419) | TEST_F(AsyncUDPSocketTest, TestWritemNontrivialCmsgs) {

FILE: folly/io/async/test/AtomicNotificationQueueTest.cpp
  type AtomicNotificationQueueConsumer (line 29) | struct AtomicNotificationQueueConsumer {
    method AtomicNotificationQueueConsumer (line 30) | explicit AtomicNotificationQueueConsumer(vector<Task>& tasks)
  function TEST (line 44) | TEST(AtomicNotificationQueueTest, TryPutMessage) {
  function TEST (line 69) | TEST(AtomicNotificationQueueTest, DiscardDequeuedTasks) {
  function TEST (line 135) | TEST(AtomicNotificationQueueTest, PutMessage) {
  function TEST (line 179) | TEST(AtomicNotificationQueueTest, ConsumeStop) {
  function TEST (line 230) | TEST(AtomicNotificationQueueTest, DriveSnapshot) {

FILE: folly/io/async/test/BlockingSocket.h
  function namespace (line 25) | namespace folly::test {
  function enableTFO (line 48) | void enableTFO() { sock_->enableTFO(); }
  function setEorTracking (line 50) | void setEorTracking(bool track) { sock_->setEorTracking(track); }
  function setAddress (line 52) | void setAddress(folly::SocketAddress address) { address_ = address; }
  function close (line 64) | void close() { sock_->close(); }
  function closeWithReset (line 65) | void closeWithReset() { sock_->closeWithReset(); }
  function flush (line 90) | void flush() {}
  function readAll (line 92) | int32_t readAll(uint8_t* buf, size_t len) {
  function read (line 96) | int32_t read(uint8_t* buf, size_t len) { return readHelper(buf, len, fal...
  function readNoBlock (line 98) | int32_t readNoBlock(uint8_t* buf, size_t len) {
  function readLen_ (line 117) | size_t readLen_{0};

FILE: folly/io/async/test/CallbackStateEnum.h
  function namespace (line 19) | namespace folly::test {

FILE: folly/io/async/test/ConnCallback.h
  function namespace (line 22) | namespace folly::test {

FILE: folly/io/async/test/DecoratedAsyncTransportWrapperTest.cpp
  type folly (line 23) | namespace folly {
    type test (line 24) | namespace test {
      class DecoratedAsyncTransportWrapperImpl (line 27) | class DecoratedAsyncTransportWrapperImpl
        method DecoratedAsyncTransportWrapperImpl (line 32) | explicit DecoratedAsyncTransportWrapperImpl(
        method UniquePtr (line 36) | static UniquePtr newSocket(folly::AsyncTransport::UniquePtr transp...
      function TEST (line 49) | TEST(DecoratedAsyncTransportWrapperTest, GetWrappingTransport) {
      function TEST (line 142) | TEST(DecoratedAsyncTransportWrapperTest, ExchangeWrappedTransport) {
      function TEST (line 177) | TEST(DecoratedAsyncTransportWrapperTest, ExchangeWrappedTransportNul...
      function TEST (line 195) | TEST(DecoratedAsyncTransportWrapperTest, Destroy) {

FILE: folly/io/async/test/DelayedDestructionBaseTest.cpp
  class DestructionOnCallback (line 25) | class DestructionOnCallback : public DelayedDestructionBase {
    method DestructionOnCallback (line 27) | DestructionOnCallback() : state_(0), deleted_(false) {}
    method onComplete (line 29) | void onComplete(int n, int& state) {
    method state (line 37) | int state() const { return state_; }
    method deleted (line 38) | bool deleted() const { return deleted_; }
    method onStackedComplete (line 41) | void onStackedComplete(int recur) {
    method onDelayedDestroy (line 54) | void onDelayedDestroy(bool delayed) override {
  type DelayedDestructionBaseTest (line 61) | struct DelayedDestructionBaseTest : public ::testing::Test {}
  function TEST_F (line 63) | TEST_F(DelayedDestructionBaseTest, basic) {

FILE: folly/io/async/test/DelayedDestructionTest.cpp
  class DeleteGuarder (line 25) | class DeleteGuarder : public DelayedDestruction {
    method doFoo (line 28) | void doFoo() {
  function TEST (line 34) | TEST(DelayedDestructionTest, GuardOnDelete) {
  function TEST (line 39) | TEST(DelayedDestructionTest, GuardOnDeleteWithPreGuard) {

FILE: folly/io/async/test/DestructorCheckTest.cpp
  class Derived (line 24) | class Derived : public DestructorCheck {}
  function TEST (line 26) | TEST(DestructorCheckTest, WithoutGuard) {
  function TEST (line 30) | TEST(DestructorCheckTest, SingleGuard) {
  function TEST (line 36) | TEST(DestructorCheckTest, SingleGuardDestroyed) {
  function TEST (line 44) | TEST(DestructorCheckTest, MultipleGuards) {
  function TEST (line 68) | TEST(DestructorCheckTest, MultipleGuardsDestroyed) {

FILE: folly/io/async/test/EpollBackendTest.cpp
  type folly (line 24) | namespace folly {
    type test (line 25) | namespace test {
      type EpollBackendProvider (line 27) | struct EpollBackendProvider : BackendProviderBase {
        method getBackend (line 28) | static std::unique_ptr<folly::EventBaseBackendBase> getBackend() {

FILE: folly/io/async/test/EventBaseBenchmark.cpp
  class CountedLoopCallback (line 23) | class CountedLoopCallback : public EventBase::LoopCallback {
    method CountedLoopCallback (line 25) | CountedLoopCallback(EventBase* eventBase, unsigned int count)
    method runLoopCallback (line 28) | void runLoopCallback() noexcept override {
  function BENCHMARK (line 40) | BENCHMARK(timeMeasurementsOn, n) {
  function BENCHMARK_RELATIVE (line 50) | BENCHMARK_RELATIVE(timeMeasurementsOff, n) {
  function main (line 71) | int main(int argc, char** argv) {

FILE: folly/io/async/test/EventBaseLocalTest.cpp
  type Foo (line 23) | struct Foo {
    method Foo (line 24) | Foo(int n_, std::function<void()> dtorFn_)
  function TEST (line 32) | TEST(EventBaseLocalTest, Basic) {
  function TEST (line 63) | TEST(EventBaseLocalTest, tryEmplace) {
  function TEST (line 78) | TEST(EventBaseLocalTest, getOrCreateNoncopyable) {
  function TEST (line 89) | TEST(EventBaseLocalTest, emplaceNoncopyable) {
  function TEST (line 96) | TEST(EventBaseLocalTest, DestructionOrder) {
  function TEST (line 117) | TEST(EventBaseLocalTest, DestructorStressTest) {

FILE: folly/io/async/test/EventBaseTest.cpp
  type folly (line 22) | namespace folly {
    type test (line 23) | namespace test {
      type DefaultBackendProvider (line 25) | struct DefaultBackendProvider : BackendProviderBase {
        method getBackend (line 26) | static std::unique_ptr<folly::EventBaseBackendBase> getBackend() {

FILE: folly/io/async/test/EventBaseTestLib.h
  function namespace (line 43) | namespace folly {
  function FOLLY_ALWAYS_INLINE (line 159) | FOLLY_ALWAYS_INLINE void scheduleEvents(
  function class (line 167) | class TestObserver : public folly::ExecutionObserver {
  function class (line 191) | class TestEventBaseObserver : public folly::EventBaseObserver {
  function class (line 205) | class TestHandler : public folly::EventHandler {
  function class (line 792) | class PartialReadHandler : public TestHandler {
  function class (line 863) | class PartialWriteHandler : public TestHandler {
  function class (line 932) | class DestroyHandler : public AsyncTimeout {
  type SharedState (line 989) | struct SharedState {
  function AsyncTimeout (line 997) | struct Timeout : AsyncTimeout {
  function class (line 1299) | class DestroyTimeout : public AsyncTimeout {
  type RunInThreadData (line 1397) | struct RunInThreadData {
  type RunInThreadArg (line 1414) | struct RunInThreadArg {
  function runInThreadTestFunc (line 1423) | static inline void runInThreadTestFunc(RunInThreadArg* arg) {
  function RunInThreadData (line 1439) | RunInThreadData data(
  function ebth (line 1519) | auto ebth = std::thread([&] { eb.loopForever(); }
  function runLoopCallback (line 1624) | void runLoopCallback() noexcept override {
  function reset (line 1875) | void reset(uint32_t maxLoopInvocations, uint32_t maxEventInvocations) {
  function handlerReady (line 1885) | void handlerReady(uint16_t /* events */) noexcept override {
  function runLoopCallback (line 1897) | void runLoopCallback() noexcept override {
  function class (line 2041) | class IdleTimeTimeoutSeries : public AsyncTimeout {
  function class (line 2254) | class PipeHandler : public EventHandler {
  function done (line 2415) | size_t done{0}
  function leakRC (line 2539) | void leakRC() {
  function EventHandler (line 2546) | struct LeakyHandler : EventHandler {
  function EventBaseObserver (line 2562) | struct LeakyEventBaseObserver : EventBaseObserver {
  function loopSample (line 2567) | void loopSample(int64_t /* busyTime */, int64_t /* idleTime */) override {
  function ExecutionObserver (line 2572) | struct LeakyExecutionObserver : ExecutionObserver {
  function LeakyHandler (line 2594) | LeakyHandler handler{*evbPtr};
  function LeakyHandler (line 2621) | LeakyHandler handler{*evbPtr};
  function stopping (line 2661) | bool stopping{false};
  function num (line 2668) | size_t num{0}
  function OnDestructionCallback (line 2700) | struct Callback : EventBase::OnDestructionCallback {
  type RepeatingBeforeLoopCallback (line 2830) | struct RepeatingBeforeLoopCallback
  function explicit (line 2831) | explicit RepeatingBeforeLoopCallback(EventBase& e) : evb(e) {}
  function runLoopCallback (line 2833) | void runLoopCallback() noexcept override {
  function std (line 2886) | const std::chrono::milliseconds kTimeslice{20};
  function class (line 2952) | class TrackingRequestData : public RequestData {
  function callbackRan (line 2977) | bool callbackRan{false};
  type BackendProviderBase (line 3066) | struct BackendProviderBase {

FILE: folly/io/async/test/EventHandlerTest.cpp
  function runInThreadsAndWait (line 36) | void runInThreadsAndWait(size_t nthreads, function<void(size_t)> cb) {
  function runInThreadsAndWait (line 46) | void runInThreadsAndWait(vector<function<void()>> cbs) {
  class EventHandlerMock (line 50) | class EventHandlerMock : public EventHandler {
    method EventHandlerMock (line 52) | EventHandlerMock(EventBase* eb, int fd)
    method handlerReady (line 56) | void handlerReady(uint16_t events) noexcept override {
  class EventHandlerTest (line 61) | class EventHandlerTest : public Test {
    method SetUp (line 65) | void SetUp() override {
    method TearDown (line 70) | void TearDown() override {
    method efd_write (line 77) | void efd_write(uint64_t val) { fileops::write(efd, &val, sizeof(val)); }
    method efd_read (line 79) | uint64_t efd_read() {
  function TEST_F (line 86) | TEST_F(EventHandlerTest, simple) {
  function TEST_F (line 107) | TEST_F(EventHandlerTest, many_concurrent_producers) {
  function TEST_F (line 140) | TEST_F(EventHandlerTest, many_concurrent_consumers) {
  class EventHandlerOobTest (line 195) | class EventHandlerOobTest : public ::testing::Test {
    method runClient (line 201) | void runClient(std::function<void(int fd)> clientOps) {
    method acceptConn (line 235) | void acceptConn() {
    method SetUp (line 263) | void SetUp() override {}
    method TearDown (line 265) | void TearDown() override {
  function TEST_F (line 279) | TEST_F(EventHandlerOobTest, EPOLLPRI) {
  function TEST_F (line 321) | TEST_F(EventHandlerOobTest, OOB_AND_NORMAL_DATA) {
  function TEST_F (line 376) | TEST_F(EventHandlerOobTest, SWALLOW_OOB) {

FILE: folly/io/async/test/HHWheelTimerHighResBenchmark.cpp
  class TestTimeoutMs (line 26) | class TestTimeoutMs : public HHWheelTimer::Callback {
    method TestTimeoutMs (line 28) | TestTimeoutMs() = default;
    method timeoutExpired (line 31) | void timeoutExpired() noexcept override {}
    method callbackCanceled (line 33) | void callbackCanceled() noexcept override {}
  class TestTimeoutUs (line 38) | class TestTimeoutUs : public HHWheelTimerHighRes::Callback {
    method TestTimeoutUs (line 40) | TestTimeoutUs() = default;
    method timeoutExpired (line 43) | void timeoutExpired() noexcept override {}
    method callbackCanceled (line 45) | void callbackCanceled() noexcept override {}
  class TestTimeoutDirectUs (line 50) | class TestTimeoutDirectUs : public TimerFDTimeoutManager::Callback {
    method TestTimeoutDirectUs (line 52) | TestTimeoutDirectUs() = default;
    method timeoutExpired (line 55) | void timeoutExpired() noexcept override {}
    method callbackCanceled (line 57) | void callbackCanceled() noexcept override {}
  function scheduleCancelTimersMs (line 60) | unsigned int scheduleCancelTimersMs(unsigned int iters, unsigned int tim...
  function scheduleCancelTimersUs (line 82) | unsigned int scheduleCancelTimersUs(unsigned int iters, unsigned int tim...
  function scheduleCancelTimersDirectUs (line 105) | unsigned int scheduleCancelTimersDirectUs(
  function main (line 170) | int main(int argc, char* argv[]) {

FILE: folly/io/async/test/HHWheelTimerHighResTest.cpp
  class TestTimeout (line 28) | class TestTimeout : public HHWheelTimerHighRes::Callback {
    method TestTimeout (line 30) | TestTimeout() {}
    method TestTimeout (line 31) | TestTimeout(HHWheelTimerHighRes* t, microseconds timeout) {
    method timeoutExpired (line 35) | void timeoutExpired() noexcept override {
    method callbackCanceled (line 42) | void callbackCanceled() noexcept override {
  type HHWheelTimerHighResTest (line 54) | struct HHWheelTimerHighResTest : public ::testing::Test {
    method HHWheelTimerHighResTest (line 55) | HHWheelTimerHighResTest() : timeoutMgr(&evb) {}
  function TEST_F (line 64) | TEST_F(HHWheelTimerHighResTest, FireOnce) {
  function TEST_F (line 105) | TEST_F(HHWheelTimerHighResTest, TestSchedulingWithinCallback) {
  function TEST_F (line 130) | TEST_F(HHWheelTimerHighResTest, TestSetDefaultTimeout) {
  function TEST_F (line 142) | TEST_F(HHWheelTimerHighResTest, CancelTimeout) {
  function TEST_F (line 226) | TEST_F(HHWheelTimerHighResTest, DestroyTimeoutSet) {
  function TEST_F (line 268) | TEST_F(HHWheelTimerHighResTest, SlowFast) {
  function TEST_F (line 296) | TEST_F(HHWheelTimerHighResTest, ReschedTest) {
  function TEST_F (line 329) | TEST_F(HHWheelTimerHighResTest, DeleteWheelInTimeout) {
  function TEST_F (line 362) | TEST_F(HHWheelTimerHighResTest, DefaultTimeout) {
  function TEST_F (line 398) | TEST_F(HHWheelTimerHighResTest, lambda) {
  function TEST_F (line 412) | TEST_F(HHWheelTimerHighResTest, lambdaThrows) {
  function TEST_F (line 429) | TEST_F(HHWheelTimerHighResTest, cancelAll) {
  function TEST_F (line 451) | TEST_F(HHWheelTimerHighResTest, IntrusivePtr) {
  function TEST_F (line 493) | TEST_F(HHWheelTimerHighResTest, GetTimeRemaining) {
  function TEST_F (line 518) | TEST_F(HHWheelTimerHighResTest, prematureTimeout) {
  function TEST_F (line 539) | TEST_F(HHWheelTimerHighResTest, Level1) {
  function TEST_F (line 553) | TEST_F(HHWheelTimerHighResTest, NegativeTimeout) {

FILE: folly/io/async/test/HHWheelTimerSlowTests.cpp
  class TestTimeout (line 32) | class TestTimeout : public HHWheelTimer::Callback {
    method TestTimeout (line 34) | TestTimeout() {}
    method TestTimeout (line 35) | TestTimeout(HHWheelTimer* t, milliseconds timeout) {
    method timeoutExpired (line 39) | void timeoutExpired() noexcept override {
    method callbackCanceled (line 46) | void callbackCanceled() noexcept override {
  type HHWheelTimerTest (line 58) | struct HHWheelTimerTest : public ::testing::Test {
  function TEST_F (line 63) | TEST_F(HHWheelTimerTest, Level2) {
  function TEST_F (line 100) | TEST_F(HHWheelTimerTest, AtMostEveryN) {
  function TEST_F (line 190) | TEST_F(HHWheelTimerTest, SlowLoop) {
  function TEST_F (line 241) | TEST_F(HHWheelTimerTest, Level1) {
  function TEST_F (line 269) | TEST_F(HHWheelTimerTest, Stress) {

FILE: folly/io/async/test/HHWheelTimerTest.cpp
  class TestTimeout (line 30) | class TestTimeout : public HHWheelTimer::Callback {
    method TestTimeout (line 32) | TestTimeout() {}
    method TestTimeout (line 33) | TestTimeout(HHWheelTimer* t, milliseconds timeout) {
    method timeoutExpired (line 37) | void timeoutExpired() noexcept override {
    method callbackCanceled (line 44) | void callbackCanceled() noexcept override {
  type HHWheelTimerTest (line 56) | struct HHWheelTimerTest : public ::testing::Test {
  function TEST_F (line 63) | TEST_F(HHWheelTimerTest, FireOnce) {
  function TEST_F (line 97) | TEST_F(HHWheelTimerTest, NoRequestContextLeak) {
  function TEST_F (line 140) | TEST_F(HHWheelTimerTest, TestSchedulingWithinCallback) {
  function TEST_F (line 165) | TEST_F(HHWheelTimerTest, TestSetDefaultTimeout) {
  function TEST_F (line 177) | TEST_F(HHWheelTimerTest, CancelTimeout) {
  function TEST_F (line 258) | TEST_F(HHWheelTimerTest, DestroyTimeoutSet) {
  function TEST_F (line 299) | TEST_F(HHWheelTimerTest, SlowFast) {
  function TEST_F (line 324) | TEST_F(HHWheelTimerTest, ReschedTest) {
  function TEST_F (line 354) | TEST_F(HHWheelTimerTest, DeleteWheelInTimeout) {
  function TEST_F (line 384) | TEST_F(HHWheelTimerTest, DefaultTimeout) {
  function TEST_F (line 417) | TEST_F(HHWheelTimerTest, lambda) {
  function TEST_F (line 427) | TEST_F(HHWheelTimerTest, lambdaThrows) {
  function TEST_F (line 434) | TEST_F(HHWheelTimerTest, cancelAll) {
  function TEST_F (line 451) | TEST_F(HHWheelTimerTest, IntrusivePtr) {
  function TEST_F (line 489) | TEST_F(HHWheelTimerTest, GetTimeRemaining) {
  function TEST_F (line 513) | TEST_F(HHWheelTimerTest, prematureTimeout) {
  function TEST_F (line 533) | TEST_F(HHWheelTimerTest, Level1) {
  function TEST_F (line 546) | TEST_F(HHWheelTimerTest, NegativeTimeout) {
  function TEST (line 563) | TEST(HHWheelTimerDetailsTest, Divider) {

FILE: folly/io/async/test/IOBenchmark.cpp
  type BenchmarkData (line 42) | struct BenchmarkData {
    method BenchmarkData (line 43) | BenchmarkData(size_t num, size_t& c) : numEntries(num), completed(c) {
    method reset (line 61) | void reset(bool useRegisteredBuffers) {
  function runTAsyncIOTest (line 84) | void runTAsyncIOTest(
  function runAsyncIOTest (line 139) | void runAsyncIOTest(
  function runIOUringTest (line 152) | void runIOUringTest(
  function main (line 223) | int main(int argc, char** argv) {

FILE: folly/io/async/test/IoTestTempFileUtil.cpp
  type folly (line 24) | namespace folly {
    type test (line 25) | namespace test {
      function TemporaryFile (line 27) | TemporaryFile TempFileUtil::getTempFile(size_t size) {

FILE: folly/io/async/test/IoTestTempFileUtil.h
  function namespace (line 24) | namespace folly {

FILE: folly/io/async/test/IoUringBackendBench.cpp
  class EventFD (line 35) | class EventFD
    method EventFD (line 46) | EventFD(
    method setNumReadPerLoop (line 64) | void setNumReadPerLoop(size_t numReadPerLoop) {
    method write (line 68) | ssize_t write(uint64_t val) {
    method handlerReady (line 75) | void handlerReady(uint16_t /*events*/) noexcept override {
    method processOne (line 98) | void processOne() {
    method createFd (line 111) | static int createFd(uint64_t num) {
    method EventFD (line 121) | EventFD(
  type EventFDRefillInfo (line 36) | struct EventFDRefillInfo {
  class EventFD (line 44) | class EventFD : public EventHandler {
    method EventFD (line 46) | EventFD(
    method setNumReadPerLoop (line 64) | void setNumReadPerLoop(size_t numReadPerLoop) {
    method write (line 68) | ssize_t write(uint64_t val) {
    method handlerReady (line 75) | void handlerReady(uint16_t /*events*/) noexcept override {
    method processOne (line 98) | void processOne() {
    method createFd (line 111) | static int createFd(uint64_t num) {
    method EventFD (line 121) | EventFD(
  class EventBaseProvider (line 147) | class EventBaseProvider {
    type Type (line 149) | enum Type {
    method getEventBase (line 155) | static std::unique_ptr<folly::EventBase> getEventBase(
  function runBM (line 194) | void runBM(
  function main (line 465) | int main(int argc, char** argv) {

FILE: folly/io/async/test/IoUringBackendSetupTest.cpp
  type folly::test (line 20) | namespace folly::test {
    function TEST (line 22) | TEST(IoUringBackendSetupTest, SetupPollNoGroup) {
    function TEST (line 34) | TEST(IoUringBackendSetupTest, SetupPollWithGroup) {
    function TEST (line 58) | TEST(IoUringBackendSetupTest, SetupPollWithGroupAndCpu) {

FILE: folly/io/async/test/IoUringEventBaseLocalTest.cpp
  type folly (line 23) | namespace folly {
    type NopSqe (line 25) | struct NopSqe : IoSqeBase {
      method processSubmit (line 26) | void processSubmit(struct io_uring_sqe* sqe) noexcept override {
      method callback (line 29) | void callback(const io_uring_cqe* cqe) noexcept override {
      method callbackCancelled (line 32) | void callbackCancelled(const io_uring_cqe*) noexcept override {
    function TEST (line 39) | TEST(IoUringEventBaseLocalTest, Basic) {

FILE: folly/io/async/test/IoUringTest.cpp
  type folly (line 23) | namespace folly {
    type test (line 24) | namespace test {
      type async_base_test_lib_detail (line 25) | namespace async_base_test_lib_detail {
        class BatchIoUring (line 43) | class BatchIoUring : public IoUring {
          method BatchIoUring (line 46) | BatchIoUring()
        function TEST (line 51) | TEST(IoUringTest, RegisteredBuffers) {

FILE: folly/io/async/test/MockAsyncSSLSocket.h
  function namespace (line 22) | namespace folly {

FILE: folly/io/async/test/MockAsyncSocketLegacyObserver.h
  function namespace (line 26) | namespace folly {

FILE: folly/io/async/test/MuxIOThreadPoolExecutorTest.cpp
  type folly (line 28) | namespace folly {
    type test (line 29) | namespace test {
      function TEST (line 31) | TEST(MuxIOThreadPoolExecutor, SingleEpollLoopCreateDestroy) {
      function TEST (line 36) | TEST(MuxIOThreadPoolExecutor, SingleEpollLoopRun) {
      function TEST (line 74) | TEST(MuxIOThreadPoolExecutor, SingleEpollLoopTimers) {
      function TEST (line 92) | TEST(MuxIOThreadPoolExecutor, InvalidSetNumThreads) {

FILE: folly/io/async/test/NotificationQueueBenchmark.cpp
  type FuncRunner (line 32) | struct FuncRunner {
  class MockConsumer (line 39) | class MockConsumer : public NotificationQueue<Func>::Consumer {
    method messageAvailable (line 41) | void messageAvailable(Func&& message) noexcept override {
  type AtomicNotificationQueueConsumerAdaptor (line 49) | struct AtomicNotificationQueueConsumerAdaptor {
    method startConsuming (line 50) | void startConsuming(
  function burn (line 57) | static void burn(size_t n) {
  function multiProducerMultiConsumer (line 64) | void multiProducerMultiConsumer(
  function multiProducerMultiConsumerNQ (line 141) | void multiProducerMultiConsumerNQ(
  function multiProducerMultiConsumerANQ (line 147) | void multiProducerMultiConsumerANQ(
  function BENCHMARK (line 156) | BENCHMARK(EnqueueBenchmark, n) {
  function BENCHMARK (line 166) | BENCHMARK(DequeueBenchmark, n) {
  function main (line 238) | int main(int argc, char* argv[]) {