Copy disabled (too large)
Download .txt
Showing preview only (10,969K chars total). Download the full file to get everything.
Repository: abseil/abseil-cpp
Branch: master
Commit: 6c1f120e3e50
Files: 1585
Total size: 10.3 MB
Directory structure:
gitextract_sr0vk97u/
├── .clang-format
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── 00-bug_report.yml
│ │ └── config.yml
│ └── PULL_REQUEST_TEMPLATE.md
├── .gitignore
├── ABSEIL_ISSUE_TEMPLATE.md
├── AUTHORS
├── BUILD.bazel
├── CMake/
│ ├── AbseilDll.cmake
│ ├── AbseilHelpers.cmake
│ ├── Googletest/
│ │ ├── CMakeLists.txt.in
│ │ └── DownloadGTest.cmake
│ ├── README.md
│ ├── abslConfig.cmake.in
│ └── install_test_project/
│ ├── CMakeLists.txt
│ ├── simple.cc
│ └── test.sh
├── CMakeLists.txt
├── CONTRIBUTING.md
├── FAQ.md
├── LICENSE
├── MODULE.bazel
├── PrivacyInfo.xcprivacy
├── README.md
├── UPGRADES.md
├── absl/
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ ├── abseil.podspec.gen.py
│ ├── algorithm/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── algorithm.h
│ │ ├── algorithm_test.cc
│ │ ├── container.h
│ │ └── container_test.cc
│ ├── base/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── attributes.h
│ │ ├── attributes_test.cc
│ │ ├── bit_cast_test.cc
│ │ ├── c_header_test.c
│ │ ├── call_once.h
│ │ ├── call_once_test.cc
│ │ ├── casts.cc
│ │ ├── casts.h
│ │ ├── casts_test.cc
│ │ ├── config.h
│ │ ├── config_test.cc
│ │ ├── const_init.h
│ │ ├── dynamic_annotations.h
│ │ ├── exception_safety_testing_test.cc
│ │ ├── fast_type_id.h
│ │ ├── fast_type_id_test.cc
│ │ ├── internal/
│ │ │ ├── atomic_hook.h
│ │ │ ├── atomic_hook_test.cc
│ │ │ ├── atomic_hook_test_helper.cc
│ │ │ ├── atomic_hook_test_helper.h
│ │ │ ├── cmake_thread_test.cc
│ │ │ ├── cycleclock.cc
│ │ │ ├── cycleclock.h
│ │ │ ├── cycleclock_config.h
│ │ │ ├── direct_mmap.h
│ │ │ ├── dynamic_annotations.h
│ │ │ ├── endian.h
│ │ │ ├── endian_test.cc
│ │ │ ├── errno_saver.h
│ │ │ ├── errno_saver_test.cc
│ │ │ ├── exception_safety_testing.cc
│ │ │ ├── exception_safety_testing.h
│ │ │ ├── exception_testing.h
│ │ │ ├── hardening.cc
│ │ │ ├── hardening.h
│ │ │ ├── hardening_test.cc
│ │ │ ├── hide_ptr.h
│ │ │ ├── iterator_traits.h
│ │ │ ├── iterator_traits_test.cc
│ │ │ ├── iterator_traits_test_helper.h
│ │ │ ├── low_level_alloc.cc
│ │ │ ├── low_level_alloc.h
│ │ │ ├── low_level_alloc_test.cc
│ │ │ ├── low_level_scheduling.h
│ │ │ ├── nullability_traits.h
│ │ │ ├── nullability_traits_test.cc
│ │ │ ├── per_thread_tls.h
│ │ │ ├── poison.cc
│ │ │ ├── poison.h
│ │ │ ├── poison_test.cc
│ │ │ ├── pretty_function.h
│ │ │ ├── raw_logging.cc
│ │ │ ├── raw_logging.h
│ │ │ ├── scheduling_mode.h
│ │ │ ├── scoped_set_env.cc
│ │ │ ├── scoped_set_env.h
│ │ │ ├── scoped_set_env_test.cc
│ │ │ ├── spinlock.cc
│ │ │ ├── spinlock.h
│ │ │ ├── spinlock_akaros.inc
│ │ │ ├── spinlock_benchmark.cc
│ │ │ ├── spinlock_linux.inc
│ │ │ ├── spinlock_posix.inc
│ │ │ ├── spinlock_wait.cc
│ │ │ ├── spinlock_wait.h
│ │ │ ├── spinlock_win32.inc
│ │ │ ├── strerror.cc
│ │ │ ├── strerror.h
│ │ │ ├── strerror_benchmark.cc
│ │ │ ├── strerror_test.cc
│ │ │ ├── sysinfo.cc
│ │ │ ├── sysinfo.h
│ │ │ ├── sysinfo_test.cc
│ │ │ ├── thread_identity.cc
│ │ │ ├── thread_identity.h
│ │ │ ├── thread_identity_benchmark.cc
│ │ │ ├── thread_identity_test.cc
│ │ │ ├── tracing.cc
│ │ │ ├── tracing.h
│ │ │ ├── tracing_strong_test.cc
│ │ │ ├── tracing_weak_test.cc
│ │ │ ├── tsan_mutex_interface.h
│ │ │ ├── unaligned_access.h
│ │ │ ├── unique_small_name_test.cc
│ │ │ ├── unscaledcycleclock.cc
│ │ │ ├── unscaledcycleclock.h
│ │ │ └── unscaledcycleclock_config.h
│ │ ├── log_severity.cc
│ │ ├── log_severity.h
│ │ ├── log_severity_test.cc
│ │ ├── macros.h
│ │ ├── no_destructor.h
│ │ ├── no_destructor_benchmark.cc
│ │ ├── no_destructor_test.cc
│ │ ├── nullability.h
│ │ ├── nullability_default_nonnull_test.cc
│ │ ├── nullability_test.cc
│ │ ├── optimization.h
│ │ ├── optimization_test.cc
│ │ ├── options.h
│ │ ├── policy_checks.h
│ │ ├── port.h
│ │ ├── prefetch.h
│ │ ├── prefetch_test.cc
│ │ ├── raw_logging_test.cc
│ │ ├── spinlock_test_common.cc
│ │ ├── thread_annotations.h
│ │ ├── throw_delegate.cc
│ │ ├── throw_delegate.h
│ │ └── throw_delegate_test.cc
│ ├── cleanup/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── cleanup.h
│ │ ├── cleanup_test.cc
│ │ └── internal/
│ │ └── cleanup.h
│ ├── container/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── btree_benchmark.cc
│ │ ├── btree_map.h
│ │ ├── btree_set.h
│ │ ├── btree_test.cc
│ │ ├── btree_test.h
│ │ ├── chunked_queue.h
│ │ ├── chunked_queue_benchmark.cc
│ │ ├── chunked_queue_test.cc
│ │ ├── fixed_array.h
│ │ ├── fixed_array_benchmark.cc
│ │ ├── fixed_array_exception_safety_test.cc
│ │ ├── fixed_array_test.cc
│ │ ├── flat_hash_map.h
│ │ ├── flat_hash_map_test.cc
│ │ ├── flat_hash_set.h
│ │ ├── flat_hash_set_test.cc
│ │ ├── hash_container_defaults.h
│ │ ├── inlined_vector.h
│ │ ├── inlined_vector_benchmark.cc
│ │ ├── inlined_vector_exception_safety_test.cc
│ │ ├── inlined_vector_test.cc
│ │ ├── internal/
│ │ │ ├── btree.h
│ │ │ ├── btree_container.h
│ │ │ ├── chunked_queue.h
│ │ │ ├── common.h
│ │ │ ├── common_policy_traits.h
│ │ │ ├── common_policy_traits_test.cc
│ │ │ ├── compressed_tuple.h
│ │ │ ├── compressed_tuple_test.cc
│ │ │ ├── container_memory.h
│ │ │ ├── container_memory_test.cc
│ │ │ ├── hash_function_defaults.h
│ │ │ ├── hash_function_defaults_test.cc
│ │ │ ├── hash_generator_testing.cc
│ │ │ ├── hash_generator_testing.h
│ │ │ ├── hash_policy_testing.h
│ │ │ ├── hash_policy_testing_test.cc
│ │ │ ├── hash_policy_traits.h
│ │ │ ├── hash_policy_traits_test.cc
│ │ │ ├── hashtable_control_bytes.h
│ │ │ ├── hashtable_control_bytes_test.cc
│ │ │ ├── hashtable_debug.h
│ │ │ ├── hashtable_debug_hooks.h
│ │ │ ├── hashtablez_sampler.cc
│ │ │ ├── hashtablez_sampler.h
│ │ │ ├── hashtablez_sampler_force_weak_definition.cc
│ │ │ ├── hashtablez_sampler_test.cc
│ │ │ ├── heterogeneous_lookup_testing.h
│ │ │ ├── inlined_vector.h
│ │ │ ├── layout.h
│ │ │ ├── layout_benchmark.cc
│ │ │ ├── layout_test.cc
│ │ │ ├── node_slot_policy.h
│ │ │ ├── node_slot_policy_test.cc
│ │ │ ├── raw_hash_map.h
│ │ │ ├── raw_hash_set.cc
│ │ │ ├── raw_hash_set.h
│ │ │ ├── raw_hash_set_allocator_test.cc
│ │ │ ├── raw_hash_set_benchmark.cc
│ │ │ ├── raw_hash_set_probe_benchmark.cc
│ │ │ ├── raw_hash_set_resize_impl.h
│ │ │ ├── raw_hash_set_resize_impl_test.cc
│ │ │ ├── raw_hash_set_test.cc
│ │ │ ├── test_allocator.h
│ │ │ ├── test_instance_tracker.cc
│ │ │ ├── test_instance_tracker.h
│ │ │ ├── test_instance_tracker_test.cc
│ │ │ ├── tracked.h
│ │ │ ├── unordered_map_constructor_test.h
│ │ │ ├── unordered_map_lookup_test.h
│ │ │ ├── unordered_map_members_test.h
│ │ │ ├── unordered_map_modifiers_test.h
│ │ │ ├── unordered_map_test.cc
│ │ │ ├── unordered_set_constructor_test.h
│ │ │ ├── unordered_set_lookup_test.h
│ │ │ ├── unordered_set_members_test.h
│ │ │ ├── unordered_set_modifiers_test.h
│ │ │ └── unordered_set_test.cc
│ │ ├── linked_hash_map.h
│ │ ├── linked_hash_map_benchmark.cc
│ │ ├── linked_hash_map_test.cc
│ │ ├── linked_hash_set.h
│ │ ├── linked_hash_set_benchmark.cc
│ │ ├── linked_hash_set_test.cc
│ │ ├── node_hash_map.h
│ │ ├── node_hash_map_test.cc
│ │ ├── node_hash_set.h
│ │ ├── node_hash_set_test.cc
│ │ └── sample_element_size_test.cc
│ ├── copts/
│ │ ├── AbseilConfigureCopts.cmake
│ │ ├── GENERATED_AbseilCopts.cmake
│ │ ├── GENERATED_copts.bzl
│ │ ├── configure_copts.bzl
│ │ ├── copts.py
│ │ └── generate_copts.py
│ ├── crc/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── crc32c.cc
│ │ ├── crc32c.h
│ │ ├── crc32c_benchmark.cc
│ │ ├── crc32c_test.cc
│ │ └── internal/
│ │ ├── cpu_detect.cc
│ │ ├── cpu_detect.h
│ │ ├── crc.cc
│ │ ├── crc.h
│ │ ├── crc32_x86_arm_combined_simd.h
│ │ ├── crc32c.h
│ │ ├── crc32c_inline.h
│ │ ├── crc_cord_state.cc
│ │ ├── crc_cord_state.h
│ │ ├── crc_cord_state_test.cc
│ │ ├── crc_internal.h
│ │ ├── crc_memcpy.h
│ │ ├── crc_memcpy_fallback.cc
│ │ ├── crc_memcpy_test.cc
│ │ ├── crc_memcpy_x86_arm_combined.cc
│ │ ├── crc_non_temporal_memcpy.cc
│ │ ├── crc_x86_arm_combined.cc
│ │ ├── gen_crc32c_consts.py
│ │ ├── non_temporal_arm_intrinsics.h
│ │ ├── non_temporal_memcpy.h
│ │ └── non_temporal_memcpy_test.cc
│ ├── debugging/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── failure_signal_handler.cc
│ │ ├── failure_signal_handler.h
│ │ ├── failure_signal_handler_test.cc
│ │ ├── internal/
│ │ │ ├── address_is_readable.cc
│ │ │ ├── address_is_readable.h
│ │ │ ├── addresses.h
│ │ │ ├── bounded_utf8_length_sequence.h
│ │ │ ├── bounded_utf8_length_sequence_test.cc
│ │ │ ├── decode_rust_punycode.cc
│ │ │ ├── decode_rust_punycode.h
│ │ │ ├── decode_rust_punycode_test.cc
│ │ │ ├── demangle.cc
│ │ │ ├── demangle.h
│ │ │ ├── demangle_rust.cc
│ │ │ ├── demangle_rust.h
│ │ │ ├── demangle_rust_test.cc
│ │ │ ├── demangle_test.cc
│ │ │ ├── elf_mem_image.cc
│ │ │ ├── elf_mem_image.h
│ │ │ ├── examine_stack.cc
│ │ │ ├── examine_stack.h
│ │ │ ├── stack_consumption.cc
│ │ │ ├── stack_consumption.h
│ │ │ ├── stack_consumption_test.cc
│ │ │ ├── stacktrace_aarch64-inl.inc
│ │ │ ├── stacktrace_arm-inl.inc
│ │ │ ├── stacktrace_config.h
│ │ │ ├── stacktrace_emscripten-inl.inc
│ │ │ ├── stacktrace_generic-inl.inc
│ │ │ ├── stacktrace_powerpc-inl.inc
│ │ │ ├── stacktrace_riscv-inl.inc
│ │ │ ├── stacktrace_unimplemented-inl.inc
│ │ │ ├── stacktrace_win32-inl.inc
│ │ │ ├── stacktrace_x86-inl.inc
│ │ │ ├── symbolize.h
│ │ │ ├── utf8_for_code_point.cc
│ │ │ ├── utf8_for_code_point.h
│ │ │ ├── utf8_for_code_point_test.cc
│ │ │ ├── vdso_support.cc
│ │ │ └── vdso_support.h
│ │ ├── leak_check.cc
│ │ ├── leak_check.h
│ │ ├── leak_check_fail_test.cc
│ │ ├── leak_check_test.cc
│ │ ├── stacktrace.cc
│ │ ├── stacktrace.h
│ │ ├── stacktrace_benchmark.cc
│ │ ├── stacktrace_test.cc
│ │ ├── symbolize.cc
│ │ ├── symbolize.h
│ │ ├── symbolize_darwin.inc
│ │ ├── symbolize_elf.inc
│ │ ├── symbolize_emscripten.inc
│ │ ├── symbolize_test.cc
│ │ ├── symbolize_unimplemented.inc
│ │ └── symbolize_win32.inc
│ ├── flags/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── commandlineflag.cc
│ │ ├── commandlineflag.h
│ │ ├── commandlineflag_test.cc
│ │ ├── config.h
│ │ ├── config_test.cc
│ │ ├── declare.h
│ │ ├── flag.h
│ │ ├── flag_benchmark.cc
│ │ ├── flag_benchmark.lds
│ │ ├── flag_test.cc
│ │ ├── flag_test_defs.cc
│ │ ├── internal/
│ │ │ ├── commandlineflag.cc
│ │ │ ├── commandlineflag.h
│ │ │ ├── flag.cc
│ │ │ ├── flag.h
│ │ │ ├── parse.h
│ │ │ ├── path_util.h
│ │ │ ├── path_util_test.cc
│ │ │ ├── private_handle_accessor.cc
│ │ │ ├── private_handle_accessor.h
│ │ │ ├── program_name.cc
│ │ │ ├── program_name.h
│ │ │ ├── program_name_test.cc
│ │ │ ├── registry.h
│ │ │ ├── sequence_lock.h
│ │ │ ├── sequence_lock_test.cc
│ │ │ ├── usage.cc
│ │ │ ├── usage.h
│ │ │ └── usage_test.cc
│ │ ├── marshalling.cc
│ │ ├── marshalling.h
│ │ ├── marshalling_test.cc
│ │ ├── parse.cc
│ │ ├── parse.h
│ │ ├── parse_test.cc
│ │ ├── reflection.cc
│ │ ├── reflection.h
│ │ ├── reflection_test.cc
│ │ ├── usage.cc
│ │ ├── usage.h
│ │ ├── usage_config.cc
│ │ ├── usage_config.h
│ │ └── usage_config_test.cc
│ ├── functional/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── any_invocable.h
│ │ ├── any_invocable_test.cc
│ │ ├── bind_front.h
│ │ ├── bind_front_test.cc
│ │ ├── function_ref.h
│ │ ├── function_ref_test.cc
│ │ ├── function_type_benchmark.cc
│ │ ├── internal/
│ │ │ ├── any_invocable.h
│ │ │ ├── front_binder.h
│ │ │ └── function_ref.h
│ │ ├── overload.h
│ │ └── overload_test.cc
│ ├── hash/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── hash.h
│ │ ├── hash_benchmark.cc
│ │ ├── hash_instantiated_test.cc
│ │ ├── hash_test.cc
│ │ ├── hash_testing.h
│ │ └── internal/
│ │ ├── city.cc
│ │ ├── city.h
│ │ ├── city_test.cc
│ │ ├── hash.cc
│ │ ├── hash.h
│ │ ├── hash_test.h
│ │ ├── low_level_hash_test.cc
│ │ ├── print_hash_of.cc
│ │ ├── spy_hash_state.h
│ │ └── weakly_mixed_integer.h
│ ├── log/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── absl_check.h
│ │ ├── absl_check_test.cc
│ │ ├── absl_log.h
│ │ ├── absl_log_basic_test.cc
│ │ ├── absl_vlog_is_on.h
│ │ ├── check.h
│ │ ├── check_test.cc
│ │ ├── check_test_impl.inc
│ │ ├── die_if_null.cc
│ │ ├── die_if_null.h
│ │ ├── die_if_null_test.cc
│ │ ├── flags.cc
│ │ ├── flags.h
│ │ ├── flags_test.cc
│ │ ├── globals.cc
│ │ ├── globals.h
│ │ ├── globals_test.cc
│ │ ├── initialize.cc
│ │ ├── initialize.h
│ │ ├── internal/
│ │ │ ├── BUILD.bazel
│ │ │ ├── append_truncated.h
│ │ │ ├── check_impl.h
│ │ │ ├── check_op.cc
│ │ │ ├── check_op.h
│ │ │ ├── conditions.cc
│ │ │ ├── conditions.h
│ │ │ ├── config.h
│ │ │ ├── container.h
│ │ │ ├── container_test.cc
│ │ │ ├── flags.h
│ │ │ ├── fnmatch.cc
│ │ │ ├── fnmatch.h
│ │ │ ├── fnmatch_benchmark.cc
│ │ │ ├── fnmatch_test.cc
│ │ │ ├── globals.cc
│ │ │ ├── globals.h
│ │ │ ├── log_format.cc
│ │ │ ├── log_format.h
│ │ │ ├── log_impl.h
│ │ │ ├── log_message.cc
│ │ │ ├── log_message.h
│ │ │ ├── log_sink_set.cc
│ │ │ ├── log_sink_set.h
│ │ │ ├── nullguard.cc
│ │ │ ├── nullguard.h
│ │ │ ├── nullstream.h
│ │ │ ├── proto.cc
│ │ │ ├── proto.h
│ │ │ ├── stderr_log_sink_test.cc
│ │ │ ├── strip.h
│ │ │ ├── structured.h
│ │ │ ├── structured_proto.cc
│ │ │ ├── structured_proto.h
│ │ │ ├── structured_proto_test.cc
│ │ │ ├── test_actions.cc
│ │ │ ├── test_actions.h
│ │ │ ├── test_helpers.cc
│ │ │ ├── test_helpers.h
│ │ │ ├── test_matchers.cc
│ │ │ ├── test_matchers.h
│ │ │ ├── vlog_config.cc
│ │ │ ├── vlog_config.h
│ │ │ ├── vlog_config_benchmark.cc
│ │ │ └── voidify.h
│ │ ├── log.h
│ │ ├── log_basic_test.cc
│ │ ├── log_basic_test_impl.inc
│ │ ├── log_benchmark.cc
│ │ ├── log_entry.cc
│ │ ├── log_entry.h
│ │ ├── log_entry_test.cc
│ │ ├── log_format_test.cc
│ │ ├── log_macro_hygiene_test.cc
│ │ ├── log_modifier_methods_test.cc
│ │ ├── log_sink.cc
│ │ ├── log_sink.h
│ │ ├── log_sink_registry.h
│ │ ├── log_sink_test.cc
│ │ ├── log_streamer.h
│ │ ├── log_streamer_test.cc
│ │ ├── scoped_mock_log.cc
│ │ ├── scoped_mock_log.h
│ │ ├── scoped_mock_log_test.cc
│ │ ├── stripping_test.cc
│ │ ├── structured.h
│ │ ├── structured_test.cc
│ │ ├── vlog_is_on.h
│ │ └── vlog_is_on_test.cc
│ ├── memory/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── memory.h
│ │ └── memory_test.cc
│ ├── meta/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── internal/
│ │ │ ├── constexpr_testing.h
│ │ │ ├── constexpr_testing_test.cc
│ │ │ ├── requires.h
│ │ │ └── requires_test.cc
│ │ ├── type_traits.h
│ │ └── type_traits_test.cc
│ ├── numeric/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── bits.h
│ │ ├── bits_benchmark.cc
│ │ ├── bits_test.cc
│ │ ├── int128.cc
│ │ ├── int128.h
│ │ ├── int128_benchmark.cc
│ │ ├── int128_have_intrinsic.inc
│ │ ├── int128_no_intrinsic.inc
│ │ ├── int128_stream_test.cc
│ │ ├── int128_test.cc
│ │ └── internal/
│ │ ├── bits.h
│ │ └── representation.h
│ ├── profiling/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── hashtable.cc
│ │ ├── hashtable.h
│ │ └── internal/
│ │ ├── exponential_biased.cc
│ │ ├── exponential_biased.h
│ │ ├── exponential_biased_test.cc
│ │ ├── periodic_sampler.cc
│ │ ├── periodic_sampler.h
│ │ ├── periodic_sampler_benchmark.cc
│ │ ├── periodic_sampler_test.cc
│ │ ├── profile_builder.cc
│ │ ├── profile_builder.h
│ │ ├── sample_recorder.h
│ │ └── sample_recorder_test.cc
│ ├── random/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── benchmarks.cc
│ │ ├── bernoulli_distribution.h
│ │ ├── bernoulli_distribution_test.cc
│ │ ├── beta_distribution.h
│ │ ├── beta_distribution_test.cc
│ │ ├── bit_gen_ref.h
│ │ ├── bit_gen_ref_test.cc
│ │ ├── discrete_distribution.cc
│ │ ├── discrete_distribution.h
│ │ ├── discrete_distribution_test.cc
│ │ ├── distributions.h
│ │ ├── distributions_test.cc
│ │ ├── examples_test.cc
│ │ ├── exponential_distribution.h
│ │ ├── exponential_distribution_test.cc
│ │ ├── gaussian_distribution.cc
│ │ ├── gaussian_distribution.h
│ │ ├── gaussian_distribution_test.cc
│ │ ├── generators_test.cc
│ │ ├── internal/
│ │ │ ├── BUILD.bazel
│ │ │ ├── chi_square.cc
│ │ │ ├── chi_square.h
│ │ │ ├── chi_square_test.cc
│ │ │ ├── distribution_caller.h
│ │ │ ├── distribution_test_util.cc
│ │ │ ├── distribution_test_util.h
│ │ │ ├── distribution_test_util_test.cc
│ │ │ ├── entropy_pool.cc
│ │ │ ├── entropy_pool.h
│ │ │ ├── entropy_pool_test.cc
│ │ │ ├── explicit_seed_seq.h
│ │ │ ├── explicit_seed_seq_test.cc
│ │ │ ├── fast_uniform_bits.h
│ │ │ ├── fast_uniform_bits_test.cc
│ │ │ ├── fastmath.h
│ │ │ ├── fastmath_test.cc
│ │ │ ├── gaussian_distribution_gentables.cc
│ │ │ ├── generate_real.h
│ │ │ ├── generate_real_test.cc
│ │ │ ├── iostream_state_saver.h
│ │ │ ├── iostream_state_saver_test.cc
│ │ │ ├── mock_helpers.h
│ │ │ ├── mock_overload_set.h
│ │ │ ├── mock_validators.h
│ │ │ ├── nanobenchmark.cc
│ │ │ ├── nanobenchmark.h
│ │ │ ├── nanobenchmark_test.cc
│ │ │ ├── nonsecure_base.h
│ │ │ ├── nonsecure_base_test.cc
│ │ │ ├── pcg_engine.h
│ │ │ ├── pcg_engine_test.cc
│ │ │ ├── platform.h
│ │ │ ├── randen.cc
│ │ │ ├── randen.h
│ │ │ ├── randen_benchmarks.cc
│ │ │ ├── randen_detect.cc
│ │ │ ├── randen_detect.h
│ │ │ ├── randen_engine.h
│ │ │ ├── randen_engine_test.cc
│ │ │ ├── randen_hwaes.cc
│ │ │ ├── randen_hwaes.h
│ │ │ ├── randen_hwaes_test.cc
│ │ │ ├── randen_round_keys.cc
│ │ │ ├── randen_slow.cc
│ │ │ ├── randen_slow.h
│ │ │ ├── randen_slow_test.cc
│ │ │ ├── randen_test.cc
│ │ │ ├── randen_traits.h
│ │ │ ├── salted_seed_seq.h
│ │ │ ├── salted_seed_seq_test.cc
│ │ │ ├── seed_material.cc
│ │ │ ├── seed_material.h
│ │ │ ├── seed_material_test.cc
│ │ │ ├── sequence_urbg.h
│ │ │ ├── traits.h
│ │ │ ├── traits_test.cc
│ │ │ ├── uniform_helper.h
│ │ │ ├── uniform_helper_test.cc
│ │ │ ├── wide_multiply.h
│ │ │ └── wide_multiply_test.cc
│ │ ├── log_uniform_int_distribution.h
│ │ ├── log_uniform_int_distribution_test.cc
│ │ ├── mock_distributions.h
│ │ ├── mock_distributions_test.cc
│ │ ├── mocking_bit_gen.h
│ │ ├── mocking_bit_gen_test.cc
│ │ ├── poisson_distribution.h
│ │ ├── poisson_distribution_test.cc
│ │ ├── random.h
│ │ ├── seed_gen_exception.cc
│ │ ├── seed_gen_exception.h
│ │ ├── seed_sequences.cc
│ │ ├── seed_sequences.h
│ │ ├── seed_sequences_test.cc
│ │ ├── uniform_int_distribution.h
│ │ ├── uniform_int_distribution_test.cc
│ │ ├── uniform_real_distribution.h
│ │ ├── uniform_real_distribution_test.cc
│ │ ├── zipf_distribution.h
│ │ └── zipf_distribution_test.cc
│ ├── status/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── internal/
│ │ │ ├── status_internal.cc
│ │ │ ├── status_internal.h
│ │ │ ├── status_matchers.cc
│ │ │ ├── status_matchers.h
│ │ │ └── statusor_internal.h
│ │ ├── status.cc
│ │ ├── status.h
│ │ ├── status_benchmark.cc
│ │ ├── status_matchers.h
│ │ ├── status_matchers_test.cc
│ │ ├── status_payload_printer.cc
│ │ ├── status_payload_printer.h
│ │ ├── status_test.cc
│ │ ├── statusor.cc
│ │ ├── statusor.h
│ │ ├── statusor_benchmark.cc
│ │ └── statusor_test.cc
│ ├── strings/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── ascii.cc
│ │ ├── ascii.h
│ │ ├── ascii_benchmark.cc
│ │ ├── ascii_test.cc
│ │ ├── atod_manual_test.cc
│ │ ├── char_formatting_test.cc
│ │ ├── charconv.cc
│ │ ├── charconv.h
│ │ ├── charconv_benchmark.cc
│ │ ├── charconv_test.cc
│ │ ├── charset.h
│ │ ├── charset_benchmark.cc
│ │ ├── charset_test.cc
│ │ ├── cord.cc
│ │ ├── cord.h
│ │ ├── cord_analysis.cc
│ │ ├── cord_analysis.h
│ │ ├── cord_buffer.h
│ │ ├── cord_buffer_test.cc
│ │ ├── cord_test.cc
│ │ ├── cord_test_helpers.h
│ │ ├── cordz_test.cc
│ │ ├── cordz_test_helpers.h
│ │ ├── escaping.cc
│ │ ├── escaping.h
│ │ ├── escaping_benchmark.cc
│ │ ├── escaping_test.cc
│ │ ├── has_absl_stringify.h
│ │ ├── has_absl_stringify_test.cc
│ │ ├── has_ostream_operator.h
│ │ ├── has_ostream_operator_test.cc
│ │ ├── internal/
│ │ │ ├── append_and_overwrite.h
│ │ │ ├── append_and_overwrite_test.cc
│ │ │ ├── charconv_bigint.cc
│ │ │ ├── charconv_bigint.h
│ │ │ ├── charconv_bigint_test.cc
│ │ │ ├── charconv_parse.cc
│ │ │ ├── charconv_parse.h
│ │ │ ├── charconv_parse_test.cc
│ │ │ ├── cord_data_edge.h
│ │ │ ├── cord_data_edge_test.cc
│ │ │ ├── cord_internal.cc
│ │ │ ├── cord_internal.h
│ │ │ ├── cord_rep_btree.cc
│ │ │ ├── cord_rep_btree.h
│ │ │ ├── cord_rep_btree_navigator.cc
│ │ │ ├── cord_rep_btree_navigator.h
│ │ │ ├── cord_rep_btree_navigator_test.cc
│ │ │ ├── cord_rep_btree_reader.cc
│ │ │ ├── cord_rep_btree_reader.h
│ │ │ ├── cord_rep_btree_reader_test.cc
│ │ │ ├── cord_rep_btree_test.cc
│ │ │ ├── cord_rep_consume.cc
│ │ │ ├── cord_rep_consume.h
│ │ │ ├── cord_rep_crc.cc
│ │ │ ├── cord_rep_crc.h
│ │ │ ├── cord_rep_crc_test.cc
│ │ │ ├── cord_rep_flat.h
│ │ │ ├── cord_rep_test_util.h
│ │ │ ├── cordz_functions.cc
│ │ │ ├── cordz_functions.h
│ │ │ ├── cordz_functions_test.cc
│ │ │ ├── cordz_handle.cc
│ │ │ ├── cordz_handle.h
│ │ │ ├── cordz_handle_test.cc
│ │ │ ├── cordz_info.cc
│ │ │ ├── cordz_info.h
│ │ │ ├── cordz_info_statistics_test.cc
│ │ │ ├── cordz_info_test.cc
│ │ │ ├── cordz_sample_token.cc
│ │ │ ├── cordz_sample_token.h
│ │ │ ├── cordz_sample_token_test.cc
│ │ │ ├── cordz_statistics.h
│ │ │ ├── cordz_update_scope.h
│ │ │ ├── cordz_update_scope_test.cc
│ │ │ ├── cordz_update_tracker.h
│ │ │ ├── cordz_update_tracker_test.cc
│ │ │ ├── damerau_levenshtein_distance.cc
│ │ │ ├── damerau_levenshtein_distance.h
│ │ │ ├── damerau_levenshtein_distance_benchmark.cc
│ │ │ ├── damerau_levenshtein_distance_test.cc
│ │ │ ├── escaping.cc
│ │ │ ├── escaping.h
│ │ │ ├── escaping_test_common.h
│ │ │ ├── generic_printer.cc
│ │ │ ├── generic_printer.h
│ │ │ ├── generic_printer_internal.h
│ │ │ ├── generic_printer_test.cc
│ │ │ ├── memutil.cc
│ │ │ ├── memutil.h
│ │ │ ├── memutil_benchmark.cc
│ │ │ ├── memutil_test.cc
│ │ │ ├── numbers_test_common.h
│ │ │ ├── ostringstream.cc
│ │ │ ├── ostringstream.h
│ │ │ ├── ostringstream_benchmark.cc
│ │ │ ├── ostringstream_test.cc
│ │ │ ├── pow10_helper.cc
│ │ │ ├── pow10_helper.h
│ │ │ ├── pow10_helper_test.cc
│ │ │ ├── resize_uninitialized.h
│ │ │ ├── resize_uninitialized_test.cc
│ │ │ ├── stl_type_traits.h
│ │ │ ├── str_format/
│ │ │ │ ├── arg.cc
│ │ │ │ ├── arg.h
│ │ │ │ ├── arg_test.cc
│ │ │ │ ├── bind.cc
│ │ │ │ ├── bind.h
│ │ │ │ ├── bind_test.cc
│ │ │ │ ├── checker.h
│ │ │ │ ├── checker_test.cc
│ │ │ │ ├── constexpr_parser.h
│ │ │ │ ├── convert_test.cc
│ │ │ │ ├── extension.cc
│ │ │ │ ├── extension.h
│ │ │ │ ├── extension_test.cc
│ │ │ │ ├── float_conversion.cc
│ │ │ │ ├── float_conversion.h
│ │ │ │ ├── output.cc
│ │ │ │ ├── output.h
│ │ │ │ ├── output_test.cc
│ │ │ │ ├── parser.cc
│ │ │ │ ├── parser.h
│ │ │ │ └── parser_test.cc
│ │ │ ├── str_join_internal.h
│ │ │ ├── str_split_internal.h
│ │ │ ├── string_constant.h
│ │ │ ├── string_constant_test.cc
│ │ │ ├── stringify_sink.cc
│ │ │ ├── stringify_sink.h
│ │ │ ├── stringify_stream.h
│ │ │ ├── stringify_stream_test.cc
│ │ │ ├── utf8.cc
│ │ │ ├── utf8.h
│ │ │ └── utf8_test.cc
│ │ ├── match.cc
│ │ ├── match.h
│ │ ├── match_test.cc
│ │ ├── numbers.cc
│ │ ├── numbers.h
│ │ ├── numbers_benchmark.cc
│ │ ├── numbers_test.cc
│ │ ├── resize_and_overwrite.h
│ │ ├── resize_and_overwrite_test.cc
│ │ ├── str_cat.cc
│ │ ├── str_cat.h
│ │ ├── str_cat_benchmark.cc
│ │ ├── str_cat_test.cc
│ │ ├── str_format.h
│ │ ├── str_format_test.cc
│ │ ├── str_join.h
│ │ ├── str_join_benchmark.cc
│ │ ├── str_join_test.cc
│ │ ├── str_replace.cc
│ │ ├── str_replace.h
│ │ ├── str_replace_benchmark.cc
│ │ ├── str_replace_test.cc
│ │ ├── str_split.cc
│ │ ├── str_split.h
│ │ ├── str_split_benchmark.cc
│ │ ├── str_split_test.cc
│ │ ├── string_view.h
│ │ ├── string_view_test.cc
│ │ ├── strip.h
│ │ ├── strip_test.cc
│ │ ├── substitute.cc
│ │ ├── substitute.h
│ │ ├── substitute_benchmark.cc
│ │ └── substitute_test.cc
│ ├── synchronization/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── barrier.cc
│ │ ├── barrier.h
│ │ ├── barrier_test.cc
│ │ ├── blocking_counter.cc
│ │ ├── blocking_counter.h
│ │ ├── blocking_counter_benchmark.cc
│ │ ├── blocking_counter_test.cc
│ │ ├── internal/
│ │ │ ├── create_thread_identity.cc
│ │ │ ├── create_thread_identity.h
│ │ │ ├── futex.h
│ │ │ ├── futex_waiter.cc
│ │ │ ├── futex_waiter.h
│ │ │ ├── graphcycles.cc
│ │ │ ├── graphcycles.h
│ │ │ ├── graphcycles_benchmark.cc
│ │ │ ├── graphcycles_test.cc
│ │ │ ├── kernel_timeout.cc
│ │ │ ├── kernel_timeout.h
│ │ │ ├── kernel_timeout_test.cc
│ │ │ ├── per_thread_sem.cc
│ │ │ ├── per_thread_sem.h
│ │ │ ├── per_thread_sem_test.cc
│ │ │ ├── pthread_waiter.cc
│ │ │ ├── pthread_waiter.h
│ │ │ ├── sem_waiter.cc
│ │ │ ├── sem_waiter.h
│ │ │ ├── stdcpp_waiter.cc
│ │ │ ├── stdcpp_waiter.h
│ │ │ ├── thread_pool.h
│ │ │ ├── waiter.h
│ │ │ ├── waiter_base.cc
│ │ │ ├── waiter_base.h
│ │ │ ├── waiter_test.cc
│ │ │ ├── win32_waiter.cc
│ │ │ └── win32_waiter.h
│ │ ├── lifetime_test.cc
│ │ ├── mutex.cc
│ │ ├── mutex.h
│ │ ├── mutex_benchmark.cc
│ │ ├── mutex_method_pointer_test.cc
│ │ ├── mutex_test.cc
│ │ ├── notification.cc
│ │ ├── notification.h
│ │ └── notification_test.cc
│ ├── time/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── civil_time.cc
│ │ ├── civil_time.h
│ │ ├── civil_time_benchmark.cc
│ │ ├── civil_time_test.cc
│ │ ├── clock.cc
│ │ ├── clock.h
│ │ ├── clock_benchmark.cc
│ │ ├── clock_interface.cc
│ │ ├── clock_interface.h
│ │ ├── clock_interface_test.cc
│ │ ├── clock_test.cc
│ │ ├── duration.cc
│ │ ├── duration_benchmark.cc
│ │ ├── duration_test.cc
│ │ ├── flag_test.cc
│ │ ├── format.cc
│ │ ├── format_benchmark.cc
│ │ ├── format_test.cc
│ │ ├── internal/
│ │ │ ├── cctz/
│ │ │ │ ├── BUILD.bazel
│ │ │ │ ├── include/
│ │ │ │ │ └── cctz/
│ │ │ │ │ ├── civil_time.h
│ │ │ │ │ ├── civil_time_detail.h
│ │ │ │ │ ├── time_zone.h
│ │ │ │ │ └── zone_info_source.h
│ │ │ │ ├── src/
│ │ │ │ │ ├── cctz_benchmark.cc
│ │ │ │ │ ├── civil_time_detail.cc
│ │ │ │ │ ├── civil_time_test.cc
│ │ │ │ │ ├── test_time_zone_names.cc
│ │ │ │ │ ├── test_time_zone_names.h
│ │ │ │ │ ├── time_zone_fixed.cc
│ │ │ │ │ ├── time_zone_fixed.h
│ │ │ │ │ ├── time_zone_format.cc
│ │ │ │ │ ├── time_zone_format_test.cc
│ │ │ │ │ ├── time_zone_if.cc
│ │ │ │ │ ├── time_zone_if.h
│ │ │ │ │ ├── time_zone_impl.cc
│ │ │ │ │ ├── time_zone_impl.h
│ │ │ │ │ ├── time_zone_info.cc
│ │ │ │ │ ├── time_zone_info.h
│ │ │ │ │ ├── time_zone_libc.cc
│ │ │ │ │ ├── time_zone_libc.h
│ │ │ │ │ ├── time_zone_lookup.cc
│ │ │ │ │ ├── time_zone_lookup_test.cc
│ │ │ │ │ ├── time_zone_name_win.cc
│ │ │ │ │ ├── time_zone_name_win.h
│ │ │ │ │ ├── time_zone_posix.cc
│ │ │ │ │ ├── time_zone_posix.h
│ │ │ │ │ ├── tzfile.h
│ │ │ │ │ └── zone_info_source.cc
│ │ │ │ └── testdata/
│ │ │ │ ├── README.zoneinfo
│ │ │ │ ├── version
│ │ │ │ └── zoneinfo/
│ │ │ │ ├── Africa/
│ │ │ │ │ ├── Abidjan
│ │ │ │ │ ├── Accra
│ │ │ │ │ ├── Addis_Ababa
│ │ │ │ │ ├── Algiers
│ │ │ │ │ ├── Asmara
│ │ │ │ │ ├── Asmera
│ │ │ │ │ ├── Bamako
│ │ │ │ │ ├── Bangui
│ │ │ │ │ ├── Banjul
│ │ │ │ │ ├── Bissau
│ │ │ │ │ ├── Blantyre
│ │ │ │ │ ├── Brazzaville
│ │ │ │ │ ├── Bujumbura
│ │ │ │ │ ├── Cairo
│ │ │ │ │ ├── Casablanca
│ │ │ │ │ ├── Ceuta
│ │ │ │ │ ├── Conakry
│ │ │ │ │ ├── Dakar
│ │ │ │ │ ├── Dar_es_Salaam
│ │ │ │ │ ├── Djibouti
│ │ │ │ │ ├── Douala
│ │ │ │ │ ├── El_Aaiun
│ │ │ │ │ ├── Freetown
│ │ │ │ │ ├── Gaborone
│ │ │ │ │ ├── Harare
│ │ │ │ │ ├── Johannesburg
│ │ │ │ │ ├── Juba
│ │ │ │ │ ├── Kampala
│ │ │ │ │ ├── Khartoum
│ │ │ │ │ ├── Kigali
│ │ │ │ │ ├── Kinshasa
│ │ │ │ │ ├── Lagos
│ │ │ │ │ ├── Libreville
│ │ │ │ │ ├── Lome
│ │ │ │ │ ├── Luanda
│ │ │ │ │ ├── Lubumbashi
│ │ │ │ │ ├── Lusaka
│ │ │ │ │ ├── Malabo
│ │ │ │ │ ├── Maputo
│ │ │ │ │ ├── Maseru
│ │ │ │ │ ├── Mbabane
│ │ │ │ │ ├── Mogadishu
│ │ │ │ │ ├── Monrovia
│ │ │ │ │ ├── Nairobi
│ │ │ │ │ ├── Ndjamena
│ │ │ │ │ ├── Niamey
│ │ │ │ │ ├── Nouakchott
│ │ │ │ │ ├── Ouagadougou
│ │ │ │ │ ├── Porto-Novo
│ │ │ │ │ ├── Sao_Tome
│ │ │ │ │ ├── Timbuktu
│ │ │ │ │ ├── Tripoli
│ │ │ │ │ ├── Tunis
│ │ │ │ │ └── Windhoek
│ │ │ │ ├── America/
│ │ │ │ │ ├── Adak
│ │ │ │ │ ├── Anchorage
│ │ │ │ │ ├── Anguilla
│ │ │ │ │ ├── Antigua
│ │ │ │ │ ├── Araguaina
│ │ │ │ │ ├── Argentina/
│ │ │ │ │ │ ├── Buenos_Aires
│ │ │ │ │ │ ├── Catamarca
│ │ │ │ │ │ ├── ComodRivadavia
│ │ │ │ │ │ ├── Cordoba
│ │ │ │ │ │ ├── Jujuy
│ │ │ │ │ │ ├── La_Rioja
│ │ │ │ │ │ ├── Mendoza
│ │ │ │ │ │ ├── Rio_Gallegos
│ │ │ │ │ │ ├── Salta
│ │ │ │ │ │ ├── San_Juan
│ │ │ │ │ │ ├── San_Luis
│ │ │ │ │ │ ├── Tucuman
│ │ │ │ │ │ └── Ushuaia
│ │ │ │ │ ├── Aruba
│ │ │ │ │ ├── Asuncion
│ │ │ │ │ ├── Atikokan
│ │ │ │ │ ├── Atka
│ │ │ │ │ ├── Bahia
│ │ │ │ │ ├── Bahia_Banderas
│ │ │ │ │ ├── Barbados
│ │ │ │ │ ├── Belem
│ │ │ │ │ ├── Belize
│ │ │ │ │ ├── Blanc-Sablon
│ │ │ │ │ ├── Boa_Vista
│ │ │ │ │ ├── Bogota
│ │ │ │ │ ├── Boise
│ │ │ │ │ ├── Buenos_Aires
│ │ │ │ │ ├── Cambridge_Bay
│ │ │ │ │ ├── Campo_Grande
│ │ │ │ │ ├── Cancun
│ │ │ │ │ ├── Caracas
│ │ │ │ │ ├── Catamarca
│ │ │ │ │ ├── Cayenne
│ │ │ │ │ ├── Cayman
│ │ │ │ │ ├── Chicago
│ │ │ │ │ ├── Chihuahua
│ │ │ │ │ ├── Ciudad_Juarez
│ │ │ │ │ ├── Coral_Harbour
│ │ │ │ │ ├── Cordoba
│ │ │ │ │ ├── Costa_Rica
│ │ │ │ │ ├── Coyhaique
│ │ │ │ │ ├── Creston
│ │ │ │ │ ├── Cuiaba
│ │ │ │ │ ├── Curacao
│ │ │ │ │ ├── Danmarkshavn
│ │ │ │ │ ├── Dawson
│ │ │ │ │ ├── Dawson_Creek
│ │ │ │ │ ├── Denver
│ │ │ │ │ ├── Detroit
│ │ │ │ │ ├── Dominica
│ │ │ │ │ ├── Edmonton
│ │ │ │ │ ├── Eirunepe
│ │ │ │ │ ├── El_Salvador
│ │ │ │ │ ├── Ensenada
│ │ │ │ │ ├── Fort_Nelson
│ │ │ │ │ ├── Fort_Wayne
│ │ │ │ │ ├── Fortaleza
│ │ │ │ │ ├── Glace_Bay
│ │ │ │ │ ├── Godthab
│ │ │ │ │ ├── Goose_Bay
│ │ │ │ │ ├── Grand_Turk
│ │ │ │ │ ├── Grenada
│ │ │ │ │ ├── Guadeloupe
│ │ │ │ │ ├── Guatemala
│ │ │ │ │ ├── Guayaquil
│ │ │ │ │ ├── Guyana
│ │ │ │ │ ├── Halifax
│ │ │ │ │ ├── Havana
│ │ │ │ │ ├── Hermosillo
│ │ │ │ │ ├── Indiana/
│ │ │ │ │ │ ├── Indianapolis
│ │ │ │ │ │ ├── Knox
│ │ │ │ │ │ ├── Marengo
│ │ │ │ │ │ ├── Petersburg
│ │ │ │ │ │ ├── Tell_City
│ │ │ │ │ │ ├── Vevay
│ │ │ │ │ │ ├── Vincennes
│ │ │ │ │ │ └── Winamac
│ │ │ │ │ ├── Indianapolis
│ │ │ │ │ ├── Inuvik
│ │ │ │ │ ├── Iqaluit
│ │ │ │ │ ├── Jamaica
│ │ │ │ │ ├── Jujuy
│ │ │ │ │ ├── Juneau
│ │ │ │ │ ├── Kentucky/
│ │ │ │ │ │ ├── Louisville
│ │ │ │ │ │ └── Monticello
│ │ │ │ │ ├── Knox_IN
│ │ │ │ │ ├── Kralendijk
│ │ │ │ │ ├── La_Paz
│ │ │ │ │ ├── Lima
│ │ │ │ │ ├── Los_Angeles
│ │ │ │ │ ├── Louisville
│ │ │ │ │ ├── Lower_Princes
│ │ │ │ │ ├── Maceio
│ │ │ │ │ ├── Managua
│ │ │ │ │ ├── Manaus
│ │ │ │ │ ├── Marigot
│ │ │ │ │ ├── Martinique
│ │ │ │ │ ├── Matamoros
│ │ │ │ │ ├── Mazatlan
│ │ │ │ │ ├── Mendoza
│ │ │ │ │ ├── Menominee
│ │ │ │ │ ├── Merida
│ │ │ │ │ ├── Metlakatla
│ │ │ │ │ ├── Mexico_City
│ │ │ │ │ ├── Miquelon
│ │ │ │ │ ├── Moncton
│ │ │ │ │ ├── Monterrey
│ │ │ │ │ ├── Montevideo
│ │ │ │ │ ├── Montreal
│ │ │ │ │ ├── Montserrat
│ │ │ │ │ ├── Nassau
│ │ │ │ │ ├── New_York
│ │ │ │ │ ├── Nipigon
│ │ │ │ │ ├── Nome
│ │ │ │ │ ├── Noronha
│ │ │ │ │ ├── North_Dakota/
│ │ │ │ │ │ ├── Beulah
│ │ │ │ │ │ ├── Center
│ │ │ │ │ │ └── New_Salem
│ │ │ │ │ ├── Nuuk
│ │ │ │ │ ├── Ojinaga
│ │ │ │ │ ├── Panama
│ │ │ │ │ ├── Pangnirtung
│ │ │ │ │ ├── Paramaribo
│ │ │ │ │ ├── Phoenix
│ │ │ │ │ ├── Port-au-Prince
│ │ │ │ │ ├── Port_of_Spain
│ │ │ │ │ ├── Porto_Acre
│ │ │ │ │ ├── Porto_Velho
│ │ │ │ │ ├── Puerto_Rico
│ │ │ │ │ ├── Punta_Arenas
│ │ │ │ │ ├── Rainy_River
│ │ │ │ │ ├── Rankin_Inlet
│ │ │ │ │ ├── Recife
│ │ │ │ │ ├── Regina
│ │ │ │ │ ├── Resolute
│ │ │ │ │ ├── Rio_Branco
│ │ │ │ │ ├── Rosario
│ │ │ │ │ ├── Santa_Isabel
│ │ │ │ │ ├── Santarem
│ │ │ │ │ ├── Santiago
│ │ │ │ │ ├── Santo_Domingo
│ │ │ │ │ ├── Sao_Paulo
│ │ │ │ │ ├── Scoresbysund
│ │ │ │ │ ├── Shiprock
│ │ │ │ │ ├── Sitka
│ │ │ │ │ ├── St_Barthelemy
│ │ │ │ │ ├── St_Johns
│ │ │ │ │ ├── St_Kitts
│ │ │ │ │ ├── St_Lucia
│ │ │ │ │ ├── St_Thomas
│ │ │ │ │ ├── St_Vincent
│ │ │ │ │ ├── Swift_Current
│ │ │ │ │ ├── Tegucigalpa
│ │ │ │ │ ├── Thule
│ │ │ │ │ ├── Thunder_Bay
│ │ │ │ │ ├── Tijuana
│ │ │ │ │ ├── Toronto
│ │ │ │ │ ├── Tortola
│ │ │ │ │ ├── Vancouver
│ │ │ │ │ ├── Virgin
│ │ │ │ │ ├── Whitehorse
│ │ │ │ │ ├── Winnipeg
│ │ │ │ │ ├── Yakutat
│ │ │ │ │ └── Yellowknife
│ │ │ │ ├── Antarctica/
│ │ │ │ │ ├── Casey
│ │ │ │ │ ├── Davis
│ │ │ │ │ ├── DumontDUrville
│ │ │ │ │ ├── Macquarie
│ │ │ │ │ ├── Mawson
│ │ │ │ │ ├── McMurdo
│ │ │ │ │ ├── Palmer
│ │ │ │ │ ├── Rothera
│ │ │ │ │ ├── South_Pole
│ │ │ │ │ ├── Syowa
│ │ │ │ │ ├── Troll
│ │ │ │ │ └── Vostok
│ │ │ │ ├── Arctic/
│ │ │ │ │ └── Longyearbyen
│ │ │ │ ├── Asia/
│ │ │ │ │ ├── Aden
│ │ │ │ │ ├── Almaty
│ │ │ │ │ ├── Amman
│ │ │ │ │ ├── Anadyr
│ │ │ │ │ ├── Aqtau
│ │ │ │ │ ├── Aqtobe
│ │ │ │ │ ├── Ashgabat
│ │ │ │ │ ├── Ashkhabad
│ │ │ │ │ ├── Atyrau
│ │ │ │ │ ├── Baghdad
│ │ │ │ │ ├── Bahrain
│ │ │ │ │ ├── Baku
│ │ │ │ │ ├── Bangkok
│ │ │ │ │ ├── Barnaul
│ │ │ │ │ ├── Beirut
│ │ │ │ │ ├── Bishkek
│ │ │ │ │ ├── Brunei
│ │ │ │ │ ├── Calcutta
│ │ │ │ │ ├── Chita
│ │ │ │ │ ├── Choibalsan
│ │ │ │ │ ├── Chongqing
│ │ │ │ │ ├── Chungking
│ │ │ │ │ ├── Colombo
│ │ │ │ │ ├── Dacca
│ │ │ │ │ ├── Damascus
│ │ │ │ │ ├── Dhaka
│ │ │ │ │ ├── Dili
│ │ │ │ │ ├── Dubai
│ │ │ │ │ ├── Dushanbe
│ │ │ │ │ ├── Famagusta
│ │ │ │ │ ├── Gaza
│ │ │ │ │ ├── Harbin
│ │ │ │ │ ├── Hebron
│ │ │ │ │ ├── Ho_Chi_Minh
│ │ │ │ │ ├── Hong_Kong
│ │ │ │ │ ├── Hovd
│ │ │ │ │ ├── Irkutsk
│ │ │ │ │ ├── Istanbul
│ │ │ │ │ ├── Jakarta
│ │ │ │ │ ├── Jayapura
│ │ │ │ │ ├── Jerusalem
│ │ │ │ │ ├── Kabul
│ │ │ │ │ ├── Kamchatka
│ │ │ │ │ ├── Karachi
│ │ │ │ │ ├── Kashgar
│ │ │ │ │ ├── Kathmandu
│ │ │ │ │ ├── Katmandu
│ │ │ │ │ ├── Khandyga
│ │ │ │ │ ├── Kolkata
│ │ │ │ │ ├── Krasnoyarsk
│ │ │ │ │ ├── Kuala_Lumpur
│ │ │ │ │ ├── Kuching
│ │ │ │ │ ├── Kuwait
│ │ │ │ │ ├── Macao
│ │ │ │ │ ├── Macau
│ │ │ │ │ ├── Magadan
│ │ │ │ │ ├── Makassar
│ │ │ │ │ ├── Manila
│ │ │ │ │ ├── Muscat
│ │ │ │ │ ├── Nicosia
│ │ │ │ │ ├── Novokuznetsk
│ │ │ │ │ ├── Novosibirsk
│ │ │ │ │ ├── Omsk
│ │ │ │ │ ├── Oral
│ │ │ │ │ ├── Phnom_Penh
│ │ │ │ │ ├── Pontianak
│ │ │ │ │ ├── Pyongyang
│ │ │ │ │ ├── Qatar
│ │ │ │ │ ├── Qostanay
│ │ │ │ │ ├── Qyzylorda
│ │ │ │ │ ├── Rangoon
│ │ │ │ │ ├── Riyadh
│ │ │ │ │ ├── Saigon
│ │ │ │ │ ├── Sakhalin
│ │ │ │ │ ├── Samarkand
│ │ │ │ │ ├── Seoul
│ │ │ │ │ ├── Shanghai
│ │ │ │ │ ├── Singapore
│ │ │ │ │ ├── Srednekolymsk
│ │ │ │ │ ├── Taipei
│ │ │ │ │ ├── Tashkent
│ │ │ │ │ ├── Tbilisi
│ │ │ │ │ ├── Tehran
│ │ │ │ │ ├── Tel_Aviv
│ │ │ │ │ ├── Thimbu
│ │ │ │ │ ├── Thimphu
│ │ │ │ │ ├── Tokyo
│ │ │ │ │ ├── Tomsk
│ │ │ │ │ ├── Ujung_Pandang
│ │ │ │ │ ├── Ulaanbaatar
│ │ │ │ │ ├── Ulan_Bator
│ │ │ │ │ ├── Urumqi
│ │ │ │ │ ├── Ust-Nera
│ │ │ │ │ ├── Vientiane
│ │ │ │ │ ├── Vladivostok
│ │ │ │ │ ├── Yakutsk
│ │ │ │ │ ├── Yangon
│ │ │ │ │ ├── Yekaterinburg
│ │ │ │ │ └── Yerevan
│ │ │ │ ├── Atlantic/
│ │ │ │ │ ├── Azores
│ │ │ │ │ ├── Bermuda
│ │ │ │ │ ├── Canary
│ │ │ │ │ ├── Cape_Verde
│ │ │ │ │ ├── Faeroe
│ │ │ │ │ ├── Faroe
│ │ │ │ │ ├── Jan_Mayen
│ │ │ │ │ ├── Madeira
│ │ │ │ │ ├── Reykjavik
│ │ │ │ │ ├── South_Georgia
│ │ │ │ │ ├── St_Helena
│ │ │ │ │ └── Stanley
│ │ │ │ ├── Australia/
│ │ │ │ │ ├── ACT
│ │ │ │ │ ├── Adelaide
│ │ │ │ │ ├── Brisbane
│ │ │ │ │ ├── Broken_Hill
│ │ │ │ │ ├── Canberra
│ │ │ │ │ ├── Currie
│ │ │ │ │ ├── Darwin
│ │ │ │ │ ├── Eucla
│ │ │ │ │ ├── Hobart
│ │ │ │ │ ├── LHI
│ │ │ │ │ ├── Lindeman
│ │ │ │ │ ├── Lord_Howe
│ │ │ │ │ ├── Melbourne
│ │ │ │ │ ├── NSW
│ │ │ │ │ ├── North
│ │ │ │ │ ├── Perth
│ │ │ │ │ ├── Queensland
│ │ │ │ │ ├── South
│ │ │ │ │ ├── Sydney
│ │ │ │ │ ├── Tasmania
│ │ │ │ │ ├── Victoria
│ │ │ │ │ ├── West
│ │ │ │ │ └── Yancowinna
│ │ │ │ ├── Brazil/
│ │ │ │ │ ├── Acre
│ │ │ │ │ ├── DeNoronha
│ │ │ │ │ ├── East
│ │ │ │ │ └── West
│ │ │ │ ├── CET
│ │ │ │ ├── CST6CDT
│ │ │ │ ├── Canada/
│ │ │ │ │ ├── Atlantic
│ │ │ │ │ ├── Central
│ │ │ │ │ ├── Eastern
│ │ │ │ │ ├── Mountain
│ │ │ │ │ ├── Newfoundland
│ │ │ │ │ ├── Pacific
│ │ │ │ │ ├── Saskatchewan
│ │ │ │ │ └── Yukon
│ │ │ │ ├── Chile/
│ │ │ │ │ ├── Continental
│ │ │ │ │ └── EasterIsland
│ │ │ │ ├── Cuba
│ │ │ │ ├── EET
│ │ │ │ ├── EST
│ │ │ │ ├── EST5EDT
│ │ │ │ ├── Egypt
│ │ │ │ ├── Eire
│ │ │ │ ├── Etc/
│ │ │ │ │ ├── GMT
│ │ │ │ │ ├── GMT+0
│ │ │ │ │ ├── GMT+1
│ │ │ │ │ ├── GMT+10
│ │ │ │ │ ├── GMT+11
│ │ │ │ │ ├── GMT+12
│ │ │ │ │ ├── GMT+2
│ │ │ │ │ ├── GMT+3
│ │ │ │ │ ├── GMT+4
│ │ │ │ │ ├── GMT+5
│ │ │ │ │ ├── GMT+6
│ │ │ │ │ ├── GMT+7
│ │ │ │ │ ├── GMT+8
│ │ │ │ │ ├── GMT+9
│ │ │ │ │ ├── GMT-0
│ │ │ │ │ ├── GMT-1
│ │ │ │ │ ├── GMT-10
│ │ │ │ │ ├── GMT-11
│ │ │ │ │ ├── GMT-12
│ │ │ │ │ ├── GMT-13
│ │ │ │ │ ├── GMT-14
│ │ │ │ │ ├── GMT-2
│ │ │ │ │ ├── GMT-3
│ │ │ │ │ ├── GMT-4
│ │ │ │ │ ├── GMT-5
│ │ │ │ │ ├── GMT-6
│ │ │ │ │ ├── GMT-7
│ │ │ │ │ ├── GMT-8
│ │ │ │ │ ├── GMT-9
│ │ │ │ │ ├── GMT0
│ │ │ │ │ ├── Greenwich
│ │ │ │ │ ├── UCT
│ │ │ │ │ ├── UTC
│ │ │ │ │ ├── Universal
│ │ │ │ │ └── Zulu
│ │ │ │ ├── Europe/
│ │ │ │ │ ├── Amsterdam
│ │ │ │ │ ├── Andorra
│ │ │ │ │ ├── Astrakhan
│ │ │ │ │ ├── Athens
│ │ │ │ │ ├── Belfast
│ │ │ │ │ ├── Belgrade
│ │ │ │ │ ├── Berlin
│ │ │ │ │ ├── Bratislava
│ │ │ │ │ ├── Brussels
│ │ │ │ │ ├── Bucharest
│ │ │ │ │ ├── Budapest
│ │ │ │ │ ├── Busingen
│ │ │ │ │ ├── Chisinau
│ │ │ │ │ ├── Copenhagen
│ │ │ │ │ ├── Dublin
│ │ │ │ │ ├── Gibraltar
│ │ │ │ │ ├── Guernsey
│ │ │ │ │ ├── Helsinki
│ │ │ │ │ ├── Isle_of_Man
│ │ │ │ │ ├── Istanbul
│ │ │ │ │ ├── Jersey
│ │ │ │ │ ├── Kaliningrad
│ │ │ │ │ ├── Kiev
│ │ │ │ │ ├── Kirov
│ │ │ │ │ ├── Kyiv
│ │ │ │ │ ├── Lisbon
│ │ │ │ │ ├── Ljubljana
│ │ │ │ │ ├── London
│ │ │ │ │ ├── Luxembourg
│ │ │ │ │ ├── Madrid
│ │ │ │ │ ├── Malta
│ │ │ │ │ ├── Mariehamn
│ │ │ │ │ ├── Minsk
│ │ │ │ │ ├── Monaco
│ │ │ │ │ ├── Moscow
│ │ │ │ │ ├── Nicosia
│ │ │ │ │ ├── Oslo
│ │ │ │ │ ├── Paris
│ │ │ │ │ ├── Podgorica
│ │ │ │ │ ├── Prague
│ │ │ │ │ ├── Riga
│ │ │ │ │ ├── Rome
│ │ │ │ │ ├── Samara
│ │ │ │ │ ├── San_Marino
│ │ │ │ │ ├── Sarajevo
│ │ │ │ │ ├── Saratov
│ │ │ │ │ ├── Simferopol
│ │ │ │ │ ├── Skopje
│ │ │ │ │ ├── Sofia
│ │ │ │ │ ├── Stockholm
│ │ │ │ │ ├── Tallinn
│ │ │ │ │ ├── Tirane
│ │ │ │ │ ├── Tiraspol
│ │ │ │ │ ├── Ulyanovsk
│ │ │ │ │ ├── Uzhgorod
│ │ │ │ │ ├── Vaduz
│ │ │ │ │ ├── Vatican
│ │ │ │ │ ├── Vienna
│ │ │ │ │ ├── Vilnius
│ │ │ │ │ ├── Volgograd
│ │ │ │ │ ├── Warsaw
│ │ │ │ │ ├── Zagreb
│ │ │ │ │ ├── Zaporozhye
│ │ │ │ │ └── Zurich
│ │ │ │ ├── Factory
│ │ │ │ ├── GB
│ │ │ │ ├── GB-Eire
│ │ │ │ ├── GMT
│ │ │ │ ├── GMT+0
│ │ │ │ ├── GMT-0
│ │ │ │ ├── GMT0
│ │ │ │ ├── Greenwich
│ │ │ │ ├── HST
│ │ │ │ ├── Hongkong
│ │ │ │ ├── Iceland
│ │ │ │ ├── Indian/
│ │ │ │ │ ├── Antananarivo
│ │ │ │ │ ├── Chagos
│ │ │ │ │ ├── Christmas
│ │ │ │ │ ├── Cocos
│ │ │ │ │ ├── Comoro
│ │ │ │ │ ├── Kerguelen
│ │ │ │ │ ├── Mahe
│ │ │ │ │ ├── Maldives
│ │ │ │ │ ├── Mauritius
│ │ │ │ │ ├── Mayotte
│ │ │ │ │ └── Reunion
│ │ │ │ ├── Iran
│ │ │ │ ├── Israel
│ │ │ │ ├── Jamaica
│ │ │ │ ├── Japan
│ │ │ │ ├── Kwajalein
│ │ │ │ ├── Libya
│ │ │ │ ├── MET
│ │ │ │ ├── MST
│ │ │ │ ├── MST7MDT
│ │ │ │ ├── Mexico/
│ │ │ │ │ ├── BajaNorte
│ │ │ │ │ ├── BajaSur
│ │ │ │ │ └── General
│ │ │ │ ├── NZ
│ │ │ │ ├── NZ-CHAT
│ │ │ │ ├── Navajo
│ │ │ │ ├── PRC
│ │ │ │ ├── PST8PDT
│ │ │ │ ├── Pacific/
│ │ │ │ │ ├── Apia
│ │ │ │ │ ├── Auckland
│ │ │ │ │ ├── Bougainville
│ │ │ │ │ ├── Chatham
│ │ │ │ │ ├── Chuuk
│ │ │ │ │ ├── Easter
│ │ │ │ │ ├── Efate
│ │ │ │ │ ├── Enderbury
│ │ │ │ │ ├── Fakaofo
│ │ │ │ │ ├── Fiji
│ │ │ │ │ ├── Funafuti
│ │ │ │ │ ├── Galapagos
│ │ │ │ │ ├── Gambier
│ │ │ │ │ ├── Guadalcanal
│ │ │ │ │ ├── Guam
│ │ │ │ │ ├── Honolulu
│ │ │ │ │ ├── Johnston
│ │ │ │ │ ├── Kanton
│ │ │ │ │ ├── Kiritimati
│ │ │ │ │ ├── Kosrae
│ │ │ │ │ ├── Kwajalein
│ │ │ │ │ ├── Majuro
│ │ │ │ │ ├── Marquesas
│ │ │ │ │ ├── Midway
│ │ │ │ │ ├── Nauru
│ │ │ │ │ ├── Niue
│ │ │ │ │ ├── Norfolk
│ │ │ │ │ ├── Noumea
│ │ │ │ │ ├── Pago_Pago
│ │ │ │ │ ├── Palau
│ │ │ │ │ ├── Pitcairn
│ │ │ │ │ ├── Pohnpei
│ │ │ │ │ ├── Ponape
│ │ │ │ │ ├── Port_Moresby
│ │ │ │ │ ├── Rarotonga
│ │ │ │ │ ├── Saipan
│ │ │ │ │ ├── Samoa
│ │ │ │ │ ├── Tahiti
│ │ │ │ │ ├── Tarawa
│ │ │ │ │ ├── Tongatapu
│ │ │ │ │ ├── Truk
│ │ │ │ │ ├── Wake
│ │ │ │ │ ├── Wallis
│ │ │ │ │ └── Yap
│ │ │ │ ├── Poland
│ │ │ │ ├── Portugal
│ │ │ │ ├── ROC
│ │ │ │ ├── ROK
│ │ │ │ ├── Singapore
│ │ │ │ ├── Turkey
│ │ │ │ ├── UCT
│ │ │ │ ├── US/
│ │ │ │ │ ├── Alaska
│ │ │ │ │ ├── Aleutian
│ │ │ │ │ ├── Arizona
│ │ │ │ │ ├── Central
│ │ │ │ │ ├── East-Indiana
│ │ │ │ │ ├── Eastern
│ │ │ │ │ ├── Hawaii
│ │ │ │ │ ├── Indiana-Starke
│ │ │ │ │ ├── Michigan
│ │ │ │ │ ├── Mountain
│ │ │ │ │ ├── Pacific
│ │ │ │ │ └── Samoa
│ │ │ │ ├── UTC
│ │ │ │ ├── Universal
│ │ │ │ ├── W-SU
│ │ │ │ ├── WET
│ │ │ │ ├── Zulu
│ │ │ │ ├── iso3166.tab
│ │ │ │ ├── zone1970.tab
│ │ │ │ └── zonenow.tab
│ │ │ ├── get_current_time_chrono.inc
│ │ │ ├── get_current_time_posix.inc
│ │ │ ├── test_util.cc
│ │ │ └── test_util.h
│ │ ├── simulated_clock.cc
│ │ ├── simulated_clock.h
│ │ ├── simulated_clock_test.cc
│ │ ├── time.cc
│ │ ├── time.h
│ │ ├── time_benchmark.cc
│ │ ├── time_test.cc
│ │ └── time_zone_test.cc
│ ├── types/
│ │ ├── BUILD.bazel
│ │ ├── CMakeLists.txt
│ │ ├── any.h
│ │ ├── any_span.h
│ │ ├── any_span_benchmark.cc
│ │ ├── any_span_test.cc
│ │ ├── compare.h
│ │ ├── compare_test.cc
│ │ ├── internal/
│ │ │ ├── any_span.h
│ │ │ └── span.h
│ │ ├── optional.h
│ │ ├── optional_ref.h
│ │ ├── optional_ref_test.cc
│ │ ├── source_location.h
│ │ ├── source_location_test.cc
│ │ ├── span.h
│ │ ├── span_test.cc
│ │ ├── variant.h
│ │ └── variant_test.cc
│ └── utility/
│ ├── BUILD.bazel
│ ├── CMakeLists.txt
│ └── utility.h
├── ci/
│ ├── absl_alternate_options.h
│ ├── cmake_common.sh
│ ├── cmake_install_test.sh
│ ├── linux_arm_clang-latest_libcxx_bazel.sh
│ ├── linux_clang-latest_libcxx_asan_bazel.sh
│ ├── linux_clang-latest_libcxx_bazel.sh
│ ├── linux_clang-latest_libcxx_tsan_bazel.sh
│ ├── linux_clang-latest_libstdcxx_bazel.sh
│ ├── linux_docker_containers.sh
│ ├── linux_gcc-floor_libstdcxx_bazel.sh
│ ├── linux_gcc-latest_libstdcxx_bazel.sh
│ ├── linux_gcc-latest_libstdcxx_cmake.sh
│ ├── linux_gcc_alpine_cmake.sh
│ ├── macos_xcode_bazel.sh
│ ├── macos_xcode_cmake.sh
│ ├── windows_clangcl_bazel.bat
│ ├── windows_msvc_bazel.bat
│ └── windows_msvc_cmake.bat
├── conanfile.py
└── create_lts.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .clang-format
================================================
---
Language: Cpp
BasedOnStyle: Google
...
================================================
FILE: .github/ISSUE_TEMPLATE/00-bug_report.yml
================================================
name: Bug Report
description: Let us know that something does not work as expected.
title: "[Bug]: Please title this bug report"
body:
- type: textarea
id: what-happened
attributes:
label: Describe the issue
description: What happened, and what did you expect to happen?
validations:
required: true
- type: textarea
id: steps
attributes:
label: Steps to reproduce the problem
description: It is important that we are able to reproduce the problem that you are experiencing. Please provide all code and relevant steps to reproduce the problem, including your `BUILD`/`CMakeLists.txt` file and build commands. Links to a GitHub branch or [godbolt.org](https://godbolt.org/) that demonstrate the problem are also helpful.
validations:
required: true
- type: textarea
id: version
attributes:
label: What version of Abseil are you using?
description: Please include the output of `git rev-parse HEAD` or the name of the LTS release that you are using.
validations:
required: true
- type: textarea
id: os
attributes:
label: What operating system and version are you using?
description: If you are using a Linux distribution please include the name and version of the distribution as well.
validations:
required: true
- type: textarea
id: compiler
attributes:
label: What compiler and version are you using?
description: Please include the output of `gcc -v` or `clang -v`, or the equivalent for your compiler.
validations:
required: true
- type: textarea
id: buildsystem
attributes:
label: What build system are you using?
description: Please include the output of `bazel --version` or `cmake --version`, or the equivalent for your build system.
validations:
required: true
- type: textarea
id: additional
attributes:
label: Additional context
description: Add any other context about the problem here.
validations:
required: false
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: false
contact_links:
- name: Question
url: https://github.com/abseil/abseil-cpp/discussions
about: Have a question? Ask us anything! :-)
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
Thank you for your contribution to Abseil!
Before submitting this PR, please be sure to read our [contributing
guidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md).
If you are a Googler, please also note that it is required that you send us a
Piper CL instead of using the GitHub pull-request process. The code propagation
process will deliver the change to GitHub.
================================================
FILE: .gitignore
================================================
# Bzlmod lockfile
MODULE.bazel.lock
# Ignore all bazel-* symlinks.
/bazel-*
# Ignore Bazel verbose explanations
--verbose_explanations
# Ignore CMake usual build directory
build
# Ignore Vim files
*.swp
# Ignore QtCreator Project file
CMakeLists.txt.user
# Ignore VS Code files
.vscode/*
# Ignore generated python artifacts
*.pyc
copts/__pycache__/
================================================
FILE: ABSEIL_ISSUE_TEMPLATE.md
================================================
Please submit a new Abseil Issue using the template below:
## [Short title of proposed API change(s)]
--------------------------------------------------------------------------------
--------------------------------------------------------------------------------
## Background
[Provide the background information that is required in order to evaluate the
proposed API changes. No controversial claims should be made here. If there are
design constraints that need to be considered, they should be presented here
**along with justification for those constraints**. Linking to other docs is
good, but please keep the **pertinent information as self contained** as
possible in this section.]
## Proposed API Change (s)
[Please clearly describe the API change(s) being proposed. If multiple changes,
please keep them clearly distinguished. When possible, **use example code
snippets to illustrate before-after API usages**. List pros-n-cons. Highlight
the main questions that you want to be answered. Given the Abseil project compatibility requirements, describe why the API change is safe.]
================================================
FILE: AUTHORS
================================================
# This is the list of Abseil authors for copyright purposes.
#
# This does not necessarily list everyone who has contributed code, since in
# some cases, their employer may be the copyright holder. To see the full list
# of contributors, see the revision history in source control.
Google Inc.
================================================
FILE: BUILD.bazel
================================================
# Copyright 2020 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
package(default_visibility = ["//visibility:public"])
licenses(["notice"]) # Apache 2.0
# Expose license for external usage through bazel.
exports_files([
"AUTHORS",
"LICENSE",
])
# For building with clang-cl.
# https://bazel.build/configure/windows#clang
platform(
name = "x64_windows-clang-cl",
constraint_values = [
"@platforms//cpu:x86_64",
"@platforms//os:windows",
"@bazel_tools//tools/cpp:clang-cl",
],
)
================================================
FILE: CMake/AbseilDll.cmake
================================================
include(CMakeParseArguments)
include(GNUInstallDirs)
set(ABSL_INTERNAL_DLL_FILES
"algorithm/algorithm.h"
"algorithm/container.h"
"base/attributes.h"
"base/call_once.h"
"base/casts.cc"
"base/casts.h"
"base/config.h"
"base/const_init.h"
"base/dynamic_annotations.h"
"base/fast_type_id.h"
"base/internal/atomic_hook.h"
"base/internal/cycleclock.cc"
"base/internal/cycleclock.h"
"base/internal/cycleclock_config.h"
"base/internal/direct_mmap.h"
"base/internal/dynamic_annotations.h"
"base/internal/endian.h"
"base/internal/errno_saver.h"
"base/internal/hardening.cc"
"base/internal/hardening.h"
"base/internal/hide_ptr.h"
"base/internal/iterator_traits.h"
"base/internal/low_level_alloc.cc"
"base/internal/low_level_alloc.h"
"base/internal/low_level_scheduling.h"
"base/internal/nullability_traits.h"
"base/internal/per_thread_tls.h"
"base/internal/poison.cc"
"base/internal/poison.h"
"base/internal/pretty_function.h"
"base/internal/raw_logging.cc"
"base/internal/raw_logging.h"
"base/internal/scheduling_mode.h"
"base/internal/scoped_set_env.cc"
"base/internal/scoped_set_env.h"
"base/internal/spinlock.cc"
"base/internal/spinlock.h"
"base/internal/spinlock_wait.cc"
"base/internal/spinlock_wait.h"
"base/internal/strerror.cc"
"base/internal/strerror.h"
"base/internal/sysinfo.cc"
"base/internal/sysinfo.h"
"base/internal/thread_identity.cc"
"base/internal/thread_identity.h"
"base/internal/tracing.cc"
"base/internal/tracing.h"
"base/internal/tsan_mutex_interface.h"
"base/internal/unaligned_access.h"
"base/internal/unscaledcycleclock.cc"
"base/internal/unscaledcycleclock.h"
"base/internal/unscaledcycleclock_config.h"
"base/log_severity.cc"
"base/log_severity.h"
"base/macros.h"
"base/no_destructor.h"
"base/nullability.h"
"base/optimization.h"
"base/options.h"
"base/policy_checks.h"
"base/port.h"
"base/prefetch.h"
"base/thread_annotations.h"
"base/throw_delegate.cc"
"base/throw_delegate.h"
"cleanup/cleanup.h"
"cleanup/internal/cleanup.h"
"container/btree_map.h"
"container/btree_set.h"
"container/chunked_queue.h"
"container/fixed_array.h"
"container/flat_hash_map.h"
"container/flat_hash_set.h"
"container/hash_container_defaults.h"
"container/inlined_vector.h"
"container/internal/btree.h"
"container/internal/btree_container.h"
"container/internal/chunked_queue.h"
"container/internal/common.h"
"container/internal/common_policy_traits.h"
"container/internal/compressed_tuple.h"
"container/internal/container_memory.h"
"container/internal/hash_function_defaults.h"
"container/internal/hash_policy_traits.h"
"container/internal/hashtable_control_bytes.h"
"container/internal/hashtable_debug.h"
"container/internal/hashtable_debug_hooks.h"
"container/internal/hashtablez_sampler.cc"
"container/internal/hashtablez_sampler.h"
"container/internal/hashtablez_sampler_force_weak_definition.cc"
"container/internal/inlined_vector.h"
"container/internal/layout.h"
"container/internal/node_slot_policy.h"
"container/internal/raw_hash_map.h"
"container/internal/raw_hash_set.cc"
"container/internal/raw_hash_set.h"
"container/internal/raw_hash_set_resize_impl.h"
"container/internal/tracked.h"
"container/linked_hash_map.h"
"container/linked_hash_set.h"
"container/node_hash_map.h"
"container/node_hash_set.h"
"crc/crc32c.cc"
"crc/crc32c.h"
"crc/internal/cpu_detect.cc"
"crc/internal/cpu_detect.h"
"crc/internal/crc.cc"
"crc/internal/crc.h"
"crc/internal/crc32_x86_arm_combined_simd.h"
"crc/internal/crc32c.h"
"crc/internal/crc32c_inline.h"
"crc/internal/crc_cord_state.cc"
"crc/internal/crc_cord_state.h"
"crc/internal/crc_internal.h"
"crc/internal/crc_memcpy.h"
"crc/internal/crc_memcpy_fallback.cc"
"crc/internal/crc_memcpy_x86_arm_combined.cc"
"crc/internal/crc_non_temporal_memcpy.cc"
"crc/internal/crc_x86_arm_combined.cc"
"crc/internal/non_temporal_arm_intrinsics.h"
"crc/internal/non_temporal_memcpy.h"
"debugging/failure_signal_handler.cc"
"debugging/failure_signal_handler.h"
"debugging/internal/address_is_readable.cc"
"debugging/internal/address_is_readable.h"
"debugging/internal/addresses.h"
"debugging/internal/bounded_utf8_length_sequence.h"
"debugging/internal/decode_rust_punycode.cc"
"debugging/internal/decode_rust_punycode.h"
"debugging/internal/demangle.cc"
"debugging/internal/demangle.h"
"debugging/internal/demangle_rust.cc"
"debugging/internal/demangle_rust.h"
"debugging/internal/elf_mem_image.cc"
"debugging/internal/elf_mem_image.h"
"debugging/internal/examine_stack.cc"
"debugging/internal/examine_stack.h"
"debugging/internal/stack_consumption.cc"
"debugging/internal/stack_consumption.h"
"debugging/internal/stacktrace_config.h"
"debugging/internal/symbolize.h"
"debugging/internal/utf8_for_code_point.cc"
"debugging/internal/utf8_for_code_point.h"
"debugging/internal/vdso_support.cc"
"debugging/internal/vdso_support.h"
"debugging/leak_check.h"
"debugging/stacktrace.cc"
"debugging/stacktrace.h"
"debugging/symbolize.cc"
"debugging/symbolize.h"
"functional/any_invocable.h"
"functional/bind_front.h"
"functional/function_ref.h"
"functional/internal/any_invocable.h"
"functional/internal/front_binder.h"
"functional/internal/function_ref.h"
"functional/overload.h"
"hash/hash.h"
"hash/internal/city.cc"
"hash/internal/city.h"
"hash/internal/hash.cc"
"hash/internal/hash.h"
"hash/internal/spy_hash_state.h"
"hash/internal/weakly_mixed_integer.h"
"log/absl_check.h"
"log/absl_log.h"
"log/absl_vlog_is_on.h"
"log/check.h"
"log/die_if_null.cc"
"log/die_if_null.h"
"log/globals.cc"
"log/globals.h"
"log/initialize.cc"
"log/initialize.h"
"log/internal/append_truncated.h"
"log/internal/check_impl.h"
"log/internal/check_op.cc"
"log/internal/check_op.h"
"log/internal/conditions.cc"
"log/internal/conditions.h"
"log/internal/config.h"
"log/internal/container.h"
"log/internal/fnmatch.cc"
"log/internal/fnmatch.h"
"log/internal/globals.cc"
"log/internal/globals.h"
"log/internal/log_format.cc"
"log/internal/log_format.h"
"log/internal/log_impl.h"
"log/internal/log_message.cc"
"log/internal/log_message.h"
"log/internal/log_sink_set.cc"
"log/internal/log_sink_set.h"
"log/internal/nullguard.cc"
"log/internal/nullguard.h"
"log/internal/nullstream.h"
"log/internal/proto.cc"
"log/internal/proto.h"
"log/internal/strip.h"
"log/internal/structured.h"
"log/internal/structured_proto.cc"
"log/internal/structured_proto.h"
"log/internal/vlog_config.cc"
"log/internal/vlog_config.h"
"log/internal/voidify.h"
"log/log.h"
"log/log_entry.cc"
"log/log_entry.h"
"log/log_sink.cc"
"log/log_sink.h"
"log/log_sink_registry.h"
"log/log_streamer.h"
"log/structured.h"
"log/vlog_is_on.h"
"memory/memory.h"
"meta/internal/requires.h"
"meta/type_traits.h"
"numeric/bits.h"
"numeric/int128.cc"
"numeric/int128.h"
"numeric/internal/bits.h"
"numeric/internal/representation.h"
"profiling/hashtable.cc"
"profiling/hashtable.h"
"profiling/internal/exponential_biased.cc"
"profiling/internal/exponential_biased.h"
"profiling/internal/periodic_sampler.cc"
"profiling/internal/periodic_sampler.h"
"profiling/internal/profile_builder.cc"
"profiling/internal/profile_builder.h"
"profiling/internal/sample_recorder.h"
"random/bernoulli_distribution.h"
"random/beta_distribution.h"
"random/bit_gen_ref.h"
"random/discrete_distribution.cc"
"random/discrete_distribution.h"
"random/distributions.h"
"random/exponential_distribution.h"
"random/gaussian_distribution.cc"
"random/gaussian_distribution.h"
"random/internal/distribution_caller.h"
"random/internal/entropy_pool.cc"
"random/internal/entropy_pool.h"
"random/internal/fast_uniform_bits.h"
"random/internal/fastmath.h"
"random/internal/generate_real.h"
"random/internal/iostream_state_saver.h"
"random/internal/nonsecure_base.h"
"random/internal/pcg_engine.h"
"random/internal/platform.h"
"random/internal/randen.cc"
"random/internal/randen.h"
"random/internal/randen_detect.cc"
"random/internal/randen_detect.h"
"random/internal/randen_engine.h"
"random/internal/randen_hwaes.cc"
"random/internal/randen_hwaes.h"
"random/internal/randen_round_keys.cc"
"random/internal/randen_slow.cc"
"random/internal/randen_slow.h"
"random/internal/randen_traits.h"
"random/internal/salted_seed_seq.h"
"random/internal/seed_material.cc"
"random/internal/seed_material.h"
"random/internal/sequence_urbg.h"
"random/internal/traits.h"
"random/internal/uniform_helper.h"
"random/internal/wide_multiply.h"
"random/log_uniform_int_distribution.h"
"random/poisson_distribution.h"
"random/random.h"
"random/seed_gen_exception.cc"
"random/seed_gen_exception.h"
"random/seed_sequences.cc"
"random/seed_sequences.h"
"random/uniform_int_distribution.h"
"random/uniform_real_distribution.h"
"random/zipf_distribution.h"
"status/internal/status_internal.cc"
"status/internal/status_internal.h"
"status/internal/statusor_internal.h"
"status/status.cc"
"status/status.h"
"status/status_payload_printer.cc"
"status/status_payload_printer.h"
"status/statusor.cc"
"status/statusor.h"
"strings/ascii.cc"
"strings/ascii.h"
"strings/charconv.cc"
"strings/charconv.h"
"strings/charset.h"
"strings/cord.cc"
"strings/cord.h"
"strings/cord_analysis.cc"
"strings/cord_analysis.h"
"strings/cord_buffer.h"
"strings/escaping.cc"
"strings/escaping.h"
"strings/has_absl_stringify.h"
"strings/has_ostream_operator.h"
"strings/internal/append_and_overwrite.h"
"strings/internal/charconv_bigint.cc"
"strings/internal/charconv_bigint.h"
"strings/internal/charconv_parse.cc"
"strings/internal/charconv_parse.h"
"strings/internal/cord_data_edge.h"
"strings/internal/cord_internal.cc"
"strings/internal/cord_internal.h"
"strings/internal/cord_rep_btree.cc"
"strings/internal/cord_rep_btree.h"
"strings/internal/cord_rep_btree_navigator.cc"
"strings/internal/cord_rep_btree_navigator.h"
"strings/internal/cord_rep_btree_reader.cc"
"strings/internal/cord_rep_btree_reader.h"
"strings/internal/cord_rep_consume.cc"
"strings/internal/cord_rep_consume.h"
"strings/internal/cord_rep_crc.cc"
"strings/internal/cord_rep_crc.h"
"strings/internal/cord_rep_flat.h"
"strings/internal/cordz_functions.cc"
"strings/internal/cordz_functions.h"
"strings/internal/cordz_handle.cc"
"strings/internal/cordz_handle.h"
"strings/internal/cordz_info.cc"
"strings/internal/cordz_info.h"
"strings/internal/cordz_sample_token.cc"
"strings/internal/cordz_sample_token.h"
"strings/internal/cordz_statistics.h"
"strings/internal/cordz_update_scope.h"
"strings/internal/cordz_update_tracker.h"
"strings/internal/damerau_levenshtein_distance.cc"
"strings/internal/damerau_levenshtein_distance.h"
"strings/internal/escaping.cc"
"strings/internal/escaping.h"
"strings/internal/generic_printer.cc"
"strings/internal/generic_printer.h"
"strings/internal/generic_printer_internal.h"
"strings/internal/memutil.cc"
"strings/internal/memutil.h"
"strings/internal/ostringstream.cc"
"strings/internal/ostringstream.h"
"strings/internal/pow10_helper.cc"
"strings/internal/pow10_helper.h"
"strings/internal/resize_uninitialized.h"
"strings/internal/stl_type_traits.h"
"strings/internal/str_format/arg.cc"
"strings/internal/str_format/arg.h"
"strings/internal/str_format/bind.cc"
"strings/internal/str_format/bind.h"
"strings/internal/str_format/checker.h"
"strings/internal/str_format/constexpr_parser.h"
"strings/internal/str_format/extension.cc"
"strings/internal/str_format/extension.h"
"strings/internal/str_format/float_conversion.cc"
"strings/internal/str_format/float_conversion.h"
"strings/internal/str_format/output.cc"
"strings/internal/str_format/output.h"
"strings/internal/str_format/parser.cc"
"strings/internal/str_format/parser.h"
"strings/internal/str_join_internal.h"
"strings/internal/str_split_internal.h"
"strings/internal/string_constant.h"
"strings/internal/stringify_sink.cc"
"strings/internal/stringify_sink.h"
"strings/internal/stringify_stream.h"
"strings/internal/utf8.cc"
"strings/internal/utf8.h"
"strings/match.cc"
"strings/match.h"
"strings/numbers.cc"
"strings/numbers.h"
"strings/resize_and_overwrite.h"
"strings/str_cat.cc"
"strings/str_cat.h"
"strings/str_format.h"
"strings/str_join.h"
"strings/str_replace.cc"
"strings/str_replace.h"
"strings/str_split.cc"
"strings/str_split.h"
"strings/strip.h"
"strings/substitute.cc"
"strings/substitute.h"
"synchronization/barrier.cc"
"synchronization/barrier.h"
"synchronization/blocking_counter.cc"
"synchronization/blocking_counter.h"
"synchronization/internal/create_thread_identity.cc"
"synchronization/internal/create_thread_identity.h"
"synchronization/internal/futex.h"
"synchronization/internal/futex_waiter.cc"
"synchronization/internal/futex_waiter.h"
"synchronization/internal/graphcycles.cc"
"synchronization/internal/graphcycles.h"
"synchronization/internal/kernel_timeout.cc"
"synchronization/internal/kernel_timeout.h"
"synchronization/internal/per_thread_sem.cc"
"synchronization/internal/per_thread_sem.h"
"synchronization/internal/pthread_waiter.cc"
"synchronization/internal/pthread_waiter.h"
"synchronization/internal/sem_waiter.cc"
"synchronization/internal/sem_waiter.h"
"synchronization/internal/stdcpp_waiter.cc"
"synchronization/internal/stdcpp_waiter.h"
"synchronization/internal/thread_pool.h"
"synchronization/internal/waiter.h"
"synchronization/internal/waiter_base.cc"
"synchronization/internal/waiter_base.h"
"synchronization/internal/win32_waiter.cc"
"synchronization/internal/win32_waiter.h"
"synchronization/mutex.cc"
"synchronization/mutex.h"
"synchronization/notification.cc"
"synchronization/notification.h"
"time/civil_time.cc"
"time/civil_time.h"
"time/clock.cc"
"time/clock.h"
"time/clock_interface.cc"
"time/clock_interface.h"
"time/duration.cc"
"time/format.cc"
"time/internal/cctz/include/cctz/civil_time.h"
"time/internal/cctz/include/cctz/civil_time_detail.h"
"time/internal/cctz/include/cctz/time_zone.h"
"time/internal/cctz/include/cctz/zone_info_source.h"
"time/internal/cctz/src/civil_time_detail.cc"
"time/internal/cctz/src/time_zone_fixed.cc"
"time/internal/cctz/src/time_zone_fixed.h"
"time/internal/cctz/src/time_zone_format.cc"
"time/internal/cctz/src/time_zone_if.cc"
"time/internal/cctz/src/time_zone_if.h"
"time/internal/cctz/src/time_zone_impl.cc"
"time/internal/cctz/src/time_zone_impl.h"
"time/internal/cctz/src/time_zone_info.cc"
"time/internal/cctz/src/time_zone_info.h"
"time/internal/cctz/src/time_zone_libc.cc"
"time/internal/cctz/src/time_zone_libc.h"
"time/internal/cctz/src/time_zone_lookup.cc"
"time/internal/cctz/src/time_zone_posix.cc"
"time/internal/cctz/src/time_zone_posix.h"
"time/internal/cctz/src/tzfile.h"
"time/internal/cctz/src/zone_info_source.cc"
"time/simulated_clock.cc"
"time/simulated_clock.h"
"time/time.cc"
"time/time.h"
"types/any.h"
"types/any_span.h"
"types/compare.h"
"types/internal/any_span.h"
"types/internal/span.h"
"types/optional.h"
"types/optional_ref.h"
"types/source_location.h"
"types/span.h"
"types/variant.h"
"utility/utility.h"
"debugging/leak_check.cc"
"strings/string_view.h"
)
if(MSVC)
list(APPEND ABSL_INTERNAL_DLL_FILES
"time/internal/cctz/src/time_zone_name_win.cc"
"time/internal/cctz/src/time_zone_name_win.h"
)
else()
list(APPEND ABSL_INTERNAL_DLL_FILES
"flags/commandlineflag.cc"
"flags/commandlineflag.h"
"flags/config.h"
"flags/declare.h"
"flags/flag.h"
"flags/internal/commandlineflag.cc"
"flags/internal/commandlineflag.h"
"flags/internal/flag.cc"
"flags/internal/flag.h"
"flags/internal/parse.h"
"flags/internal/path_util.h"
"flags/internal/private_handle_accessor.cc"
"flags/internal/private_handle_accessor.h"
"flags/internal/program_name.cc"
"flags/internal/program_name.h"
"flags/internal/registry.h"
"flags/internal/sequence_lock.h"
"flags/internal/usage.cc"
"flags/internal/usage.h"
"flags/marshalling.cc"
"flags/marshalling.h"
"flags/parse.cc"
"flags/parse.h"
"flags/reflection.cc"
"flags/reflection.h"
"flags/usage.cc"
"flags/usage.h"
"flags/usage_config.cc"
"flags/usage_config.h"
"log/flags.cc"
"log/flags.h"
"log/internal/flags.h"
)
endif()
set(ABSL_INTERNAL_DLL_TARGETS
"absl_check"
"absl_log"
"absl_vlog_is_on"
"algorithm"
"algorithm_container"
"any"
"any_invocable"
"atomic_hook"
"base"
"base_internal"
"bind_front"
"bits"
"btree"
"check"
"city"
"civil_time"
"compare"
"compressed_tuple"
"config"
"container"
"container_common"
"container_memory"
"cord"
"cord_internal"
"cordz_functions"
"cordz_handle"
"cordz_info"
"cordz_sample_token"
"core_headers"
"counting_allocator"
"crc_cord_state"
"crc_cpu_detect"
"crc_internal"
"crc32c"
"debugging"
"debugging_internal"
"demangle_internal"
"die_if_null"
"dynamic_annotations"
"endian"
"examine_stack"
"exponential_biased"
"failure_signal_handler"
"fixed_array"
"flat_hash_map"
"flat_hash_set"
"function_ref"
"graphcycles_internal"
"hash"
"hash_function_defaults"
"hash_policy_traits"
"hashtable_debug"
"hashtable_debug_hooks"
"hashtablez_sampler"
"inlined_vector"
"inlined_vector_internal"
"int128"
"kernel_timeout_internal"
"layout"
"leak_check"
"log_internal_check_impl"
"log_internal_check_op"
"log_internal_conditions"
"log_internal_config"
"log_internal_fnmatch"
"log_internal_format"
"log_internal_globals"
"log_internal_log_impl"
"log_internal_proto"
"log_internal_message"
"log_internal_log_sink_set"
"log_internal_nullguard"
"log_internal_nullstream"
"log_internal_strip"
"log_internal_voidify"
"log_internal_append_truncated"
"log_globals"
"log_initialize"
"log"
"log_entry"
"log_sink"
"log_sink_registry"
"log_streamer"
"log_internal_structured"
"log_severity"
"log_structured"
"low_level_hash"
"malloc_internal"
"memory"
"meta"
"node_hash_map"
"node_hash_set"
"node_slot_policy"
"non_temporal_arm_intrinsics"
"non_temporal_memcpy"
"numeric"
"optional"
"periodic_sampler"
"pow10_helper"
"pretty_function"
"random_bit_gen_ref"
"random_distributions"
"random_internal_distribution_caller"
"random_internal_distributions"
"random_internal_explicit_seed_seq"
"random_internal_fastmath"
"random_internal_fast_uniform_bits"
"random_internal_generate_real"
"random_internal_iostream_state_saver"
"random_internal_nonsecure_base"
"random_internal_pcg_engine"
"random_internal_platform"
"random_internal_pool_urbg"
"random_internal_randen"
"random_internal_randen_engine"
"random_internal_randen_hwaes"
"random_internal_randen_hwaes_impl"
"random_internal_randen_slow"
"random_internal_salted_seed_seq"
"random_internal_seed_material"
"random_internal_sequence_urbg"
"random_internal_traits"
"random_internal_uniform_helper"
"random_internal_wide_multiply"
"random_random"
"random_seed_gen_exception"
"random_seed_sequences"
"raw_hash_map"
"raw_hash_set"
"raw_logging_internal"
"sample_recorder"
"scoped_set_env"
"span"
"spinlock_wait"
"spy_hash_state"
"stack_consumption"
"stacktrace"
"status"
"statusor"
"str_format"
"str_format_internal"
"strerror"
"strings"
"strings_internal"
"string_view"
"symbolize"
"synchronization"
"thread_pool"
"throw_delegate"
"time"
"time_zone"
"tracked"
"type_traits"
"utility"
"variant"
"vlog_config_internal"
"vlog_is_on"
)
if(NOT MSVC)
list(APPEND ABSL_INTERNAL_DLL_TARGETS
"flags"
"flags_commandlineflag"
"flags_commandlineflag_internal"
"flags_config"
"flags_internal"
"flags_marshalling"
"flags_parse"
"flags_path_util"
"flags_private_handle_accessor"
"flags_program_name"
"flags_reflection"
"flags_usage"
"flags_usage_internal"
"log_internal_flags"
"log_flags"
)
endif()
set(ABSL_INTERNAL_TEST_DLL_FILES
"hash/hash_testing.h"
"log/scoped_mock_log.cc"
"log/scoped_mock_log.h"
"random/internal/chi_square.cc"
"random/internal/chi_square.h"
"random/internal/distribution_test_util.cc"
"random/internal/distribution_test_util.h"
"random/internal/mock_helpers.h"
"random/internal/mock_overload_set.h"
"random/mocking_bit_gen.h"
"random/mock_distributions.h"
"status/status_matchers.h"
"status/internal/status_matchers.cc"
"status/internal/status_matchers.h"
"strings/cordz_test_helpers.h"
"strings/cord_test_helpers.h"
)
set(ABSL_INTERNAL_TEST_DLL_TARGETS
"cord_test_helpers"
"cordz_test_helpers"
"hash_testing"
"random_mocking_bit_gen"
"random_internal_distribution_test_util"
"random_internal_mock_overload_set"
"scoped_mock_log"
"status_matchers"
)
include(CheckCXXSourceCompiles)
check_cxx_source_compiles(
[==[
#ifdef _MSC_VER
# if _MSVC_LANG < 201703L
# error "The compiler defaults or is configured for C++ < 17"
# endif
#elif __cplusplus < 201703L
# error "The compiler defaults or is configured for C++ < 17"
#endif
int main() { return 0; }
]==]
ABSL_INTERNAL_AT_LEAST_CXX17)
check_cxx_source_compiles(
[==[
#ifdef _MSC_VER
# if _MSVC_LANG < 202002L
# error "The compiler defaults or is configured for C++ < 20"
# endif
#elif __cplusplus < 202002L
# error "The compiler defaults or is configured for C++ < 20"
#endif
int main() { return 0; }
]==]
ABSL_INTERNAL_AT_LEAST_CXX20)
if(ABSL_INTERNAL_AT_LEAST_CXX20)
set(ABSL_INTERNAL_CXX_STD_FEATURE cxx_std_20)
elseif(ABSL_INTERNAL_AT_LEAST_CXX17)
set(ABSL_INTERNAL_CXX_STD_FEATURE cxx_std_17)
else()
message(FATAL_ERROR "The compiler defaults to or is configured for C++ < 17. C++ >= 17 is required and Abseil and all libraries that use Abseil must use the same C++ language standard")
endif()
function(absl_internal_dll_contains)
cmake_parse_arguments(ABSL_INTERNAL_DLL
""
"OUTPUT;TARGET"
""
${ARGN}
)
STRING(REGEX REPLACE "^absl::" "" _target ${ABSL_INTERNAL_DLL_TARGET})
if (_target IN_LIST ABSL_INTERNAL_DLL_TARGETS)
set(${ABSL_INTERNAL_DLL_OUTPUT} 1 PARENT_SCOPE)
else()
set(${ABSL_INTERNAL_DLL_OUTPUT} 0 PARENT_SCOPE)
endif()
endfunction()
function(absl_internal_test_dll_contains)
cmake_parse_arguments(ABSL_INTERNAL_TEST_DLL
""
"OUTPUT;TARGET"
""
${ARGN}
)
STRING(REGEX REPLACE "^absl::" "" _target ${ABSL_INTERNAL_TEST_DLL_TARGET})
if (_target IN_LIST ABSL_INTERNAL_TEST_DLL_TARGETS)
set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 1 PARENT_SCOPE)
else()
set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 0 PARENT_SCOPE)
endif()
endfunction()
function(absl_internal_dll_targets)
cmake_parse_arguments(ABSL_INTERNAL_DLL
""
"OUTPUT"
"DEPS"
${ARGN}
)
set(_deps "")
foreach(dep IN LISTS ABSL_INTERNAL_DLL_DEPS)
absl_internal_dll_contains(TARGET ${dep} OUTPUT _dll_contains)
absl_internal_test_dll_contains(TARGET ${dep} OUTPUT _test_dll_contains)
if (_dll_contains)
list(APPEND _deps abseil_dll)
elseif (_test_dll_contains)
list(APPEND _deps abseil_test_dll)
else()
list(APPEND _deps ${dep})
endif()
endforeach()
# Because we may have added the DLL multiple times
list(REMOVE_DUPLICATES _deps)
set(${ABSL_INTERNAL_DLL_OUTPUT} "${_deps}" PARENT_SCOPE)
endfunction()
function(absl_make_dll)
cmake_parse_arguments(ABSL_INTERNAL_MAKE_DLL
""
"TEST"
""
${ARGN}
)
if (ABSL_INTERNAL_MAKE_DLL_TEST)
set(_dll "abseil_test_dll")
set(_dll_files ${ABSL_INTERNAL_TEST_DLL_FILES})
set(_dll_libs "abseil_dll" "GTest::gtest" "GTest::gmock")
set(_dll_compile_definitions "GTEST_LINKED_AS_SHARED_LIBRARY=1")
set(_dll_includes ${absl_gtest_src_dir}/googletest/include ${absl_gtest_src_dir}/googlemock/include)
set(_dll_consume "ABSL_CONSUME_TEST_DLL")
set(_dll_build "ABSL_BUILD_TEST_DLL")
else()
set(_dll "abseil_dll")
set(_dll_files ${ABSL_INTERNAL_DLL_FILES})
set(_dll_libs
Threads::Threads
# TODO(#1495): Use $<LINK_LIBRARY:FRAMEWORK,CoreFoundation> once our
# minimum CMake version >= 3.24
$<$<PLATFORM_ID:Darwin>:-Wl,-framework,CoreFoundation>
)
set(_dll_compile_definitions "")
set(_dll_includes "")
set(_dll_consume "ABSL_CONSUME_DLL")
set(_dll_build "ABSL_BUILD_DLL")
endif()
add_library(
${_dll}
SHARED
${_dll_files}
)
target_link_libraries(
${_dll}
PRIVATE
${_dll_libs}
${ABSL_DEFAULT_LINKOPTS}
$<$<BOOL:${ANDROID}>:-llog>
$<$<BOOL:${MINGW}>:-ladvapi32>
$<$<BOOL:${MINGW}>:-ldbghelp>
$<$<BOOL:${MINGW}>:-lbcrypt>
)
set_target_properties(${_dll} PROPERTIES
LINKER_LANGUAGE "CXX"
SOVERSION ${ABSL_SOVERSION}
)
target_include_directories(
${_dll}
PUBLIC
"$<BUILD_INTERFACE:${ABSL_COMMON_INCLUDE_DIRS}>"
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
PRIVATE
${_dll_includes}
)
target_compile_options(
${_dll}
PRIVATE
${ABSL_DEFAULT_COPTS}
)
foreach(cflag ${ABSL_CC_LIB_COPTS})
if(${cflag} MATCHES "^(-Wno|/wd)")
# These flags are needed to suppress warnings that might fire in our headers.
set(PC_CFLAGS "${PC_CFLAGS} ${cflag}")
elseif(${cflag} MATCHES "^(-W|/w[1234eo])")
# Don't impose our warnings on others.
else()
set(PC_CFLAGS "${PC_CFLAGS} ${cflag}")
endif()
endforeach()
string(REPLACE ";" " " PC_LINKOPTS "${ABSL_CC_LIB_LINKOPTS}")
FILE(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/lib/pkgconfig/${_dll}.pc" CONTENT "\
prefix=${CMAKE_INSTALL_PREFIX}\n\
exec_prefix=\${prefix}\n\
libdir=${CMAKE_INSTALL_FULL_LIBDIR}\n\
includedir=${CMAKE_INSTALL_FULL_INCLUDEDIR}\n\
\n\
Name: ${_dll}\n\
Description: Abseil DLL library\n\
URL: https://abseil.io/\n\
Version: ${absl_VERSION}\n\
Libs: -L\${libdir} $<$<NOT:$<BOOL:${ABSL_CC_LIB_IS_INTERFACE}>>:-l${_dll}> ${PC_LINKOPTS}\n\
Cflags: -I\${includedir}${PC_CFLAGS}\n")
INSTALL(FILES "${CMAKE_BINARY_DIR}/lib/pkgconfig/${_dll}.pc"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
target_compile_definitions(
${_dll}
PUBLIC
${_dll_compile_definitions}
PRIVATE
${_dll_build}
NOMINMAX
INTERFACE
${ABSL_CC_LIB_DEFINES}
${_dll_consume}
)
if(ABSL_PROPAGATE_CXX_STD)
# Abseil libraries require C++17 as the current minimum standard. When
# compiled with a higher minimum (either because it is the compiler's
# default or explicitly requested), then Abseil requires that standard.
target_compile_features(${_dll} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})
endif()
install(TARGETS ${_dll} EXPORT ${PROJECT_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
)
add_library(absl::${_dll} ALIAS ${_dll})
endfunction()
================================================
FILE: CMake/AbseilHelpers.cmake
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
include(CMakeParseArguments)
include(AbseilConfigureCopts)
include(AbseilDll)
# The IDE folder for Abseil that will be used if Abseil is included in a CMake
# project that sets
# set_property(GLOBAL PROPERTY USE_FOLDERS ON)
# For example, Visual Studio supports folders.
if(NOT DEFINED ABSL_IDE_FOLDER)
set(ABSL_IDE_FOLDER Abseil)
endif()
if(ABSL_USE_SYSTEM_INCLUDES)
set(ABSL_INTERNAL_INCLUDE_WARNING_GUARD SYSTEM)
else()
set(ABSL_INTERNAL_INCLUDE_WARNING_GUARD "")
endif()
# absl_cc_library()
#
# CMake function to imitate Bazel's cc_library rule.
#
# Parameters:
# NAME: name of target (see Note)
# HDRS: List of public header files for the library
# SRCS: List of source files for the library
# DEPS: List of other libraries to be linked in to the binary targets
# COPTS: List of private compile options
# DEFINES: List of public defines
# LINKOPTS: List of link options
# PUBLIC: Add this so that this library will be exported under absl::
# Also in IDE, target will appear in Abseil folder while non PUBLIC will be in Abseil/internal.
# TESTONLY: When added, this target will only be built if both
# BUILD_TESTING=ON and ABSL_BUILD_TESTING=ON.
#
# Note:
# By default, absl_cc_library will always create a library named absl_${NAME},
# and alias target absl::${NAME}. The absl:: form should always be used.
# This is to reduce namespace pollution.
#
# absl_cc_library(
# NAME
# awesome
# HDRS
# "a.h"
# SRCS
# "a.cc"
# )
# absl_cc_library(
# NAME
# fantastic_lib
# SRCS
# "b.cc"
# DEPS
# absl::awesome # not "awesome" !
# PUBLIC
# )
#
# absl_cc_library(
# NAME
# main_lib
# ...
# DEPS
# absl::fantastic_lib
# )
#
# TODO(b/320467376): Implement "ALWAYSLINK".
function(absl_cc_library)
cmake_parse_arguments(ABSL_CC_LIB
"DISABLE_INSTALL;PUBLIC;TESTONLY"
"NAME"
"HDRS;SRCS;COPTS;DEFINES;LINKOPTS;DEPS"
${ARGN}
)
if(ABSL_CC_LIB_TESTONLY AND
NOT ((BUILD_TESTING AND ABSL_BUILD_TESTING) OR
(ABSL_BUILD_TEST_HELPERS AND ABSL_CC_LIB_PUBLIC)))
return()
endif()
if(ABSL_ENABLE_INSTALL)
set(_NAME "${ABSL_CC_LIB_NAME}")
else()
set(_NAME "absl_${ABSL_CC_LIB_NAME}")
endif()
# Check if this is a header-only library
# Note that as of February 2019, many popular OS's (for example, Ubuntu
# 16.04 LTS) only come with cmake 3.5 by default. For this reason, we can't
# use list(FILTER...)
set(ABSL_CC_SRCS "${ABSL_CC_LIB_SRCS}")
foreach(src_file IN LISTS ABSL_CC_SRCS)
if(${src_file} MATCHES ".*\\.(h|inc)")
list(REMOVE_ITEM ABSL_CC_SRCS "${src_file}")
endif()
endforeach()
if(ABSL_CC_SRCS STREQUAL "")
set(ABSL_CC_LIB_IS_INTERFACE 1)
else()
set(ABSL_CC_LIB_IS_INTERFACE 0)
endif()
# Determine this build target's relationship to the DLL. It's one of four things:
# 1. "dll" -- This target is part of the DLL
# 2. "dll_dep" -- This target is not part of the DLL, but depends on the DLL.
# Note that we assume any target not in the DLL depends on the
# DLL. This is not a technical necessity but a convenience
# which happens to be true, because nearly every target is
# part of the DLL.
# 3. "shared" -- This is a shared library, perhaps on a non-windows platform
# where DLL doesn't make sense.
# 4. "static" -- This target does not depend on the DLL and should be built
# statically.
if (${ABSL_BUILD_DLL})
if(ABSL_ENABLE_INSTALL)
absl_internal_dll_contains(TARGET ${_NAME} OUTPUT _in_dll)
absl_internal_test_dll_contains(TARGET ${_NAME} OUTPUT _in_test_dll)
else()
absl_internal_dll_contains(TARGET ${ABSL_CC_LIB_NAME} OUTPUT _in_dll)
absl_internal_test_dll_contains(TARGET ${ABSL_CC_LIB_NAME} OUTPUT _in_test_dll)
endif()
if (${_in_dll} OR ${_in_test_dll})
# This target should be replaced by the DLL
set(_build_type "dll")
set(ABSL_CC_LIB_IS_INTERFACE 1)
else()
# Building a DLL, but this target is not part of the DLL
set(_build_type "dll_dep")
endif()
elseif(BUILD_SHARED_LIBS)
set(_build_type "shared")
else()
set(_build_type "static")
endif()
# Generate a pkg-config file for every library:
if(ABSL_ENABLE_INSTALL)
if(absl_VERSION)
set(PC_VERSION "${absl_VERSION}")
else()
set(PC_VERSION "head")
endif()
if(NOT _build_type STREQUAL "dll")
set(LNK_LIB "${LNK_LIB} -labsl_${_NAME}")
endif()
foreach(dep ${ABSL_CC_LIB_DEPS})
if(${dep} MATCHES "^absl::(.*)")
# for DLL builds many libs are not created, but add
# the pkgconfigs nevertheless, pointing to the dll.
if(_build_type STREQUAL "dll")
# hide this MATCHES in an if-clause so it doesn't overwrite
# the CMAKE_MATCH_1 from (${dep} MATCHES "^absl::(.*)")
if(NOT PC_DEPS MATCHES "abseil_dll")
# Join deps with commas.
if(PC_DEPS)
set(PC_DEPS "${PC_DEPS},")
endif()
# don't duplicate dll-dep if it exists already
set(PC_DEPS "${PC_DEPS} abseil_dll = ${PC_VERSION}")
set(LNK_LIB "${LNK_LIB} -labseil_dll")
endif()
else()
# Join deps with commas.
if(PC_DEPS)
set(PC_DEPS "${PC_DEPS},")
endif()
set(PC_DEPS "${PC_DEPS} absl_${CMAKE_MATCH_1} = ${PC_VERSION}")
endif()
endif()
endforeach()
foreach(cflag ${ABSL_CC_LIB_COPTS})
# Strip out the CMake-specific `SHELL:` prefix, which is used to construct
# a group of space-separated options.
# https://cmake.org/cmake/help/v3.30/command/target_compile_options.html#option-de-duplication
string(REGEX REPLACE "^SHELL:" "" cflag "${cflag}")
if(${cflag} MATCHES "^-Xarch_")
# An -Xarch_ flag implies that its successor only applies to the
# specified platform. Such option groups are each specified in a single
# `SHELL:`-prefixed string in the COPTS list, which we simply ignore.
elseif(${cflag} MATCHES "^(-Wno-|/wd)")
# These flags are needed to suppress warnings that might fire in our headers.
set(PC_CFLAGS "${PC_CFLAGS} ${cflag}")
elseif(${cflag} MATCHES "^(-W|/w[1234eo])")
# Don't impose our warnings on others.
elseif(${cflag} MATCHES "^-m")
# Don't impose CPU instruction requirements on others, as
# the code performs feature detection on runtime.
else()
set(PC_CFLAGS "${PC_CFLAGS} ${cflag}")
endif()
endforeach()
string(REPLACE ";" " " PC_LINKOPTS "${ABSL_CC_LIB_LINKOPTS}")
FILE(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/lib/pkgconfig/absl_${_NAME}.pc" CONTENT "\
prefix=${CMAKE_INSTALL_PREFIX}\n\
exec_prefix=\${prefix}\n\
libdir=${CMAKE_INSTALL_FULL_LIBDIR}\n\
includedir=${CMAKE_INSTALL_FULL_INCLUDEDIR}\n\
\n\
Name: absl_${_NAME}\n\
Description: Abseil ${_NAME} library\n\
URL: https://abseil.io/\n\
Version: ${PC_VERSION}\n\
Requires:${PC_DEPS}\n\
Libs: -L\${libdir} $<$<NOT:$<BOOL:${ABSL_CC_LIB_IS_INTERFACE}>>:${LNK_LIB}> ${PC_LINKOPTS}\n\
Cflags: -I\${includedir}${PC_CFLAGS}\n")
INSTALL(FILES "${CMAKE_BINARY_DIR}/lib/pkgconfig/absl_${_NAME}.pc"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig")
endif()
if(NOT ABSL_CC_LIB_IS_INTERFACE)
if(_build_type STREQUAL "dll_dep")
# This target depends on the DLL. When adding dependencies to this target,
# any depended-on-target which is contained inside the DLL is replaced
# with a dependency on the DLL.
add_library(${_NAME} STATIC "")
target_sources(${_NAME} PRIVATE ${ABSL_CC_LIB_SRCS} ${ABSL_CC_LIB_HDRS})
absl_internal_dll_targets(
DEPS ${ABSL_CC_LIB_DEPS}
OUTPUT _dll_deps
)
target_link_libraries(${_NAME}
PUBLIC ${_dll_deps}
PRIVATE
${ABSL_CC_LIB_LINKOPTS}
${ABSL_DEFAULT_LINKOPTS}
)
if (ABSL_CC_LIB_TESTONLY)
set(_gtest_link_define "GTEST_LINKED_AS_SHARED_LIBRARY=1")
else()
set(_gtest_link_define)
endif()
target_compile_definitions(${_NAME}
PUBLIC
ABSL_CONSUME_DLL
"${_gtest_link_define}"
)
elseif(_build_type STREQUAL "static" OR _build_type STREQUAL "shared")
add_library(${_NAME} "")
target_sources(${_NAME} PRIVATE ${ABSL_CC_LIB_SRCS} ${ABSL_CC_LIB_HDRS})
if(APPLE)
set_target_properties(${_NAME} PROPERTIES
INSTALL_RPATH "@loader_path")
elseif(UNIX)
set_target_properties(${_NAME} PROPERTIES
INSTALL_RPATH "$ORIGIN")
endif()
target_link_libraries(${_NAME}
PUBLIC ${ABSL_CC_LIB_DEPS}
PRIVATE
${ABSL_CC_LIB_LINKOPTS}
${ABSL_DEFAULT_LINKOPTS}
)
else()
message(FATAL_ERROR "Invalid build type: ${_build_type}")
endif()
# Linker language can be inferred from sources, but in the case of DLLs we
# don't have any .cc files so it would be ambiguous. We could set it
# explicitly only in the case of DLLs but, because "CXX" is always the
# correct linker language for static or for shared libraries, we set it
# unconditionally.
set_property(TARGET ${_NAME} PROPERTY LINKER_LANGUAGE "CXX")
target_include_directories(${_NAME} ${ABSL_INTERNAL_INCLUDE_WARNING_GUARD}
PUBLIC
"$<BUILD_INTERFACE:${ABSL_COMMON_INCLUDE_DIRS}>"
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
target_compile_options(${_NAME}
PRIVATE ${ABSL_CC_LIB_COPTS})
target_compile_definitions(${_NAME} PUBLIC ${ABSL_CC_LIB_DEFINES})
# Add all Abseil targets to a a folder in the IDE for organization.
if(ABSL_CC_LIB_PUBLIC)
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})
elseif(ABSL_CC_LIB_TESTONLY)
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)
else()
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal)
endif()
if(ABSL_PROPAGATE_CXX_STD)
# Abseil libraries require C++17 as the current minimum standard. When
# compiled with a higher standard (either because it is the compiler's
# default or explicitly requested), then Abseil requires that standard.
target_compile_features(${_NAME} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})
endif()
# When being installed, we lose the absl_ prefix. We want to put it back
# to have properly named lib files. This is a no-op when we are not being
# installed.
if(ABSL_ENABLE_INSTALL)
set_target_properties(${_NAME} PROPERTIES
OUTPUT_NAME "absl_${_NAME}"
SOVERSION "${ABSL_SOVERSION}"
)
endif()
else()
# Generating header-only library
add_library(${_NAME} INTERFACE)
target_include_directories(${_NAME} ${ABSL_INTERNAL_INCLUDE_WARNING_GUARD}
INTERFACE
"$<BUILD_INTERFACE:${ABSL_COMMON_INCLUDE_DIRS}>"
$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
if (_build_type STREQUAL "dll")
if(${_in_dll})
set(ABSL_CC_LIB_DEPS abseil_dll)
endif()
if(${_in_test_dll})
set(ABSL_CC_LIB_DEPS abseil_test_dll)
endif()
endif()
target_link_libraries(${_NAME}
INTERFACE
${ABSL_CC_LIB_DEPS}
${ABSL_CC_LIB_LINKOPTS}
${ABSL_DEFAULT_LINKOPTS}
)
target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES})
if(ABSL_PROPAGATE_CXX_STD)
# Abseil libraries require C++17 as the current minimum standard.
# Top-level application CMake projects should ensure a consistent C++
# standard for all compiled sources by setting CMAKE_CXX_STANDARD.
target_compile_features(${_NAME} INTERFACE ${ABSL_INTERNAL_CXX_STD_FEATURE})
endif()
endif()
if(ABSL_ENABLE_INSTALL)
install(TARGETS ${_NAME} EXPORT ${PROJECT_NAME}Targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
)
endif()
add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME})
endfunction()
# absl_cc_test()
#
# CMake function to imitate Bazel's cc_test rule.
#
# Parameters:
# NAME: name of target (see Usage below)
# SRCS: List of source files for the binary
# DEPS: List of other libraries to be linked in to the binary targets
# COPTS: List of private compile options
# DEFINES: List of public defines
# LINKOPTS: List of link options
#
# Note:
# By default, absl_cc_test will always create a binary named absl_${NAME}.
# This will also add it to ctest list as absl_${NAME}.
#
# Usage:
# absl_cc_library(
# NAME
# awesome
# HDRS
# "a.h"
# SRCS
# "a.cc"
# PUBLIC
# )
#
# absl_cc_test(
# NAME
# awesome_test
# SRCS
# "awesome_test.cc"
# DEPS
# absl::awesome
# GTest::gmock
# GTest::gtest_main
# )
function(absl_cc_test)
if(NOT (BUILD_TESTING AND ABSL_BUILD_TESTING))
return()
endif()
cmake_parse_arguments(ABSL_CC_TEST
""
"NAME"
"SRCS;COPTS;DEFINES;LINKOPTS;DEPS"
${ARGN}
)
set(_NAME "absl_${ABSL_CC_TEST_NAME}")
add_executable(${_NAME} "")
target_sources(${_NAME} PRIVATE ${ABSL_CC_TEST_SRCS})
target_include_directories(${_NAME}
PUBLIC ${ABSL_COMMON_INCLUDE_DIRS}
PRIVATE ${absl_gtest_src_dir}/googletest/include ${absl_gtest_src_dir}/googlemock/include
)
if (${ABSL_BUILD_DLL})
target_compile_definitions(${_NAME}
PUBLIC
${ABSL_CC_TEST_DEFINES}
ABSL_CONSUME_DLL
ABSL_CONSUME_TEST_DLL
GTEST_LINKED_AS_SHARED_LIBRARY=1
)
# Replace dependencies on targets inside the DLL with abseil_dll itself.
absl_internal_dll_targets(
DEPS ${ABSL_CC_TEST_DEPS}
OUTPUT ABSL_CC_TEST_DEPS
)
absl_internal_dll_targets(
DEPS ${ABSL_CC_TEST_LINKOPTS}
OUTPUT ABSL_CC_TEST_LINKOPTS
)
else()
target_compile_definitions(${_NAME}
PUBLIC
${ABSL_CC_TEST_DEFINES}
)
endif()
target_compile_options(${_NAME}
PRIVATE ${ABSL_CC_TEST_COPTS}
)
target_link_libraries(${_NAME}
PUBLIC ${ABSL_CC_TEST_DEPS}
PRIVATE ${ABSL_CC_TEST_LINKOPTS}
)
# Add all Abseil targets to a folder in the IDE for organization.
set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)
if(ABSL_PROPAGATE_CXX_STD)
# Abseil libraries require C++17 as the current minimum standard.
# Top-level application CMake projects should ensure a consistent C++
# standard for all compiled sources by setting CMAKE_CXX_STANDARD.
target_compile_features(${_NAME} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})
endif()
add_test(NAME ${_NAME} COMMAND ${_NAME})
endfunction()
================================================
FILE: CMake/Googletest/CMakeLists.txt.in
================================================
cmake_minimum_required(VERSION 3.16)
project(googletest-external NONE)
include(ExternalProject)
ExternalProject_Add(googletest
URL "${absl_gtest_download_url}" # May be empty
SOURCE_DIR "${absl_gtest_src_dir}"
BINARY_DIR "${absl_gtest_build_dir}"
CONFIGURE_COMMAND ""
BUILD_COMMAND ""
INSTALL_COMMAND ""
TEST_COMMAND ""
)
================================================
FILE: CMake/Googletest/DownloadGTest.cmake
================================================
# Integrates googletest at configure time. Based on the instructions at
# https://github.com/google/googletest/tree/master/googletest#incorporating-into-an-existing-cmake-project
# Set up the external googletest project, downloading the latest from Github
# master if requested.
configure_file(
${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.in
${CMAKE_BINARY_DIR}/googletest-external/CMakeLists.txt
)
set(ABSL_SAVE_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
set(ABSL_SAVE_CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
if (BUILD_SHARED_LIBS)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DGTEST_CREATE_SHARED_LIBRARY=1")
endif()
# Configure and build the googletest source.
execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
RESULT_VARIABLE result
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-external )
if(result)
message(FATAL_ERROR "CMake step for googletest failed: ${result}")
endif()
execute_process(COMMAND ${CMAKE_COMMAND} --build .
RESULT_VARIABLE result
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-external)
if(result)
message(FATAL_ERROR "Build step for googletest failed: ${result}")
endif()
set(CMAKE_CXX_FLAGS ${ABSL_SAVE_CMAKE_CXX_FLAGS})
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ABSL_SAVE_CMAKE_RUNTIME_OUTPUT_DIRECTORY})
# Prevent overriding the parent project's compiler/linker settings on Windows
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
# Add googletest directly to our build. This defines the gtest and gtest_main
# targets.
add_subdirectory(${absl_gtest_src_dir} ${absl_gtest_build_dir} EXCLUDE_FROM_ALL)
================================================
FILE: CMake/README.md
================================================
# Abseil CMake Build Instructions
Abseil comes with a CMake build script ([CMakeLists.txt](../CMakeLists.txt))
that can be used on a wide range of platforms ("C" stands for cross-platform.).
If you don't have CMake installed already, you can download it for free from
<https://www.cmake.org/>.
CMake works by generating native makefiles or build projects that can
be used in the compiler environment of your choice.
For API/ABI compatibility reasons, we strongly recommend building Abseil in a
subdirectory of your project or as an embedded dependency.
## Incorporating Abseil Into a CMake Project
The recommendations below are similar to those for using CMake within the
googletest framework
(<https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project>)
### Step-by-Step Instructions
1. If you want to build the Abseil tests, integrate the Abseil dependency
[Google Test](https://github.com/google/googletest) into your CMake
project. To disable Abseil tests, you have to pass either
`-DBUILD_TESTING=OFF` or `-DABSL_BUILD_TESTING=OFF` when configuring your
project with CMake.
2. Download Abseil and copy it into a subdirectory in your CMake project or add
Abseil as a [git submodule](https://git-scm.com/docs/git-submodule) in your
CMake project.
3. You can then use the CMake command
[`add_subdirectory()`](https://cmake.org/cmake/help/latest/command/add_subdirectory.html)
to include Abseil directly in your CMake project.
4. Add the **absl::** target you wish to use to the
[`target_link_libraries()`](https://cmake.org/cmake/help/latest/command/target_link_libraries.html)
section of your executable or of your library.<br>
Here is a short CMakeLists.txt example of an application project using Abseil.
```cmake
cmake_minimum_required(VERSION 3.16)
project(my_app_project)
# Pick the C++ standard to compile with.
# Abseil currently supports C++17 and C++20.
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_subdirectory(abseil-cpp)
add_executable(my_exe source.cpp)
target_link_libraries(my_exe absl::base absl::synchronization absl::strings)
```
Note that if you are developing a library designed for use by other clients, you
should instead leave `CMAKE_CXX_STANDARD` unset (or only set if being built as
the current top-level CMake project) and configure the minimum required C++
standard at the target level. If you require a later minimum C++ standard than
Abseil does, it's a good idea to also enforce that `CMAKE_CXX_STANDARD` (which
will control Abseil library targets) is set to at least that minimum. For
example:
```cmake
cmake_minimum_required(VERSION 3.16)
project(my_lib_project)
# Leave C++ standard up to the root application, so set it only if this is the
# current top-level CMake project.
if(CMAKE_SOURCE_DIR STREQUAL my_lib_project_SOURCE_DIR)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
endif()
add_subdirectory(abseil-cpp)
add_library(my_lib source.cpp)
target_link_libraries(my_lib absl::base absl::synchronization absl::strings)
# Enforce that my_lib requires C++17. Important to document for clients that they
# must set CMAKE_CXX_STANDARD to 17 or higher for proper Abseil ABI compatibility
# (since otherwise, Abseil library targets could be compiled with a lower C++
# standard than my_lib).
target_compile_features(my_lib PUBLIC cxx_std_17)
if(CMAKE_CXX_STANDARD LESS 17)
message(FATAL_ERROR
"my_lib_project requires CMAKE_CXX_STANDARD >= 17 (got: ${CMAKE_CXX_STANDARD})")
endif()
```
Then the top-level application project that uses your library is responsible for
setting a consistent `CMAKE_CXX_STANDARD` that is sufficiently high.
### Running Abseil Tests with CMake
Use the `-DABSL_BUILD_TESTING=ON` flag to run Abseil tests. Note that
BUILD_TESTING must also be on (the default).
You will need to provide Abseil with a Googletest dependency. There are two
options for how to do this:
* Use `-DABSL_USE_GOOGLETEST_HEAD`. This will automatically download the latest
Googletest source into the build directory at configure time. Googletest will
then be compiled directly alongside Abseil's tests.
* Manually integrate Googletest with your build. See
https://github.com/google/googletest/blob/master/googletest/README.md#using-cmake
for more information on using Googletest in a CMake project.
For example, to run just the Abseil tests, you could use this script:
```
cd path/to/abseil-cpp
mkdir build
cd build
cmake -DABSL_BUILD_TESTING=ON -DABSL_USE_GOOGLETEST_HEAD=ON ..
make -j
ctest
```
Currently, we only run our tests with CMake in a Linux environment, but we are
working on the rest of our supported platforms. See
https://github.com/abseil/abseil-cpp/projects/1 and
https://github.com/abseil/abseil-cpp/issues/109 for more information.
### Available Abseil CMake Public Targets
Here's a non-exhaustive list of Abseil CMake public targets:
```cmake
absl::algorithm
absl::base
absl::debugging
absl::flat_hash_map
absl::flags
absl::memory
absl::meta
absl::numeric
absl::random_random
absl::strings
absl::synchronization
absl::time
absl::utility
```
## Traditional CMake Set-Up
For larger projects, it may make sense to use the traditional CMake set-up where you build and install projects separately.
First, you'd need to build and install Google Test:
```
cmake -S /source/googletest -B /build/googletest -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/installation/dir -DBUILD_GMOCK=ON
cmake --build /build/googletest --target install
```
Then you need to configure and build Abseil. Make sure you enable `ABSL_USE_EXTERNAL_GOOGLETEST` and `ABSL_FIND_GOOGLETEST`. You also need to enable `ABSL_ENABLE_INSTALL` so that you can install Abseil itself.
```
cmake -S /source/abseil-cpp -B /build/abseil-cpp -DCMAKE_PREFIX_PATH=/installation/dir -DCMAKE_INSTALL_PREFIX=/installation/dir -DABSL_ENABLE_INSTALL=ON -DABSL_USE_EXTERNAL_GOOGLETEST=ON -DABSL_FIND_GOOGLETEST=ON
cmake --build /temporary/build/abseil-cpp
```
(`CMAKE_PREFIX_PATH` is where you already have Google Test installed; `CMAKE_INSTALL_PREFIX` is where you want to have Abseil installed; they can be different.)
Run the tests:
```
ctest --test-dir /temporary/build/abseil-cpp
```
And finally install:
```
cmake --build /temporary/build/abseil-cpp --target install
```
# CMake Option Synopsis
## Enable Standard CMake Installation
`-DABSL_ENABLE_INSTALL=ON`
## Google Test Options
`-DABSL_BUILD_TESTING=ON` must be set to enable testing
- Have Abseil download and build Google Test for you: `-DABSL_USE_EXTERNAL_GOOGLETEST=OFF` (default)
- Download and build latest Google Test: `-DABSL_USE_GOOGLETEST_HEAD=ON`
- Download specific Google Test version (ZIP archive): `-DABSL_GOOGLETEST_DOWNLOAD_URL=https://.../version.zip`
- Use Google Test from specific local directory: `-DABSL_LOCAL_GOOGLETEST_DIR=/path/to/googletest`
- Use Google Test included elsewhere in your project: `-DABSL_USE_EXTERNAL_GOOGLETEST=ON`
- Use standard CMake `find_package(CTest)` to find installed Google Test: `-DABSL_USE_EXTERNAL_GOOGLETEST=ON -DABSL_FIND_GOOGLETEST=ON`
================================================
FILE: CMake/abslConfig.cmake.in
================================================
# absl CMake configuration file.
include(CMakeFindDependencyMacro)
find_dependency(Threads)
@PACKAGE_INIT@
include ("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
================================================
FILE: CMake/install_test_project/CMakeLists.txt
================================================
#
# Copyright 2019 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# A simple CMakeLists.txt for testing cmake installation
cmake_minimum_required(VERSION 3.16)
project(absl_cmake_testing CXX)
add_executable(simple simple.cc)
find_package(absl REQUIRED)
target_link_libraries(simple absl::strings absl::config)
================================================
FILE: CMake/install_test_project/simple.cc
================================================
//
// Copyright 2019 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <iostream>
#include "absl/base/config.h"
#include "absl/strings/substitute.h"
#if !defined(ABSL_LTS_RELEASE_VERSION) || ABSL_LTS_RELEASE_VERSION != 99998877
#error ABSL_LTS_RELEASE_VERSION is not set correctly.
#endif
#if !defined(ABSL_LTS_RELEASE_PATCH_LEVEL) || ABSL_LTS_RELEASE_PATCH_LEVEL != 0
#error ABSL_LTS_RELEASE_PATCH_LEVEL is not set correctly.
#endif
int main(int argc, char** argv) {
for (int i = 0; i < argc; ++i) {
std::cout << absl::Substitute("Arg $0: $1\n", i, argv[i]);
}
}
================================================
FILE: CMake/install_test_project/test.sh
================================================
#!/bin/bash
#
# Copyright 2019 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Unit and integration tests for Abseil LTS CMake installation
# Fail on any error. Treat unset variables an error. Print commands as executed.
set -euox pipefail
absl_dir=/abseil-cpp
absl_build_dir=/buildfs
googletest_builddir=/googletest_builddir
googletest_archive="googletest-${ABSL_GOOGLETEST_VERSION}.tar.gz"
project_dir="${absl_dir}/CMake/install_test_project"
project_build_dir=/buildfs/project-build
build_shared_libs="OFF"
if [ "${LINK_TYPE:-}" = "DYNAMIC" ]; then
build_shared_libs="ON"
fi
# Build and install GoogleTest
mkdir "${googletest_builddir}"
pushd "${googletest_builddir}"
curl -L "${ABSL_GOOGLETEST_DOWNLOAD_URL}" --output "${googletest_archive}"
tar -xz -f "${googletest_archive}"
pushd "googletest-${ABSL_GOOGLETEST_VERSION}"
mkdir build
pushd build
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS="${build_shared_libs}" ..
make -j $(nproc)
make install
ldconfig
popd
popd
popd
# Run the LTS transformations
./create_lts.py 99998877
# Build and install Abseil
pushd "${absl_build_dir}"
cmake "${absl_dir}" \
-DABSL_USE_EXTERNAL_GOOGLETEST=ON \
-DABSL_FIND_GOOGLETEST=ON \
-DCMAKE_BUILD_TYPE=Release \
-DABSL_BUILD_TESTING=ON \
-DBUILD_SHARED_LIBS="${build_shared_libs}"
make -j $(nproc)
ctest -j $(nproc) --output-on-failure
make install
ldconfig
popd
# Test the project against the installed Abseil
mkdir -p "${project_build_dir}"
pushd "${project_build_dir}"
cmake "${project_dir}"
cmake --build . --target simple
output="$(${project_build_dir}/simple "printme" 2>&1)"
if [[ "${output}" != *"Arg 1: printme"* ]]; then
echo "Faulty output on simple project:"
echo "${output}"
exit 1
fi
popd
if ! grep absl::strings "/usr/local/lib/cmake/absl/abslTargets.cmake"; then
cat "/usr/local/lib/cmake/absl/abslTargets.cmake"
echo "CMake targets named incorrectly"
exit 1
fi
pushd "${HOME}"
cat > hello-abseil.cc << EOF
#include <cstdlib>
#include "absl/strings/str_format.h"
int main(int argc, char **argv) {
absl::PrintF("Hello Abseil!\n");
return EXIT_SUCCESS;
}
EOF
if [ "${LINK_TYPE:-}" != "DYNAMIC" ]; then
pc_args=($(pkg-config --cflags --libs --static absl_str_format))
g++ -static -o hello-abseil hello-abseil.cc "${pc_args[@]}"
else
pc_args=($(pkg-config --cflags --libs absl_str_format))
g++ -o hello-abseil hello-abseil.cc "${pc_args[@]}"
fi
hello="$(./hello-abseil)"
[[ "${hello}" == "Hello Abseil!" ]]
popd
echo "Install test complete!"
exit 0
================================================
FILE: CMakeLists.txt
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md
# As of 2024-07-01, CMake 3.16 is the minimum supported version.
cmake_minimum_required(VERSION 3.16)
# Allow the user to specify the CMAKE_MSVC_DEBUG_INFORMATION_FORMAT
if (POLICY CMP0141)
cmake_policy(SET CMP0141 NEW)
endif (POLICY CMP0141)
project(absl LANGUAGES CXX)
set(ABSL_SOVERSION 0)
include(CTest)
# Output directory is correct by default for most build setups. However, when
# building Abseil as a DLL, it is important to have the DLL in the same
# directory as the executable using it. Thus, we put all executables in a single
# /bin directory.
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
# when absl is included as subproject (i.e. using add_subdirectory(abseil-cpp))
# in the source tree of a project that uses it, install rules are disabled.
if(NOT CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
option(ABSL_ENABLE_INSTALL "Enable install rule" OFF)
else()
option(ABSL_ENABLE_INSTALL "Enable install rule" ON)
endif()
set(CMAKE_INSTALL_RPATH "$ORIGIN")
set(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)
set(CMAKE_BUILD_RPATH_USE_ORIGIN ON)
option(ABSL_PROPAGATE_CXX_STD
"Use CMake C++ standard meta features (e.g. cxx_std_17) that propagate to targets that link to Abseil"
ON)
option(ABSL_USE_SYSTEM_INCLUDES
"Silence warnings in Abseil headers by marking them as SYSTEM includes"
OFF)
list(APPEND CMAKE_MODULE_PATH
${CMAKE_CURRENT_LIST_DIR}/CMake
${CMAKE_CURRENT_LIST_DIR}/absl/copts
)
option(ABSL_MSVC_STATIC_RUNTIME
"Link static runtime libraries"
OFF)
if(ABSL_MSVC_STATIC_RUNTIME)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
else()
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()
include(CMakePackageConfigHelpers)
include(GNUInstallDirs)
include(AbseilDll)
include(AbseilHelpers)
##
## Using absl targets
##
## all public absl targets are
## exported with the absl:: prefix
##
## e.g absl::base absl::synchronization absl::strings ....
##
## DO NOT rely on the internal targets outside of the prefix
# include current path
list(APPEND ABSL_COMMON_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})
if("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
set(ABSL_USING_CLANG ON)
else()
set(ABSL_USING_CLANG OFF)
endif()
# find dependencies
## pthread
find_package(Threads REQUIRED)
include(CMakeDependentOption)
option(ABSL_BUILD_TESTING
"If ON, Abseil will build all of Abseil's own tests." OFF)
option(ABSL_BUILD_TEST_HELPERS
"If ON, Abseil will build libraries that you can use to write tests against Abseil code. This option requires that Abseil is configured to use GoogleTest."
OFF)
option(ABSL_USE_EXTERNAL_GOOGLETEST
"If ON, Abseil will assume that the targets for GoogleTest are already provided by the including project. This makes sense when Abseil is used with add_subdirectory." OFF)
cmake_dependent_option(ABSL_FIND_GOOGLETEST
"If ON, Abseil will use find_package(GTest) rather than assuming that GoogleTest is already provided by the including project."
ON
"ABSL_USE_EXTERNAL_GOOGLETEST"
OFF)
option(ABSL_USE_GOOGLETEST_HEAD
"If ON, abseil will download HEAD from GoogleTest at config time." OFF)
set(ABSL_GOOGLETEST_DOWNLOAD_URL "" CACHE STRING "If set, download GoogleTest from this URL")
set(ABSL_LOCAL_GOOGLETEST_DIR "/usr/src/googletest" CACHE PATH
"If ABSL_USE_GOOGLETEST_HEAD is OFF and ABSL_GOOGLETEST_URL is not set, specifies the directory of a local GoogleTest checkout."
)
option(ABSL_BUILD_MONOLITHIC_SHARED_LIBS
"Build Abseil as a single shared library (always enabled for Windows)"
OFF
)
if(NOT BUILD_SHARED_LIBS AND ABSL_BUILD_MONOLITHIC_SHARED_LIBS)
message(WARNING "Not building a shared library because BUILD_SHARED_LIBS is not set. Ignoring ABSL_BUILD_MONOLITHIC_SHARED_LIBS.")
endif()
if((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)
if (ABSL_USE_EXTERNAL_GOOGLETEST)
if (ABSL_FIND_GOOGLETEST)
find_package(GTest REQUIRED)
elseif(NOT TARGET GTest::gtest)
if(TARGET gtest)
# When Google Test is included directly rather than through find_package, the aliases are missing.
add_library(GTest::gtest ALIAS gtest)
add_library(GTest::gtest_main ALIAS gtest_main)
add_library(GTest::gmock ALIAS gmock)
add_library(GTest::gmock_main ALIAS gmock_main)
else()
message(FATAL_ERROR "ABSL_USE_EXTERNAL_GOOGLETEST is ON and ABSL_FIND_GOOGLETEST is OFF, which means that the top-level project must build the Google Test project. However, the target gtest was not found.")
endif()
endif()
else()
set(absl_gtest_build_dir ${CMAKE_BINARY_DIR}/googletest-build)
if(ABSL_USE_GOOGLETEST_HEAD AND ABSL_GOOGLETEST_DOWNLOAD_URL)
message(FATAL_ERROR "Do not set both ABSL_USE_GOOGLETEST_HEAD and ABSL_GOOGLETEST_DOWNLOAD_URL")
endif()
if(ABSL_USE_GOOGLETEST_HEAD)
set(absl_gtest_download_url "https://github.com/google/googletest/archive/main.zip")
elseif(ABSL_GOOGLETEST_DOWNLOAD_URL)
set(absl_gtest_download_url ${ABSL_GOOGLETEST_DOWNLOAD_URL})
endif()
if(absl_gtest_download_url)
set(absl_gtest_src_dir ${CMAKE_BINARY_DIR}/googletest-src)
else()
set(absl_gtest_src_dir ${ABSL_LOCAL_GOOGLETEST_DIR})
endif()
include(CMake/Googletest/DownloadGTest.cmake)
endif()
endif()
add_subdirectory(absl)
if(ABSL_ENABLE_INSTALL)
# absl:lts-remove-begin(system installation is supported for LTS releases)
# We don't support system-wide installation
list(APPEND SYSTEM_INSTALL_DIRS "/usr/local" "/usr" "/opt/" "/opt/local" "c:/Program Files/${PROJECT_NAME}")
if(NOT DEFINED CMAKE_INSTALL_PREFIX OR CMAKE_INSTALL_PREFIX IN_LIST SYSTEM_INSTALL_DIRS)
message(WARNING "\
The default and system-level install directories are unsupported except in LTS \
releases of Abseil. Please set CMAKE_INSTALL_PREFIX to install Abseil in your \
source or build tree directly.\
")
endif()
# absl:lts-remove-end
# install as a subdirectory only
install(EXPORT ${PROJECT_NAME}Targets
NAMESPACE absl::
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
configure_package_config_file(
CMake/abslConfig.cmake.in
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
# Abseil only has a version in LTS releases. This mechanism is accomplished
# Abseil's internal Copybara (https://github.com/google/copybara) workflows and
# isn't visible in the CMake buildsystem itself.
if(absl_VERSION)
write_basic_package_version_file(
"${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
COMPATIBILITY ExactVersion
)
install(FILES "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
endif() # absl_VERSION
# Install the headers except for "options.h" which is installed separately.
install(DIRECTORY absl
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
FILES_MATCHING
PATTERN "*.inc"
PATTERN "*.h"
PATTERN "options.h" EXCLUDE
PATTERN "copts" EXCLUDE
PATTERN "testdata" EXCLUDE
)
# Rewrite options.h to use the compiled ABI.
file(READ "absl/base/options.h" ABSL_INTERNAL_OPTIONS_H_CONTENTS)
# Handle features that require at least C++20.
if (ABSL_INTERNAL_AT_LEAST_CXX20)
foreach(FEATURE "ORDERING" "SOURCE_LOCATION")
string(REPLACE
"#define ABSL_OPTION_USE_STD_${FEATURE} 2"
"#define ABSL_OPTION_USE_STD_${FEATURE} 1"
ABSL_INTERNAL_OPTIONS_H_PINNED
"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}")
set(ABSL_INTERNAL_OPTIONS_H_CONTENTS "${ABSL_INTERNAL_OPTIONS_H_PINNED}")
endforeach()
endif()
# Handle features that require at least C++17.
if (ABSL_INTERNAL_AT_LEAST_CXX17)
foreach(FEATURE "ANY" "OPTIONAL" "STRING_VIEW" "VARIANT")
string(REPLACE
"#define ABSL_OPTION_USE_STD_${FEATURE} 2"
"#define ABSL_OPTION_USE_STD_${FEATURE} 1"
ABSL_INTERNAL_OPTIONS_H_PINNED
"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}")
set(ABSL_INTERNAL_OPTIONS_H_CONTENTS "${ABSL_INTERNAL_OPTIONS_H_PINNED}")
endforeach()
endif()
# Any feature that still has the value of 2 (because it was not handled above)
# should be set to 0.
string(REGEX REPLACE
"#define ABSL_OPTION_USE_STD_([^ ]*) 2"
"#define ABSL_OPTION_USE_STD_\\1 0"
ABSL_INTERNAL_OPTIONS_H_PINNED
"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}")
# If the file already exists, check if it matches the new contents.
# This avoids writing the file if it is already up-to-date when the CMake
# generation is triggered and triggering unnecessary rebuilds.
set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE TRUE)
if (EXISTS "${CMAKE_BINARY_DIR}/options-pinned.h")
file(READ "${CMAKE_BINARY_DIR}/options-pinned.h" ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS)
if ("${ABSL_INTERNAL_OPTIONS_H_PINNED}" STREQUAL "${ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS}")
set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE FALSE)
endif()
endif()
# If the file needs an update, generate it.
if (ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE)
file(GENERATE OUTPUT "${CMAKE_BINARY_DIR}/options-pinned.h" CONTENT "${ABSL_INTERNAL_OPTIONS_H_PINNED}")
endif()
install(FILES "${CMAKE_BINARY_DIR}/options-pinned.h"
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/absl/base
RENAME "options.h")
endif() # ABSL_ENABLE_INSTALL
================================================
FILE: CONTRIBUTING.md
================================================
# How to Contribute to Abseil
We'd love to accept your patches and contributions to this project. There are
just a few small guidelines you need to follow.
NOTE: If you are new to GitHub, please start by reading [Pull Request
howto](https://help.github.com/articles/about-pull-requests/)
## Contributor License Agreement
Contributions to this project must be accompanied by a Contributor License
Agreement. You (or your employer) retain the copyright to your contribution,
this simply gives us permission to use and redistribute your contributions as
part of the project. Head over to <https://cla.developers.google.com/> to see
your current agreements on file or to sign a new one.
You generally only need to submit a CLA once, so if you've already submitted one
(even if it was for a different project), you probably don't need to do it
again.
## Contribution Guidelines
Potential contributors sometimes ask us if the Abseil project is the appropriate
home for their utility library code or for specific functions implementing
missing portions of the standard. Often, the answer to this question is "no".
We’d like to articulate our thinking on this issue so that our choices can be
understood by everyone and so that contributors can have a better intuition
about whether Abseil might be interested in adopting a new library.
### Priorities
Although our mission is to augment the C++ standard library, our goal is not to
provide a full forward-compatible implementation of the latest standard. For us
to consider a library for inclusion in Abseil, it is not enough that a library
is useful. We generally choose to release a library when it meets at least one
of the following criteria:
* **Widespread usage** - Using our internal codebase to help gauge usage, most
of the libraries we've released have tens of thousands of users.
* **Anticipated widespread usage** - Pre-adoption of some standard-compliant
APIs may not have broad adoption initially but can be expected to pick up
usage when it replaces legacy APIs. `absl::from_chars`, for example,
replaces existing code that converts strings to numbers and will therefore
likely see usage growth.
* **High impact** - APIs that provide a key solution to a specific problem,
such as `absl::FixedArray`, have higher impact than usage numbers may signal
and are released because of their importance.
* **Direct support for a library that falls under one of the above** - When we
want access to a smaller library as an implementation detail for a
higher-priority library we plan to release, we may release it, as we did
with portions of `absl/meta/type_traits.h`. One consequence of this is that
the presence of a library in Abseil does not necessarily mean that other
similar libraries would be a high priority.
### API Freeze Consequences
Via the
[Abseil Compatibility Guidelines](https://abseil.io/about/compatibility), we
have promised a large degree of API stability. In particular, we will not make
backward-incompatible changes to released APIs without also shipping a tool or
process that can upgrade our users' code. We are not yet at the point of easily
releasing such tools. Therefore, at this time, shipping a library establishes an
API contract which is borderline unchangeable. (We can add new functionality,
but we cannot easily change existing behavior.) This constraint forces us to
very carefully review all APIs that we ship.
## Coding Style
To keep the source consistent, readable, diffable and easy to merge, we use a
fairly rigid coding style, as defined by the
[google-styleguide](https://github.com/google/styleguide) project. All patches
will be expected to conform to the style outlined
[here](https://google.github.io/styleguide/cppguide.html).
## Guidelines for Pull Requests
* If you are a Googler, it is required that you send us a Piper CL instead of
using the GitHub pull-request process. The code propagation process will
deliver the change to GitHub.
* Create **small PRs** that are narrowly focused on **addressing a single
concern**. We often receive PRs that are trying to fix several things at a
time, but if only one fix is considered acceptable, nothing gets merged and
both author's & review's time is wasted. Create more PRs to address
different concerns and everyone will be happy.
* For speculative changes, consider opening an [Abseil
issue](https://github.com/abseil/abseil-cpp/issues) and discussing it first.
If you are suggesting a behavioral or API change, consider starting with an
[Abseil proposal template](ABSEIL_ISSUE_TEMPLATE.md).
* Provide a good **PR description** as a record of **what** change is being
made and **why** it was made. Link to a GitHub issue if it exists.
* Don't fix code style and formatting unless you are already changing that
line to address an issue. Formatting of modified lines may be done using
`git clang-format`. PRs with irrelevant changes won't be merged. If
you do want to fix formatting or style, do that in a separate PR.
* Unless your PR is trivial, you should expect there will be reviewer comments
that you'll need to address before merging. We expect you to be reasonably
responsive to those comments, otherwise the PR will be closed after 2-3
weeks of inactivity.
* Maintain **clean commit history** and use **meaningful commit messages**.
PRs with messy commit history are difficult to review and won't be merged.
Use `rebase -i upstream/master` to curate your commit history and/or to
bring in latest changes from master (but avoid rebasing in the middle of a
code review).
* Keep your PR up to date with upstream/master (if there are merge conflicts,
we can't really merge your change).
* **All tests need to be passing** before your change can be merged. We
recommend you **run tests locally** (see below)
* Exceptions to the rules can be made if there's a compelling reason for doing
so. That is - the rules are here to serve us, not the other way around, and
the rules need to be serving their intended purpose to be valuable.
* All submissions, including submissions by project members, require review.
## Running Tests
If you have [Bazel](https://bazel.build/) installed, use `bazel test
--test_tag_filters="-benchmark" ...` to run the unit tests.
If you are running the Linux operating system and have
[Docker](https://www.docker.com/) installed, you can also run the `linux_*.sh`
scripts under the `ci/`(https://github.com/abseil/abseil-cpp/tree/master/ci)
directory to test Abseil under a variety of conditions.
## Abseil Committers
The current members of the Abseil engineering team are the only committers at
present.
## Release Process
Abseil lives at head, where latest-and-greatest code can be found.
================================================
FILE: FAQ.md
================================================
# Abseil FAQ
## Is Abseil the right home for my utility library?
Most often the answer to the question is "no." As both the
[About Abseil](https://abseil.io/about/) page and our
[contributing guidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md#contribution-guidelines)
explain, Abseil contains a variety of core C++ library code that is widely used
at [Google](https://www.google.com/). As such, Abseil's primary purpose is to be
used as a dependency by Google's open source C++ projects. While we do hope that
Abseil is also useful to the C++ community at large, this added constraint also
means that we are unlikely to accept a contribution of utility code that isn't
already widely used by Google.
## How do I set the C++ dialect used to build Abseil?
The short answer is that whatever mechanism you choose, you need to make sure
that you set this option consistently at the global level for your entire
project. If, for example, you want to set the C++ dialect to C++17, with
[Bazel](https://bazel.build/) as the build system and `gcc` or `clang` as the
compiler, there are several ways to do this: * Pass `--cxxopt=-std=c++17` on the
command line (for example, `bazel build --cxxopt=-std=c++17 ...`) * Set the
environment variable `BAZEL_CXXOPTS` (for example, `BAZEL_CXXOPTS=-std=c++17`) *
Add `build --cxxopt=-std=c++17` to your
[`.bazelrc` file](https://docs.bazel.build/versions/master/guide.html#bazelrc)
If you are using CMake as the build system, you'll need to add a line like
`set(CMAKE_CXX_STANDARD 17)` to your top level `CMakeLists.txt` file. If you are
developing a library designed to be used by other clients, you should instead
leave `CMAKE_CXX_STANDARD` unset and configure the minimum C++ standard required
by each of your library targets via `target_compile_features`. See the
[CMake build instructions](https://github.com/abseil/abseil-cpp/blob/master/CMake/README.md)
for more information.
For a longer answer to this question and to understand why some other approaches
don't work, see the answer to ["What is ABI and why don't you recommend using a
pre-compiled version of
Abseil?"](#what-is-abi-and-why-dont-you-recommend-using-a-pre-compiled-version-of-abseil)
## What is ABI and why don't you recommend using a pre-compiled version of Abseil?
For the purposes of this discussion,
[ABI](https://en.wikipedia.org/wiki/Application_binary_interface) refers to the
compiled representation of code interfaces. This contrasts with
[API](https://en.wikipedia.org/wiki/Application_programming_interface), which
refers to the interfaces defined in the source code. [Abseil has a strong
promise of API compatibility, but does not make any promise of ABI
compatibility](https://abseil.io/about/compatibility). Let's take a look at what
this means in practice.
You might be tempted to do something like this in a
[Bazel](https://bazel.build/) `BUILD` file:
```
# DON'T DO THIS!!!
cc_library(
name = "my_library",
srcs = ["my_library.cc"],
copts = ["-std=c++17"], # May create a mixed-mode compile!
deps = ["@com_google_absl//absl/strings"],
)
```
Applying `-std=c++17` to an individual target in your `BUILD` file is going to
compile that specific target in C++17 mode, but it isn't going to ensure the
Abseil library is built in C++17 mode, since the Abseil library itself is a
different build target. If your code includes an Abseil header, then your
program may contain conflicting definitions of the same
class/function/variable/enum, etc. As a rule, all compile options that affect
the ABI of a program need to be applied to the entire build on a global basis.
C++ has something called the
[One Definition Rule](https://en.wikipedia.org/wiki/One_Definition_Rule) (ODR).
C++ doesn't allow multiple definitions of the same class/function/variable/enum,
etc. ODR violations sometimes result in linker errors, but linkers do not always
catch violations. Uncaught ODR violations can result in strange runtime
behaviors or crashes that can be hard to debug.
If you build the Abseil library and your code using different compile options
that affect ABI, there is a good chance you will run afoul of the One Definition
Rule. Examples of GCC compile options that affect ABI include (but aren't
limited to) language dialect (e.g. `-std=`), optimization level (e.g. `-O2`),
code generation flags (e.g. `-fexceptions`), and preprocessor defines (e.g.
`-DNDEBUG`).
If you use a pre-compiled version of Abseil, (for example, from your Linux
distribution package manager or from something like
[vcpkg](https://github.com/microsoft/vcpkg)) you have to be very careful to
ensure ABI compatibility across the components of your program. The only way you
can be sure your program is going to be correct regarding ABI is to ensure
you've used the exact same compile options as were used to build the
pre-compiled library. This does not mean that Abseil cannot work as part of a
Linux distribution since a knowledgeable binary packager will have ensured that
all packages have been built with consistent compile options. This is one of the
reasons we warn against - though do not outright reject - using Abseil as a
pre-compiled library.
Another possible way that you might run afoul of ABI issues is if you
accidentally include two versions of Abseil in your program. Multiple versions
of Abseil can end up within the same binary if your program uses the Abseil
library and another library also transitively depends on Abseil (resulting in
what is sometimes called the diamond dependency problem). In cases such as this
you must structure your build so that all libraries use the same version of
Abseil.
[Abseil's strong promise of API compatibility between releases](https://abseil.io/about/compatibility)
means the latest "HEAD" release of Abseil is almost certainly the right choice
if you are doing as we recommend and building all of your code from source.
For these reasons we recommend you avoid pre-compiled code and build the Abseil
library yourself in a consistent manner with the rest of your code.
## What is "live at head" and how do I do it?
From Abseil's point-of-view, "live at head" means that every Abseil source
release (which happens on an almost daily basis) is either API compatible with
the previous release, or comes with an automated tool that you can run over code
to make it compatible. In practice, the need to use an automated tool is
extremely rare. This means that upgrading from one source release to another
should be a routine practice that can and should be performed often.
We recommend you update to the
[latest commit in the `master` branch of Abseil](https://github.com/abseil/abseil-cpp/commits/master)
as often as possible. Not only will you pick up bug fixes more quickly, but if
you have good automated testing, you will catch and be able to fix any
[Hyrum's Law](https://www.hyrumslaw.com/) dependency problems on an incremental
basis instead of being overwhelmed by them and having difficulty isolating them
if you wait longer between updates.
If you are using the [Bazel](https://bazel.build/) build system with
[Bzlmod](https://bazel.build/external/overview#bzlmod), you can use a
`git_override` in your `MODULE.bazel` file to track the latest commit.
For example, to update to the latest commit, you would add (or update) the
following snippet in your `MODULE.bazel` file:
```starlark
bazel_dep(name = "abseil-cpp", version = "20260107.1")
git_override(
module_name = "abseil-cpp",
remote = "https://github.com/abseil/abseil-cpp.git",
# Replace the following line with the latest commit.
commit = "6ec9964c325db0610a376b3cb81de073ea6ada90",
)
```
You can commit the updated `MODULE.bazel` file to your source control every time
you update, and if you have good automated testing, you might even consider
automating this.
## Why do I see strange behaviors when I use Abseil hash tables?
Abseil's hash function uses a random seed.
Many programmers believe incorrectly that this is a defense against
[hash flooding](https://en.wikipedia.org/wiki/Collision_attack#Hash_flooding).
While it does make a hash flooding attack more difficult, Abseil's hash function
prioritizes speed over thorough mixing (and thus is not cryptographically
secure), and the current seed implementation is also not cryptographically
secure. If you are storing a large amount of attacker-controlled data, the most
reliable defense against hash-flooding is to use a container that does not have
`O(n)` worst-case behavior.
The real reason for hash randomization is to prevent
[Hyrum's Law](https://www.hyrumslaw.com/) dependencies on iteration order. This
has allowed us to roll out steady improvements to the implementation without
breaking users who may have otherwise written code that was dependent on
ordering or other characteristics.
The current implementation uses a global seed, which, if linked incorrectly
(e.g., static Abseil in multiple DSOs), can cause the ODR violations. If more
than one seed is linked, different calls to the hash function may return
different values, rendering hash elements inaccessible, causing crashes, or
other arbitrarily bad behaviors.
We are often asked for a knob to disable hash randomization. The answer is a
hard "no", even under test or under a flag, because people will find a way to
force it and allow their code or tests to depend on it. At Google-scale, the
compute costs that are saved by preserving the ability to improve the
implementation far outweigh the inconvenience of learning how to write code
resilient to change.
## How do I use the LLVM Sanitizers with Abseil?
LLVM Sanitizers are a suite of powerful, dynamic analysis tools that
automatically detect various critical bugs during program execution. They work
by instrumenting the compiled binary and linking a runtime library to intercept
operations and report issues.
We receive many incorrect bug reports from users trying to use the sanitizers.
The most common cause of these issues is ODR violations in the form of an
instrumentation mismatch. This happens when users try to link libraries compiled
with sanitizer instrumentation with uninstrumented libraries. It is important
that all code in the application is built with the same sanitizer configuration.
The easiest way to do this is to use [Bazel](https://bazel.build) and pass the
sanitizer options on the commandline, but it is important not to overlook the
importance of avoiding precompiled system libraries, including the C++ standard
library. For instance,
[MemorySanitizer requires an instrumented `libc++`](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).
Since most users are not going to build `libc++` with Bazel, here is a
MemorySanitizer recipe that currently works (and could easily be tweaked for
ThreadSanitizer and friends):
```shell
# From the root of the LLVM source tree, configure libc++ to be instrumented with MSAN:
cmake -G Ninja -S runtimes -B build_msan -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi;libunwind" -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="${HOME}/llvm-msan" -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DLLVM_USE_SANITIZER=MemoryWithOrigins -DLLVM_TARGETS_TO_BUILD="host"
# Build and install it into ${HOME}/llvm-msan
ninja -C build_msan install-cxx install-cxxabi install-unwind
# Then build (or test) your code like this:
bazel test --repo_env=CC=clang --repo_env=BAZEL_CXXOPTS=nostdinc++ --repo_env=BAZEL_LINKOPTS=-L${HOME}/llvm-msan/lib:-lc++:-lc++abi:-lgcc_s:-lm:-Wl,-rpath=${HOME}/llvm-msan/lib --repo_env=CPLUS_INCLUDE_PATH=${HOME}/llvm-msan/include/c++/v1 --copt=-fsanitize=memory --linkopt=-fsanitize=memory --linkopt=-fsanitize-link-c++-runtime ...
```
You should consider adding these options to a
[`.bazelrc`](https://bazel.build/run/bazelrc) file to avoid retyping them.
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: MODULE.bazel
================================================
# Copyright 2024 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# https://bazel.build/external/overview#bzlmod
module(
name = "abseil-cpp",
version = "head",
compatibility_level = 1,
)
cc_configure = use_extension("@rules_cc//cc:extensions.bzl",
"cc_configure_extension",
dev_dependency = True)
use_repo(cc_configure, "local_config_cc")
bazel_dep(name = "rules_cc", version = "0.2.9")
bazel_dep(name = "bazel_skylib", version = "1.8.1")
bazel_dep(name = "platforms", version = "1.0.0")
bazel_dep(
name = "google_benchmark",
version = "1.9.5",
dev_dependency = True,
)
# Note: Googletest is NOT a dev_dependency. Some Abseil test utilities
# intended to be used by Abseil users depend on GoogleTest.
bazel_dep(
name = "googletest",
version = "1.17.0.bcr.2",
)
================================================
FILE: PrivacyInfo.xcprivacy
================================================
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>NSPrivacyTracking</key>
<false/>
<key>NSPrivacyCollectedDataTypes</key>
<array/>
<key>NSPrivacyTrackingDomains</key>
<array/>
<key>NSPrivacyAccessedAPITypes</key>
<array/>
</dict>
</plist>
================================================
FILE: README.md
================================================
# Abseil - C++ Common Libraries
The repository contains the Abseil C++ library code. Abseil is an open-source
collection of C++ code (compliant to C++17) designed to augment the C++
standard library.
## Table of Contents
- [About Abseil](#about)
- [Quickstart](#quickstart)
- [Building Abseil](#build)
- [Support](#support)
- [Codemap](#codemap)
- [Releases](#releases)
- [License](#license)
- [Links](#links)
<a name="about"></a>
## About Abseil
Abseil is an open-source collection of C++ library code designed to augment
the C++ standard library. The Abseil library code is collected from Google's
own C++ code base, has been extensively tested and used in production, and
is the same code we depend on in our daily coding lives.
In some cases, Abseil provides pieces missing from the C++ standard; in
others, Abseil provides alternatives to the standard for special needs
we've found through usage in the Google code base. We denote those cases
clearly within the library code we provide you.
Abseil is not meant to be a competitor to the standard library; we've
just found that many of these utilities serve a purpose within our code
base, and we now want to provide those resources to the C++ community as
a whole.
<a name="quickstart"></a>
## Quickstart
If you want to just get started, make sure you at least run through the
[Abseil Quickstart](https://abseil.io/docs/cpp/quickstart). The Quickstart
contains information about setting up your development environment, downloading
the Abseil code, running tests, and getting a simple binary working.
<a name="build"></a>
## Building Abseil
[Bazel](https://bazel.build) and [CMake](https://cmake.org/) are the official
build systems for Abseil.
See the [quickstart](https://abseil.io/docs/cpp/quickstart) for more information
on building Abseil using the Bazel build system.
If you require CMake support, please check the [CMake build
instructions](CMake/README.md) and [CMake
Quickstart](https://abseil.io/docs/cpp/quickstart-cmake).
<a name="support"></a>
## Support
Abseil follows Google's [Foundational C++ Support
Policy](https://opensource.google/documentation/policies/cplusplus-support). See
[this
table](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md)
for a list of currently supported versions compilers, platforms, and build
tools.
<a name="codemap"></a>
## Codemap
Abseil contains the following C++ library components:
* [`base`](absl/base/)
<br /> The `base` library contains initialization code and other code which
all other Abseil code depends on. Code within `base` may not depend on any
other code (other than the C++ standard library).
* [`algorithm`](absl/algorithm/)
<br /> The `algorithm` library contains additions to the C++ `<algorithm>`
library and container-based versions of such algorithms.
* [`cleanup`](absl/cleanup/)
<br /> The `cleanup` library contains the control-flow-construct-like type
`absl::Cleanup` which is used for executing a callback on scope exit.
* [`container`](absl/container/)
<br /> The `container` library contains additional STL-style containers,
including Abseil's unordered "Swiss table" containers.
* [`crc`](absl/crc/) The `crc` library contains code for
computing error-detecting cyclic redundancy checks on data.
* [`debugging`](absl/debugging/)
<br /> The `debugging` library contains code useful for enabling leak
checks, and stacktrace and symbolization utilities.
* [`flags`](absl/flags/)
<br /> The `flags` library contains code for handling command line flags for
libraries and binaries built with Abseil.
* [`hash`](absl/hash/)
<br /> The `hash` library contains the hashing framework and default hash
functor implementations for hashable types in Abseil.
* [`log`](absl/log/)
<br /> The `log` library contains `LOG` and `CHECK` macros and facilities
for writing logged messages out to disk, `stderr`, or user-extensible
destinations.
* [`memory`](absl/memory/)
<br /> The `memory` library contains memory management facilities that augment
C++'s `<memory>` library.
* [`meta`](absl/meta/)
<br /> The `meta` library contains type checks
similar to those available in the C++ `<type_traits>` library.
* [`numeric`](absl/numeric/)
<br /> The `numeric` library contains 128-bit integer types as well as
implementations of C++20's bitwise math functions.
* [`profiling`](absl/profiling/)
<br /> The `profiling` library contains utility code for profiling C++
entities. It is currently a private dependency of other Abseil libraries.
* [`random`](absl/random/)
<br /> The `random` library contains functions for generating pseudorandom
values.
* [`status`](absl/status/)
<br /> The `status` library contains abstractions for error handling,
specifically `absl::Status` and `absl::StatusOr<T>`.
* [`strings`](absl/strings/)
<br /> The `strings` library contains a variety of strings routines and
utilities.
* [`synchronization`](absl/synchronization/)
<br /> The `synchronization` library contains concurrency primitives (Abseil's
`absl::Mutex` class, an alternative to `std::mutex`) and a variety of
synchronization abstractions.
* [`time`](absl/time/)
<br /> The `time` library contains abstractions for computing with absolute
points in time, durations of time, and formatting and parsing time within
time zones.
* [`types`](absl/types/)
<br /> The `types` library contains non-container utility types.
* [`utility`](absl/utility/)
<br /> The `utility` library contains utility and helper code.
<a name="releases"></a>
## Releases
Abseil recommends users "live-at-head" (update to the latest commit from the
master branch as often as possible). However, we realize this philosophy doesn't
work for every project, so we also provide [Long Term Support
Releases](https://github.com/abseil/abseil-cpp/releases) to which we backport
fixes for severe bugs. See our [release
management](https://abseil.io/about/releases) document for more details.
<a name="license"></a>
## License
The Abseil C++ library is licensed under the terms of the Apache
license. See [LICENSE](LICENSE) for more information.
<a name="links"></a>
## Links
For more information about Abseil:
* Consult our [Abseil Introduction](https://abseil.io/about/intro)
* Read [Why Adopt Abseil](https://abseil.io/about/philosophy) to understand our
design philosophy.
* Peruse our
[Abseil Compatibility Guarantees](https://abseil.io/about/compatibility) to
understand both what we promise to you, and what we expect of you in return.
================================================
FILE: UPGRADES.md
================================================
# C++ Upgrade Tools
Abseil may occasionally release API-breaking changes. As noted in our
[Compatibility Guidelines][compatibility-guide], we will aim to provide a tool
to do the work of effecting such API-breaking changes, when absolutely
necessary.
These tools will be listed on the [C++ Upgrade Tools][upgrade-tools] guide on
https://abseil.io.
For more information, the [C++ Automated Upgrade Guide][api-upgrades-guide]
outlines this process.
[compatibility-guide]: https://abseil.io/about/compatibility
[api-upgrades-guide]: https://abseil.io/docs/cpp/tools/api-upgrades
[upgrade-tools]: https://abseil.io/docs/cpp/tools/upgrades/
================================================
FILE: absl/BUILD.bazel
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
load("@bazel_skylib//lib:selects.bzl", "selects")
package(default_visibility = ["//visibility:public"])
licenses(["notice"])
config_setting(
name = "clang_compiler",
flag_values = {
"@bazel_tools//tools/cpp:compiler": "clang",
},
visibility = [":__subpackages__"],
)
config_setting(
name = "mingw_unspecified_compiler",
flag_values = {
"@bazel_tools//tools/cpp:compiler": "mingw",
},
visibility = [":__subpackages__"],
)
config_setting(
name = "mingw-gcc_compiler",
flag_values = {
"@bazel_tools//tools/cpp:compiler": "mingw-gcc",
},
visibility = [":__subpackages__"],
)
config_setting(
name = "fuchsia",
constraint_values = [
"@platforms//os:fuchsia",
],
visibility = [":__subpackages__"],
)
selects.config_setting_group(
name = "mingw_compiler",
match_any = [
":mingw_unspecified_compiler",
":mingw-gcc_compiler",
],
visibility = [":__subpackages__"],
)
# Expose internals to privileged external repositories.
package_group(
name = "friends",
packages = [],
)
================================================
FILE: absl/CMakeLists.txt
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
add_subdirectory(base)
add_subdirectory(algorithm)
add_subdirectory(cleanup)
add_subdirectory(container)
add_subdirectory(crc)
add_subdirectory(debugging)
add_subdirectory(flags)
add_subdirectory(functional)
add_subdirectory(hash)
add_subdirectory(log)
add_subdirectory(memory)
add_subdirectory(meta)
add_subdirectory(numeric)
add_subdirectory(profiling)
add_subdirectory(random)
add_subdirectory(status)
add_subdirectory(strings)
add_subdirectory(synchronization)
add_subdirectory(time)
add_subdirectory(types)
add_subdirectory(utility)
if (ABSL_BUILD_DLL)
absl_make_dll()
if ((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)
absl_make_dll(TEST ON)
endif()
endif()
================================================
FILE: absl/abseil.podspec.gen.py
================================================
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""This script generates abseil.podspec from all BUILD.bazel files.
This is expected to run on abseil git repository with Bazel 1.0 on Linux.
It recursively analyzes BUILD.bazel files using query command of Bazel to
dump its build rules in XML format. From these rules, it constructs podspec
structure.
"""
import argparse
import collections
import os
import re
import subprocess
import xml.etree.ElementTree
# Template of root podspec.
SPEC_TEMPLATE = """
# This file has been automatically generated from a script.
# Please make modifications to `abseil.podspec.gen.py` instead.
Pod::Spec.new do |s|
s.name = 'abseil'
s.version = '${version}'
s.summary = 'Abseil Common Libraries (C++) from Google'
s.homepage = 'https://abseil.io'
s.license = 'Apache License, Version 2.0'
s.authors = { 'Abseil Team' => 'abseil-io@googlegroups.com' }
s.source = {
:git => 'https://github.com/abseil/abseil-cpp.git',
:tag => '${tag}',
}
s.resource_bundles = {
s.module_name => 'PrivacyInfo.xcprivacy',
}
s.module_name = 'absl'
s.header_mappings_dir = 'absl'
s.header_dir = 'absl'
s.libraries = 'c++'
s.compiler_flags = '-Wno-everything'
s.pod_target_xcconfig = {
'USER_HEADER_SEARCH_PATHS' => '$(inherited) "$(PODS_TARGET_SRCROOT)"',
'USE_HEADERMAP' => 'NO',
'ALWAYS_SEARCH_USER_PATHS' => 'NO',
'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
}
s.ios.deployment_target = '12.0'
s.osx.deployment_target = '10.13'
s.tvos.deployment_target = '12.0'
s.watchos.deployment_target = '4.0'
s.visionos.deployment_target = '1.0'
s.subspec 'xcprivacy' do |ss|
ss.resource_bundles = {
ss.module_name => 'PrivacyInfo.xcprivacy',
}
end
"""
# Rule object representing the rule of Bazel BUILD.
Rule = collections.namedtuple(
"Rule", "type name package srcs hdrs textual_hdrs deps visibility testonly")
def get_elem_value(elem, name):
"""Returns the value of XML element with the given name."""
for child in elem:
if child.attrib.get("name") != name:
continue
if child.tag == "string":
return child.attrib.get("value")
if child.tag == "boolean":
return child.attrib.get("value") == "true"
if child.tag == "list":
return [nested_child.attrib.get("value") for nested_child in child]
raise "Cannot recognize tag: " + child.tag
return None
def normalize_paths(paths):
"""Returns the list of normalized path."""
# e.g. ["//absl/strings:dir/header.h"] -> ["absl/strings/dir/header.h"]
return [path.lstrip("/").replace(":", "/") for path in paths]
def parse_rule(elem, package):
"""Returns a rule from bazel XML rule."""
return Rule(
type=elem.attrib["class"],
name=get_elem_value(elem, "name"),
package=package,
srcs=normalize_paths(get_elem_value(elem, "srcs") or []),
hdrs=normalize_paths(get_elem_value(elem, "hdrs") or []),
textual_hdrs=normalize_paths(get_elem_value(elem, "textual_hdrs") or []),
deps=get_elem_value(elem, "deps") or [],
visibility=get_elem_value(elem, "visibility") or [],
testonly=get_elem_value(elem, "testonly") or False)
def read_build(package):
"""Runs bazel query on given package file and returns all cc rules."""
result = subprocess.check_output(
["bazel", "query", package + ":all", "--output", "xml"])
root = xml.etree.ElementTree.fromstring(result)
return [
parse_rule(elem, package)
for elem in root
if elem.tag == "rule" and elem.attrib["class"].startswith("cc_")
]
def collect_rules(root_path):
"""Collects and returns all rules from root path recursively."""
rules = []
for cur, _, _ in os.walk(root_path):
build_path = os.path.join(cur, "BUILD.bazel")
if os.path.exists(build_path):
rules.extend(read_build("//" + cur))
return rules
def relevant_rule(rule):
"""Returns true if a given rule is relevant when generating a podspec."""
return (
# cc_library only (ignore cc_test, cc_binary)
rule.type == "cc_library" and
# ignore empty rule
(rule.hdrs + rule.textual_hdrs + rule.srcs) and
# ignore test-only rule
not rule.testonly)
def get_spec_var(depth):
"""Returns the name of variable for spec with given depth."""
return "s" if depth == 0 else "s{}".format(depth)
def get_spec_name(label):
"""Converts the label of bazel rule to the name of podspec."""
assert label.startswith("//absl/"), "{} doesn't start with //absl/".format(
label)
# e.g. //absl/apple/banana -> abseil/apple/banana
return "abseil/" + label[7:]
def write_podspec(f, rules, args):
"""Writes a podspec from given rules and args."""
rule_dir = build_rule_directory(rules)["abseil"]
# Write root part with given arguments
spec = re.sub(r"\$\{(\w+)\}", lambda x: args[x.group(1)],
SPEC_TEMPLATE).lstrip()
f.write(spec)
# Write all target rules
write_podspec_map(f, rule_dir, 0)
f.write("end\n")
def build_rule_directory(rules):
"""Builds a tree-style rule directory from given rules."""
rule_dir = {}
for rule in rules:
cur = rule_dir
for frag in get_spec_name(rule.package).split("/"):
cur = cur.setdefault(frag, {})
cur[rule.name] = rule
return rule_dir
def write_podspec_map(f, cur_map, depth):
"""Writes podspec from rule map recursively."""
for key, value in sorted(cur_map.items()):
indent = " " * (depth + 1)
f.write("{indent}{var0}.subspec '{key}' do |{var1}|\n".format(
indent=indent,
key=key,
var0=get_spec_var(depth),
var1=get_spec_var(depth + 1)))
if isinstance(value, dict):
write_podspec_map(f, value, depth + 1)
else:
write_podspec_rule(f, value, depth + 1)
f.write("{indent}end\n".format(indent=indent))
def write_podspec_rule(f, rule, depth):
"""Writes podspec from given rule."""
indent = " " * (depth + 1)
spec_var = get_spec_var(depth)
# Puts all files in hdrs, textual_hdrs, and srcs into source_files.
# Since CocoaPods treats header_files a bit differently from bazel,
# this won't generate a header_files field so that all source_files
# are considered as header files.
srcs = sorted(set(rule.hdrs + rule.textual_hdrs + rule.srcs))
write_indented_list(
f, "{indent}{var}.source_files = ".format(indent=indent, var=spec_var),
srcs)
# Writes dependencies of this rule.
for dep in sorted(rule.deps):
name = get_spec_name(dep.replace(":", "/"))
f.write("{indent}{var}.dependency '{dep}'\n".format(
indent=indent, var=spec_var, dep=name))
# Writes dependency to xcprivacy
f.write(
"{indent}{var}.dependency '{dep}'\n".format(
indent=indent, var=spec_var, dep="abseil/xcprivacy"
)
)
def write_indented_list(f, leading, values):
"""Writes leading values in an indented style."""
f.write(leading)
f.write((",\n" + " " * len(leading)).join("'{}'".format(v) for v in values))
f.write("\n")
def generate(args):
"""Generates a podspec file from all BUILD files under absl directory."""
rules = filter(relevant_rule, collect_rules("absl"))
with open(args.output, "wt") as f:
write_podspec(f, rules, vars(args))
def main():
parser = argparse.ArgumentParser(
description="Generates abseil.podspec from BUILD.bazel")
parser.add_argument(
"-v", "--version", help="The version of podspec", required=True)
parser.add_argument(
"-t",
"--tag",
default=None,
help="The name of git tag (default: version)")
parser.add_argument(
"-o",
"--output",
default="abseil.podspec",
help="The name of output file (default: abseil.podspec)")
args = parser.parse_args()
if args.tag is None:
args.tag = args.version
generate(args)
if __name__ == "__main__":
main()
================================================
FILE: absl/algorithm/BUILD.bazel
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
load("@rules_cc//cc:cc_library.bzl", "cc_library")
load("@rules_cc//cc:cc_test.bzl", "cc_test")
load(
"//absl:copts/configure_copts.bzl",
"ABSL_DEFAULT_COPTS",
"ABSL_DEFAULT_LINKOPTS",
"ABSL_TEST_COPTS",
)
package(
default_visibility = ["//visibility:public"],
features = [
"header_modules",
"layering_check",
"parse_headers",
],
)
licenses(["notice"])
cc_library(
name = "algorithm",
hdrs = ["algorithm.h"],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
"//absl/base:config",
],
)
cc_test(
name = "algorithm_test",
size = "small",
srcs = ["algorithm_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":algorithm",
"//absl/base:config",
"@googletest//:gtest",
"@googletest//:gtest_main",
],
)
cc_library(
name = "container",
hdrs = [
"container.h",
],
copts = ABSL_DEFAULT_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":algorithm",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/meta:type_traits",
],
)
cc_test(
name = "container_test",
srcs = ["container_test.cc"],
copts = ABSL_TEST_COPTS,
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":container",
"//absl/base",
"//absl/base:config",
"//absl/base:core_headers",
"//absl/memory",
"//absl/random",
"//absl/types:span",
"@googletest//:gtest",
"@googletest//:gtest_main",
],
)
================================================
FILE: absl/algorithm/CMakeLists.txt
================================================
#
# Copyright 2017 The Abseil Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
absl_cc_library(
NAME
algorithm
HDRS
"algorithm.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::config
PUBLIC
)
absl_cc_test(
NAME
algorithm_test
SRCS
"algorithm_test.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::algorithm
absl::config
GTest::gmock_main
)
absl_cc_library(
NAME
algorithm_container
HDRS
"container.h"
COPTS
${ABSL_DEFAULT_COPTS}
DEPS
absl::algorithm
absl::config
absl::core_headers
absl::meta
PUBLIC
)
absl_cc_test(
NAME
container_test
SRCS
"container_test.cc"
COPTS
${ABSL_TEST_COPTS}
DEPS
absl::algorithm_container
absl::config
absl::core_headers
absl::memory
absl::random_random
absl::span
GTest::gmock_main
)
================================================
FILE: absl/algorithm/algorithm.h
================================================
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: algorithm.h
// -----------------------------------------------------------------------------
//
// This header file contains Google extensions to the standard <algorithm> C++
// header.
#ifndef ABSL_ALGORITHM_ALGORITHM_H_
#define ABSL_ALGORITHM_ALGORITHM_H_
#include <algorithm>
#include <iterator>
#include <type_traits>
#include "absl/base/config.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
// equal()
// rotate()
//
// Historical note: Abseil once provided implementations of these algorithms
// prior to their adoption in C++14. New code should prefer to use the std
// variants.
//
// See the documentation for the STL <algorithm> header for more information:
// https://en.cppreference.com/w/cpp/header/algorithm
using std::equal;
using std::rotate;
// linear_search()
//
// Performs a linear search for `value` using the iterator `first` up to
// but not including `last`, returning true if [`first`, `last`) contains an
// element equal to `value`.
//
// A linear search is of O(n) complexity which is guaranteed to make at most
// n = (`last` - `first`) comparisons. A linear search over short containers
// may be faster than a binary search, even when the container is sorted.
template <typename InputIterator, typename EqualityComparable>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool linear_search(
InputIterator first, InputIterator last, const EqualityComparable& value) {
return std::find(first, last, value) != last;
}
ABSL_NAMESPACE_END
} // namespace absl
#endif // ABSL_ALGORITHM_ALGORITHM_H_
================================================
FILE: absl/algorithm/algorithm_test.cc
================================================
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/algorithm/algorithm.h"
#include <array>
#include <vector>
#include "gtest/gtest.h"
#include "absl/base/config.h"
namespace {
class LinearSearchTest : public testing::Test {
protected:
LinearSearchTest() : container_{1, 2, 3} {}
static bool Is3(int n) { return n == 3; }
static bool Is4(int n) { return n == 4; }
std::vector<int> container_;
};
TEST_F(LinearSearchTest, linear_search) {
EXPECT_TRUE(absl::linear_search(container_.begin(), container_.end(), 3));
EXPECT_FALSE(absl::linear_search(container_.begin(), container_.end(), 4));
}
TEST_F(LinearSearchTest, linear_searchConst) {
const std::vector<int> *const const_container = &container_;
EXPECT_TRUE(
absl::linear_search(const_container->begin(), const_container->end(), 3));
EXPECT_FALSE(
absl::linear_search(const_container->begin(), const_container->end(), 4));
}
#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \
ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
TEST_F(LinearSearchTest, Constexpr) {
static constexpr std::array<int, 3> kArray = {1, 2, 3};
static_assert(absl::linear_search(kArray.begin(), kArray.end(), 3));
static_assert(!absl::linear_search(kArray.begin(), kArray.end(), 4));
}
#endif // defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&
// ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L
} // namespace
================================================
FILE: absl/algorithm/container.h
================================================
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: container.h
// -----------------------------------------------------------------------------
//
// This header file provides Container-based versions of algorithmic functions
// within the C++ standard library. The following standard library sets of
// functions are covered within this file:
//
// * Algorithmic <iterator> functions
// * Algorithmic <numeric> functions
// * <algorithm> functions
//
// The standard library functions operate on iterator ranges; the functions
// within this API operate on containers, though many return iterator ranges.
//
// All functions within this API are named with a `c_` prefix. Calls such as
// `absl::c_xx(container, ...) are equivalent to std:: functions such as
// `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on
// iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`)
// have no equivalent here.
//
// For template parameter and variable naming, `C` indicates the container type
// to which the function is applied, `Pred` indicates the predicate object type
// to be used by the function and `T` indicates the applicable element type.
#ifndef ABSL_ALGORITHM_CONTAINER_H_
#define ABSL_ALGORITHM_CONTAINER_H_
#include <algorithm>
#include <cassert>
#include <iterator>
#include <numeric>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include "absl/algorithm/algorithm.h"
#include "absl/base/config.h"
#include "absl/base/macros.h"
#include "absl/meta/type_traits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace container_algorithm_internal {
// NOTE: it is important to defer to ADL lookup for building with C++ modules,
// especially for headers like <valarray> which are not visible from this file
// but specialize std::begin and std::end.
using std::begin;
using std::end;
// The type of the iterator given by begin(c) (possibly std::begin(c)).
// ContainerIter<const vector<T>> gives vector<T>::const_iterator,
// while ContainerIter<vector<T>> gives vector<T>::iterator.
template <typename C>
using ContainerIter = decltype(begin(std::declval<C&>()));
// An MSVC bug involving template parameter substitution requires us to use
// decltype() here instead of just std::pair.
template <typename C1, typename C2>
using ContainerIterPairType = decltype(std::make_pair(
std::declval<ContainerIter<C1>>(), std::declval<ContainerIter<C2>>()));
template <typename C>
using ContainerDifferenceType = decltype(std::distance(
std::declval<ContainerIter<C>>(), std::declval<ContainerIter<C>>()));
template <typename C>
using ContainerPointerType =
typename std::iterator_traits<ContainerIter<C>>::pointer;
// container_algorithm_internal::c_begin and
// container_algorithm_internal::c_end are abbreviations for proper ADL
// lookup of std::begin and std::end, i.e.
// using std::begin;
// using std::end;
// std::foo(begin(c), end(c));
// becomes
// std::foo(container_algorithm_internal::c_begin(c),
// container_algorithm_internal::c_end(c));
// These are meant for internal use only.
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 ContainerIter<C> c_begin(C& c) {
return begin(c);
}
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 ContainerIter<C> c_end(C& c) {
return end(c);
}
template <typename T>
struct IsUnorderedContainer : std::false_type {};
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
struct IsUnorderedContainer<
std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type {};
template <class Key, class Hash, class KeyEqual, class Allocator>
struct IsUnorderedContainer<std::unordered_set<Key, Hash, KeyEqual, Allocator>>
: std::true_type {};
} // namespace container_algorithm_internal
// PUBLIC API
//------------------------------------------------------------------------------
// Abseil algorithm.h functions
//------------------------------------------------------------------------------
// c_linear_search()
//
// Container-based version of absl::linear_search() for performing a linear
// search within a container.
//
// For a generalization that uses a predicate, see absl::c_any_of().
template <typename C, typename EqualityComparable>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_linear_search(
const C& c, EqualityComparable&& value) {
return absl::linear_search(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<EqualityComparable>(value));
}
//------------------------------------------------------------------------------
// <iterator> algorithms
//------------------------------------------------------------------------------
// c_distance()
//
// Container-based version of the <iterator> `std::distance()` function to
// return the number of elements within a container.
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17
container_algorithm_internal::ContainerDifferenceType<const C>
c_distance(const C& c) {
return std::distance(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c));
}
//------------------------------------------------------------------------------
// <algorithm> Non-modifying sequence operations
//------------------------------------------------------------------------------
// c_all_of()
//
// Container-based version of the <algorithm> `std::all_of()` function to
// test if all elements within a container satisfy a condition.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_all_of(const C& c, Pred&& pred) {
return std::all_of(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_any_of()
//
// Container-based version of the <algorithm> `std::any_of()` function to
// test if any element in a container fulfills a condition.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_any_of(const C& c, Pred&& pred) {
return std::any_of(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_none_of()
//
// Container-based version of the <algorithm> `std::none_of()` function to
// test if no elements in a container fulfill a condition.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_none_of(const C& c, Pred&& pred) {
return std::none_of(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_for_each()
//
// Container-based version of the <algorithm> `std::for_each()` function to
// apply a function to a container's elements.
template <typename C, typename Function>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t<Function> c_for_each(C&& c,
Function&& f) {
return std::for_each(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Function>(f));
}
// c_find()
//
// Container-based version of the <algorithm> `std::find()` function to find
// the first element containing the passed value within a container value.
template <typename C, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_find(C& c, T&& value) {
return std::find(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<T>(value));
}
// c_contains()
//
// Container-based version of the <algorithm> `std::ranges::contains()` C++23
// function to search a container for a value.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains(const Sequence& sequence,
T&& value) {
return absl::c_find(sequence, std::forward<T>(value)) !=
container_algorithm_internal::c_end(sequence);
}
// c_find_if()
//
// Container-based version of the <algorithm> `std::find_if()` function to find
// the first element in a container matching the given condition.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_find_if(C& c, Pred&& pred) {
return std::find_if(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_find_if_not()
//
// Container-based version of the <algorithm> `std::find_if_not()` function to
// find the first element in a container not matching the given condition.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_find_if_not(C& c, Pred&& pred) {
return std::find_if_not(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_find_end()
//
// Container-based version of the <algorithm> `std::find_end()` function to
// find the last subsequence within a container.
template <typename Sequence1, typename Sequence2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence1>
c_find_end(Sequence1& sequence, Sequence2& subsequence) {
return std::find_end(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(subsequence),
container_algorithm_internal::c_end(subsequence));
}
// Overload of c_find_end() for using a predicate evaluation other than `==` as
// the function's test condition.
template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence1>
c_find_end(Sequence1& sequence, Sequence2& subsequence,
BinaryPredicate&& pred) {
return std::find_end(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(subsequence),
container_algorithm_internal::c_end(subsequence),
std::forward<BinaryPredicate>(pred));
}
// c_find_first_of()
//
// Container-based version of the <algorithm> `std::find_first_of()` function to
// find the first element within the container that is also within the options
// container.
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C1>
c_find_first_of(C1& container, const C2& options) {
return std::find_first_of(container_algorithm_internal::c_begin(container),
container_algorithm_internal::c_end(container),
container_algorithm_internal::c_begin(options),
container_algorithm_internal::c_end(options));
}
// Overload of c_find_first_of() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename C1, typename C2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C1>
c_find_first_of(C1& container, const C2& options, BinaryPredicate&& pred) {
return std::find_first_of(container_algorithm_internal::c_begin(container),
container_algorithm_internal::c_end(container),
container_algorithm_internal::c_begin(options),
container_algorithm_internal::c_end(options),
std::forward<BinaryPredicate>(pred));
}
// c_adjacent_find()
//
// Container-based version of the <algorithm> `std::adjacent_find()` function to
// find equal adjacent elements within a container.
template <typename Sequence>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_adjacent_find(Sequence& sequence) {
return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence));
}
// Overload of c_adjacent_find() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename Sequence, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_adjacent_find(Sequence& sequence, BinaryPredicate&& pred) {
return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
std::forward<BinaryPredicate>(pred));
}
// c_count()
//
// Container-based version of the <algorithm> `std::count()` function to count
// values that match within a container.
template <typename C, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerDifferenceType<const C>
c_count(const C& c, T&& value) {
return std::count(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<T>(value));
}
// c_count_if()
//
// Container-based version of the <algorithm> `std::count_if()` function to
// count values matching a condition within a container.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerDifferenceType<const C>
c_count_if(const C& c, Pred&& pred) {
return std::count_if(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_mismatch()
//
// Container-based version of the <algorithm> `std::mismatch()` function to
// return the first element where two ordered containers differ. Applies `==` to
// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIterPairType<C1, C2>
c_mismatch(C1& c1, C2& c2) {
return std::mismatch(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2));
}
// Overload of c_mismatch() for using a predicate evaluation other than `==` as
// the function's test condition. Applies `pred`to the first N elements of `c1`
// and `c2`, where N = min(size(c1), size(c2)).
template <typename C1, typename C2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIterPairType<C1, C2>
c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) {
return std::mismatch(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), pred);
}
// c_equal()
//
// Container-based version of the <algorithm> `std::equal()` function to
// test whether two containers are equal.
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_equal(const C1& c1, const C2& c2) {
return std::equal(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2));
}
// Overload of c_equal() for using a predicate evaluation other than `==` as
// the function's test condition.
template <typename C1, typename C2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_equal(const C1& c1, const C2& c2,
BinaryPredicate&& pred) {
return std::equal(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2),
std::forward<BinaryPredicate>(pred));
}
// c_is_permutation()
//
// Container-based version of the <algorithm> `std::is_permutation()` function
// to test whether a container is a permutation of another.
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_permutation(const C1& c1,
const C2& c2) {
return std::is_permutation(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2));
}
// Overload of c_is_permutation() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename C1, typename C2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_permutation(
const C1& c1, const C2& c2, BinaryPredicate&& pred) {
return std::is_permutation(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2),
std::forward<BinaryPredicate>(pred));
}
// c_search()
//
// Container-based version of the <algorithm> `std::search()` function to search
// a container for a subsequence.
template <typename Sequence1, typename Sequence2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence1>
c_search(Sequence1& sequence, Sequence2& subsequence) {
return std::search(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(subsequence),
container_algorithm_internal::c_end(subsequence));
}
// Overload of c_search() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence1>
c_search(Sequence1& sequence, Sequence2& subsequence,
BinaryPredicate&& pred) {
return std::search(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(subsequence),
container_algorithm_internal::c_end(subsequence),
std::forward<BinaryPredicate>(pred));
}
// c_contains_subrange()
//
// Container-based version of the <algorithm> `std::ranges::contains_subrange()`
// C++23 function to search a container for a subsequence.
template <typename Sequence1, typename Sequence2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains_subrange(
Sequence1& sequence, Sequence2& subsequence) {
return absl::c_search(sequence, subsequence) !=
container_algorithm_internal::c_end(sequence);
}
// Overload of c_contains_subrange() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains_subrange(
Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
return absl::c_search(sequence, subsequence,
std::forward<BinaryPredicate>(pred)) !=
container_algorithm_internal::c_end(sequence);
}
// c_search_n()
//
// Container-based version of the <algorithm> `std::search_n()` function to
// search a container for the first sequence of N elements.
template <typename Sequence, typename Size, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_search_n(Sequence& sequence, Size count, T&& value) {
return std::search_n(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), count,
std::forward<T>(value));
}
// Overload of c_search_n() for using a predicate evaluation other than
// `==` as the function's test condition.
template <typename Sequence, typename Size, typename T,
typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_search_n(Sequence& sequence, Size count, T&& value,
BinaryPredicate&& pred) {
return std::search_n(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), count,
std::forward<T>(value),
std::forward<BinaryPredicate>(pred));
}
//------------------------------------------------------------------------------
// <algorithm> Modifying sequence operations
//------------------------------------------------------------------------------
// c_copy()
//
// Container-based version of the <algorithm> `std::copy()` function to copy a
// container's elements into an iterator.
template <typename InputSequence, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_copy(const InputSequence& input, OutputIterator output) {
return std::copy(container_algorithm_internal::c_begin(input),
container_algorithm_internal::c_end(input), output);
}
// c_copy_n()
//
// Container-based version of the <algorithm> `std::copy_n()` function to copy a
// container's first N elements into an iterator.
template <typename C, typename Size, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_copy_n(const C& input, Size n, OutputIterator output) {
return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
}
// c_copy_if()
//
// Container-based version of the <algorithm> `std::copy_if()` function to copy
// a container's elements satisfying some condition into an iterator.
template <typename InputSequence, typename OutputIterator, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_copy_if(const InputSequence& input, OutputIterator output, Pred&& pred) {
return std::copy_if(container_algorithm_internal::c_begin(input),
container_algorithm_internal::c_end(input), output,
std::forward<Pred>(pred));
}
// c_copy_backward()
//
// Container-based version of the <algorithm> `std::copy_backward()` function to
// copy a container's elements in reverse order into an iterator.
template <typename C, typename BidirectionalIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 BidirectionalIterator
c_copy_backward(const C& src, BidirectionalIterator dest) {
return std::copy_backward(container_algorithm_internal::c_begin(src),
container_algorithm_internal::c_end(src), dest);
}
// c_move()
//
// Container-based version of the <algorithm> `std::move()` function to move
// a container's elements into an iterator.
template <typename C, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_move(C&& src,
OutputIterator dest) {
return std::move(container_algorithm_internal::c_begin(src),
container_algorithm_internal::c_end(src), dest);
}
// c_move_backward()
//
// Container-based version of the <algorithm> `std::move_backward()` function to
// move a container's elements into an iterator in reverse order.
template <typename C, typename BidirectionalIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 BidirectionalIterator
c_move_backward(C&& src, BidirectionalIterator dest) {
return std::move_backward(container_algorithm_internal::c_begin(src),
container_algorithm_internal::c_end(src), dest);
}
// c_swap_ranges()
//
// Container-based version of the <algorithm> `std::swap_ranges()` function to
// swap a container's elements with another container's elements. Swaps the
// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C2>
c_swap_ranges(C1& c1, C2& c2) {
auto first1 = container_algorithm_internal::c_begin(c1);
auto last1 = container_algorithm_internal::c_end(c1);
auto first2 = container_algorithm_internal::c_begin(c2);
auto last2 = container_algorithm_internal::c_end(c2);
using std::swap;
for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
swap(*first1, *first2);
}
return first2;
}
// c_transform()
//
// Container-based version of the <algorithm> `std::transform()` function to
// transform a container's elements using the unary operation, storing the
// result in an iterator pointing to the last transformed element in the output
// range.
template <typename InputSequence, typename OutputIterator, typename UnaryOp>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_transform(
const InputSequence& input, OutputIterator output, UnaryOp&& unary_op) {
return std::transform(container_algorithm_internal::c_begin(input),
container_algorithm_internal::c_end(input), output,
std::forward<UnaryOp>(unary_op));
}
// Overload of c_transform() for performing a transformation using a binary
// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,
// where N = min(size(c1), size(c2)).
template <typename InputSequence1, typename InputSequence2,
typename OutputIterator, typename BinaryOp>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_transform(const InputSequence1& input1, const InputSequence2& input2,
OutputIterator output, BinaryOp&& binary_op) {
auto first1 = container_algorithm_internal::c_begin(input1);
auto last1 = container_algorithm_internal::c_end(input1);
auto first2 = container_algorithm_internal::c_begin(input2);
auto last2 = container_algorithm_internal::c_end(input2);
for (; first1 != last1 && first2 != last2;
++first1, (void)++first2, ++output) {
*output = binary_op(*first1, *first2);
}
return output;
}
// c_replace()
//
// Container-based version of the <algorithm> `std::replace()` function to
// replace a container's elements of some value with a new value. The container
// is modified in place.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_replace(Sequence& sequence,
const T& old_value,
const T& new_value) {
std::replace(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), old_value,
new_value);
}
// c_replace_if()
//
// Container-based version of the <algorithm> `std::replace_if()` function to
// replace a container's elements of some value with a new value based on some
// condition. The container is modified in place.
template <typename C, typename Pred, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_replace_if(C& c, Pred&& pred,
T&& new_value) {
std::replace_if(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred), std::forward<T>(new_value));
}
// c_replace_copy()
//
// Container-based version of the <algorithm> `std::replace_copy()` function to
// replace a container's elements of some value with a new value and return the
// results within an iterator.
template <typename C, typename OutputIterator, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_replace_copy(
const C& c, OutputIterator result, T&& old_value, T&& new_value) {
return std::replace_copy(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result,
std::forward<T>(old_value),
std::forward<T>(new_value));
}
// c_replace_copy_if()
//
// Container-based version of the <algorithm> `std::replace_copy_if()` function
// to replace a container's elements of some value with a new value based on
// some condition, and return the results within an iterator.
template <typename C, typename OutputIterator, typename Pred, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_replace_copy_if(
const C& c, OutputIterator result, Pred&& pred, const T& new_value) {
return std::replace_copy_if(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result,
std::forward<Pred>(pred), new_value);
}
// c_fill()
//
// Container-based version of the <algorithm> `std::fill()` function to fill a
// container with some value.
template <typename C, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_fill(C& c, const T& value) {
std::fill(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), value);
}
// c_fill_n()
//
// Container-based version of the <algorithm> `std::fill_n()` function to fill
// the first N elements in a container with some value.
template <typename C, typename Size, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_fill_n(C& c, Size n,
const T& value) {
std::fill_n(container_algorithm_internal::c_begin(c), n, value);
}
// c_generate()
//
// Container-based version of the <algorithm> `std::generate()` function to
// assign a container's elements to the values provided by the given generator.
template <typename C, typename Generator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_generate(C& c, Generator&& gen) {
std::generate(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Generator>(gen));
}
// c_generate_n()
//
// Container-based version of the <algorithm> `std::generate_n()` function to
// assign a container's first N elements to the values provided by the given
// generator.
template <typename C, typename Size, typename Generator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_generate_n(C& c, Size n, Generator&& gen) {
return std::generate_n(container_algorithm_internal::c_begin(c), n,
std::forward<Generator>(gen));
}
// Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
// and `unique()` are omitted, because it's not clear whether or not such
// functions should call erase on their supplied sequences afterwards. Either
// behavior would be surprising for a different set of users.
// c_remove_copy()
//
// Container-based version of the <algorithm> `std::remove_copy()` function to
// copy a container's elements while removing any elements matching the given
// `value`.
template <typename C, typename OutputIterator, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_remove_copy(const C& c, OutputIterator result, const T& value) {
return std::remove_copy(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result,
value);
}
// c_remove_copy_if()
//
// Container-based version of the <algorithm> `std::remove_copy_if()` function
// to copy a container's elements while removing any elements matching the given
// condition.
template <typename C, typename OutputIterator, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_remove_copy_if(const C& c, OutputIterator result, Pred&& pred) {
return std::remove_copy_if(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result,
std::forward<Pred>(pred));
}
// c_unique_copy()
//
// Container-based version of the <algorithm> `std::unique_copy()` function to
// copy a container's elements while removing any elements containing duplicate
// values.
template <typename C, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_unique_copy(const C& c, OutputIterator result) {
return std::unique_copy(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result);
}
// Overload of c_unique_copy() for using a predicate evaluation other than
// `==` for comparing uniqueness of the element values.
template <typename C, typename OutputIterator, typename BinaryPredicate>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_unique_copy(const C& c, OutputIterator result, BinaryPredicate&& pred) {
return std::unique_copy(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result,
std::forward<BinaryPredicate>(pred));
}
// c_reverse()
//
// Container-based version of the <algorithm> `std::reverse()` function to
// reverse a container's elements.
template <typename Sequence>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_reverse(Sequence& sequence) {
std::reverse(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence));
}
// c_reverse_copy()
//
// Container-based version of the <algorithm> `std::reverse()` function to
// reverse a container's elements and write them to an iterator range.
template <typename C, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_reverse_copy(const C& sequence, OutputIterator result) {
return std::reverse_copy(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
result);
}
// c_rotate()
//
// Container-based version of the <algorithm> `std::rotate()` function to
// shift a container's elements leftward such that the `middle` element becomes
// the first element in the container.
template <typename C,
typename Iterator = container_algorithm_internal::ContainerIter<C>>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 Iterator c_rotate(C& sequence,
Iterator middle) {
return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,
container_algorithm_internal::c_end(sequence));
}
// c_rotate_copy()
//
// Container-based version of the <algorithm> `std::rotate_copy()` function to
// shift a container's elements leftward such that the `middle` element becomes
// the first element in a new iterator range.
template <typename C, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_rotate_copy(const C& sequence,
container_algorithm_internal::ContainerIter<const C> middle,
OutputIterator result) {
return std::rotate_copy(container_algorithm_internal::c_begin(sequence),
middle, container_algorithm_internal::c_end(sequence),
result);
}
// c_shuffle()
//
// Container-based version of the <algorithm> `std::shuffle()` function to
// randomly shuffle elements within the container using a `gen()` uniform random
// number generator.
template <typename RandomAccessContainer, typename UniformRandomBitGenerator>
void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {
std::shuffle(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<UniformRandomBitGenerator>(gen));
}
// c_sample()
//
// Container-based version of the <algorithm> `std::sample()` function to
// randomly sample elements from the container without replacement using a
// `gen()` uniform random number generator and write them to an iterator range.
template <typename C, typename OutputIterator, typename Distance,
typename UniformRandomBitGenerator>
OutputIterator c_sample(const C& c, OutputIterator result, Distance n,
UniformRandomBitGenerator&& gen) {
return std::sample(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), result, n,
std::forward<UniformRandomBitGenerator>(gen));
}
//------------------------------------------------------------------------------
// <algorithm> Partition functions
//------------------------------------------------------------------------------
// c_is_partitioned()
//
// Container-based version of the <algorithm> `std::is_partitioned()` function
// to test whether all elements in the container for which `pred` returns `true`
// precede those for which `pred` is `false`.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_partitioned(const C& c,
Pred&& pred) {
return std::is_partitioned(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_partition()
//
// Container-based version of the <algorithm> `std::partition()` function
// to rearrange all elements in a container in such a way that all elements for
// which `pred` returns `true` precede all those for which it returns `false`,
// returning an iterator to the first element of the second group.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_partition(C& c, Pred&& pred) {
return std::partition(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_stable_partition()
//
// Container-based version of the <algorithm> `std::stable_partition()` function
// to rearrange all elements in a container in such a way that all elements for
// which `pred` returns `true` precede all those for which it returns `false`,
// preserving the relative ordering between the two groups. The function returns
// an iterator to the first element of the second group.
template <typename C, typename Pred>
container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c,
Pred&& pred) {
return std::stable_partition(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
// c_partition_copy()
//
// Container-based version of the <algorithm> `std::partition_copy()` function
// to partition a container's elements and return them into two iterators: one
// for which `pred` returns `true`, and one for which `pred` returns `false.`
template <typename C, typename OutputIterator1, typename OutputIterator2,
typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 std::pair<OutputIterator1, OutputIterator2>
c_partition_copy(const C& c, OutputIterator1 out_true,
OutputIterator2 out_false, Pred&& pred) {
return std::partition_copy(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c), out_true,
out_false, std::forward<Pred>(pred));
}
// c_partition_point()
//
// Container-based version of the <algorithm> `std::partition_point()` function
// to return the first element of an already partitioned container for which
// the given `pred` is not `true`.
template <typename C, typename Pred>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_partition_point(C& c, Pred&& pred) {
return std::partition_point(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<Pred>(pred));
}
//------------------------------------------------------------------------------
// <algorithm> Sorting functions
//------------------------------------------------------------------------------
// c_sort()
//
// Container-based version of the <algorithm> `std::sort()` function
// to sort elements in ascending order of their values.
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort(C& c) {
std::sort(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c));
}
// Overload of c_sort() for performing a `comp` comparison other than the
// default `operator<`.
template <typename C, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort(C& c, LessThan&& comp) {
std::sort(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<LessThan>(comp));
}
// c_stable_sort()
//
// Container-based version of the <algorithm> `std::stable_sort()` function
// to sort elements in ascending order of their values, preserving the order
// of equivalents.
template <typename C>
void c_stable_sort(C& c) {
std::stable_sort(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c));
}
// Overload of c_stable_sort() for performing a `comp` comparison other than the
// default `operator<`.
template <typename C, typename LessThan>
void c_stable_sort(C& c, LessThan&& comp) {
std::stable_sort(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<LessThan>(comp));
}
// c_is_sorted()
//
// Container-based version of the <algorithm> `std::is_sorted()` function
// to evaluate whether the given container is sorted in ascending order.
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_sorted(const C& c) {
return std::is_sorted(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c));
}
// c_is_sorted() overload for performing a `comp` comparison other than the
// default `operator<`.
template <typename C, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_sorted(const C& c,
LessThan&& comp) {
return std::is_sorted(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<LessThan>(comp));
}
// c_partial_sort()
//
// Container-based version of the <algorithm> `std::partial_sort()` function
// to rearrange elements within a container such that elements before `middle`
// are sorted in ascending order.
template <typename RandomAccessContainer>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_partial_sort(
RandomAccessContainer& sequence,
container_algorithm_internal::ContainerIter<RandomAccessContainer> middle) {
std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
container_algorithm_internal::c_end(sequence));
}
// Overload of c_partial_sort() for performing a `comp` comparison other than
// the default `operator<`.
template <typename RandomAccessContainer, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_partial_sort(
RandomAccessContainer& sequence,
container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
LessThan&& comp) {
std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
container_algorithm_internal::c_end(sequence),
std::forward<LessThan>(comp));
}
// c_partial_sort_copy()
//
// Container-based version of the <algorithm> `std::partial_sort_copy()`
// function to sort the elements in the given range `result` within the larger
// `sequence` in ascending order (and using `result` as the output parameter).
// At most min(result.last - result.first, sequence.last - sequence.first)
// elements from the sequence will be stored in the result.
template <typename C, typename RandomAccessContainer>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<RandomAccessContainer>
c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(result),
container_algorithm_internal::c_end(result));
}
// Overload of c_partial_sort_copy() for performing a `comp` comparison other
// than the default `operator<`.
template <typename C, typename RandomAccessContainer, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<RandomAccessContainer>
c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,
LessThan&& comp) {
return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
container_algorithm_internal::c_begin(result),
container_algorithm_internal::c_end(result),
std::forward<LessThan>(comp));
}
// c_is_sorted_until()
//
// Container-based version of the <algorithm> `std::is_sorted_until()` function
// to return the first element within a container that is not sorted in
// ascending order as an iterator.
template <typename C>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_is_sorted_until(C& c) {
return std::is_sorted_until(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c));
}
// Overload of c_is_sorted_until() for performing a `comp` comparison other than
// the default `operator<`.
template <typename C, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<C>
c_is_sorted_until(C& c, LessThan&& comp) {
return std::is_sorted_until(container_algorithm_internal::c_begin(c),
container_algorithm_internal::c_end(c),
std::forward<LessThan>(comp));
}
// c_nth_element()
//
// Container-based version of the <algorithm> `std::nth_element()` function
// to rearrange the elements within a container such that the `nth` element
// would be in that position in an ordered sequence; other elements may be in
// any order, except that all preceding `nth` will be less than that element,
// and all following `nth` will be greater than that element.
template <typename RandomAccessContainer>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_nth_element(
RandomAccessContainer& sequence,
container_algorithm_internal::ContainerIter<RandomAccessContainer> nth) {
std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
container_algorithm_internal::c_end(sequence));
}
// Overload of c_nth_element() for performing a `comp` comparison other than
// the default `operator<`.
template <typename RandomAccessContainer, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_nth_element(
RandomAccessContainer& sequence,
container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
LessThan&& comp) {
std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
container_algorithm_internal::c_end(sequence),
std::forward<LessThan>(comp));
}
//------------------------------------------------------------------------------
// <algorithm> Binary Search
//------------------------------------------------------------------------------
// c_lower_bound()
//
// Container-based version of the <algorithm> `std::lower_bound()` function
// to return an iterator pointing to the first element in a sorted container
// which does not compare less than `value`.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_lower_bound(Sequence& sequence, const T& value) {
return std::lower_bound(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value);
}
// Overload of c_lower_bound() for performing a `comp` comparison other than
// the default `operator<`.
template <typename Sequence, typename T, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_lower_bound(Sequence& sequence, const T& value, LessThan&& comp) {
return std::lower_bound(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value,
std::forward<LessThan>(comp));
}
// c_upper_bound()
//
// Container-based version of the <algorithm> `std::upper_bound()` function
// to return an iterator pointing to the first element in a sorted container
// which is greater than `value`.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_upper_bound(Sequence& sequence, const T& value) {
return std::upper_bound(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value);
}
// Overload of c_upper_bound() for performing a `comp` comparison other than
// the default `operator<`.
template <typename Sequence, typename T, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIter<Sequence>
c_upper_bound(Sequence& sequence, const T& value, LessThan&& comp) {
return std::upper_bound(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value,
std::forward<LessThan>(comp));
}
// c_equal_range()
//
// Container-based version of the <algorithm> `std::equal_range()` function
// to return an iterator pair pointing to the first and last elements in a
// sorted container which compare equal to `value`.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
c_equal_range(Sequence& sequence, const T& value) {
return std::equal_range(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value);
}
// Overload of c_equal_range() for performing a `comp` comparison other than
// the default `operator<`.
template <typename Sequence, typename T, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20
container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
c_equal_range(Sequence& sequence, const T& value, LessThan&& comp) {
return std::equal_range(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence), value,
std::forward<LessThan>(comp));
}
// c_binary_search()
//
// Container-based version of the <algorithm> `std::binary_search()` function
// to test if any element in the sorted container contains a value equivalent to
// 'value'.
template <typename Sequence, typename T>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_binary_search(
const Sequence& sequence, const T& value) {
return std::binary_search(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
value);
}
// Overload of c_binary_search() for performing a `comp` comparison other than
// the default `operator<`.
template <typename Sequence, typename T, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_binary_search(
const Sequence& sequence, const T& value, LessThan&& comp) {
return std::binary_search(container_algorithm_internal::c_begin(sequence),
container_algorithm_internal::c_end(sequence),
value, std::forward<LessThan>(comp));
}
//------------------------------------------------------------------------------
// <algorithm> Merge functions
//------------------------------------------------------------------------------
// c_merge()
//
// Container-based version of the <algorithm> `std::merge()` function
// to merge two sorted containers into a single sorted iterator.
template <typename C1, typename C2, typename OutputIterator>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_merge(const C1& c1, const C2& c2, OutputIterator result) {
return std::merge(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), result);
}
// Overload of c_merge() for performing a `comp` comparison other than
// the default `operator<`.
template <typename C1, typename C2, typename OutputIterator, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_merge(const C1& c1, const C2& c2, OutputIterator result, LessThan&& comp) {
return std::merge(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), result,
std::forward<LessThan>(comp));
}
// c_inplace_merge()
//
// Container-based version of the <algorithm> `std::inplace_merge()` function
// to merge a supplied iterator `middle` into a container.
template <typename C>
void c_inplace_merge(C& c,
container_algorithm_internal::ContainerIter<C> middle) {
std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
container_algorithm_internal::c_end(c));
}
// Overload of c_inplace_merge() for performing a merge using a `comp` other
// than `operator<`.
template <typename C, typename LessThan>
void c_inplace_merge(C& c,
container_algorithm_internal::ContainerIter<C> middle,
LessThan&& comp) {
std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
container_algorithm_internal::c_end(c),
std::forward<LessThan>(comp));
}
// c_includes()
//
// Container-based version of the <algorithm> `std::includes()` function
// to test whether a sorted container `c1` entirely contains another sorted
// container `c2`.
template <typename C1, typename C2>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_includes(const C1& c1,
const C2& c2) {
return std::includes(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2));
}
// Overload of c_includes() for performing a merge using a `comp` other than
// `operator<`.
template <typename C1, typename C2, typename LessThan>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_includes(const C1& c1, const C2& c2,
LessThan&& comp) {
return std::includes(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2),
std::forward<LessThan>(comp));
}
// c_set_union()
//
// Container-based version of the <algorithm> `std::set_union()` function
// to return an iterator containing the union of two containers; duplicate
// values are not copied into the output.
template <typename C1, typename C2, typename OutputIterator,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_set_union(const C1& c1, const C2& c2, OutputIterator output) {
return std::set_union(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output);
}
// Overload of c_set_union() for performing a merge using a `comp` other than
// `operator<`.
template <typename C1, typename C2, typename OutputIterator, typename LessThan,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_union(
const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {
return std::set_union(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output,
std::forward<LessThan>(comp));
}
// c_set_intersection()
//
// Container-based version of the <algorithm> `std::set_intersection()` function
// to return an iterator containing the intersection of two sorted containers.
template <typename C1, typename C2, typename OutputIterator,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_set_intersection(const C1& c1, const C2& c2, OutputIterator output) {
// In debug builds, ensure that both containers are sorted with respect to the
// default comparator. std::set_intersection requires the containers be sorted
// using operator<.
ABSL_ASSERT(absl::c_is_sorted(c1));
ABSL_ASSERT(absl::c_is_sorted(c2));
return std::set_intersection(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output);
}
// Overload of c_set_intersection() for performing a merge using a `comp` other
// than `operator<`.
template <typename C1, typename C2, typename OutputIterator, typename LessThan,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_intersection(
const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {
// In debug builds, ensure that both containers are sorted with respect to the
// default comparator. std::set_intersection requires the containers be sorted
// using the same comparator.
ABSL_ASSERT(absl::c_is_sorted(c1, comp));
ABSL_ASSERT(absl::c_is_sorted(c2, comp));
return std::set_intersection(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output,
std::forward<LessThan>(comp));
}
// c_set_difference()
//
// Container-based version of the <algorithm> `std::set_difference()` function
// to return an iterator containing elements present in the first container but
// not in the second.
template <typename C1, typename C2, typename OutputIterator,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_set_difference(const C1& c1, const C2& c2, OutputIterator output) {
return std::set_difference(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output);
}
// Overload of c_set_difference() for performing a merge using a `comp` other
// than `operator<`.
template <typename C1, typename C2, typename OutputIterator, typename LessThan,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_difference(
const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {
return std::set_difference(container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output,
std::forward<LessThan>(comp));
}
// c_set_symmetric_difference()
//
// Container-based version of the <algorithm> `std::set_symmetric_difference()`
// function to return an iterator containing elements present in either one
// container or the other, but not both.
template <typename C1, typename C2, typename OutputIterator,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator
c_set_symmetric_difference(const C1& c1, const C2& c2, OutputIterator output) {
return std::set_symmetric_difference(
container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output);
}
// Overload of c_set_symmetric_difference() for performing a merge using a
// `comp` other than `operator<`.
template <typename C1, typename C2, typename OutputIterator, typename LessThan,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C1>::value,
void>::type,
typename = typename std::enable_if<
!container_algorithm_internal::IsUnorderedContainer<C2>::value,
void>::type>
ABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_symmetric_difference(
const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {
return std::set_symmetric_difference(
container_algorithm_internal::c_begin(c1),
container_algorithm_internal::c_end(c1),
container_algorithm_internal::c_begin(c2),
container_algorithm_internal::c_end(c2), output,
std::forward<LessThan>(comp));
}
//-------------------------------------------------------------------
gitextract_sr0vk97u/ ├── .clang-format ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── 00-bug_report.yml │ │ └── config.yml │ └── PULL_REQUEST_TEMPLATE.md ├── .gitignore ├── ABSEIL_ISSUE_TEMPLATE.md ├── AUTHORS ├── BUILD.bazel ├── CMake/ │ ├── AbseilDll.cmake │ ├── AbseilHelpers.cmake │ ├── Googletest/ │ │ ├── CMakeLists.txt.in │ │ └── DownloadGTest.cmake │ ├── README.md │ ├── abslConfig.cmake.in │ └── install_test_project/ │ ├── CMakeLists.txt │ ├── simple.cc │ └── test.sh ├── CMakeLists.txt ├── CONTRIBUTING.md ├── FAQ.md ├── LICENSE ├── MODULE.bazel ├── PrivacyInfo.xcprivacy ├── README.md ├── UPGRADES.md ├── absl/ │ ├── BUILD.bazel │ ├── CMakeLists.txt │ ├── abseil.podspec.gen.py │ ├── algorithm/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── algorithm.h │ │ ├── algorithm_test.cc │ │ ├── container.h │ │ └── container_test.cc │ ├── base/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── attributes.h │ │ ├── attributes_test.cc │ │ ├── bit_cast_test.cc │ │ ├── c_header_test.c │ │ ├── call_once.h │ │ ├── call_once_test.cc │ │ ├── casts.cc │ │ ├── casts.h │ │ ├── casts_test.cc │ │ ├── config.h │ │ ├── config_test.cc │ │ ├── const_init.h │ │ ├── dynamic_annotations.h │ │ ├── exception_safety_testing_test.cc │ │ ├── fast_type_id.h │ │ ├── fast_type_id_test.cc │ │ ├── internal/ │ │ │ ├── atomic_hook.h │ │ │ ├── atomic_hook_test.cc │ │ │ ├── atomic_hook_test_helper.cc │ │ │ ├── atomic_hook_test_helper.h │ │ │ ├── cmake_thread_test.cc │ │ │ ├── cycleclock.cc │ │ │ ├── cycleclock.h │ │ │ ├── cycleclock_config.h │ │ │ ├── direct_mmap.h │ │ │ ├── dynamic_annotations.h │ │ │ ├── endian.h │ │ │ ├── endian_test.cc │ │ │ ├── errno_saver.h │ │ │ ├── errno_saver_test.cc │ │ │ ├── exception_safety_testing.cc │ │ │ ├── exception_safety_testing.h │ │ │ ├── exception_testing.h │ │ │ ├── hardening.cc │ │ │ ├── hardening.h │ │ │ ├── hardening_test.cc │ │ │ ├── hide_ptr.h │ │ │ ├── iterator_traits.h │ │ │ ├── iterator_traits_test.cc │ │ │ ├── iterator_traits_test_helper.h │ │ │ ├── low_level_alloc.cc │ │ │ ├── low_level_alloc.h │ │ │ ├── low_level_alloc_test.cc │ │ │ ├── low_level_scheduling.h │ │ │ ├── nullability_traits.h │ │ │ ├── nullability_traits_test.cc │ │ │ ├── per_thread_tls.h │ │ │ ├── poison.cc │ │ │ ├── poison.h │ │ │ ├── poison_test.cc │ │ │ ├── pretty_function.h │ │ │ ├── raw_logging.cc │ │ │ ├── raw_logging.h │ │ │ ├── scheduling_mode.h │ │ │ ├── scoped_set_env.cc │ │ │ ├── scoped_set_env.h │ │ │ ├── scoped_set_env_test.cc │ │ │ ├── spinlock.cc │ │ │ ├── spinlock.h │ │ │ ├── spinlock_akaros.inc │ │ │ ├── spinlock_benchmark.cc │ │ │ ├── spinlock_linux.inc │ │ │ ├── spinlock_posix.inc │ │ │ ├── spinlock_wait.cc │ │ │ ├── spinlock_wait.h │ │ │ ├── spinlock_win32.inc │ │ │ ├── strerror.cc │ │ │ ├── strerror.h │ │ │ ├── strerror_benchmark.cc │ │ │ ├── strerror_test.cc │ │ │ ├── sysinfo.cc │ │ │ ├── sysinfo.h │ │ │ ├── sysinfo_test.cc │ │ │ ├── thread_identity.cc │ │ │ ├── thread_identity.h │ │ │ ├── thread_identity_benchmark.cc │ │ │ ├── thread_identity_test.cc │ │ │ ├── tracing.cc │ │ │ ├── tracing.h │ │ │ ├── tracing_strong_test.cc │ │ │ ├── tracing_weak_test.cc │ │ │ ├── tsan_mutex_interface.h │ │ │ ├── unaligned_access.h │ │ │ ├── unique_small_name_test.cc │ │ │ ├── unscaledcycleclock.cc │ │ │ ├── unscaledcycleclock.h │ │ │ └── unscaledcycleclock_config.h │ │ ├── log_severity.cc │ │ ├── log_severity.h │ │ ├── log_severity_test.cc │ │ ├── macros.h │ │ ├── no_destructor.h │ │ ├── no_destructor_benchmark.cc │ │ ├── no_destructor_test.cc │ │ ├── nullability.h │ │ ├── nullability_default_nonnull_test.cc │ │ ├── nullability_test.cc │ │ ├── optimization.h │ │ ├── optimization_test.cc │ │ ├── options.h │ │ ├── policy_checks.h │ │ ├── port.h │ │ ├── prefetch.h │ │ ├── prefetch_test.cc │ │ ├── raw_logging_test.cc │ │ ├── spinlock_test_common.cc │ │ ├── thread_annotations.h │ │ ├── throw_delegate.cc │ │ ├── throw_delegate.h │ │ └── throw_delegate_test.cc │ ├── cleanup/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── cleanup.h │ │ ├── cleanup_test.cc │ │ └── internal/ │ │ └── cleanup.h │ ├── container/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── btree_benchmark.cc │ │ ├── btree_map.h │ │ ├── btree_set.h │ │ ├── btree_test.cc │ │ ├── btree_test.h │ │ ├── chunked_queue.h │ │ ├── chunked_queue_benchmark.cc │ │ ├── chunked_queue_test.cc │ │ ├── fixed_array.h │ │ ├── fixed_array_benchmark.cc │ │ ├── fixed_array_exception_safety_test.cc │ │ ├── fixed_array_test.cc │ │ ├── flat_hash_map.h │ │ ├── flat_hash_map_test.cc │ │ ├── flat_hash_set.h │ │ ├── flat_hash_set_test.cc │ │ ├── hash_container_defaults.h │ │ ├── inlined_vector.h │ │ ├── inlined_vector_benchmark.cc │ │ ├── inlined_vector_exception_safety_test.cc │ │ ├── inlined_vector_test.cc │ │ ├── internal/ │ │ │ ├── btree.h │ │ │ ├── btree_container.h │ │ │ ├── chunked_queue.h │ │ │ ├── common.h │ │ │ ├── common_policy_traits.h │ │ │ ├── common_policy_traits_test.cc │ │ │ ├── compressed_tuple.h │ │ │ ├── compressed_tuple_test.cc │ │ │ ├── container_memory.h │ │ │ ├── container_memory_test.cc │ │ │ ├── hash_function_defaults.h │ │ │ ├── hash_function_defaults_test.cc │ │ │ ├── hash_generator_testing.cc │ │ │ ├── hash_generator_testing.h │ │ │ ├── hash_policy_testing.h │ │ │ ├── hash_policy_testing_test.cc │ │ │ ├── hash_policy_traits.h │ │ │ ├── hash_policy_traits_test.cc │ │ │ ├── hashtable_control_bytes.h │ │ │ ├── hashtable_control_bytes_test.cc │ │ │ ├── hashtable_debug.h │ │ │ ├── hashtable_debug_hooks.h │ │ │ ├── hashtablez_sampler.cc │ │ │ ├── hashtablez_sampler.h │ │ │ ├── hashtablez_sampler_force_weak_definition.cc │ │ │ ├── hashtablez_sampler_test.cc │ │ │ ├── heterogeneous_lookup_testing.h │ │ │ ├── inlined_vector.h │ │ │ ├── layout.h │ │ │ ├── layout_benchmark.cc │ │ │ ├── layout_test.cc │ │ │ ├── node_slot_policy.h │ │ │ ├── node_slot_policy_test.cc │ │ │ ├── raw_hash_map.h │ │ │ ├── raw_hash_set.cc │ │ │ ├── raw_hash_set.h │ │ │ ├── raw_hash_set_allocator_test.cc │ │ │ ├── raw_hash_set_benchmark.cc │ │ │ ├── raw_hash_set_probe_benchmark.cc │ │ │ ├── raw_hash_set_resize_impl.h │ │ │ ├── raw_hash_set_resize_impl_test.cc │ │ │ ├── raw_hash_set_test.cc │ │ │ ├── test_allocator.h │ │ │ ├── test_instance_tracker.cc │ │ │ ├── test_instance_tracker.h │ │ │ ├── test_instance_tracker_test.cc │ │ │ ├── tracked.h │ │ │ ├── unordered_map_constructor_test.h │ │ │ ├── unordered_map_lookup_test.h │ │ │ ├── unordered_map_members_test.h │ │ │ ├── unordered_map_modifiers_test.h │ │ │ ├── unordered_map_test.cc │ │ │ ├── unordered_set_constructor_test.h │ │ │ ├── unordered_set_lookup_test.h │ │ │ ├── unordered_set_members_test.h │ │ │ ├── unordered_set_modifiers_test.h │ │ │ └── unordered_set_test.cc │ │ ├── linked_hash_map.h │ │ ├── linked_hash_map_benchmark.cc │ │ ├── linked_hash_map_test.cc │ │ ├── linked_hash_set.h │ │ ├── linked_hash_set_benchmark.cc │ │ ├── linked_hash_set_test.cc │ │ ├── node_hash_map.h │ │ ├── node_hash_map_test.cc │ │ ├── node_hash_set.h │ │ ├── node_hash_set_test.cc │ │ └── sample_element_size_test.cc │ ├── copts/ │ │ ├── AbseilConfigureCopts.cmake │ │ ├── GENERATED_AbseilCopts.cmake │ │ ├── GENERATED_copts.bzl │ │ ├── configure_copts.bzl │ │ ├── copts.py │ │ └── generate_copts.py │ ├── crc/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── crc32c.cc │ │ ├── crc32c.h │ │ ├── crc32c_benchmark.cc │ │ ├── crc32c_test.cc │ │ └── internal/ │ │ ├── cpu_detect.cc │ │ ├── cpu_detect.h │ │ ├── crc.cc │ │ ├── crc.h │ │ ├── crc32_x86_arm_combined_simd.h │ │ ├── crc32c.h │ │ ├── crc32c_inline.h │ │ ├── crc_cord_state.cc │ │ ├── crc_cord_state.h │ │ ├── crc_cord_state_test.cc │ │ ├── crc_internal.h │ │ ├── crc_memcpy.h │ │ ├── crc_memcpy_fallback.cc │ │ ├── crc_memcpy_test.cc │ │ ├── crc_memcpy_x86_arm_combined.cc │ │ ├── crc_non_temporal_memcpy.cc │ │ ├── crc_x86_arm_combined.cc │ │ ├── gen_crc32c_consts.py │ │ ├── non_temporal_arm_intrinsics.h │ │ ├── non_temporal_memcpy.h │ │ └── non_temporal_memcpy_test.cc │ ├── debugging/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── failure_signal_handler.cc │ │ ├── failure_signal_handler.h │ │ ├── failure_signal_handler_test.cc │ │ ├── internal/ │ │ │ ├── address_is_readable.cc │ │ │ ├── address_is_readable.h │ │ │ ├── addresses.h │ │ │ ├── bounded_utf8_length_sequence.h │ │ │ ├── bounded_utf8_length_sequence_test.cc │ │ │ ├── decode_rust_punycode.cc │ │ │ ├── decode_rust_punycode.h │ │ │ ├── decode_rust_punycode_test.cc │ │ │ ├── demangle.cc │ │ │ ├── demangle.h │ │ │ ├── demangle_rust.cc │ │ │ ├── demangle_rust.h │ │ │ ├── demangle_rust_test.cc │ │ │ ├── demangle_test.cc │ │ │ ├── elf_mem_image.cc │ │ │ ├── elf_mem_image.h │ │ │ ├── examine_stack.cc │ │ │ ├── examine_stack.h │ │ │ ├── stack_consumption.cc │ │ │ ├── stack_consumption.h │ │ │ ├── stack_consumption_test.cc │ │ │ ├── stacktrace_aarch64-inl.inc │ │ │ ├── stacktrace_arm-inl.inc │ │ │ ├── stacktrace_config.h │ │ │ ├── stacktrace_emscripten-inl.inc │ │ │ ├── stacktrace_generic-inl.inc │ │ │ ├── stacktrace_powerpc-inl.inc │ │ │ ├── stacktrace_riscv-inl.inc │ │ │ ├── stacktrace_unimplemented-inl.inc │ │ │ ├── stacktrace_win32-inl.inc │ │ │ ├── stacktrace_x86-inl.inc │ │ │ ├── symbolize.h │ │ │ ├── utf8_for_code_point.cc │ │ │ ├── utf8_for_code_point.h │ │ │ ├── utf8_for_code_point_test.cc │ │ │ ├── vdso_support.cc │ │ │ └── vdso_support.h │ │ ├── leak_check.cc │ │ ├── leak_check.h │ │ ├── leak_check_fail_test.cc │ │ ├── leak_check_test.cc │ │ ├── stacktrace.cc │ │ ├── stacktrace.h │ │ ├── stacktrace_benchmark.cc │ │ ├── stacktrace_test.cc │ │ ├── symbolize.cc │ │ ├── symbolize.h │ │ ├── symbolize_darwin.inc │ │ ├── symbolize_elf.inc │ │ ├── symbolize_emscripten.inc │ │ ├── symbolize_test.cc │ │ ├── symbolize_unimplemented.inc │ │ └── symbolize_win32.inc │ ├── flags/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── commandlineflag.cc │ │ ├── commandlineflag.h │ │ ├── commandlineflag_test.cc │ │ ├── config.h │ │ ├── config_test.cc │ │ ├── declare.h │ │ ├── flag.h │ │ ├── flag_benchmark.cc │ │ ├── flag_benchmark.lds │ │ ├── flag_test.cc │ │ ├── flag_test_defs.cc │ │ ├── internal/ │ │ │ ├── commandlineflag.cc │ │ │ ├── commandlineflag.h │ │ │ ├── flag.cc │ │ │ ├── flag.h │ │ │ ├── parse.h │ │ │ ├── path_util.h │ │ │ ├── path_util_test.cc │ │ │ ├── private_handle_accessor.cc │ │ │ ├── private_handle_accessor.h │ │ │ ├── program_name.cc │ │ │ ├── program_name.h │ │ │ ├── program_name_test.cc │ │ │ ├── registry.h │ │ │ ├── sequence_lock.h │ │ │ ├── sequence_lock_test.cc │ │ │ ├── usage.cc │ │ │ ├── usage.h │ │ │ └── usage_test.cc │ │ ├── marshalling.cc │ │ ├── marshalling.h │ │ ├── marshalling_test.cc │ │ ├── parse.cc │ │ ├── parse.h │ │ ├── parse_test.cc │ │ ├── reflection.cc │ │ ├── reflection.h │ │ ├── reflection_test.cc │ │ ├── usage.cc │ │ ├── usage.h │ │ ├── usage_config.cc │ │ ├── usage_config.h │ │ └── usage_config_test.cc │ ├── functional/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── any_invocable.h │ │ ├── any_invocable_test.cc │ │ ├── bind_front.h │ │ ├── bind_front_test.cc │ │ ├── function_ref.h │ │ ├── function_ref_test.cc │ │ ├── function_type_benchmark.cc │ │ ├── internal/ │ │ │ ├── any_invocable.h │ │ │ ├── front_binder.h │ │ │ └── function_ref.h │ │ ├── overload.h │ │ └── overload_test.cc │ ├── hash/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── hash.h │ │ ├── hash_benchmark.cc │ │ ├── hash_instantiated_test.cc │ │ ├── hash_test.cc │ │ ├── hash_testing.h │ │ └── internal/ │ │ ├── city.cc │ │ ├── city.h │ │ ├── city_test.cc │ │ ├── hash.cc │ │ ├── hash.h │ │ ├── hash_test.h │ │ ├── low_level_hash_test.cc │ │ ├── print_hash_of.cc │ │ ├── spy_hash_state.h │ │ └── weakly_mixed_integer.h │ ├── log/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── absl_check.h │ │ ├── absl_check_test.cc │ │ ├── absl_log.h │ │ ├── absl_log_basic_test.cc │ │ ├── absl_vlog_is_on.h │ │ ├── check.h │ │ ├── check_test.cc │ │ ├── check_test_impl.inc │ │ ├── die_if_null.cc │ │ ├── die_if_null.h │ │ ├── die_if_null_test.cc │ │ ├── flags.cc │ │ ├── flags.h │ │ ├── flags_test.cc │ │ ├── globals.cc │ │ ├── globals.h │ │ ├── globals_test.cc │ │ ├── initialize.cc │ │ ├── initialize.h │ │ ├── internal/ │ │ │ ├── BUILD.bazel │ │ │ ├── append_truncated.h │ │ │ ├── check_impl.h │ │ │ ├── check_op.cc │ │ │ ├── check_op.h │ │ │ ├── conditions.cc │ │ │ ├── conditions.h │ │ │ ├── config.h │ │ │ ├── container.h │ │ │ ├── container_test.cc │ │ │ ├── flags.h │ │ │ ├── fnmatch.cc │ │ │ ├── fnmatch.h │ │ │ ├── fnmatch_benchmark.cc │ │ │ ├── fnmatch_test.cc │ │ │ ├── globals.cc │ │ │ ├── globals.h │ │ │ ├── log_format.cc │ │ │ ├── log_format.h │ │ │ ├── log_impl.h │ │ │ ├── log_message.cc │ │ │ ├── log_message.h │ │ │ ├── log_sink_set.cc │ │ │ ├── log_sink_set.h │ │ │ ├── nullguard.cc │ │ │ ├── nullguard.h │ │ │ ├── nullstream.h │ │ │ ├── proto.cc │ │ │ ├── proto.h │ │ │ ├── stderr_log_sink_test.cc │ │ │ ├── strip.h │ │ │ ├── structured.h │ │ │ ├── structured_proto.cc │ │ │ ├── structured_proto.h │ │ │ ├── structured_proto_test.cc │ │ │ ├── test_actions.cc │ │ │ ├── test_actions.h │ │ │ ├── test_helpers.cc │ │ │ ├── test_helpers.h │ │ │ ├── test_matchers.cc │ │ │ ├── test_matchers.h │ │ │ ├── vlog_config.cc │ │ │ ├── vlog_config.h │ │ │ ├── vlog_config_benchmark.cc │ │ │ └── voidify.h │ │ ├── log.h │ │ ├── log_basic_test.cc │ │ ├── log_basic_test_impl.inc │ │ ├── log_benchmark.cc │ │ ├── log_entry.cc │ │ ├── log_entry.h │ │ ├── log_entry_test.cc │ │ ├── log_format_test.cc │ │ ├── log_macro_hygiene_test.cc │ │ ├── log_modifier_methods_test.cc │ │ ├── log_sink.cc │ │ ├── log_sink.h │ │ ├── log_sink_registry.h │ │ ├── log_sink_test.cc │ │ ├── log_streamer.h │ │ ├── log_streamer_test.cc │ │ ├── scoped_mock_log.cc │ │ ├── scoped_mock_log.h │ │ ├── scoped_mock_log_test.cc │ │ ├── stripping_test.cc │ │ ├── structured.h │ │ ├── structured_test.cc │ │ ├── vlog_is_on.h │ │ └── vlog_is_on_test.cc │ ├── memory/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── memory.h │ │ └── memory_test.cc │ ├── meta/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── internal/ │ │ │ ├── constexpr_testing.h │ │ │ ├── constexpr_testing_test.cc │ │ │ ├── requires.h │ │ │ └── requires_test.cc │ │ ├── type_traits.h │ │ └── type_traits_test.cc │ ├── numeric/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── bits.h │ │ ├── bits_benchmark.cc │ │ ├── bits_test.cc │ │ ├── int128.cc │ │ ├── int128.h │ │ ├── int128_benchmark.cc │ │ ├── int128_have_intrinsic.inc │ │ ├── int128_no_intrinsic.inc │ │ ├── int128_stream_test.cc │ │ ├── int128_test.cc │ │ └── internal/ │ │ ├── bits.h │ │ └── representation.h │ ├── profiling/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── hashtable.cc │ │ ├── hashtable.h │ │ └── internal/ │ │ ├── exponential_biased.cc │ │ ├── exponential_biased.h │ │ ├── exponential_biased_test.cc │ │ ├── periodic_sampler.cc │ │ ├── periodic_sampler.h │ │ ├── periodic_sampler_benchmark.cc │ │ ├── periodic_sampler_test.cc │ │ ├── profile_builder.cc │ │ ├── profile_builder.h │ │ ├── sample_recorder.h │ │ └── sample_recorder_test.cc │ ├── random/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── benchmarks.cc │ │ ├── bernoulli_distribution.h │ │ ├── bernoulli_distribution_test.cc │ │ ├── beta_distribution.h │ │ ├── beta_distribution_test.cc │ │ ├── bit_gen_ref.h │ │ ├── bit_gen_ref_test.cc │ │ ├── discrete_distribution.cc │ │ ├── discrete_distribution.h │ │ ├── discrete_distribution_test.cc │ │ ├── distributions.h │ │ ├── distributions_test.cc │ │ ├── examples_test.cc │ │ ├── exponential_distribution.h │ │ ├── exponential_distribution_test.cc │ │ ├── gaussian_distribution.cc │ │ ├── gaussian_distribution.h │ │ ├── gaussian_distribution_test.cc │ │ ├── generators_test.cc │ │ ├── internal/ │ │ │ ├── BUILD.bazel │ │ │ ├── chi_square.cc │ │ │ ├── chi_square.h │ │ │ ├── chi_square_test.cc │ │ │ ├── distribution_caller.h │ │ │ ├── distribution_test_util.cc │ │ │ ├── distribution_test_util.h │ │ │ ├── distribution_test_util_test.cc │ │ │ ├── entropy_pool.cc │ │ │ ├── entropy_pool.h │ │ │ ├── entropy_pool_test.cc │ │ │ ├── explicit_seed_seq.h │ │ │ ├── explicit_seed_seq_test.cc │ │ │ ├── fast_uniform_bits.h │ │ │ ├── fast_uniform_bits_test.cc │ │ │ ├── fastmath.h │ │ │ ├── fastmath_test.cc │ │ │ ├── gaussian_distribution_gentables.cc │ │ │ ├── generate_real.h │ │ │ ├── generate_real_test.cc │ │ │ ├── iostream_state_saver.h │ │ │ ├── iostream_state_saver_test.cc │ │ │ ├── mock_helpers.h │ │ │ ├── mock_overload_set.h │ │ │ ├── mock_validators.h │ │ │ ├── nanobenchmark.cc │ │ │ ├── nanobenchmark.h │ │ │ ├── nanobenchmark_test.cc │ │ │ ├── nonsecure_base.h │ │ │ ├── nonsecure_base_test.cc │ │ │ ├── pcg_engine.h │ │ │ ├── pcg_engine_test.cc │ │ │ ├── platform.h │ │ │ ├── randen.cc │ │ │ ├── randen.h │ │ │ ├── randen_benchmarks.cc │ │ │ ├── randen_detect.cc │ │ │ ├── randen_detect.h │ │ │ ├── randen_engine.h │ │ │ ├── randen_engine_test.cc │ │ │ ├── randen_hwaes.cc │ │ │ ├── randen_hwaes.h │ │ │ ├── randen_hwaes_test.cc │ │ │ ├── randen_round_keys.cc │ │ │ ├── randen_slow.cc │ │ │ ├── randen_slow.h │ │ │ ├── randen_slow_test.cc │ │ │ ├── randen_test.cc │ │ │ ├── randen_traits.h │ │ │ ├── salted_seed_seq.h │ │ │ ├── salted_seed_seq_test.cc │ │ │ ├── seed_material.cc │ │ │ ├── seed_material.h │ │ │ ├── seed_material_test.cc │ │ │ ├── sequence_urbg.h │ │ │ ├── traits.h │ │ │ ├── traits_test.cc │ │ │ ├── uniform_helper.h │ │ │ ├── uniform_helper_test.cc │ │ │ ├── wide_multiply.h │ │ │ └── wide_multiply_test.cc │ │ ├── log_uniform_int_distribution.h │ │ ├── log_uniform_int_distribution_test.cc │ │ ├── mock_distributions.h │ │ ├── mock_distributions_test.cc │ │ ├── mocking_bit_gen.h │ │ ├── mocking_bit_gen_test.cc │ │ ├── poisson_distribution.h │ │ ├── poisson_distribution_test.cc │ │ ├── random.h │ │ ├── seed_gen_exception.cc │ │ ├── seed_gen_exception.h │ │ ├── seed_sequences.cc │ │ ├── seed_sequences.h │ │ ├── seed_sequences_test.cc │ │ ├── uniform_int_distribution.h │ │ ├── uniform_int_distribution_test.cc │ │ ├── uniform_real_distribution.h │ │ ├── uniform_real_distribution_test.cc │ │ ├── zipf_distribution.h │ │ └── zipf_distribution_test.cc │ ├── status/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── internal/ │ │ │ ├── status_internal.cc │ │ │ ├── status_internal.h │ │ │ ├── status_matchers.cc │ │ │ ├── status_matchers.h │ │ │ └── statusor_internal.h │ │ ├── status.cc │ │ ├── status.h │ │ ├── status_benchmark.cc │ │ ├── status_matchers.h │ │ ├── status_matchers_test.cc │ │ ├── status_payload_printer.cc │ │ ├── status_payload_printer.h │ │ ├── status_test.cc │ │ ├── statusor.cc │ │ ├── statusor.h │ │ ├── statusor_benchmark.cc │ │ └── statusor_test.cc │ ├── strings/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── ascii.cc │ │ ├── ascii.h │ │ ├── ascii_benchmark.cc │ │ ├── ascii_test.cc │ │ ├── atod_manual_test.cc │ │ ├── char_formatting_test.cc │ │ ├── charconv.cc │ │ ├── charconv.h │ │ ├── charconv_benchmark.cc │ │ ├── charconv_test.cc │ │ ├── charset.h │ │ ├── charset_benchmark.cc │ │ ├── charset_test.cc │ │ ├── cord.cc │ │ ├── cord.h │ │ ├── cord_analysis.cc │ │ ├── cord_analysis.h │ │ ├── cord_buffer.h │ │ ├── cord_buffer_test.cc │ │ ├── cord_test.cc │ │ ├── cord_test_helpers.h │ │ ├── cordz_test.cc │ │ ├── cordz_test_helpers.h │ │ ├── escaping.cc │ │ ├── escaping.h │ │ ├── escaping_benchmark.cc │ │ ├── escaping_test.cc │ │ ├── has_absl_stringify.h │ │ ├── has_absl_stringify_test.cc │ │ ├── has_ostream_operator.h │ │ ├── has_ostream_operator_test.cc │ │ ├── internal/ │ │ │ ├── append_and_overwrite.h │ │ │ ├── append_and_overwrite_test.cc │ │ │ ├── charconv_bigint.cc │ │ │ ├── charconv_bigint.h │ │ │ ├── charconv_bigint_test.cc │ │ │ ├── charconv_parse.cc │ │ │ ├── charconv_parse.h │ │ │ ├── charconv_parse_test.cc │ │ │ ├── cord_data_edge.h │ │ │ ├── cord_data_edge_test.cc │ │ │ ├── cord_internal.cc │ │ │ ├── cord_internal.h │ │ │ ├── cord_rep_btree.cc │ │ │ ├── cord_rep_btree.h │ │ │ ├── cord_rep_btree_navigator.cc │ │ │ ├── cord_rep_btree_navigator.h │ │ │ ├── cord_rep_btree_navigator_test.cc │ │ │ ├── cord_rep_btree_reader.cc │ │ │ ├── cord_rep_btree_reader.h │ │ │ ├── cord_rep_btree_reader_test.cc │ │ │ ├── cord_rep_btree_test.cc │ │ │ ├── cord_rep_consume.cc │ │ │ ├── cord_rep_consume.h │ │ │ ├── cord_rep_crc.cc │ │ │ ├── cord_rep_crc.h │ │ │ ├── cord_rep_crc_test.cc │ │ │ ├── cord_rep_flat.h │ │ │ ├── cord_rep_test_util.h │ │ │ ├── cordz_functions.cc │ │ │ ├── cordz_functions.h │ │ │ ├── cordz_functions_test.cc │ │ │ ├── cordz_handle.cc │ │ │ ├── cordz_handle.h │ │ │ ├── cordz_handle_test.cc │ │ │ ├── cordz_info.cc │ │ │ ├── cordz_info.h │ │ │ ├── cordz_info_statistics_test.cc │ │ │ ├── cordz_info_test.cc │ │ │ ├── cordz_sample_token.cc │ │ │ ├── cordz_sample_token.h │ │ │ ├── cordz_sample_token_test.cc │ │ │ ├── cordz_statistics.h │ │ │ ├── cordz_update_scope.h │ │ │ ├── cordz_update_scope_test.cc │ │ │ ├── cordz_update_tracker.h │ │ │ ├── cordz_update_tracker_test.cc │ │ │ ├── damerau_levenshtein_distance.cc │ │ │ ├── damerau_levenshtein_distance.h │ │ │ ├── damerau_levenshtein_distance_benchmark.cc │ │ │ ├── damerau_levenshtein_distance_test.cc │ │ │ ├── escaping.cc │ │ │ ├── escaping.h │ │ │ ├── escaping_test_common.h │ │ │ ├── generic_printer.cc │ │ │ ├── generic_printer.h │ │ │ ├── generic_printer_internal.h │ │ │ ├── generic_printer_test.cc │ │ │ ├── memutil.cc │ │ │ ├── memutil.h │ │ │ ├── memutil_benchmark.cc │ │ │ ├── memutil_test.cc │ │ │ ├── numbers_test_common.h │ │ │ ├── ostringstream.cc │ │ │ ├── ostringstream.h │ │ │ ├── ostringstream_benchmark.cc │ │ │ ├── ostringstream_test.cc │ │ │ ├── pow10_helper.cc │ │ │ ├── pow10_helper.h │ │ │ ├── pow10_helper_test.cc │ │ │ ├── resize_uninitialized.h │ │ │ ├── resize_uninitialized_test.cc │ │ │ ├── stl_type_traits.h │ │ │ ├── str_format/ │ │ │ │ ├── arg.cc │ │ │ │ ├── arg.h │ │ │ │ ├── arg_test.cc │ │ │ │ ├── bind.cc │ │ │ │ ├── bind.h │ │ │ │ ├── bind_test.cc │ │ │ │ ├── checker.h │ │ │ │ ├── checker_test.cc │ │ │ │ ├── constexpr_parser.h │ │ │ │ ├── convert_test.cc │ │ │ │ ├── extension.cc │ │ │ │ ├── extension.h │ │ │ │ ├── extension_test.cc │ │ │ │ ├── float_conversion.cc │ │ │ │ ├── float_conversion.h │ │ │ │ ├── output.cc │ │ │ │ ├── output.h │ │ │ │ ├── output_test.cc │ │ │ │ ├── parser.cc │ │ │ │ ├── parser.h │ │ │ │ └── parser_test.cc │ │ │ ├── str_join_internal.h │ │ │ ├── str_split_internal.h │ │ │ ├── string_constant.h │ │ │ ├── string_constant_test.cc │ │ │ ├── stringify_sink.cc │ │ │ ├── stringify_sink.h │ │ │ ├── stringify_stream.h │ │ │ ├── stringify_stream_test.cc │ │ │ ├── utf8.cc │ │ │ ├── utf8.h │ │ │ └── utf8_test.cc │ │ ├── match.cc │ │ ├── match.h │ │ ├── match_test.cc │ │ ├── numbers.cc │ │ ├── numbers.h │ │ ├── numbers_benchmark.cc │ │ ├── numbers_test.cc │ │ ├── resize_and_overwrite.h │ │ ├── resize_and_overwrite_test.cc │ │ ├── str_cat.cc │ │ ├── str_cat.h │ │ ├── str_cat_benchmark.cc │ │ ├── str_cat_test.cc │ │ ├── str_format.h │ │ ├── str_format_test.cc │ │ ├── str_join.h │ │ ├── str_join_benchmark.cc │ │ ├── str_join_test.cc │ │ ├── str_replace.cc │ │ ├── str_replace.h │ │ ├── str_replace_benchmark.cc │ │ ├── str_replace_test.cc │ │ ├── str_split.cc │ │ ├── str_split.h │ │ ├── str_split_benchmark.cc │ │ ├── str_split_test.cc │ │ ├── string_view.h │ │ ├── string_view_test.cc │ │ ├── strip.h │ │ ├── strip_test.cc │ │ ├── substitute.cc │ │ ├── substitute.h │ │ ├── substitute_benchmark.cc │ │ └── substitute_test.cc │ ├── synchronization/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── barrier.cc │ │ ├── barrier.h │ │ ├── barrier_test.cc │ │ ├── blocking_counter.cc │ │ ├── blocking_counter.h │ │ ├── blocking_counter_benchmark.cc │ │ ├── blocking_counter_test.cc │ │ ├── internal/ │ │ │ ├── create_thread_identity.cc │ │ │ ├── create_thread_identity.h │ │ │ ├── futex.h │ │ │ ├── futex_waiter.cc │ │ │ ├── futex_waiter.h │ │ │ ├── graphcycles.cc │ │ │ ├── graphcycles.h │ │ │ ├── graphcycles_benchmark.cc │ │ │ ├── graphcycles_test.cc │ │ │ ├── kernel_timeout.cc │ │ │ ├── kernel_timeout.h │ │ │ ├── kernel_timeout_test.cc │ │ │ ├── per_thread_sem.cc │ │ │ ├── per_thread_sem.h │ │ │ ├── per_thread_sem_test.cc │ │ │ ├── pthread_waiter.cc │ │ │ ├── pthread_waiter.h │ │ │ ├── sem_waiter.cc │ │ │ ├── sem_waiter.h │ │ │ ├── stdcpp_waiter.cc │ │ │ ├── stdcpp_waiter.h │ │ │ ├── thread_pool.h │ │ │ ├── waiter.h │ │ │ ├── waiter_base.cc │ │ │ ├── waiter_base.h │ │ │ ├── waiter_test.cc │ │ │ ├── win32_waiter.cc │ │ │ └── win32_waiter.h │ │ ├── lifetime_test.cc │ │ ├── mutex.cc │ │ ├── mutex.h │ │ ├── mutex_benchmark.cc │ │ ├── mutex_method_pointer_test.cc │ │ ├── mutex_test.cc │ │ ├── notification.cc │ │ ├── notification.h │ │ └── notification_test.cc │ ├── time/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── civil_time.cc │ │ ├── civil_time.h │ │ ├── civil_time_benchmark.cc │ │ ├── civil_time_test.cc │ │ ├── clock.cc │ │ ├── clock.h │ │ ├── clock_benchmark.cc │ │ ├── clock_interface.cc │ │ ├── clock_interface.h │ │ ├── clock_interface_test.cc │ │ ├── clock_test.cc │ │ ├── duration.cc │ │ ├── duration_benchmark.cc │ │ ├── duration_test.cc │ │ ├── flag_test.cc │ │ ├── format.cc │ │ ├── format_benchmark.cc │ │ ├── format_test.cc │ │ ├── internal/ │ │ │ ├── cctz/ │ │ │ │ ├── BUILD.bazel │ │ │ │ ├── include/ │ │ │ │ │ └── cctz/ │ │ │ │ │ ├── civil_time.h │ │ │ │ │ ├── civil_time_detail.h │ │ │ │ │ ├── time_zone.h │ │ │ │ │ └── zone_info_source.h │ │ │ │ ├── src/ │ │ │ │ │ ├── cctz_benchmark.cc │ │ │ │ │ ├── civil_time_detail.cc │ │ │ │ │ ├── civil_time_test.cc │ │ │ │ │ ├── test_time_zone_names.cc │ │ │ │ │ ├── test_time_zone_names.h │ │ │ │ │ ├── time_zone_fixed.cc │ │ │ │ │ ├── time_zone_fixed.h │ │ │ │ │ ├── time_zone_format.cc │ │ │ │ │ ├── time_zone_format_test.cc │ │ │ │ │ ├── time_zone_if.cc │ │ │ │ │ ├── time_zone_if.h │ │ │ │ │ ├── time_zone_impl.cc │ │ │ │ │ ├── time_zone_impl.h │ │ │ │ │ ├── time_zone_info.cc │ │ │ │ │ ├── time_zone_info.h │ │ │ │ │ ├── time_zone_libc.cc │ │ │ │ │ ├── time_zone_libc.h │ │ │ │ │ ├── time_zone_lookup.cc │ │ │ │ │ ├── time_zone_lookup_test.cc │ │ │ │ │ ├── time_zone_name_win.cc │ │ │ │ │ ├── time_zone_name_win.h │ │ │ │ │ ├── time_zone_posix.cc │ │ │ │ │ ├── time_zone_posix.h │ │ │ │ │ ├── tzfile.h │ │ │ │ │ └── zone_info_source.cc │ │ │ │ └── testdata/ │ │ │ │ ├── README.zoneinfo │ │ │ │ ├── version │ │ │ │ └── zoneinfo/ │ │ │ │ ├── Africa/ │ │ │ │ │ ├── Abidjan │ │ │ │ │ ├── Accra │ │ │ │ │ ├── Addis_Ababa │ │ │ │ │ ├── Algiers │ │ │ │ │ ├── Asmara │ │ │ │ │ ├── Asmera │ │ │ │ │ ├── Bamako │ │ │ │ │ ├── Bangui │ │ │ │ │ ├── Banjul │ │ │ │ │ ├── Bissau │ │ │ │ │ ├── Blantyre │ │ │ │ │ ├── Brazzaville │ │ │ │ │ ├── Bujumbura │ │ │ │ │ ├── Cairo │ │ │ │ │ ├── Casablanca │ │ │ │ │ ├── Ceuta │ │ │ │ │ ├── Conakry │ │ │ │ │ ├── Dakar │ │ │ │ │ ├── Dar_es_Salaam │ │ │ │ │ ├── Djibouti │ │ │ │ │ ├── Douala │ │ │ │ │ ├── El_Aaiun │ │ │ │ │ ├── Freetown │ │ │ │ │ ├── Gaborone │ │ │ │ │ ├── Harare │ │ │ │ │ ├── Johannesburg │ │ │ │ │ ├── Juba │ │ │ │ │ ├── Kampala │ │ │ │ │ ├── Khartoum │ │ │ │ │ ├── Kigali │ │ │ │ │ ├── Kinshasa │ │ │ │ │ ├── Lagos │ │ │ │ │ ├── Libreville │ │ │ │ │ ├── Lome │ │ │ │ │ ├── Luanda │ │ │ │ │ ├── Lubumbashi │ │ │ │ │ ├── Lusaka │ │ │ │ │ ├── Malabo │ │ │ │ │ ├── Maputo │ │ │ │ │ ├── Maseru │ │ │ │ │ ├── Mbabane │ │ │ │ │ ├── Mogadishu │ │ │ │ │ ├── Monrovia │ │ │ │ │ ├── Nairobi │ │ │ │ │ ├── Ndjamena │ │ │ │ │ ├── Niamey │ │ │ │ │ ├── Nouakchott │ │ │ │ │ ├── Ouagadougou │ │ │ │ │ ├── Porto-Novo │ │ │ │ │ ├── Sao_Tome │ │ │ │ │ ├── Timbuktu │ │ │ │ │ ├── Tripoli │ │ │ │ │ ├── Tunis │ │ │ │ │ └── Windhoek │ │ │ │ ├── America/ │ │ │ │ │ ├── Adak │ │ │ │ │ ├── Anchorage │ │ │ │ │ ├── Anguilla │ │ │ │ │ ├── Antigua │ │ │ │ │ ├── Araguaina │ │ │ │ │ ├── Argentina/ │ │ │ │ │ │ ├── Buenos_Aires │ │ │ │ │ │ ├── Catamarca │ │ │ │ │ │ ├── ComodRivadavia │ │ │ │ │ │ ├── Cordoba │ │ │ │ │ │ ├── Jujuy │ │ │ │ │ │ ├── La_Rioja │ │ │ │ │ │ ├── Mendoza │ │ │ │ │ │ ├── Rio_Gallegos │ │ │ │ │ │ ├── Salta │ │ │ │ │ │ ├── San_Juan │ │ │ │ │ │ ├── San_Luis │ │ │ │ │ │ ├── Tucuman │ │ │ │ │ │ └── Ushuaia │ │ │ │ │ ├── Aruba │ │ │ │ │ ├── Asuncion │ │ │ │ │ ├── Atikokan │ │ │ │ │ ├── Atka │ │ │ │ │ ├── Bahia │ │ │ │ │ ├── Bahia_Banderas │ │ │ │ │ ├── Barbados │ │ │ │ │ ├── Belem │ │ │ │ │ ├── Belize │ │ │ │ │ ├── Blanc-Sablon │ │ │ │ │ ├── Boa_Vista │ │ │ │ │ ├── Bogota │ │ │ │ │ ├── Boise │ │ │ │ │ ├── Buenos_Aires │ │ │ │ │ ├── Cambridge_Bay │ │ │ │ │ ├── Campo_Grande │ │ │ │ │ ├── Cancun │ │ │ │ │ ├── Caracas │ │ │ │ │ ├── Catamarca │ │ │ │ │ ├── Cayenne │ │ │ │ │ ├── Cayman │ │ │ │ │ ├── Chicago │ │ │ │ │ ├── Chihuahua │ │ │ │ │ ├── Ciudad_Juarez │ │ │ │ │ ├── Coral_Harbour │ │ │ │ │ ├── Cordoba │ │ │ │ │ ├── Costa_Rica │ │ │ │ │ ├── Coyhaique │ │ │ │ │ ├── Creston │ │ │ │ │ ├── Cuiaba │ │ │ │ │ ├── Curacao │ │ │ │ │ ├── Danmarkshavn │ │ │ │ │ ├── Dawson │ │ │ │ │ ├── Dawson_Creek │ │ │ │ │ ├── Denver │ │ │ │ │ ├── Detroit │ │ │ │ │ ├── Dominica │ │ │ │ │ ├── Edmonton │ │ │ │ │ ├── Eirunepe │ │ │ │ │ ├── El_Salvador │ │ │ │ │ ├── Ensenada │ │ │ │ │ ├── Fort_Nelson │ │ │ │ │ ├── Fort_Wayne │ │ │ │ │ ├── Fortaleza │ │ │ │ │ ├── Glace_Bay │ │ │ │ │ ├── Godthab │ │ │ │ │ ├── Goose_Bay │ │ │ │ │ ├── Grand_Turk │ │ │ │ │ ├── Grenada │ │ │ │ │ ├── Guadeloupe │ │ │ │ │ ├── Guatemala │ │ │ │ │ ├── Guayaquil │ │ │ │ │ ├── Guyana │ │ │ │ │ ├── Halifax │ │ │ │ │ ├── Havana │ │ │ │ │ ├── Hermosillo │ │ │ │ │ ├── Indiana/ │ │ │ │ │ │ ├── Indianapolis │ │ │ │ │ │ ├── Knox │ │ │ │ │ │ ├── Marengo │ │ │ │ │ │ ├── Petersburg │ │ │ │ │ │ ├── Tell_City │ │ │ │ │ │ ├── Vevay │ │ │ │ │ │ ├── Vincennes │ │ │ │ │ │ └── Winamac │ │ │ │ │ ├── Indianapolis │ │ │ │ │ ├── Inuvik │ │ │ │ │ ├── Iqaluit │ │ │ │ │ ├── Jamaica │ │ │ │ │ ├── Jujuy │ │ │ │ │ ├── Juneau │ │ │ │ │ ├── Kentucky/ │ │ │ │ │ │ ├── Louisville │ │ │ │ │ │ └── Monticello │ │ │ │ │ ├── Knox_IN │ │ │ │ │ ├── Kralendijk │ │ │ │ │ ├── La_Paz │ │ │ │ │ ├── Lima │ │ │ │ │ ├── Los_Angeles │ │ │ │ │ ├── Louisville │ │ │ │ │ ├── Lower_Princes │ │ │ │ │ ├── Maceio │ │ │ │ │ ├── Managua │ │ │ │ │ ├── Manaus │ │ │ │ │ ├── Marigot │ │ │ │ │ ├── Martinique │ │ │ │ │ ├── Matamoros │ │ │ │ │ ├── Mazatlan │ │ │ │ │ ├── Mendoza │ │ │ │ │ ├── Menominee │ │ │ │ │ ├── Merida │ │ │ │ │ ├── Metlakatla │ │ │ │ │ ├── Mexico_City │ │ │ │ │ ├── Miquelon │ │ │ │ │ ├── Moncton │ │ │ │ │ ├── Monterrey │ │ │ │ │ ├── Montevideo │ │ │ │ │ ├── Montreal │ │ │ │ │ ├── Montserrat │ │ │ │ │ ├── Nassau │ │ │ │ │ ├── New_York │ │ │ │ │ ├── Nipigon │ │ │ │ │ ├── Nome │ │ │ │ │ ├── Noronha │ │ │ │ │ ├── North_Dakota/ │ │ │ │ │ │ ├── Beulah │ │ │ │ │ │ ├── Center │ │ │ │ │ │ └── New_Salem │ │ │ │ │ ├── Nuuk │ │ │ │ │ ├── Ojinaga │ │ │ │ │ ├── Panama │ │ │ │ │ ├── Pangnirtung │ │ │ │ │ ├── Paramaribo │ │ │ │ │ ├── Phoenix │ │ │ │ │ ├── Port-au-Prince │ │ │ │ │ ├── Port_of_Spain │ │ │ │ │ ├── Porto_Acre │ │ │ │ │ ├── Porto_Velho │ │ │ │ │ ├── Puerto_Rico │ │ │ │ │ ├── Punta_Arenas │ │ │ │ │ ├── Rainy_River │ │ │ │ │ ├── Rankin_Inlet │ │ │ │ │ ├── Recife │ │ │ │ │ ├── Regina │ │ │ │ │ ├── Resolute │ │ │ │ │ ├── Rio_Branco │ │ │ │ │ ├── Rosario │ │ │ │ │ ├── Santa_Isabel │ │ │ │ │ ├── Santarem │ │ │ │ │ ├── Santiago │ │ │ │ │ ├── Santo_Domingo │ │ │ │ │ ├── Sao_Paulo │ │ │ │ │ ├── Scoresbysund │ │ │ │ │ ├── Shiprock │ │ │ │ │ ├── Sitka │ │ │ │ │ ├── St_Barthelemy │ │ │ │ │ ├── St_Johns │ │ │ │ │ ├── St_Kitts │ │ │ │ │ ├── St_Lucia │ │ │ │ │ ├── St_Thomas │ │ │ │ │ ├── St_Vincent │ │ │ │ │ ├── Swift_Current │ │ │ │ │ ├── Tegucigalpa │ │ │ │ │ ├── Thule │ │ │ │ │ ├── Thunder_Bay │ │ │ │ │ ├── Tijuana │ │ │ │ │ ├── Toronto │ │ │ │ │ ├── Tortola │ │ │ │ │ ├── Vancouver │ │ │ │ │ ├── Virgin │ │ │ │ │ ├── Whitehorse │ │ │ │ │ ├── Winnipeg │ │ │ │ │ ├── Yakutat │ │ │ │ │ └── Yellowknife │ │ │ │ ├── Antarctica/ │ │ │ │ │ ├── Casey │ │ │ │ │ ├── Davis │ │ │ │ │ ├── DumontDUrville │ │ │ │ │ ├── Macquarie │ │ │ │ │ ├── Mawson │ │ │ │ │ ├── McMurdo │ │ │ │ │ ├── Palmer │ │ │ │ │ ├── Rothera │ │ │ │ │ ├── South_Pole │ │ │ │ │ ├── Syowa │ │ │ │ │ ├── Troll │ │ │ │ │ └── Vostok │ │ │ │ ├── Arctic/ │ │ │ │ │ └── Longyearbyen │ │ │ │ ├── Asia/ │ │ │ │ │ ├── Aden │ │ │ │ │ ├── Almaty │ │ │ │ │ ├── Amman │ │ │ │ │ ├── Anadyr │ │ │ │ │ ├── Aqtau │ │ │ │ │ ├── Aqtobe │ │ │ │ │ ├── Ashgabat │ │ │ │ │ ├── Ashkhabad │ │ │ │ │ ├── Atyrau │ │ │ │ │ ├── Baghdad │ │ │ │ │ ├── Bahrain │ │ │ │ │ ├── Baku │ │ │ │ │ ├── Bangkok │ │ │ │ │ ├── Barnaul │ │ │ │ │ ├── Beirut │ │ │ │ │ ├── Bishkek │ │ │ │ │ ├── Brunei │ │ │ │ │ ├── Calcutta │ │ │ │ │ ├── Chita │ │ │ │ │ ├── Choibalsan │ │ │ │ │ ├── Chongqing │ │ │ │ │ ├── Chungking │ │ │ │ │ ├── Colombo │ │ │ │ │ ├── Dacca │ │ │ │ │ ├── Damascus │ │ │ │ │ ├── Dhaka │ │ │ │ │ ├── Dili │ │ │ │ │ ├── Dubai │ │ │ │ │ ├── Dushanbe │ │ │ │ │ ├── Famagusta │ │ │ │ │ ├── Gaza │ │ │ │ │ ├── Harbin │ │ │ │ │ ├── Hebron │ │ │ │ │ ├── Ho_Chi_Minh │ │ │ │ │ ├── Hong_Kong │ │ │ │ │ ├── Hovd │ │ │ │ │ ├── Irkutsk │ │ │ │ │ ├── Istanbul │ │ │ │ │ ├── Jakarta │ │ │ │ │ ├── Jayapura │ │ │ │ │ ├── Jerusalem │ │ │ │ │ ├── Kabul │ │ │ │ │ ├── Kamchatka │ │ │ │ │ ├── Karachi │ │ │ │ │ ├── Kashgar │ │ │ │ │ ├── Kathmandu │ │ │ │ │ ├── Katmandu │ │ │ │ │ ├── Khandyga │ │ │ │ │ ├── Kolkata │ │ │ │ │ ├── Krasnoyarsk │ │ │ │ │ ├── Kuala_Lumpur │ │ │ │ │ ├── Kuching │ │ │ │ │ ├── Kuwait │ │ │ │ │ ├── Macao │ │ │ │ │ ├── Macau │ │ │ │ │ ├── Magadan │ │ │ │ │ ├── Makassar │ │ │ │ │ ├── Manila │ │ │ │ │ ├── Muscat │ │ │ │ │ ├── Nicosia │ │ │ │ │ ├── Novokuznetsk │ │ │ │ │ ├── Novosibirsk │ │ │ │ │ ├── Omsk │ │ │ │ │ ├── Oral │ │ │ │ │ ├── Phnom_Penh │ │ │ │ │ ├── Pontianak │ │ │ │ │ ├── Pyongyang │ │ │ │ │ ├── Qatar │ │ │ │ │ ├── Qostanay │ │ │ │ │ ├── Qyzylorda │ │ │ │ │ ├── Rangoon │ │ │ │ │ ├── Riyadh │ │ │ │ │ ├── Saigon │ │ │ │ │ ├── Sakhalin │ │ │ │ │ ├── Samarkand │ │ │ │ │ ├── Seoul │ │ │ │ │ ├── Shanghai │ │ │ │ │ ├── Singapore │ │ │ │ │ ├── Srednekolymsk │ │ │ │ │ ├── Taipei │ │ │ │ │ ├── Tashkent │ │ │ │ │ ├── Tbilisi │ │ │ │ │ ├── Tehran │ │ │ │ │ ├── Tel_Aviv │ │ │ │ │ ├── Thimbu │ │ │ │ │ ├── Thimphu │ │ │ │ │ ├── Tokyo │ │ │ │ │ ├── Tomsk │ │ │ │ │ ├── Ujung_Pandang │ │ │ │ │ ├── Ulaanbaatar │ │ │ │ │ ├── Ulan_Bator │ │ │ │ │ ├── Urumqi │ │ │ │ │ ├── Ust-Nera │ │ │ │ │ ├── Vientiane │ │ │ │ │ ├── Vladivostok │ │ │ │ │ ├── Yakutsk │ │ │ │ │ ├── Yangon │ │ │ │ │ ├── Yekaterinburg │ │ │ │ │ └── Yerevan │ │ │ │ ├── Atlantic/ │ │ │ │ │ ├── Azores │ │ │ │ │ ├── Bermuda │ │ │ │ │ ├── Canary │ │ │ │ │ ├── Cape_Verde │ │ │ │ │ ├── Faeroe │ │ │ │ │ ├── Faroe │ │ │ │ │ ├── Jan_Mayen │ │ │ │ │ ├── Madeira │ │ │ │ │ ├── Reykjavik │ │ │ │ │ ├── South_Georgia │ │ │ │ │ ├── St_Helena │ │ │ │ │ └── Stanley │ │ │ │ ├── Australia/ │ │ │ │ │ ├── ACT │ │ │ │ │ ├── Adelaide │ │ │ │ │ ├── Brisbane │ │ │ │ │ ├── Broken_Hill │ │ │ │ │ ├── Canberra │ │ │ │ │ ├── Currie │ │ │ │ │ ├── Darwin │ │ │ │ │ ├── Eucla │ │ │ │ │ ├── Hobart │ │ │ │ │ ├── LHI │ │ │ │ │ ├── Lindeman │ │ │ │ │ ├── Lord_Howe │ │ │ │ │ ├── Melbourne │ │ │ │ │ ├── NSW │ │ │ │ │ ├── North │ │ │ │ │ ├── Perth │ │ │ │ │ ├── Queensland │ │ │ │ │ ├── South │ │ │ │ │ ├── Sydney │ │ │ │ │ ├── Tasmania │ │ │ │ │ ├── Victoria │ │ │ │ │ ├── West │ │ │ │ │ └── Yancowinna │ │ │ │ ├── Brazil/ │ │ │ │ │ ├── Acre │ │ │ │ │ ├── DeNoronha │ │ │ │ │ ├── East │ │ │ │ │ └── West │ │ │ │ ├── CET │ │ │ │ ├── CST6CDT │ │ │ │ ├── Canada/ │ │ │ │ │ ├── Atlantic │ │ │ │ │ ├── Central │ │ │ │ │ ├── Eastern │ │ │ │ │ ├── Mountain │ │ │ │ │ ├── Newfoundland │ │ │ │ │ ├── Pacific │ │ │ │ │ ├── Saskatchewan │ │ │ │ │ └── Yukon │ │ │ │ ├── Chile/ │ │ │ │ │ ├── Continental │ │ │ │ │ └── EasterIsland │ │ │ │ ├── Cuba │ │ │ │ ├── EET │ │ │ │ ├── EST │ │ │ │ ├── EST5EDT │ │ │ │ ├── Egypt │ │ │ │ ├── Eire │ │ │ │ ├── Etc/ │ │ │ │ │ ├── GMT │ │ │ │ │ ├── GMT+0 │ │ │ │ │ ├── GMT+1 │ │ │ │ │ ├── GMT+10 │ │ │ │ │ ├── GMT+11 │ │ │ │ │ ├── GMT+12 │ │ │ │ │ ├── GMT+2 │ │ │ │ │ ├── GMT+3 │ │ │ │ │ ├── GMT+4 │ │ │ │ │ ├── GMT+5 │ │ │ │ │ ├── GMT+6 │ │ │ │ │ ├── GMT+7 │ │ │ │ │ ├── GMT+8 │ │ │ │ │ ├── GMT+9 │ │ │ │ │ ├── GMT-0 │ │ │ │ │ ├── GMT-1 │ │ │ │ │ ├── GMT-10 │ │ │ │ │ ├── GMT-11 │ │ │ │ │ ├── GMT-12 │ │ │ │ │ ├── GMT-13 │ │ │ │ │ ├── GMT-14 │ │ │ │ │ ├── GMT-2 │ │ │ │ │ ├── GMT-3 │ │ │ │ │ ├── GMT-4 │ │ │ │ │ ├── GMT-5 │ │ │ │ │ ├── GMT-6 │ │ │ │ │ ├── GMT-7 │ │ │ │ │ ├── GMT-8 │ │ │ │ │ ├── GMT-9 │ │ │ │ │ ├── GMT0 │ │ │ │ │ ├── Greenwich │ │ │ │ │ ├── UCT │ │ │ │ │ ├── UTC │ │ │ │ │ ├── Universal │ │ │ │ │ └── Zulu │ │ │ │ ├── Europe/ │ │ │ │ │ ├── Amsterdam │ │ │ │ │ ├── Andorra │ │ │ │ │ ├── Astrakhan │ │ │ │ │ ├── Athens │ │ │ │ │ ├── Belfast │ │ │ │ │ ├── Belgrade │ │ │ │ │ ├── Berlin │ │ │ │ │ ├── Bratislava │ │ │ │ │ ├── Brussels │ │ │ │ │ ├── Bucharest │ │ │ │ │ ├── Budapest │ │ │ │ │ ├── Busingen │ │ │ │ │ ├── Chisinau │ │ │ │ │ ├── Copenhagen │ │ │ │ │ ├── Dublin │ │ │ │ │ ├── Gibraltar │ │ │ │ │ ├── Guernsey │ │ │ │ │ ├── Helsinki │ │ │ │ │ ├── Isle_of_Man │ │ │ │ │ ├── Istanbul │ │ │ │ │ ├── Jersey │ │ │ │ │ ├── Kaliningrad │ │ │ │ │ ├── Kiev │ │ │ │ │ ├── Kirov │ │ │ │ │ ├── Kyiv │ │ │ │ │ ├── Lisbon │ │ │ │ │ ├── Ljubljana │ │ │ │ │ ├── London │ │ │ │ │ ├── Luxembourg │ │ │ │ │ ├── Madrid │ │ │ │ │ ├── Malta │ │ │ │ │ ├── Mariehamn │ │ │ │ │ ├── Minsk │ │ │ │ │ ├── Monaco │ │ │ │ │ ├── Moscow │ │ │ │ │ ├── Nicosia │ │ │ │ │ ├── Oslo │ │ │ │ │ ├── Paris │ │ │ │ │ ├── Podgorica │ │ │ │ │ ├── Prague │ │ │ │ │ ├── Riga │ │ │ │ │ ├── Rome │ │ │ │ │ ├── Samara │ │ │ │ │ ├── San_Marino │ │ │ │ │ ├── Sarajevo │ │ │ │ │ ├── Saratov │ │ │ │ │ ├── Simferopol │ │ │ │ │ ├── Skopje │ │ │ │ │ ├── Sofia │ │ │ │ │ ├── Stockholm │ │ │ │ │ ├── Tallinn │ │ │ │ │ ├── Tirane │ │ │ │ │ ├── Tiraspol │ │ │ │ │ ├── Ulyanovsk │ │ │ │ │ ├── Uzhgorod │ │ │ │ │ ├── Vaduz │ │ │ │ │ ├── Vatican │ │ │ │ │ ├── Vienna │ │ │ │ │ ├── Vilnius │ │ │ │ │ ├── Volgograd │ │ │ │ │ ├── Warsaw │ │ │ │ │ ├── Zagreb │ │ │ │ │ ├── Zaporozhye │ │ │ │ │ └── Zurich │ │ │ │ ├── Factory │ │ │ │ ├── GB │ │ │ │ ├── GB-Eire │ │ │ │ ├── GMT │ │ │ │ ├── GMT+0 │ │ │ │ ├── GMT-0 │ │ │ │ ├── GMT0 │ │ │ │ ├── Greenwich │ │ │ │ ├── HST │ │ │ │ ├── Hongkong │ │ │ │ ├── Iceland │ │ │ │ ├── Indian/ │ │ │ │ │ ├── Antananarivo │ │ │ │ │ ├── Chagos │ │ │ │ │ ├── Christmas │ │ │ │ │ ├── Cocos │ │ │ │ │ ├── Comoro │ │ │ │ │ ├── Kerguelen │ │ │ │ │ ├── Mahe │ │ │ │ │ ├── Maldives │ │ │ │ │ ├── Mauritius │ │ │ │ │ ├── Mayotte │ │ │ │ │ └── Reunion │ │ │ │ ├── Iran │ │ │ │ ├── Israel │ │ │ │ ├── Jamaica │ │ │ │ ├── Japan │ │ │ │ ├── Kwajalein │ │ │ │ ├── Libya │ │ │ │ ├── MET │ │ │ │ ├── MST │ │ │ │ ├── MST7MDT │ │ │ │ ├── Mexico/ │ │ │ │ │ ├── BajaNorte │ │ │ │ │ ├── BajaSur │ │ │ │ │ └── General │ │ │ │ ├── NZ │ │ │ │ ├── NZ-CHAT │ │ │ │ ├── Navajo │ │ │ │ ├── PRC │ │ │ │ ├── PST8PDT │ │ │ │ ├── Pacific/ │ │ │ │ │ ├── Apia │ │ │ │ │ ├── Auckland │ │ │ │ │ ├── Bougainville │ │ │ │ │ ├── Chatham │ │ │ │ │ ├── Chuuk │ │ │ │ │ ├── Easter │ │ │ │ │ ├── Efate │ │ │ │ │ ├── Enderbury │ │ │ │ │ ├── Fakaofo │ │ │ │ │ ├── Fiji │ │ │ │ │ ├── Funafuti │ │ │ │ │ ├── Galapagos │ │ │ │ │ ├── Gambier │ │ │ │ │ ├── Guadalcanal │ │ │ │ │ ├── Guam │ │ │ │ │ ├── Honolulu │ │ │ │ │ ├── Johnston │ │ │ │ │ ├── Kanton │ │ │ │ │ ├── Kiritimati │ │ │ │ │ ├── Kosrae │ │ │ │ │ ├── Kwajalein │ │ │ │ │ ├── Majuro │ │ │ │ │ ├── Marquesas │ │ │ │ │ ├── Midway │ │ │ │ │ ├── Nauru │ │ │ │ │ ├── Niue │ │ │ │ │ ├── Norfolk │ │ │ │ │ ├── Noumea │ │ │ │ │ ├── Pago_Pago │ │ │ │ │ ├── Palau │ │ │ │ │ ├── Pitcairn │ │ │ │ │ ├── Pohnpei │ │ │ │ │ ├── Ponape │ │ │ │ │ ├── Port_Moresby │ │ │ │ │ ├── Rarotonga │ │ │ │ │ ├── Saipan │ │ │ │ │ ├── Samoa │ │ │ │ │ ├── Tahiti │ │ │ │ │ ├── Tarawa │ │ │ │ │ ├── Tongatapu │ │ │ │ │ ├── Truk │ │ │ │ │ ├── Wake │ │ │ │ │ ├── Wallis │ │ │ │ │ └── Yap │ │ │ │ ├── Poland │ │ │ │ ├── Portugal │ │ │ │ ├── ROC │ │ │ │ ├── ROK │ │ │ │ ├── Singapore │ │ │ │ ├── Turkey │ │ │ │ ├── UCT │ │ │ │ ├── US/ │ │ │ │ │ ├── Alaska │ │ │ │ │ ├── Aleutian │ │ │ │ │ ├── Arizona │ │ │ │ │ ├── Central │ │ │ │ │ ├── East-Indiana │ │ │ │ │ ├── Eastern │ │ │ │ │ ├── Hawaii │ │ │ │ │ ├── Indiana-Starke │ │ │ │ │ ├── Michigan │ │ │ │ │ ├── Mountain │ │ │ │ │ ├── Pacific │ │ │ │ │ └── Samoa │ │ │ │ ├── UTC │ │ │ │ ├── Universal │ │ │ │ ├── W-SU │ │ │ │ ├── WET │ │ │ │ ├── Zulu │ │ │ │ ├── iso3166.tab │ │ │ │ ├── zone1970.tab │ │ │ │ └── zonenow.tab │ │ │ ├── get_current_time_chrono.inc │ │ │ ├── get_current_time_posix.inc │ │ │ ├── test_util.cc │ │ │ └── test_util.h │ │ ├── simulated_clock.cc │ │ ├── simulated_clock.h │ │ ├── simulated_clock_test.cc │ │ ├── time.cc │ │ ├── time.h │ │ ├── time_benchmark.cc │ │ ├── time_test.cc │ │ └── time_zone_test.cc │ ├── types/ │ │ ├── BUILD.bazel │ │ ├── CMakeLists.txt │ │ ├── any.h │ │ ├── any_span.h │ │ ├── any_span_benchmark.cc │ │ ├── any_span_test.cc │ │ ├── compare.h │ │ ├── compare_test.cc │ │ ├── internal/ │ │ │ ├── any_span.h │ │ │ └── span.h │ │ ├── optional.h │ │ ├── optional_ref.h │ │ ├── optional_ref_test.cc │ │ ├── source_location.h │ │ ├── source_location_test.cc │ │ ├── span.h │ │ ├── span_test.cc │ │ ├── variant.h │ │ └── variant_test.cc │ └── utility/ │ ├── BUILD.bazel │ ├── CMakeLists.txt │ └── utility.h ├── ci/ │ ├── absl_alternate_options.h │ ├── cmake_common.sh │ ├── cmake_install_test.sh │ ├── linux_arm_clang-latest_libcxx_bazel.sh │ ├── linux_clang-latest_libcxx_asan_bazel.sh │ ├── linux_clang-latest_libcxx_bazel.sh │ ├── linux_clang-latest_libcxx_tsan_bazel.sh │ ├── linux_clang-latest_libstdcxx_bazel.sh │ ├── linux_docker_containers.sh │ ├── linux_gcc-floor_libstdcxx_bazel.sh │ ├── linux_gcc-latest_libstdcxx_bazel.sh │ ├── linux_gcc-latest_libstdcxx_cmake.sh │ ├── linux_gcc_alpine_cmake.sh │ ├── macos_xcode_bazel.sh │ ├── macos_xcode_cmake.sh │ ├── windows_clangcl_bazel.bat │ ├── windows_msvc_bazel.bat │ └── windows_msvc_cmake.bat ├── conanfile.py └── create_lts.py
Showing preview only (558K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6636 symbols across 822 files)
FILE: CMake/install_test_project/simple.cc
function main (line 28) | int main(int argc, char** argv) {
FILE: absl/abseil.podspec.gen.py
function get_elem_value (line 64) | def get_elem_value(elem, name):
function normalize_paths (line 79) | def normalize_paths(paths):
function parse_rule (line 85) | def parse_rule(elem, package):
function read_build (line 99) | def read_build(package):
function collect_rules (line 111) | def collect_rules(root_path):
function relevant_rule (line 121) | def relevant_rule(rule):
function get_spec_var (line 132) | def get_spec_var(depth):
function get_spec_name (line 137) | def get_spec_name(label):
function write_podspec (line 145) | def write_podspec(f, rules, args):
function build_rule_directory (line 157) | def build_rule_directory(rules):
function write_podspec_map (line 168) | def write_podspec_map(f, cur_map, depth):
function write_podspec_rule (line 184) | def write_podspec_rule(f, rule, depth):
function write_indented_list (line 209) | def write_indented_list(f, leading, values):
function generate (line 216) | def generate(args):
function main (line 223) | def main():
FILE: absl/algorithm/algorithm.h
function namespace (line 31) | namespace absl {
FILE: absl/algorithm/algorithm_test.cc
class LinearSearchTest (line 25) | class LinearSearchTest : public testing::Test {
method LinearSearchTest (line 27) | LinearSearchTest() : container_{1, 2, 3} {}
method Is3 (line 29) | static bool Is3(int n) { return n == 3; }
method Is4 (line 30) | static bool Is4(int n) { return n == 4; }
function TEST_F (line 35) | TEST_F(LinearSearchTest, linear_search) {
function TEST_F (line 40) | TEST_F(LinearSearchTest, linear_searchConst) {
function TEST_F (line 51) | TEST_F(LinearSearchTest, Constexpr) {
FILE: absl/algorithm/container.h
function namespace (line 58) | namespace absl {
function c_linear_search (line 135) | bool c_linear_search(
function c_all_of (line 167) | bool c_all_of(const C& c, Pred&& pred) {
function c_any_of (line 178) | bool c_any_of(const C& c, Pred&& pred) {
function c_none_of (line 189) | bool c_none_of(const C& c, Pred&& pred) {
function c_contains (line 225) | bool c_contains(const Sequence& sequence,
function c_equal (line 395) | bool c_equal(const C1& c1, const C2& c2) {
function c_equal (line 405) | bool c_equal(const C1& c1, const C2& c2,
function c_is_permutation (line 419) | bool c_is_permutation(const C1& c1,
function c_is_permutation (line 430) | bool c_is_permutation(
function OutputIterator (line 524) | OutputIterator
function OutputIterator (line 535) | OutputIterator
function OutputIterator (line 545) | OutputIterator
function BidirectionalIterator (line 557) | BidirectionalIterator
function OutputIterator (line 613) | OutputIterator c_transform(
function OutputIterator (line 625) | OutputIterator
function OutputIterator (line 673) | OutputIterator c_replace_copy(
function OutputIterator (line 687) | OutputIterator c_replace_copy_if(
function OutputIterator (line 749) | OutputIterator
function OutputIterator (line 762) | OutputIterator
function OutputIterator (line 775) | OutputIterator
function OutputIterator (line 784) | OutputIterator
function OutputIterator (line 806) | OutputIterator
function OutputIterator (line 832) | OutputIterator
function c_is_partitioned (line 877) | bool c_is_partitioned(const C& c,
function c_is_sorted (line 992) | bool c_is_sorted(const C& c) {
function c_is_sorted (line 1000) | bool c_is_sorted(const C& c,
function c_binary_search (line 1196) | bool c_binary_search(
function c_binary_search (line 1206) | bool c_binary_search(
function OutputIterator (line 1222) | OutputIterator
function OutputIterator (line 1233) | OutputIterator
function c_includes (line 1270) | bool c_includes(const C1& c1,
function c_includes (line 1281) | bool c_includes(const C1& c1, const C2& c2,
function OutputIterator (line 1302) | OutputIterator
function OutputIterator (line 1319) | OutputIterator c_set_union(
function OutputIterator (line 1339) | OutputIterator
function OutputIterator (line 1361) | OutputIterator c_set_intersection(
function OutputIterator (line 1387) | OutputIterator
function OutputIterator (line 1404) | OutputIterator c_set_difference(
function OutputIterator (line 1425) | OutputIterator
function OutputIterator (line 1443) | OutputIterator c_set_symmetric_difference(
function c_is_heap (line 1546) | bool c_is_heap(
function c_is_heap (line 1555) | bool c_is_heap(
function c_lexicographical_compare (line 1674) | bool c_lexicographical_compare(
function c_lexicographical_compare (line 1686) | bool c_lexicographical_compare(
function OutputIt (line 1820) | OutputIt
function OutputIt (line 1830) | OutputIt c_adjacent_difference(
function OutputIt (line 1844) | OutputIt
function OutputIt (line 1854) | OutputIt c_partial_sum(
FILE: absl/algorithm/container_test.cc
class NonMutatingTest (line 58) | class NonMutatingTest : public testing::Test {
type AccumulateCalls (line 66) | struct AccumulateCalls {
function Predicate (line 71) | bool Predicate(int value) { return value < 3; }
function BinPredicate (line 72) | bool BinPredicate(int v1, int v2) { return v1 < v2; }
function Equals (line 73) | bool Equals(int v1, int v2) { return v1 == v2; }
function IsOdd (line 74) | bool IsOdd(int x) { return x % 2 != 0; }
function TEST_F (line 76) | TEST_F(NonMutatingTest, Distance) {
function TEST_F (line 89) | TEST_F(NonMutatingTest, Distance_OverloadedBeginEnd) {
function TEST_F (line 101) | TEST_F(NonMutatingTest, ForEach) {
function TEST_F (line 114) | TEST_F(NonMutatingTest, FindReturnsCorrectType) {
function TEST_F (line 120) | TEST_F(NonMutatingTest, Contains) {
function TEST_F (line 125) | TEST_F(NonMutatingTest, FindIf) { absl::c_find_if(container_, Predicate); }
function TEST_F (line 127) | TEST_F(NonMutatingTest, FindIfNot) {
function TEST_F (line 131) | TEST_F(NonMutatingTest, FindEnd) {
function TEST_F (line 136) | TEST_F(NonMutatingTest, FindEndWithPredicate) {
function TEST_F (line 141) | TEST_F(NonMutatingTest, FindFirstOf) {
function TEST_F (line 147) | TEST_F(NonMutatingTest, FindFirstOfWithPredicate) {
function TEST_F (line 153) | TEST_F(NonMutatingTest, AdjacentFind) { absl::c_adjacent_find(sequence_); }
function TEST_F (line 155) | TEST_F(NonMutatingTest, AdjacentFindWithPredicate) {
function TEST_F (line 159) | TEST_F(NonMutatingTest, Count) { EXPECT_EQ(1, absl::c_count(container_, ...
function TEST_F (line 161) | TEST_F(NonMutatingTest, CountIf) {
function TEST_F (line 167) | TEST_F(NonMutatingTest, Mismatch) {
function TEST_F (line 216) | TEST_F(NonMutatingTest, MismatchWithPredicate) {
function TEST_F (line 254) | TEST_F(NonMutatingTest, Equal) {
function TEST_F (line 268) | TEST_F(NonMutatingTest, EqualWithPredicate) {
function TEST_F (line 282) | TEST_F(NonMutatingTest, IsPermutation) {
function TEST_F (line 295) | TEST_F(NonMutatingTest, IsPermutationWithPredicate) {
function TEST_F (line 308) | TEST_F(NonMutatingTest, Search) {
function TEST_F (line 314) | TEST_F(NonMutatingTest, SearchWithPredicate) {
function TEST_F (line 319) | TEST_F(NonMutatingTest, ContainsSubrange) {
function TEST_F (line 325) | TEST_F(NonMutatingTest, ContainsSubrangeWithPredicate) {
function TEST_F (line 330) | TEST_F(NonMutatingTest, SearchN) { absl::c_search_n(sequence_, 3, 1); }
function TEST_F (line 332) | TEST_F(NonMutatingTest, SearchNWithPredicate) {
function TEST_F (line 336) | TEST_F(NonMutatingTest, LowerBound) {
function TEST_F (line 343) | TEST_F(NonMutatingTest, LowerBoundWithPredicate) {
function TEST_F (line 351) | TEST_F(NonMutatingTest, UpperBound) {
function TEST_F (line 358) | TEST_F(NonMutatingTest, UpperBoundWithPredicate) {
function TEST_F (line 366) | TEST_F(NonMutatingTest, EqualRange) {
function TEST_F (line 373) | TEST_F(NonMutatingTest, EqualRangeArray) {
function TEST_F (line 379) | TEST_F(NonMutatingTest, EqualRangeWithPredicate) {
function TEST_F (line 388) | TEST_F(NonMutatingTest, BinarySearch) {
function TEST_F (line 393) | TEST_F(NonMutatingTest, BinarySearchWithPredicate) {
function TEST_F (line 401) | TEST_F(NonMutatingTest, MinElement) {
function TEST_F (line 407) | TEST_F(NonMutatingTest, MinElementWithPredicate) {
function TEST_F (line 414) | TEST_F(NonMutatingTest, MaxElement) {
function TEST_F (line 420) | TEST_F(NonMutatingTest, MaxElementWithPredicate) {
function TEST_F (line 427) | TEST_F(NonMutatingTest, LexicographicalCompare) {
function TEST_F (line 439) | TEST_F(NonMutatingTest, LexicographicalCopmareWithPredicate) {
function TEST_F (line 454) | TEST_F(NonMutatingTest, Includes) {
function TEST_F (line 460) | TEST_F(NonMutatingTest, IncludesWithPredicate) {
class NumericMutatingTest (line 467) | class NumericMutatingTest : public testing::Test {
function TEST_F (line 473) | TEST_F(NumericMutatingTest, Iota) {
function TEST_F (line 479) | TEST_F(NonMutatingTest, Accumulate) {
function TEST_F (line 483) | TEST_F(NonMutatingTest, AccumulateWithBinaryOp) {
function TEST_F (line 488) | TEST_F(NonMutatingTest, AccumulateLvalueInit) {
function TEST_F (line 493) | TEST_F(NonMutatingTest, AccumulateWithBinaryOpLvalueInit) {
function TEST_F (line 499) | TEST_F(NonMutatingTest, InnerProduct) {
function TEST_F (line 504) | TEST_F(NonMutatingTest, InnerProductWithBinaryOps) {
function TEST_F (line 510) | TEST_F(NonMutatingTest, InnerProductLvalueInit) {
function TEST_F (line 516) | TEST_F(NonMutatingTest, InnerProductWithBinaryOpsLvalueInit) {
function TEST_F (line 523) | TEST_F(NumericMutatingTest, AdjacentDifference) {
function TEST_F (line 530) | TEST_F(NumericMutatingTest, AdjacentDifferenceWithBinaryOp) {
function TEST_F (line 538) | TEST_F(NumericMutatingTest, PartialSum) {
function TEST_F (line 545) | TEST_F(NumericMutatingTest, PartialSumWithBinaryOp) {
function TEST_F (line 553) | TEST_F(NonMutatingTest, LinearSearch) {
function TEST_F (line 558) | TEST_F(NonMutatingTest, AllOf) {
function TEST_F (line 564) | TEST_F(NonMutatingTest, AnyOf) {
function TEST_F (line 570) | TEST_F(NonMutatingTest, NoneOf) {
function TEST_F (line 576) | TEST_F(NonMutatingTest, MinMaxElementLess) {
function TEST_F (line 583) | TEST_F(NonMutatingTest, MinMaxElementGreater) {
function TEST_F (line 590) | TEST_F(NonMutatingTest, MinMaxElementNoPredicate) {
class SortingTest (line 597) | class SortingTest : public testing::Test {
function TEST_F (line 604) | TEST_F(SortingTest, IsSorted) {
function TEST_F (line 610) | TEST_F(SortingTest, IsSortedWithPredicate) {
function TEST_F (line 616) | TEST_F(SortingTest, IsSortedUntil) {
function TEST_F (line 621) | TEST_F(SortingTest, NthElement) {
function TEST (line 629) | TEST(MutatingTest, IsPartitioned) {
function TEST (line 638) | TEST(MutatingTest, Partition) {
function TEST (line 646) | TEST(MutatingTest, StablePartition) {
function TEST (line 652) | TEST(MutatingTest, PartitionCopy) {
function TEST (line 663) | TEST(MutatingTest, PartitionPoint) {
function TEST (line 669) | TEST(MutatingTest, CopyMiddle) {
function TEST (line 683) | TEST(MutatingTest, CopyFrontInserter) {
function TEST (line 693) | TEST(MutatingTest, CopyBackInserter) {
function TEST (line 707) | TEST(MutatingTest, CopyN) {
function TEST (line 715) | TEST(MutatingTest, CopyIf) {
function TEST (line 723) | TEST(MutatingTest, CopyBackward) {
function TEST (line 730) | TEST(MutatingTest, Move) {
function TEST (line 745) | TEST(MutatingTest, MoveBackward) {
function TEST (line 758) | TEST(MutatingTest, MoveWithRvalue) {
function TEST (line 773) | TEST(MutatingTest, SwapRanges) {
function TEST_F (line 790) | TEST_F(NonMutatingTest, Transform) {
function TEST (line 818) | TEST(MutatingTest, Replace) {
function TEST (line 831) | TEST(MutatingTest, ReplaceIf) {
function TEST (line 839) | TEST(MutatingTest, ReplaceCopy) {
function TEST (line 848) | TEST(MutatingTest, Sort) {
function TEST (line 854) | TEST(MutatingTest, SortWithPredicate) {
type Element (line 862) | struct Element {
function TEST (line 878) | TEST(MutatingTest, StableSort) {
function TEST (line 886) | TEST(MutatingTest, StableSortWithPredicate) {
function TEST (line 896) | TEST(MutatingTest, ReplaceCopyIf) {
function TEST (line 905) | TEST(MutatingTest, Fill) {
function TEST (line 911) | TEST(MutatingTest, FillN) {
function TEST (line 917) | TEST(MutatingTest, Generate) {
function TEST (line 924) | TEST(MutatingTest, GenerateN) {
function TEST (line 931) | TEST(MutatingTest, RemoveCopy) {
function TEST (line 937) | TEST(MutatingTest, RemoveCopyIf) {
function TEST (line 944) | TEST(MutatingTest, UniqueCopy) {
function TEST (line 951) | TEST(MutatingTest, UniqueCopyWithPredicate) {
function TEST (line 959) | TEST(MutatingTest, Reverse) {
function TEST (line 969) | TEST(MutatingTest, ReverseCopy) {
function TEST (line 975) | TEST(MutatingTest, Rotate) {
function TEST (line 982) | TEST(MutatingTest, RotateCopy) {
function TEST (line 991) | TEST(MutatingTest, Shuffle) {
function TEST (line 997) | TEST(MutatingTest, Sample) {
function TEST (line 1005) | TEST(MutatingTest, PartialSort) {
function TEST (line 1013) | TEST(MutatingTest, PartialSortCopy) {
function TEST (line 1022) | TEST(MutatingTest, Merge) {
function TEST (line 1029) | TEST(MutatingTest, MergeWithComparator) {
function TEST (line 1036) | TEST(MutatingTest, InplaceMerge) {
function TEST (line 1042) | TEST(MutatingTest, InplaceMergeWithComparator) {
class SetOperationsTest (line 1048) | class SetOperationsTest : public testing::Test {
function TEST_F (line 1057) | TEST_F(SetOperationsTest, SetUnion) {
function TEST_F (line 1063) | TEST_F(SetOperationsTest, SetUnionWithComparator) {
function TEST_F (line 1070) | TEST_F(SetOperationsTest, SetIntersection) {
function TEST_F (line 1076) | TEST_F(SetOperationsTest, SetIntersectionWithComparator) {
function TEST_F (line 1083) | TEST_F(SetOperationsTest, SetDifference) {
function TEST_F (line 1089) | TEST_F(SetOperationsTest, SetDifferenceWithComparator) {
function TEST_F (line 1096) | TEST_F(SetOperationsTest, SetSymmetricDifference) {
function TEST_F (line 1102) | TEST_F(SetOperationsTest, SetSymmetricDifferenceWithComparator) {
function TEST (line 1109) | TEST(HeapOperationsTest, WithoutComparator) {
function TEST (line 1126) | TEST(HeapOperationsTest, WithComparator) {
function TEST (line 1144) | TEST(MutatingTest, PermutationOperations) {
function TEST (line 1163) | TEST(ConstexprTest, Distance) {
function TEST (line 1168) | TEST(ConstexprTest, MinElement) {
function TEST (line 1173) | TEST(ConstexprTest, MinElementWithPredicate) {
function TEST (line 1178) | TEST(ConstexprTest, MaxElement) {
function TEST (line 1183) | TEST(ConstexprTest, MaxElementWithPredicate) {
function TEST (line 1188) | TEST(ConstexprTest, MinMaxElement) {
function TEST (line 1195) | TEST(ConstexprTest, MinMaxElementWithPredicate) {
function TEST (line 1208) | TEST(ConstexprTest, LinearSearch) {
function TEST (line 1214) | TEST(ConstexprTest, AllOf) {
function TEST (line 1220) | TEST(ConstexprTest, AnyOf) {
function TEST (line 1226) | TEST(ConstexprTest, NoneOf) {
function TEST (line 1232) | TEST(ConstexprTest, ForEach) {
function TEST (line 1241) | TEST(ConstexprTest, Find) {
function TEST (line 1247) | TEST(ConstexprTest, Contains) {
function TEST (line 1253) | TEST(ConstexprTest, FindIf) {
function TEST (line 1261) | TEST(ConstexprTest, FindIfNot) {
function TEST (line 1269) | TEST(ConstexprTest, FindEnd) {
function TEST (line 1275) | TEST(ConstexprTest, FindFirstOf) {
function TEST (line 1280) | TEST(ConstexprTest, AdjacentFind) {
function TEST (line 1285) | TEST(ConstexprTest, AdjacentFindWithPredicate) {
function TEST (line 1291) | TEST(ConstexprTest, Count) {
function TEST (line 1299) | TEST(ConstexprTest, CountIf) {
function TEST (line 1305) | TEST(ConstexprTest, Mismatch) {
function TEST (line 1315) | TEST(ConstexprTest, MismatchWithPredicate) {
function TEST (line 1325) | TEST(ConstexprTest, Equal) {
function TEST (line 1333) | TEST(ConstexprTest, EqualWithPredicate) {
function TEST (line 1341) | TEST(ConstexprTest, IsPermutation) {
function TEST (line 1349) | TEST(ConstexprTest, IsPermutationWithPredicate) {
function TEST (line 1358) | TEST(ConstexprTest, Search) {
function TEST (line 1366) | TEST(ConstexprTest, SearchWithPredicate) {
function TEST (line 1376) | TEST(ConstexprTest, ContainsSubrange) {
function TEST (line 1384) | TEST(ConstexprTest, ContainsSubrangeWithPredicate) {
function TEST (line 1394) | TEST(ConstexprTest, SearchN) {
function TEST (line 1401) | TEST(ConstexprTest, SearchNWithPredicate) {
function TEST (line 1411) | TEST(ConstexprTest, Copy) {
function TEST (line 1421) | TEST(ConstexprTest, CopyN) {
function TEST (line 1431) | TEST(ConstexprTest, CopyIf) {
function TEST (line 1441) | TEST(ConstexprTest, CopyBackward) {
function TEST (line 1451) | TEST(ConstexprTest, Move) {
function TEST (line 1461) | TEST(ConstexprTest, MoveBackward) {
function TEST (line 1471) | TEST(ConstexprTest, SwapRanges) {
function TEST (line 1486) | TEST(ConstexprTest, Transform) {
function TEST (line 1496) | TEST(ConstexprTest, Replace) {
function TEST (line 1506) | TEST(ConstexprTest, ReplaceIf) {
function TEST (line 1516) | TEST(ConstexprTest, ReplaceCopy) {
function TEST (line 1526) | TEST(ConstexprTest, ReplaceCopyIf) {
function TEST (line 1537) | TEST(ConstexprTest, Fill) {
function TEST (line 1546) | TEST(ConstexprTest, FillN) {
function TEST (line 1555) | TEST(ConstexprTest, Generate) {
function TEST (line 1564) | TEST(ConstexprTest, GenerateN) {
function TEST (line 1573) | TEST(ConstexprTest, RemoveCopy) {
function TEST (line 1583) | TEST(ConstexprTest, RemoveCopyIf) {
function TEST (line 1593) | TEST(ConstexprTest, UniqueCopy) {
function TEST (line 1603) | TEST(ConstexprTest, UniqueCopyWithPredicate) {
function TEST (line 1613) | TEST(ConstexprTest, Reverse) {
function TEST (line 1623) | TEST(ConstexprTest, ReverseCopy) {
function TEST (line 1633) | TEST(ConstexprTest, Rotate) {
function TEST (line 1643) | TEST(ConstexprTest, RotateCopy) {
function TEST (line 1653) | TEST(ConstexprTest, IsPartitioned) {
function TEST (line 1662) | TEST(ConstexprTest, Partition) {
function TEST (line 1673) | TEST(ConstexprTest, PartitionCopy) {
function TEST (line 1686) | TEST(ConstexprTest, PartitionPoint) {
function TEST (line 1693) | TEST(ConstexprTest, Sort) {
function TEST (line 1703) | TEST(ConstexprTest, SortWithPredicate) {
function TEST (line 1713) | TEST(ConstexprTest, IsSorted) {
function TEST (line 1720) | TEST(ConstexprTest, IsSortedWithPredicate) {
function TEST (line 1727) | TEST(ConstexprTest, PartialSort) {
function TEST (line 1738) | TEST(ConstexprTest, PartialSortWithPredicate) {
function TEST (line 1749) | TEST(ConstexprTest, PartialSortCopy) {
function TEST (line 1760) | TEST(ConstexprTest, PartialSortCopyWithPredicate) {
function TEST (line 1771) | TEST(ConstexprTest, IsSortedUntil) {
function TEST (line 1779) | TEST(ConstexprTest, IsSortedUntilWithPredicate) {
function TEST (line 1788) | TEST(ConstexprTest, NthElement) {
function TEST (line 1801) | TEST(ConstexprTest, NthElementWithPredicate) {
function TEST (line 1817) | TEST(ConstexprTest, LowerBound) {
function TEST (line 1823) | TEST(ConstexprTest, LowerBoundWithPredicate) {
function TEST (line 1830) | TEST(ConstexprTest, UpperBound) {
function TEST (line 1836) | TEST(ConstexprTest, UpperBoundWithPredicate) {
function TEST (line 1843) | TEST(ConstexprTest, EqualRange) {
function TEST (line 1850) | TEST(ConstexprTest, EqualRangeWithPredicate) {
function TEST (line 1858) | TEST(ConstexprTest, BinarySearch) {
function TEST (line 1864) | TEST(ConstexprTest, BinarySearchWithPredicate) {
function TEST (line 1871) | TEST(ConstexprTest, Merge) {
function TEST (line 1882) | TEST(ConstexprTest, MergeWithPredicate) {
function TEST (line 1893) | TEST(ConstexprTest, Includes) {
function TEST (line 1900) | TEST(ConstexprTest, IncludesWithPredicate) {
function TEST (line 1908) | TEST(ConstexprTest, SetUnion) {
function TEST (line 1919) | TEST(ConstexprTest, SetUnionWithPredicate) {
function TEST (line 1930) | TEST(ConstexprTest, SetIntersection) {
function TEST (line 1941) | TEST(ConstexprTest, SetIntersectionWithPredicate) {
function TEST (line 1952) | TEST(ConstexprTest, SetDifference) {
function TEST (line 1963) | TEST(ConstexprTest, SetDifferenceWithPredicate) {
function TEST (line 1974) | TEST(ConstexprTest, SetSymmetricDifference) {
function TEST (line 1985) | TEST(ConstexprTest, SetSymmetricDifferenceWithPredicate) {
function TEST (line 1997) | TEST(ConstexprTest, PushHeap) {
function TEST (line 2006) | TEST(ConstexprTest, PushHeapWithPredicate) {
function TEST (line 2015) | TEST(ConstexprTest, PopHeap) {
function TEST (line 2024) | TEST(ConstexprTest, PopHeapWithPredicate) {
function TEST (line 2033) | TEST(ConstexprTest, MakeHeap) {
function TEST (line 2042) | TEST(ConstexprTest, MakeHeapWithPredicate) {
function TEST (line 2051) | TEST(ConstexprTest, SortHeap) {
function TEST (line 2061) | TEST(ConstexprTest, SortHeapWithPredicate) {
function TEST (line 2071) | TEST(ConstexprTest, IsHeap) {
function TEST (line 2078) | TEST(ConstexprTest, IsHeapWithPredicate) {
function TEST (line 2085) | TEST(ConstexprTest, IsHeapUntil) {
function TEST (line 2092) | TEST(ConstexprTest, IsHeapUntilWithPredicate) {
function TEST (line 2100) | TEST(ConstexprTest, LexicographicalCompare) {
function TEST (line 2109) | TEST(ConstexprTest, LexicographicalCompareWithPredicate) {
function TEST (line 2121) | TEST(ConstexprTest, NextPermutation) {
function TEST (line 2130) | TEST(ConstexprTest, NextPermutationWithPredicate) {
function TEST (line 2139) | TEST(ConstexprTest, PrevPermutation) {
function TEST (line 2148) | TEST(ConstexprTest, PrevPermutationWithPredicate) {
function TEST (line 2157) | TEST(ConstexprTest, Iota) {
function TEST (line 2166) | TEST(ConstexprTest, Accumulate) {
function TEST (line 2171) | TEST(ConstexprTest, AccumulateWithPredicate) {
function TEST (line 2176) | TEST(ConstexprTest, InnerProduct) {
function TEST (line 2182) | TEST(ConstexprTest, InnerProductWithPredicate) {
function TEST (line 2189) | TEST(ConstexprTest, AdjacentDifference) {
function TEST (line 2199) | TEST(ConstexprTest, AdjacentDifferenceWithPredicate) {
function TEST (line 2209) | TEST(ConstexprTest, PartialSum) {
function TEST (line 2219) | TEST(ConstexprTest, PartialSumWithPredicate) {
FILE: absl/base/attributes.h
type AbslInternal_YouForgotToExplicitlyInitializeAField (line 772) | struct AbslInternal_YouForgotToExplicitlyInitializeAField {
FILE: absl/base/attributes_test.cc
function TEST (line 22) | TEST(Attributes, RequireExplicitInit) {
FILE: absl/base/bit_cast_test.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/c_header_test.c
function main (line 30) | int main() { return 0; }
FILE: absl/base/call_once.h
function namespace (line 46) | namespace absl {
FILE: absl/base/call_once_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/casts.cc
type absl (line 27) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 28) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/casts.h
function namespace (line 50) | namespace absl {
function Dest (line 194) | inline Dest bit_cast(const Source& source) {
function namespace (line 204) | namespace base_internal {
function To (line 255) | [[nodiscard]]
function To (line 286) | [[nodiscard]]
FILE: absl/base/casts_test.cc
type BaseForImplicitCast (line 25) | struct BaseForImplicitCast {
method BaseForImplicitCast (line 26) | explicit BaseForImplicitCast(int value) : x(value) {}
method BaseForImplicitCast (line 27) | BaseForImplicitCast(const BaseForImplicitCast& other) = delete;
method BaseForImplicitCast (line 28) | BaseForImplicitCast& operator=(const BaseForImplicitCast& other) = del...
type DerivedForImplicitCast (line 31) | struct DerivedForImplicitCast : BaseForImplicitCast {
method DerivedForImplicitCast (line 32) | explicit DerivedForImplicitCast(int value) : BaseForImplicitCast(value...
function TEST (line 43) | TEST(ImplicitCastTest, LValueReference) {
function TEST (line 50) | TEST(ImplicitCastTest, RValueReference) {
class BaseForDownCast (line 62) | class BaseForDownCast {
class DerivedForDownCast (line 67) | class DerivedForDownCast : public BaseForDownCast {}
class Derived2ForDownCast (line 68) | class Derived2ForDownCast : public BaseForDownCast {}
function TEST (line 70) | TEST(DownCastTest, Pointer) {
function TEST (line 103) | TEST(DownCastTest, Reference) {
function TEST (line 136) | TEST(DownCastTest, ErrorMessage) {
FILE: absl/base/config_test.cc
function TEST (line 24) | TEST(ConfigTest, Endianness) {
function TEST (line 45) | TEST(ConfigTest, ThreadLocal) {
FILE: absl/base/const_init.h
function ABSL_NAMESPACE_BEGIN (line 67) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/dynamic_annotations.h
function ABSL_INTERNAL_STATIC_INLINE (line 326) | ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
function ABSL_INTERNAL_STATIC_INLINE (line 330) | ABSL_INTERNAL_STATIC_INLINE void ABSL_INTERNAL_C_SYMBOL(
function namespace (line 400) | namespace absl {
function namespace (line 452) | namespace absl {
FILE: absl/base/exception_safety_testing_test.cc
type testing (line 30) | namespace testing {
function ExpectNoThrow (line 40) | void ExpectNoThrow(const F& f) {
function TEST (line 48) | TEST(ThrowingValueTest, Throws) {
function TestOp (line 67) | void TestOp(const F& f) {
function TEST (line 75) | TEST(ThrowingValueTest, ThrowingCtors) {
function TEST (line 83) | TEST(ThrowingValueTest, ThrowingAssignment) {
function TEST (line 111) | TEST(ThrowingValueTest, ThrowingComparisons) {
function TEST (line 121) | TEST(ThrowingValueTest, ThrowingArithmeticOps) {
function TEST (line 139) | TEST(ThrowingValueTest, ThrowingLogicalOps) {
function TEST (line 147) | TEST(ThrowingValueTest, ThrowingBitwiseOps) {
function TEST (line 156) | TEST(ThrowingValueTest, ThrowingCompoundAssignmentOps) {
function TEST (line 170) | TEST(ThrowingValueTest, ThrowingStreamOps) {
function TEST (line 185) | TEST(ThrowingValueTest, StreamOpsOutput) {
function TestAllocatingOp (line 228) | void TestAllocatingOp(const F& f) {
function TEST (line 236) | TEST(ThrowingValueTest, ThrowingAllocatingOps) {
function TEST (line 243) | TEST(ThrowingValueTest, NonThrowingMoveCtor) {
function TEST (line 253) | TEST(ThrowingValueTest, NonThrowingMoveAssign) {
function TEST (line 263) | TEST(ThrowingValueTest, ThrowingCopyCtor) {
function TEST (line 269) | TEST(ThrowingValueTest, ThrowingCopyAssign) {
function TEST (line 275) | TEST(ThrowingValueTest, NonThrowingCopyCtor) {
function TEST (line 285) | TEST(ThrowingValueTest, NonThrowingCopyAssign) {
function TEST (line 295) | TEST(ThrowingValueTest, ThrowingSwap) {
function TEST (line 300) | TEST(ThrowingValueTest, NonThrowingSwap) {
function TEST (line 305) | TEST(ThrowingValueTest, NonThrowingAllocation) {
function TEST (line 319) | TEST(ThrowingValueTest, NonThrowingDelete) {
function TEST (line 331) | TEST(ThrowingValueTest, NonThrowingPlacementDelete) {
function TEST (line 361) | TEST(ThrowingValueTest, NonThrowingDestructor) {
function TEST (line 369) | TEST(ThrowingBoolTest, ThrowingBool) {
function TEST (line 380) | TEST(ThrowingAllocatorTest, MemoryManagement) {
function TEST (line 396) | TEST(ThrowingAllocatorTest, CallsGlobalNew) {
function TEST (line 408) | TEST(ThrowingAllocatorTest, ThrowingConstructors) {
function TEST (line 425) | TEST(ThrowingAllocatorTest, NonThrowingConstruction) {
function TEST (line 483) | TEST(ThrowingAllocatorTest, ThrowingAllocatorConstruction) {
function TEST (line 489) | TEST(ThrowingAllocatorTest, State) {
function TEST (line 501) | TEST(ThrowingAllocatorTest, InVector) {
function TEST (line 507) | TEST(ThrowingAllocatorTest, InList) {
type NullaryTestValidator (line 516) | struct NullaryTestValidator : public std::false_type {}
function HasNullaryTest (line 525) | bool HasNullaryTest(const TesterInstance&) {
function DummyOp (line 529) | void DummyOp(void*) {}
type UnaryTestValidator (line 532) | struct UnaryTestValidator : public std::false_type {}
function HasUnaryTest (line 541) | bool HasUnaryTest(const TesterInstance&) {
function TEST (line 545) | TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
type ExampleStruct (line 575) | struct ExampleStruct {}
function ExampleFunctionFactory (line 577) | std::unique_ptr<ExampleStruct> ExampleFunctionFactory() {
function ExampleFunctionOperation (line 581) | void ExampleFunctionOperation(ExampleStruct*) {}
function ExampleFunctionContract (line 583) | testing::AssertionResult ExampleFunctionContract(ExampleStruct*) {
function TEST (line 613) | TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) {
type NonNegative (line 643) | struct NonNegative {
function CheckNonNegativeInvariants (line 648) | testing::AssertionResult CheckNonNegativeInvariants(NonNegative* g) {
type FailsBasicGuarantee (line 668) | struct FailsBasicGuarantee : public NonNegative {
function TEST (line 676) | TEST(ExceptionCheckTest, BasicGuaranteeFailure) {
type FollowsBasicGuarantee (line 680) | struct FollowsBasicGuarantee : public NonNegative {
function TEST (line 687) | TEST(ExceptionCheckTest, BasicGuarantee) {
function TEST (line 691) | TEST(ExceptionCheckTest, StrongGuaranteeFailure) {
type BasicGuaranteeWithExtraContracts (line 696) | struct BasicGuaranteeWithExtraContracts : public NonNegative {
function TEST (line 708) | TEST(ExceptionCheckTest, BasicGuaranteeWithExtraContracts) {
type FollowsStrongGuarantee (line 726) | struct FollowsStrongGuarantee : public NonNegative {
function TEST (line 730) | TEST(ExceptionCheckTest, StrongGuarantee) {
type HasReset (line 735) | struct HasReset : public NonNegative {
method reset (line 742) | void reset() { i = 0; }
function CheckHasResetContracts (line 745) | testing::AssertionResult CheckHasResetContracts(HasReset* h) {
function TEST (line 750) | TEST(ExceptionCheckTest, ModifyingChecker) {
function TEST (line 775) | TEST(ExceptionSafetyTesterTest, ResetsCountdown) {
type NonCopyable (line 787) | struct NonCopyable : public NonNegative {
method NonCopyable (line 788) | NonCopyable(const NonCopyable&) = delete;
method NonCopyable (line 789) | NonCopyable() : NonNegative{0} {}
function TEST (line 794) | TEST(ExceptionCheckTest, NonCopyable) {
type NonEqualityComparable (line 800) | struct NonEqualityComparable : public NonNegative {
method ModifyOnThrow (line 803) | void ModifyOnThrow() {
function TEST (line 811) | TEST(ExceptionCheckTest, NonEqualityComparable) {
type ExhaustivenessTester (line 824) | struct ExhaustivenessTester {
function TEST (line 855) | TEST(ExceptionCheckTest, Exhaustiveness) {
type LeaksIfCtorThrows (line 871) | struct LeaksIfCtorThrows : private exceptions_internal::TrackedObject {
method LeaksIfCtorThrows (line 872) | LeaksIfCtorThrows() : TrackedObject(ABSL_PRETTY_FUNCTION) {
method LeaksIfCtorThrows (line 878) | LeaksIfCtorThrows(const LeaksIfCtorThrows&) noexcept
function TEST (line 884) | TEST(ExceptionCheckTest, TestLeakyCtor) {
type Tracked (line 890) | struct Tracked : private exceptions_internal::TrackedObject {
method Tracked (line 891) | Tracked() : TrackedObject(ABSL_PRETTY_FUNCTION) {}
function TEST (line 894) | TEST(ConstructorTrackerTest, CreatedBefore) {
function TEST (line 899) | TEST(ConstructorTrackerTest, CreatedAfter) {
function TEST (line 904) | TEST(ConstructorTrackerTest, NotDestroyedAfter) {
function TEST (line 915) | TEST(ConstructorTrackerTest, DestroyedTwice) {
function TEST (line 925) | TEST(ConstructorTrackerTest, ConstructedTwice) {
function TEST (line 937) | TEST(ThrowingValueTraitsTest, RelationalOperators) {
function TEST (line 947) | TEST(ThrowingAllocatorTraitsTest, Assignablility) {
type NullaryTestValidator<
TesterInstance,
absl::void_t<decltype(std::declval<TesterInstance>().Test())>> (line 519) | struct NullaryTestValidator<
type UnaryTestValidator<
TesterInstance,
absl::void_t<decltype(std::declval<TesterInstance>().Test(DummyOp))>> (line 535) | struct UnaryTestValidator<
FILE: absl/base/fast_type_id.h
function namespace (line 23) | namespace absl {
function FastTypeIdType (line 66) | FastTypeIdType FastTypeId() {
FILE: absl/base/fast_type_id_test.cc
function TEST (line 46) | TEST(FastTypeIdTest, PrimitiveTypes) {
function TEST (line 82) | TEST(FastTypeIdTest, FixedWidthTypes) {
function TEST (line 108) | TEST(FastTypeIdTest, AliasTypes) {
function TEST (line 113) | TEST(FastTypeIdTest, TemplateSpecializations) {
type Base (line 121) | struct Base {}
type Derived (line 122) | struct Derived : Base {}
type PDerived (line 123) | struct PDerived : private Base {}
function TEST (line 125) | TEST(FastTypeIdTest, Inheritance) {
FILE: absl/base/internal/atomic_hook.h
function namespace (line 38) | namespace absl {
FILE: absl/base/internal/atomic_hook_test.cc
function TestHook (line 27) | void TestHook(int x) { value = x; }
function TEST (line 29) | TEST(AtomicHookTest, NoDefaultFunction) {
function TEST (line 56) | TEST(AtomicHookTest, WithDefaultFunction) {
function OverrideFunc (line 78) | void OverrideFunc() { override_func_calls++; }
type OverrideInstaller (line 79) | struct OverrideInstaller {
method OverrideInstaller (line 80) | OverrideInstaller() { absl::atomic_hook_internal::func.Store(OverrideF...
function TEST (line 83) | TEST(AtomicHookTest, DynamicInitFromAnotherTU) {
FILE: absl/base/internal/atomic_hook_test_helper.cc
type absl (line 20) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 21) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/atomic_hook_test_helper.h
function namespace (line 20) | namespace absl {
FILE: absl/base/internal/cmake_thread_test.cc
function main (line 18) | int main() {
FILE: absl/base/internal/cycleclock.cc
type absl (line 32) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/cycleclock.h
function namespace (line 53) | namespace absl {
FILE: absl/base/internal/cycleclock_config.h
function namespace (line 23) | namespace absl {
FILE: absl/base/internal/direct_mmap.h
function namespace (line 68) | namespace absl {
function namespace (line 149) | namespace absl {
FILE: absl/base/internal/endian.h
function namespace (line 30) | namespace absl {
FILE: absl/base/internal/endian_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/errno_saver.h
function namespace (line 22) | namespace absl {
FILE: absl/base/internal/errno_saver_test.cc
type ErrnoPrinter (line 26) | struct ErrnoPrinter {
function TEST (line 34) | TEST(ErrnoSaverTest, Works) {
FILE: absl/base/internal/exception_safety_testing.cc
type testing (line 22) | namespace testing {
function MakeExceptionSafetyTester (line 28) | exceptions_internal::ExceptionSafetyTestBuilder<> MakeExceptionSafetyT...
type exceptions_internal (line 32) | namespace exceptions_internal {
function MaybeThrow (line 38) | void MaybeThrow(absl::string_view msg, bool throw_bad_alloc) {
function FailureMessage (line 45) | testing::AssertionResult FailureMessage(const TestException& e,
function GetSpecString (line 50) | std::string GetSpecString(TypeSpec spec) {
function GetSpecString (line 69) | std::string GetSpecString(AllocSpec spec) {
FILE: absl/base/internal/exception_safety_testing.h
function namespace (line 41) | namespace testing {
function namespace (line 66) | namespace exceptions_internal {
function UnsetCountdown (line 103) | inline void UnsetCountdown() { SetCountdown(-1); }
type TrackedAddress (line 110) | struct TrackedAddress {
function class (line 118) | class ConstructorTracker {
function class (line 193) | class TrackedObject {
function class (line 213) | class ThrowingBool {
function TypeSpec (line 235) | enum class TypeSpec {
function ThrowingBool (line 437) | ThrowingBool operator||(const ThrowingValue& other) const {
function AllocSpec (line 617) | enum class AllocSpec {
function size_type (line 732) | size_type max_size() const noexcept {
function ReadState (line 765) | void ReadState() {
function ReadStateAndMaybeThrow (line 771) | void ReadStateAndMaybeThrow(absl::string_view msg) const {
function AssertionResult (line 809) | AssertionResult TestNothrowOp(const Operation& operation) {
function namespace (line 828) | namespace exceptions_internal {
function namespace (line 867) | namespace exceptions_internal {
function AssertionResult (line 1055) | AssertionResult Test(const NewOperation& new_operation) const {
function AssertionResult (line 1091) | AssertionResult TestImpl(SelectedOperation selected_operation,
FILE: absl/base/internal/hardening.cc
type absl (line 30) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 31) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/hardening.h
function namespace (line 39) | namespace absl {
FILE: absl/base/internal/hardening_test.cc
function TEST (line 22) | TEST(BoundsCheckTest, HardeningAssertInBounds) {
function TEST (line 26) | TEST(BoundsChecksDeathTest, HardeningAssertInBounds) {
FILE: absl/base/internal/iterator_traits.h
function namespace (line 30) | namespace absl {
FILE: absl/base/internal/iterator_traits_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/iterator_traits_test_helper.h
function namespace (line 23) | namespace absl {
function ABSL_NAMESPACE_END (line 73) | ABSL_NAMESPACE_END
FILE: absl/base/internal/low_level_alloc.cc
type absl (line 68) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 69) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/low_level_alloc.h
function namespace (line 58) | namespace absl {
FILE: absl/base/internal/low_level_alloc_test.cc
type absl (line 30) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 31) | ABSL_NAMESPACE_BEGIN
function main (line 161) | int main(int argc, char *argv[]) {
FILE: absl/base/internal/low_level_scheduling.h
function namespace (line 32) | namespace absl {
FILE: absl/base/internal/nullability_traits.h
function namespace (line 23) | namespace absl {
FILE: absl/base/internal/nullability_traits_test.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/poison.cc
type absl (line 38) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 39) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/poison.h
function namespace (line 22) | namespace absl {
FILE: absl/base/internal/poison_test.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/raw_logging.cc
type absl (line 76) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 77) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/raw_logging.h
function namespace (line 122) | namespace absl {
FILE: absl/base/internal/scheduling_mode.h
function namespace (line 23) | namespace absl {
FILE: absl/base/internal/scoped_set_env.cc
type absl (line 25) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 26) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/scoped_set_env.h
function namespace (line 24) | namespace absl {
FILE: absl/base/internal/scoped_set_env_test.cc
function GetEnvVar (line 26) | std::string GetEnvVar(const char* name) {
function TEST (line 49) | TEST(ScopedSetEnvTest, SetNonExistingVarToString) {
function TEST (line 61) | TEST(ScopedSetEnvTest, SetNonExistingVarToNull) {
function TEST (line 73) | TEST(ScopedSetEnvTest, SetExistingVarToString) {
function TEST (line 86) | TEST(ScopedSetEnvTest, SetExistingVarToNull) {
FILE: absl/base/internal/spinlock.cc
type absl (line 60) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 61) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/spinlock.h
function namespace (line 47) | namespace tcmalloc {
function namespace (line 56) | namespace absl {
function GetAdaptiveSpinCount (line 180) | static int GetAdaptiveSpinCount() {
function SetAdaptiveSpinCount (line 183) | static void SetAdaptiveSpinCount(int count) {
function IsCooperative (line 217) | static constexpr bool IsCooperative(SchedulingMode scheduling_mode) {
function RegisterWithTsan (line 221) | constexpr void RegisterWithTsan() {
function SlowLock (line 234) | void SlowLock() ABSL_ATTRIBUTE_COLD;
function explicit (line 259) | inline explicit SpinLockHolder(SpinLock* l) ABSL_EXCLUSIVE_LOCK_FUNCTION(l)
function TryLockInternal (line 281) | inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
FILE: absl/base/internal/spinlock_benchmark.cc
function BM_TryLock (line 28) | static void BM_TryLock(benchmark::State& state) {
function BM_SpinLock (line 43) | static void BM_SpinLock(benchmark::State& state) {
FILE: absl/base/internal/spinlock_wait.cc
type absl (line 34) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/spinlock_wait.h
function namespace (line 26) | namespace absl {
function SpinLockWake (line 83) | inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
function SpinLockDelay (line 88) | inline void absl::base_internal::SpinLockDelay(
FILE: absl/base/internal/strerror.cc
type absl (line 27) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 28) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/strerror.h
function namespace (line 22) | namespace absl {
FILE: absl/base/internal/strerror_benchmark.cc
function BM_AbslStrError (line 23) | void BM_AbslStrError(benchmark::State& state) {
FILE: absl/base/internal/strerror_test.cc
function TEST (line 33) | TEST(StrErrorTest, ValidErrorCode) {
function TEST (line 39) | TEST(StrErrorTest, InvalidErrorCode) {
function TEST (line 47) | TEST(StrErrorTest, MultipleThreads) {
FILE: absl/base/internal/sysinfo.cc
type absl (line 73) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 74) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/sysinfo.h
function namespace (line 36) | namespace absl {
FILE: absl/base/internal/sysinfo_test.cc
type absl (line 30) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 31) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/thread_identity.cc
type absl (line 35) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 36) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/thread_identity.h
function namespace (line 38) | namespace base {
function namespace (line 44) | namespace absl {
FILE: absl/base/internal/thread_identity_benchmark.cc
function BM_SafeCurrentThreadIdentity (line 22) | void BM_SafeCurrentThreadIdentity(benchmark::State& state) {
function BM_UnsafeCurrentThreadIdentity (line 30) | void BM_UnsafeCurrentThreadIdentity(benchmark::State& state) {
FILE: absl/base/internal/thread_identity_test.cc
type absl (line 28) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 29) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/tracing.cc
type absl (line 20) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 21) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/tracing.h
function ABSL_NAMESPACE_BEGIN (line 21) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/tracing_strong_test.cc
type Function (line 31) | enum Function { kWait, kContinue, kSignal, kObserved }
type absl (line 39) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 40) | ABSL_NAMESPACE_BEGIN
function TEST (line 82) | TEST(TracingInternal, InvokesStrongFunctionWithNullptr) {
function TEST (line 98) | TEST(TracingInternal, InvokesStrongFunctionWithObjectAddress) {
FILE: absl/base/internal/tracing_weak_test.cc
function TEST (line 20) | TEST(TracingInternal, HasDefaultImplementation) {
FILE: absl/base/internal/unaligned_access.h
function namespace (line 35) | namespace absl {
FILE: absl/base/internal/unique_small_name_test.cc
function DoNotOptimize (line 25) | void DoNotOptimize(const T& var) {
function TEST (line 36) | TEST(UniqueSmallName, NonAutomaticVar) {
function TEST (line 43) | TEST(UniqueSmallName, FreeFunction) {
function VeryLongFreeFunctionName (line 49) | int VeryLongFreeFunctionName() { return 456; }
type VeryLongStructName (line 51) | struct VeryLongStructName {
function TEST (line 62) | TEST(UniqueSmallName, Struct) {
FILE: absl/base/internal/unscaledcycleclock.cc
type absl (line 39) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 40) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/internal/unscaledcycleclock.h
function namespace (line 50) | namespace absl {
FILE: absl/base/log_severity.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/log_severity.h
function class (line 71) | class LogSeverity : int {
function absl (line 115) | constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
function absl (line 121) | constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
type class (line 136) | enum class
function LogSeverityAtMost (line 151) | enum class LogSeverityAtMost : int {
FILE: absl/base/log_severity_test.cc
function StreamHelper (line 39) | std::string StreamHelper(T value) {
function TEST (line 45) | TEST(StreamTest, Works) {
function TEST_P (line 65) | TEST_P(ParseFlagFromOutOfRangeIntegerTest, ReturnsError) {
function TEST_P (line 77) | TEST_P(ParseFlagFromAlmostOutOfRangeIntegerTest, YieldsExpectedValue) {
function TEST_P (line 101) | TEST_P(ParseFlagFromIntegerMatchingEnumeratorTest, YieldsExpectedValue) {
function TEST_P (line 117) | TEST_P(ParseFlagFromOtherIntegerTest, YieldsExpectedValue) {
function TEST_P (line 155) | TEST_P(ParseFlagFromEnumeratorTest, YieldsExpectedValue) {
function TEST_P (line 168) | TEST_P(ParseFlagFromGarbageTest, ReturnsError) {
function TEST_P (line 183) | TEST_P(UnparseFlagToEnumeratorTest, ReturnsExpectedValueAndRoundTrips) {
function TEST_P (line 199) | TEST_P(UnparseFlagToOtherIntegerTest, ReturnsExpectedValueAndRoundTrips) {
function TEST (line 212) | TEST(LogThresholdTest, LogSeverityAtLeastTest) {
function TEST (line 220) | TEST(LogThresholdTest, LogSeverityAtMostTest) {
function TEST (line 228) | TEST(LogThresholdTest, Extremes) {
function TEST (line 234) | TEST(LogThresholdTest, Output) {
FILE: absl/base/macros.h
function ABSL_NAMESPACE_BEGIN (line 49) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/no_destructor.h
function namespace (line 45) | namespace absl {
FILE: absl/base/no_destructor_benchmark.cc
class BM_Blob (line 36) | class BM_Blob {
method BM_Blob (line 38) | BM_Blob(int val) { for (auto& d : data_) d = val; }
method BM_Blob (line 39) | BM_Blob() : BM_Blob(-1) {}
method Verify (line 40) | void Verify(int val) const { // val must be the c-tor argument
function BM_Blob (line 50) | const BM_Blob& NoDestrBlobFunc() {
method BM_Blob (line 38) | BM_Blob(int val) { for (auto& d : data_) d = val; }
method BM_Blob (line 39) | BM_Blob() : BM_Blob(-1) {}
method Verify (line 40) | void Verify(int val) const { // val must be the c-tor argument
function BM_Blob (line 58) | const BM_Blob& OnHeapBlobFunc() {
method BM_Blob (line 38) | BM_Blob(int val) { for (auto& d : data_) d = val; }
method BM_Blob (line 39) | BM_Blob() : BM_Blob(-1) {}
method Verify (line 40) | void Verify(int val) const { // val must be the c-tor argument
function BM_Direct (line 73) | void BM_Direct(benchmark::State& state) {
function BM_NoDestr (line 80) | void BM_NoDestr(benchmark::State& state) {
function BM_OnHeap (line 87) | void BM_OnHeap(benchmark::State& state) {
type BM_Type (line 100) | enum BM_Type { kNoDestr, kOnHeap, kDirect }
function FuncType (line 105) | FuncType BlobFunc(BM_Type t, int i) {
function FuncType (line 117) | FuncType BlobFunc<0>(BM_Type t, int i) {
function RandIdx (line 132) | int RandIdx(int i) {
function BM_Many (line 139) | void BM_Many(benchmark::State& state) {
function BM_DirectMany (line 157) | void BM_DirectMany(benchmark::State& state) { BM_Many<kDirect>(state); }
function BM_NoDestrMany (line 158) | void BM_NoDestrMany(benchmark::State& state) { BM_Many<kNoDestr>(state); }
function BM_OnHeapMany (line 159) | void BM_OnHeapMany(benchmark::State& state) { BM_Many<kOnHeap>(state); }
FILE: absl/base/no_destructor_test.cc
type Blob (line 30) | struct Blob {
method Blob (line 31) | Blob() : val(42) {}
method Blob (line 32) | Blob(int x, int y) : val(x + y) {}
method Blob (line 33) | Blob(std::initializer_list<int> xs) {
method Blob (line 38) | Blob(const Blob& /*b*/) = delete;
method Blob (line 39) | Blob(Blob&& b) noexcept : val(b.val) {
type TypeWithDeletedDestructor (line 51) | struct TypeWithDeletedDestructor {
function TEST (line 55) | TEST(NoDestructorTest, DestructorNeverCalled) {
function TEST (line 60) | TEST(NoDestructorTest, Noncopyable) {
function TEST (line 74) | TEST(NoDestructorTest, Interface) {
function TEST (line 106) | TEST(NoDestructorTest, SfinaeRegressionAbstractArg) {
function MyArray (line 156) | const MyArray& Array() {
function MyVector (line 164) | const MyVector& Vector() {
function TEST (line 174) | TEST(NoDestructorTest, StaticPattern) {
function TEST (line 199) | TEST(NoDestructorTest, ClassTemplateArgumentDeduction) {
FILE: absl/base/nullability_default_nonnull_test.cc
function ABSL_POINTERS_DEFAULT_NONNULL (line 20) | ABSL_POINTERS_DEFAULT_NONNULL
FILE: absl/base/nullability_test.cc
function funcWithNonnullArg (line 24) | void funcWithNonnullArg(int* absl_nonnull /*arg*/) {}
function funcWithDeducedNonnullArg (line 26) | void funcWithDeducedNonnullArg(T* absl_nonnull /*arg*/) {}
function TEST (line 28) | TEST(NonnullTest, NonnullArgument) {
function TEST (line 39) | TEST(NonnullTest, NonnullReturn) {
function TEST (line 44) | TEST(PassThroughTest, PassesThroughRawPointerToInt) {
function TEST (line 50) | TEST(PassThroughTest, PassesThroughRawPointerToVoid) {
function TEST (line 56) | TEST(PassThroughTest, PassesThroughUniquePointerToInt) {
function TEST (line 63) | TEST(PassThroughTest, PassesThroughSharedPointerToInt) {
function TEST (line 70) | TEST(PassThroughTest, PassesThroughSharedPointerToVoid) {
function TEST (line 77) | TEST(PassThroughTest, PassesThroughPointerToMemberObject) {
function TEST (line 84) | TEST(PassThroughTest, PassesThroughPointerToMemberFunction) {
FILE: absl/base/optimization_test.cc
function TEST (line 28) | TEST(PredictTest, PredictTrue) {
function TEST (line 41) | TEST(PredictTest, PredictFalse) {
function TEST (line 54) | TEST(PredictTest, OneEvaluation) {
function TEST (line 63) | TEST(PredictTest, OperatorOrder) {
function TEST (line 72) | TEST(PredictTest, Pointer) {
function TEST (line 82) | TEST(PredictTest, Optional) {
class ImplicitlyConvertibleToBool (line 92) | class ImplicitlyConvertibleToBool {
method ImplicitlyConvertibleToBool (line 94) | explicit ImplicitlyConvertibleToBool(bool value) : value_(value) {}
function TEST (line 103) | TEST(PredictTest, ImplicitBoolConversion) {
class ExplicitlyConvertibleToBool (line 112) | class ExplicitlyConvertibleToBool {
method ExplicitlyConvertibleToBool (line 114) | explicit ExplicitlyConvertibleToBool(bool value) : value_(value) {}
function TEST (line 121) | TEST(PredictTest, ExplicitBoolConversion) {
function TEST (line 132) | TEST(AbslAssume, Compiles) {
FILE: absl/base/prefetch.h
function namespace (line 41) | namespace absl {
FILE: absl/base/prefetch_test.cc
function TEST (line 28) | TEST(PrefetchTest, PrefetchToLocalCache_StackA) {
function TEST (line 35) | TEST(PrefetchTest, PrefetchToLocalCache_Heap) {
function TEST (line 52) | TEST(PrefetchTest, PrefetchToLocalCache_Nullptr) {
function TEST (line 58) | TEST(PrefetchTest, PrefetchToLocalCache_InvalidPtr) {
FILE: absl/base/raw_logging_test.cc
function TEST (line 28) | TEST(RawLoggingCompilationTest, Log) {
function TEST (line 38) | TEST(RawLoggingCompilationTest, LogWithNulls) {
function TEST (line 42) | TEST(RawLoggingCompilationTest, PassingCheck) {
function TEST (line 46) | TEST(RawLoggingCompilationTest, DebugLog) {
function TEST (line 50) | TEST(RawLoggingCompilationTest, PassingDebugCheck) {
function TEST (line 61) | TEST(RawLoggingDeathTest, FailingDebugCheck) {
function TEST (line 67) | TEST(RawLoggingDeathTest, FailingCheck) {
function TEST (line 72) | TEST(RawLoggingDeathTest, LogFatal) {
function TEST (line 77) | TEST(InternalLog, CompilationTest) {
function TEST (line 88) | TEST(InternalLogDeathTest, FailingCheck) {
function TEST (line 93) | TEST(InternalLogDeathTest, LogFatal) {
FILE: absl/base/spinlock_test_common.cc
type absl (line 41) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 42) | ABSL_NAMESPACE_BEGIN
FILE: absl/base/thread_annotations.h
function namespace (line 312) | namespace absl {
FILE: absl/base/throw_delegate.cc
type absl (line 25) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 26) | ABSL_NAMESPACE_BEGIN
function ThrowStdLogicError (line 36) | void ThrowStdLogicError(const char* what_arg) {
function ThrowStdInvalidArgument (line 44) | void ThrowStdInvalidArgument(const std::string& what_arg) {
function ThrowStdInvalidArgument (line 52) | void ThrowStdInvalidArgument(const char* what_arg) {
function ThrowStdDomainError (line 61) | void ThrowStdDomainError(const std::string& what_arg) {
function ThrowStdDomainError (line 69) | void ThrowStdDomainError(const char* what_arg) {
function ThrowStdLengthError (line 78) | void ThrowStdLengthError(const std::string& what_arg) {
function ThrowStdLengthError (line 86) | void ThrowStdLengthError(const char* what_arg) {
function ThrowStdOutOfRange (line 95) | void ThrowStdOutOfRange(const std::string& what_arg) {
function ThrowStdOutOfRange (line 103) | void ThrowStdOutOfRange(const char* what_arg) {
function ThrowStdRuntimeError (line 112) | void ThrowStdRuntimeError(const std::string& what_arg) {
function ThrowStdRuntimeError (line 120) | void ThrowStdRuntimeError(const char* what_arg) {
function ThrowStdRangeError (line 129) | void ThrowStdRangeError(const std::string& what_arg) {
function ThrowStdRangeError (line 137) | void ThrowStdRangeError(const char* what_arg) {
function ThrowStdOverflowError (line 146) | void ThrowStdOverflowError(const std::string& what_arg) {
function ThrowStdOverflowError (line 154) | void ThrowStdOverflowError(const char* what_arg) {
function ThrowStdUnderflowError (line 163) | void ThrowStdUnderflowError(const std::string& what_arg) {
function ThrowStdUnderflowError (line 171) | void ThrowStdUnderflowError(const char* what_arg) {
function ThrowStdBadFunctionCall (line 180) | void ThrowStdBadFunctionCall() {
function ThrowStdBadAlloc (line 188) | void ThrowStdBadAlloc() {
function ThrowStdBadArrayNewLength (line 196) | void ThrowStdBadArrayNewLength() {
FILE: absl/base/throw_delegate.h
function namespace (line 22) | namespace absl {
FILE: absl/base/throw_delegate_test.cc
function ExpectThrowChar (line 42) | void ExpectThrowChar(void (*f)(const char*)) {
function ExpectThrowString (line 56) | void ExpectThrowString(void (*f)(const std::string&)) {
function ExpectThrowNoWhat (line 70) | void ExpectThrowNoWhat(void (*f)()) {
function TEST (line 82) | TEST(ThrowDelegate, ThrowStdLogicErrorChar) {
function TEST (line 86) | TEST(ThrowDelegate, ThrowStdInvalidArgumentChar) {
function TEST (line 90) | TEST(ThrowDelegate, ThrowStdDomainErrorChar) {
function TEST (line 94) | TEST(ThrowDelegate, ThrowStdLengthErrorChar) {
function TEST (line 98) | TEST(ThrowDelegate, ThrowStdOutOfRangeChar) {
function TEST (line 102) | TEST(ThrowDelegate, ThrowStdRuntimeErrorChar) {
function TEST (line 106) | TEST(ThrowDelegate, ThrowStdRangeErrorChar) {
function TEST (line 110) | TEST(ThrowDelegate, ThrowStdOverflowErrorChar) {
function TEST (line 114) | TEST(ThrowDelegate, ThrowStdUnderflowErrorChar) {
function TEST (line 118) | TEST(ThrowDelegate, ThrowStdLogicErrorString) {
function TEST (line 122) | TEST(ThrowDelegate, ThrowStdInvalidArgumentString) {
function TEST (line 126) | TEST(ThrowDelegate, ThrowStdDomainErrorString) {
function TEST (line 130) | TEST(ThrowDelegate, ThrowStdLengthErrorString) {
function TEST (line 134) | TEST(ThrowDelegate, ThrowStdOutOfRangeString) {
function TEST (line 138) | TEST(ThrowDelegate, ThrowStdRuntimeErrorString) {
function TEST (line 142) | TEST(ThrowDelegate, ThrowStdRangeErrorString) {
function TEST (line 146) | TEST(ThrowDelegate, ThrowStdOverflowErrorString) {
function TEST (line 150) | TEST(ThrowDelegate, ThrowStdUnderflowErrorString) {
function TEST (line 154) | TEST(ThrowDelegate, ThrowStdBadFunctionCallNoWhat) {
function TEST (line 158) | TEST(ThrowDelegate, ThrowStdBadAllocNoWhat) {
function TEST (line 162) | TEST(ThrowDelegate, ThrowStdBadArrayNewLength) {
FILE: absl/cleanup/cleanup.h
function namespace (line 81) | namespace absl {
FILE: absl/cleanup/cleanup_test.cc
function IsSame (line 30) | constexpr bool IsSame() {
type IdentityFactory (line 34) | struct IdentityFactory {
method Callback (line 36) | static Callback AsCallback(Callback callback) {
class FunctorClass (line 44) | class FunctorClass {
method FunctorClass (line 48) | explicit FunctorClass(Callback callback) : callback_(std::move(callbac...
method FunctorClass (line 50) | FunctorClass(FunctorClass&& other)
method FunctorClass (line 53) | FunctorClass(const FunctorClass&) = delete;
method FunctorClass (line 55) | FunctorClass& operator=(const FunctorClass&) = delete;
method FunctorClass (line 57) | FunctorClass& operator=(FunctorClass&&) = delete;
type FunctorClassFactory (line 71) | struct FunctorClassFactory {
method FunctorClass (line 73) | static FunctorClass AsCallback(Callback callback) {
type StdFunctionFactory (line 78) | struct StdFunctionFactory {
method AsCallback (line 80) | static std::function<void()> AsCallback(Callback callback) {
type CleanupTest (line 88) | struct CleanupTest : public ::testing::Test {}
function FnPtrFunction (line 92) | void FnPtrFunction() { fn_ptr_called = true; }
function TYPED_TEST (line 94) | TYPED_TEST(CleanupTest, FactoryProducesCorrectType) {
function TYPED_TEST (line 119) | TYPED_TEST(CleanupTest, CTADProducesCorrectType) {
function TYPED_TEST (line 144) | TYPED_TEST(CleanupTest, FactoryAndCTADProduceSameType) {
function TYPED_TEST (line 189) | TYPED_TEST(CleanupTest, BasicUsage) {
function TYPED_TEST (line 201) | TYPED_TEST(CleanupTest, BasicUsageWithFunctionPointer) {
function TYPED_TEST (line 212) | TYPED_TEST(CleanupTest, Cancel) {
function TYPED_TEST (line 227) | TYPED_TEST(CleanupTest, Invoke) {
function TYPED_TEST (line 244) | TYPED_TEST(CleanupTest, Move) {
type DestructionCounter (line 267) | struct DestructionCounter {
function TYPED_TEST (line 273) | TYPED_TEST(CleanupTest, DestructorDestroys) {
function TYPED_TEST (line 283) | TYPED_TEST(CleanupTest, CancelDestroys) {
function TYPED_TEST (line 296) | TYPED_TEST(CleanupTest, InvokeDestroys) {
FILE: absl/cleanup/internal/cleanup.h
function namespace (line 26) | namespace absl {
FILE: absl/container/btree_benchmark.cc
type absl (line 46) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 47) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/btree_map.h
function namespace (line 71) | namespace absl {
function namespace (line 880) | namespace container_internal {
FILE: absl/container/btree_set.h
function namespace (line 69) | namespace absl {
function namespace (line 793) | namespace container_internal {
FILE: absl/container/btree_test.cc
type absl (line 54) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 55) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/btree_test.h
function namespace (line 31) | namespace absl {
FILE: absl/container/chunked_queue.h
function namespace (line 115) | namespace absl {
function chunked_queue (line 219) | chunked_queue(allocator_type()) {}
function explicit (line 222) | explicit chunked_queue(const allocator_type& alloc)
function explicit (line 226) | explicit chunked_queue(size_type count,
function alloc_and_size_ (line 245) | alloc_and_size_(alloc) {
function chunked_queue (line 258) | chunked_queue(const chunked_queue& other)
function alloc_and_size_ (line 265) | alloc_and_size_(alloc) {
function assign (line 396) | void assign(size_type count, const T& value) {
function assign (line 404) | void assign(std::initializer_list<T> il) { assign(il.begin(), il.end()); }
function push_back (line 408) | void push_back(const T& val) { emplace_back(val); }
function push_back (line 409) | void push_back(T&& val) { emplace_back(std::move(val)); }
function swap (line 451) | void swap(chunked_queue& other) noexcept {
function iterator (line 473) | iterator begin() { return head_; }
function iterator (line 474) | iterator end() { return tail_; }
type AllocatorAndSize (line 490) | struct AllocatorAndSize
function Construct (line 510) | void Construct(T* start, T* limit) {
function Destroy (line 517) | size_t Destroy(T* start, T* limit) {
function T (line 526) | T* block_begin(Block* b) const {
function T (line 529) | T* block_end(Block* b) const {
function NewBlockSize (line 538) | size_t NewBlockSize() {
FILE: absl/container/chunked_queue_benchmark.cc
class forward_list_queue (line 33) | class forward_list_queue {
method forward_list_queue (line 37) | forward_list_queue() = default;
method emplace_back (line 41) | void emplace_back(Args&&... args) {
method push_back (line 51) | void push_back(const T& value) { emplace_back(value); }
method iterator (line 52) | iterator begin() { return list_.begin(); }
method iterator (line 53) | iterator end() { return list_.end(); }
method T (line 54) | T& front() { return list_.front(); }
method T (line 55) | const T& front() const { return list_.front(); }
method pop_front (line 56) | void pop_front() { list_.pop_front(); }
method empty (line 57) | bool empty() const { return list_.empty(); }
method clear (line 58) | void clear() { list_.clear(); }
class Element (line 76) | class Element {
method Element (line 78) | Element() : Element(-1) {}
method Element (line 79) | Element(int type) : type_(type) {}
function Q (line 89) | Q MakeQueue(int64_t num_elements) {
function CustomArgs (line 97) | void CustomArgs(benchmark::internal::Benchmark* b) {
function BM_construct (line 104) | void BM_construct(benchmark::State& state) {
function BM_destroy (line 123) | void BM_destroy(benchmark::State& state) {
function BM_push_back (line 149) | void BM_push_back(benchmark::State& state) {
function BM_pop_front (line 174) | void BM_pop_front(benchmark::State& state) {
function BM_clear (line 199) | void BM_clear(benchmark::State& state) {
function BM_iter (line 224) | void BM_iter(benchmark::State& state) {
function BM_resize_shrink (line 250) | void BM_resize_shrink(benchmark::State& state) {
function BM_resize_grow (line 276) | void BM_resize_grow(benchmark::State& state) {
function BM_assign_shrink (line 302) | void BM_assign_shrink(benchmark::State& state) {
function BM_assign_grow (line 328) | void BM_assign_grow(benchmark::State& state) {
function BM_push_pop (line 354) | void BM_push_pop(benchmark::State& state) {
FILE: absl/container/chunked_queue_test.cc
type adl_namespace (line 42) | namespace adl_namespace {
function TEST (line 44) | TEST(ChunkedQueueADLTest, Swap) {
function TEST (line 63) | TEST(Internal, elements_in_bytes) {
function TEST (line 73) | TEST(Internal, BlockSizedDelete) {
function BlockSizeRounding (line 84) | void BlockSizeRounding() {
function TEST (line 98) | TEST(Internal, BlockSizeRounding1) { BlockSizeRounding<1>(); }
function TEST (line 99) | TEST(Internal, BlockSizeRounding17) { BlockSizeRounding<17>(); }
function TEST (line 100) | TEST(Internal, BlockSizeRounding101) { BlockSizeRounding<101>(); }
function TEST (line 101) | TEST(Internal, BlockSizeRounding528) { BlockSizeRounding<528>(); }
function TEST (line 103) | TEST(ChunkedQueue, MinMaxBlockSize) {
function TEST (line 108) | TEST(ChunkedQueue, Empty) {
function TEST (line 121) | TEST(ChunkedQueue, CopyConstruct) {
function TEST (line 129) | TEST(ChunkedQueue, CopyConstructMultipleChunks) {
function TEST (line 139) | TEST(ChunkedQueue, BeginEndConstruct) {
function TEST (line 146) | TEST(ChunkedQueue, InitializerListConstruct) {
function TEST (line 152) | TEST(ChunkedQueue, CountConstruct) {
function TEST (line 158) | TEST(ChunkedQueue, CountValueConstruct) {
function TEST (line 164) | TEST(ChunkedQueue, InitializerListAssign) {
function TEST (line 171) | TEST(ChunkedQueue, CopyAssign) {
function TEST (line 178) | TEST(ChunkedQueue, CopyAssignSelf) {
function TEST (line 186) | TEST(ChunkedQueue, CopyAssignDestinationBigger) {
function TEST (line 198) | TEST(ChunkedQueue, CopyAssignSourceBiggerMultipleChunks) {
function TEST (line 210) | TEST(ChunkedQueue, CopyAssignDestinationBiggerMultipleChunks) {
function TEST (line 222) | TEST(ChunkedQueue, AssignCountValue) {
function TEST (line 233) | TEST(ChunkedQueue, MoveConstruct) {
function TEST (line 241) | TEST(ChunkedQueue, MoveAssign) {
function TEST (line 250) | TEST(ChunkedQueue, MoveAssignImmovable) {
function TEST (line 266) | TEST(ChunkedQueue, MoveAssignSelf) {
function TEST (line 275) | TEST(ChunkedQueue, MoveAssignDestinationBigger) {
function TEST (line 287) | TEST(ChunkedQueue, MoveAssignDestinationBiggerMultipleChunks) {
function TEST (line 299) | TEST(ChunkedQueue, ConstFrontBack) {
function TEST (line 326) | TEST(ChunkedQueue, PushAndPop) {
function TEST (line 346) | TEST(ChunkedQueue, Swap) {
function TEST (line 372) | TEST(ChunkedQueue, ShrinkToFit) {
function TEST (line 389) | TEST(ChunkedQueue, ResizeExtends) {
function TEST (line 396) | TEST(ChunkedQueue, ResizeShrinks) {
function TEST (line 405) | TEST(ChunkedQueue, ResizeExtendsMultipleBlocks) {
function TEST (line 412) | TEST(ChunkedQueue, ResizeShrinksMultipleBlocks) {
function TEST (line 422) | TEST(ChunkedQueue, ResizeValue) {
function TEST (line 437) | TEST(ChunkedQueue, MaxSize) {
function TEST (line 443) | TEST(ChunkedQueue, AssignExtends) {
function TEST (line 451) | TEST(ChunkedQueue, AssignShrinks) {
function TEST (line 459) | TEST(ChunkedQueue, AssignBoundaryCondition) {
function TEST (line 483) | TEST(ChunkedQueue, Iterator) {
function TEST (line 516) | TEST(ChunkedQueue, IteratorDefaultConstructor) {
function TEST (line 525) | TEST(ChunkedQueue, IteratorConversion) {
type TestEntry (line 540) | struct TestEntry {
function TEST (line 544) | TEST(ChunkedQueue, Iterator2) {
function TEST (line 564) | TEST(ChunkedQueue, Iterator_MultipleBlocks) {
function TEST (line 590) | TEST(ChunkedQueue, Iterator_PopFrontInvalidate) {
function TEST (line 606) | TEST(ChunkedQueue, Iterator_PushBackInvalidate) {
type MyType (line 617) | struct MyType {
method MyType (line 621) | explicit MyType(int x) : val(x) { constructor_calls++; }
method MyType (line 622) | MyType(const MyType& t) : val(t.val) { constructor_calls++; }
function TEST (line 631) | TEST(ChunkedQueue, ConstructorDestructorCalls) {
function TEST (line 658) | TEST(ChunkedQueue, MoveObjects) {
function TEST (line 669) | TEST(ChunkedQueue, EmplaceBack1) {
function TEST (line 677) | TEST(ChunkedQueue, EmplaceBack2) {
function TEST (line 684) | TEST(ChunkedQueue, OveralignmentEmplaceBack) {
function TEST (line 696) | TEST(ChunkedQueue, StatelessAllocatorDoesntAffectObjectSizes) {
function TEST (line 728) | TEST(ChunkedQueue, DoesNotRoundBlockSizesUpWithNonDefaultAllocator) {
function TEST (line 748) | TEST(ChunkedQueue, Hardening) {
FILE: absl/container/fixed_array.h
function namespace (line 56) | namespace absl {
function size_type (line 191) | constexpr size_type max_size() const {
function pointer (line 216) | pointer data() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function reference (line 224) | reference operator[](size_type i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function const_reference (line 232) | const_reference operator[](size_type i) const ABSL_ATTRIBUTE_LIFETIME_BO...
function reference (line 241) | reference at(size_type i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function const_reference (line 250) | const_reference at(size_type i) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function reference (line 260) | reference front() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function reference (line 275) | reference back() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 290) | iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
function const_iterator (line 294) | const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return data...
function iterator (line 306) | iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND { return data() + size(); }
function const_iterator (line 317) | const_iterator cend() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return end(); }
function const_reverse_iterator (line 328) | const_reverse_iterator rbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function reverse_iterator (line 342) | reverse_iterator rend() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function const_reverse_iterator (line 348) | const_reverse_iterator rend() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function fill (line 362) | void fill(const value_type& val) { std::fill(begin(), end(), val); }
function H (line 392) | H AbslHashValue(H h, const FixedArray& v) {
function pointer (line 427) | static pointer AsValueType(pointer ptr) { return ptr; }
function pointer (line 428) | static pointer AsValueType(StorageElementWrapper<value_type>* ptr) {
function class (line 435) | class NonEmptyInlinedStorage {
function class (line 453) | class EmptyInlinedStorage {
function class (line 472) | class Storage : public InlinedStorage {
function StorageElement (line 486) | StorageElement* begin() const { return data_; }
function StorageElement (line 487) | StorageElement* end() const { return begin() + size(); }
function StorageElement (line 501) | StorageElement* InitializeData() {
FILE: absl/container/fixed_array_benchmark.cc
class SimpleClass (line 26) | class SimpleClass {
method SimpleClass (line 28) | SimpleClass() : i(3) {}
function BM_FixedArray (line 36) | void BM_FixedArray(benchmark::State& state) {
FILE: absl/container/fixed_array_exception_safety_test.cc
type absl (line 25) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 26) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/fixed_array_test.cc
function IsOnStack (line 46) | static bool IsOnStack(const ArrayType& a) {
class ConstructionTester (line 50) | class ConstructionTester {
method ConstructionTester (line 52) | ConstructionTester() : self_ptr_(this), value_(0) { constructions++; }
method CheckConstructed (line 64) | void CheckConstructed() { assert(self_ptr_ == this); }
method set (line 66) | void set(int value) { value_ = value; }
method get (line 67) | int get() { return value_; }
class ThreeInts (line 82) | class ThreeInts {
method ThreeInts (line 84) | ThreeInts() {
function TEST (line 98) | TEST(FixedArrayTest, CopyCtor) {
function TEST (line 112) | TEST(FixedArrayTest, MoveCtor) {
function TEST (line 133) | TEST(FixedArrayTest, SmallObjects) {
function TEST (line 190) | TEST(FixedArrayTest, AtThrows) {
function TEST (line 197) | TEST(FixedArrayTest, Hardened) {
function TEST (line 212) | TEST(FixedArrayRelationalsTest, EqualArrays) {
function TEST (line 233) | TEST(FixedArrayRelationalsTest, UnequalArrays) {
function TestArray (line 256) | static void TestArray(int n) {
function TestArrayOfArrays (line 300) | static void TestArrayOfArrays(int n) {
function TEST (line 360) | TEST(IteratorConstructorTest, NonInline) {
function TEST (line 370) | TEST(IteratorConstructorTest, Inline) {
function TEST (line 380) | TEST(IteratorConstructorTest, NonPod) {
function TEST (line 391) | TEST(IteratorConstructorTest, FromEmptyVector) {
function TEST (line 398) | TEST(IteratorConstructorTest, FromNonEmptyVector) {
function TEST (line 408) | TEST(IteratorConstructorTest, FromBidirectionalIteratorRange) {
function TEST (line 415) | TEST(IteratorConstructorTest, FromCpp20ForwardIteratorRange) {
function TEST (line 429) | TEST(InitListConstructorTest, InitListConstruction) {
function TEST (line 434) | TEST(FillConstructorTest, NonEmptyArrays) {
function TEST (line 442) | TEST(FillConstructorTest, EmptyArray) {
function TEST (line 448) | TEST(FillConstructorTest, NotTriviallyCopyable) {
function TEST (line 456) | TEST(FillConstructorTest, Disambiguation) {
function TEST (line 461) | TEST(FixedArrayTest, ManySizedArrays) {
function TEST (line 473) | TEST(FixedArrayTest, ManySizedArraysOfArraysOf1) {
function TEST (line 482) | TEST(FixedArrayTest, ManySizedArraysOfArraysOf2) {
function TEST (line 496) | TEST(FixedArrayTest, AvoidParanoidDiagnostics) {
function TEST (line 501) | TEST(FixedArrayTest, TooBigInlinedSpace) {
type PickyDelete (line 525) | struct PickyDelete {
method PickyDelete (line 526) | PickyDelete() {}
function TEST (line 538) | TEST(FixedArrayTest, UsesGlobalAlloc) {
function TEST (line 543) | TEST(FixedArrayTest, Data) {
function TEST (line 554) | TEST(FixedArrayTest, Empty) {
function TEST (line 563) | TEST(FixedArrayTest, FrontAndBack) {
function TEST (line 576) | TEST(FixedArrayTest, ReverseIteratorInlined) {
function TEST (line 603) | TEST(FixedArrayTest, ReverseIteratorAllocated) {
function TEST (line 630) | TEST(FixedArrayTest, Fill) {
function TEST (line 646) | TEST(FixedArrayTest, DefaultCtorDoesNotValueInit) {
function TEST (line 663) | TEST(AllocatorSupportTest, CountInlineAllocations) {
function TEST (line 684) | TEST(AllocatorSupportTest, CountOutoflineAllocations) {
function TEST (line 705) | TEST(AllocatorSupportTest, CountCopyInlineAllocations) {
function TEST (line 733) | TEST(AllocatorSupportTest, CountCopyOutoflineAllocations) {
function TEST (line 761) | TEST(AllocatorSupportTest, SizeValAllocConstructor) {
function TEST (line 791) | TEST(AllocatorSupportTest, PropagatesStatefulAllocator) {
function TEST (line 809) | TEST(FixedArrayTest, AddressSanitizerAnnotations1) {
function TEST (line 820) | TEST(FixedArrayTest, AddressSanitizerAnnotations2) {
function TEST (line 831) | TEST(FixedArrayTest, AddressSanitizerAnnotations3) {
function TEST (line 840) | TEST(FixedArrayTest, AddressSanitizerAnnotations4) {
function TEST (line 857) | TEST(FixedArrayTest, AbslHashValueWorks) {
FILE: absl/container/flat_hash_map.h
function namespace (line 48) | namespace absl {
function namespace (line 607) | namespace container_internal {
function construct (line 654) | void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
FILE: absl/container/flat_hash_map_test.cc
type absl (line 41) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 42) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/flat_hash_set.h
function namespace (line 49) | namespace absl {
function namespace (line 511) | namespace container_internal {
function construct (line 552) | void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
function T (line 564) | static T& element(slot_type* slot) { return *slot; }
FILE: absl/container/flat_hash_set_test.cc
type absl (line 45) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 46) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/hash_container_defaults.h
function namespace (line 21) | namespace absl {
FILE: absl/container/inlined_vector.h
function namespace (line 60) | namespace absl {
function resize (line 602) | void resize(size_type n) {
function resize (line 612) | void resize(size_type n, const_reference v) {
function iterator (line 621) | iterator insert(const_iterator pos,
function iterator (line 628) | iterator insert(const_iterator pos,
function iterator (line 636) | iterator insert(const_iterator pos, size_type n,
function iterator (line 665) | iterator insert(const_iterator pos, std::initializer_list<value_type> list)
function push_back (line 752) | void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
function push_back (line 756) | void push_back(value_type&& v) {
function pop_back (line 763) | void pop_back() noexcept {
function iterator (line 776) | iterator erase(const_iterator pos) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 801) | iterator erase(const_iterator from,
function clear (line 818) | void clear() noexcept {
function reserve (line 827) | void reserve(size_type n) { storage_.Reserve(n); }
function shrink_to_fit (line 837) | void shrink_to_fit() {
function swap (line 846) | void swap(InlinedVector& other) {
function MoveAssignment (line 856) | void MoveAssignment(MemcpyPolicy, InlinedVector&& other) {
function DestroyExistingAndAdopt (line 877) | void DestroyExistingAndAdopt(InlinedVector&& other) {
function MoveAssignment (line 888) | void MoveAssignment(ElementwiseAssignPolicy, InlinedVector&& other) {
function MoveAssignment (line 902) | void MoveAssignment(ElementwiseConstructPolicy, InlinedVector&& other) {
FILE: absl/container/inlined_vector_benchmark.cc
function BM_InlinedVectorFill (line 27) | void BM_InlinedVectorFill(benchmark::State& state) {
function BM_InlinedVectorFillRange (line 41) | void BM_InlinedVectorFillRange(benchmark::State& state) {
function BM_StdVectorFill (line 54) | void BM_StdVectorFill(benchmark::State& state) {
function StringRepresentedInline (line 72) | bool StringRepresentedInline(std::string s) {
function GetNonShortStringOptimizationSize (line 78) | int GetNonShortStringOptimizationSize() {
function BM_InlinedVectorFillString (line 90) | void BM_InlinedVectorFillString(benchmark::State& state) {
function BM_StdVectorFillString (line 106) | void BM_StdVectorFillString(benchmark::State& state) {
type Buffer (line 122) | struct Buffer { // some arbitrary structure for benchmarking.
function BM_InlinedVectorAssignments (line 129) | void BM_InlinedVectorAssignments(benchmark::State& state) {
function BM_CreateFromContainer (line 151) | void BM_CreateFromContainer(benchmark::State& state) {
type LargeCopyableOnly (line 161) | struct LargeCopyableOnly {
method LargeCopyableOnly (line 162) | LargeCopyableOnly() : d(1024, 17) {}
method LargeCopyableOnly (line 163) | LargeCopyableOnly(const LargeCopyableOnly& o) = default;
method LargeCopyableOnly (line 164) | LargeCopyableOnly& operator=(const LargeCopyableOnly& o) = default;
type LargeCopyableSwappable (line 169) | struct LargeCopyableSwappable {
method LargeCopyableSwappable (line 170) | LargeCopyableSwappable() : d(1024, 17) {}
method LargeCopyableSwappable (line 172) | LargeCopyableSwappable(const LargeCopyableSwappable& o) = default;
method LargeCopyableSwappable (line 174) | LargeCopyableSwappable& operator=(LargeCopyableSwappable o) {
method swap (line 180) | void swap(LargeCopyableSwappable& a, LargeCopyableSwappable& b) {
type LargeCopyableMovable (line 188) | struct LargeCopyableMovable {
method LargeCopyableMovable (line 189) | LargeCopyableMovable() : d(1024, 17) {}
type LargeCopyableMovableSwappable (line 195) | struct LargeCopyableMovableSwappable {
method LargeCopyableMovableSwappable (line 196) | LargeCopyableMovableSwappable() : d(1024, 17) {}
method LargeCopyableMovableSwappable (line 197) | LargeCopyableMovableSwappable(const LargeCopyableMovableSwappable& o) =
method LargeCopyableMovableSwappable (line 199) | LargeCopyableMovableSwappable(LargeCopyableMovableSwappable&& o) = def...
method LargeCopyableMovableSwappable (line 201) | LargeCopyableMovableSwappable& operator=(LargeCopyableMovableSwappable...
method LargeCopyableMovableSwappable (line 206) | LargeCopyableMovableSwappable& operator=(LargeCopyableMovableSwappable...
method swap (line 209) | void swap(LargeCopyableMovableSwappable& a,
function BM_SwapElements (line 219) | void BM_SwapElements(benchmark::State& state) {
function BM_Sizeof (line 242) | void BM_Sizeof(benchmark::State& state) {
function BM_InlinedVectorIndexInlined (line 270) | void BM_InlinedVectorIndexInlined(benchmark::State& state) {
function BM_InlinedVectorIndexExternal (line 279) | void BM_InlinedVectorIndexExternal(benchmark::State& state) {
function BM_StdVectorIndex (line 288) | void BM_StdVectorIndex(benchmark::State& state) {
function BM_InlinedVectorDataInlined (line 297) | void BM_InlinedVectorDataInlined(benchmark::State& state) {
function BM_InlinedVectorDataExternal (line 306) | void BM_InlinedVectorDataExternal(benchmark::State& state) {
function BM_StdVectorData (line 316) | void BM_StdVectorData(benchmark::State& state) {
function BM_InlinedVectorSizeInlined (line 326) | void BM_InlinedVectorSizeInlined(benchmark::State& state) {
function BM_InlinedVectorSizeExternal (line 335) | void BM_InlinedVectorSizeExternal(benchmark::State& state) {
function BM_StdVectorSize (line 344) | void BM_StdVectorSize(benchmark::State& state) {
function BM_InlinedVectorEmptyInlined (line 353) | void BM_InlinedVectorEmptyInlined(benchmark::State& state) {
function BM_InlinedVectorEmptyExternal (line 362) | void BM_InlinedVectorEmptyExternal(benchmark::State& state) {
function BM_StdVectorEmpty (line 371) | void BM_StdVectorEmpty(benchmark::State& state) {
type TrivialType (line 398) | struct TrivialType {
class NontrivialType (line 402) | class NontrivialType {
method ABSL_ATTRIBUTE_NOINLINE (line 404) | ABSL_ATTRIBUTE_NOINLINE NontrivialType() : val_() {
method ABSL_ATTRIBUTE_NOINLINE (line 408) | ABSL_ATTRIBUTE_NOINLINE NontrivialType(const NontrivialType& other)
method ABSL_ATTRIBUTE_NOINLINE (line 413) | ABSL_ATTRIBUTE_NOINLINE NontrivialType& operator=(
method ABSL_ATTRIBUTE_NOINLINE (line 420) | ABSL_ATTRIBUTE_NOINLINE ~NontrivialType() noexcept {
function BatchedBenchmark (line 429) | void BatchedBenchmark(benchmark::State& state, PrepareVecFn prepare_vec,
function BM_ConstructFromSize (line 450) | void BM_ConstructFromSize(benchmark::State& state) {
function BM_ConstructFromSizeRef (line 466) | void BM_ConstructFromSizeRef(benchmark::State& state) {
function BM_ConstructFromRange (line 484) | void BM_ConstructFromRange(benchmark::State& state) {
function BM_ConstructFromCopy (line 500) | void BM_ConstructFromCopy(benchmark::State& state) {
function BM_ConstructFromMove (line 517) | void BM_ConstructFromMove(benchmark::State& state) {
function BM_CopyTrivial (line 538) | void BM_CopyTrivial(benchmark::State& state) {
function BM_CopyNonTrivial (line 549) | void BM_CopyNonTrivial(benchmark::State& state) {
function BM_AssignSizeRef (line 560) | void BM_AssignSizeRef(benchmark::State& state) {
function BM_AssignRange (line 577) | void BM_AssignRange(benchmark::State& state) {
function BM_AssignFromCopy (line 592) | void BM_AssignFromCopy(benchmark::State& state) {
function BM_AssignFromMove (line 607) | void BM_AssignFromMove(benchmark::State& state) {
function BM_ResizeSize (line 628) | void BM_ResizeSize(benchmark::State& state) {
function BM_ResizeSizeRef (line 643) | void BM_ResizeSizeRef(benchmark::State& state) {
function BM_InsertSizeRef (line 662) | void BM_InsertSizeRef(benchmark::State& state) {
function BM_InsertRange (line 682) | void BM_InsertRange(benchmark::State& state) {
function BM_EmplaceBack (line 702) | void BM_EmplaceBack(benchmark::State& state) {
function BM_PopBack (line 717) | void BM_PopBack(benchmark::State& state) {
function BM_EraseOne (line 732) | void BM_EraseOne(benchmark::State& state) {
function BM_EraseRange (line 750) | void BM_EraseRange(benchmark::State& state) {
function BM_Clear (line 768) | void BM_Clear(benchmark::State& state) {
function BM_Reserve (line 778) | void BM_Reserve(benchmark::State& state) {
function BM_ShrinkToFit (line 793) | void BM_ShrinkToFit(benchmark::State& state) {
function BM_Swap (line 808) | void BM_Swap(benchmark::State& state) {
FILE: absl/container/inlined_vector_exception_safety_test.cc
class TestParams (line 69) | class TestParams {
method GetSizeAt (line 72) | constexpr static size_t GetSizeAt(size_t i) { return kSizes[1 + i]; }
type NoSizeTest (line 112) | struct NoSizeTest : ::testing::Test {}
type OneSizeTest (line 116) | struct OneSizeTest : ::testing::Test {}
type TwoSizeTest (line 120) | struct TwoSizeTest : ::testing::Test {}
function InlinedVectorInvariants (line 124) | bool InlinedVectorInvariants(VecT* vec) {
function NoThrowGuarantee (line 144) | bool NoThrowGuarantee(VecT* /* vec */) {
function TYPED_TEST (line 148) | TYPED_TEST(NoSizeTest, DefaultConstructor) {
function TYPED_TEST (line 157) | TYPED_TEST(OneSizeTest, SizeConstructor) {
function TYPED_TEST (line 167) | TYPED_TEST(OneSizeTest, SizeRefConstructor) {
function TYPED_TEST (line 178) | TYPED_TEST(OneSizeTest, InitializerListConstructor) {
function TYPED_TEST (line 191) | TYPED_TEST(OneSizeTest, RangeConstructor) {
function TYPED_TEST (line 204) | TYPED_TEST(OneSizeTest, CopyConstructor) {
function TYPED_TEST (line 216) | TYPED_TEST(OneSizeTest, MoveConstructor) {
function TYPED_TEST (line 228) | TYPED_TEST(TwoSizeTest, Assign) {
function TYPED_TEST (line 267) | TYPED_TEST(TwoSizeTest, Resize) {
function TYPED_TEST (line 287) | TYPED_TEST(OneSizeTest, Insert) {
function TYPED_TEST (line 310) | TYPED_TEST(TwoSizeTest, Insert) {
function TYPED_TEST (line 363) | TYPED_TEST(OneSizeTest, EmplaceBack) {
function TYPED_TEST (line 386) | TYPED_TEST(OneSizeTest, PopBack) {
function TYPED_TEST (line 399) | TYPED_TEST(OneSizeTest, Erase) {
function TYPED_TEST (line 447) | TYPED_TEST(OneSizeTest, Clear) {
function TYPED_TEST (line 460) | TYPED_TEST(TwoSizeTest, Reserve) {
function TYPED_TEST (line 472) | TYPED_TEST(OneSizeTest, ShrinkToFit) {
function TYPED_TEST (line 485) | TYPED_TEST(TwoSizeTest, Swap) {
FILE: absl/container/inlined_vector_test.cc
class InstanceTest (line 77) | class InstanceTest : public ::testing::Test {}
class RefCounted (line 82) | class RefCounted {
method RefCounted (line 84) | RefCounted(int value, int* count) : value_(value), count_(count) { Ref...
method RefCounted (line 86) | RefCounted(const RefCounted& v) : value_(v.value_), count_(v.count_) {
method swap (line 95) | void swap(RefCounted& a, RefCounted& b) {
method RefCounted (line 101) | RefCounted& operator=(RefCounted v) {
method Ref (line 107) | void Ref() const {
method Unref (line 112) | void Unref() const {
class Dynamic (line 124) | class Dynamic {
function Fill (line 133) | static void Fill(Container* v, size_t len, int offset = 0) {
function IntVec (line 139) | static IntVec Fill(size_t len, int offset = 0) {
function TEST (line 145) | TEST(IntVec, SimpleOps) {
function TEST (line 195) | TEST(IntVec, PopBackNoOverflow) {
function TEST (line 201) | TEST(IntVec, AtThrows) {
function TEST (line 208) | TEST(IntVec, ReverseIterator) {
function TEST (line 238) | TEST(IntVec, Erase) {
function TEST (line 255) | TEST(IntVec, Hardened) {
function TEST (line 269) | TEST(UniquePtr, MoveConstruct) {
function TEST (line 290) | TEST(UniquePtr, MoveAssign) {
function TEST (line 314) | TEST(UniquePtr, Swap) {
function TEST (line 343) | TEST(UniquePtr, EraseSingle) {
function TEST (line 369) | TEST(UniquePtr, EraseMulti) {
function TEST (line 392) | TEST(RefCountedVec, EraseBeginEnd) {
type NoDefaultCtor (line 437) | struct NoDefaultCtor {
method NoDefaultCtor (line 438) | explicit NoDefaultCtor(int) {}
type NoCopy (line 440) | struct NoCopy {
method NoCopy (line 441) | NoCopy() {}
method NoCopy (line 442) | NoCopy(const NoCopy&) = delete;
type NoAssign (line 444) | struct NoAssign {
method NoAssign (line 445) | NoAssign() {}
method NoAssign (line 446) | NoAssign& operator=(const NoAssign&) = delete;
type MoveOnly (line 448) | struct MoveOnly {
method MoveOnly (line 449) | MoveOnly() {}
method MoveOnly (line 450) | MoveOnly(MoveOnly&&) = default;
method MoveOnly (line 451) | MoveOnly& operator=(MoveOnly&&) = default;
function TEST (line 453) | TEST(InlinedVectorTest, NoDefaultCtor) {
function TEST (line 457) | TEST(InlinedVectorTest, NoCopy) {
function TEST (line 461) | TEST(InlinedVectorTest, NoAssign) {
function TEST (line 465) | TEST(InlinedVectorTest, MoveOnly) {
function TEST (line 477) | TEST(InlinedVectorTest, Noexcept) {
function TEST (line 490) | TEST(InlinedVectorTest, EmplaceBack) {
function TEST (line 504) | TEST(InlinedVectorTest, ShrinkToFitGrowingVector) {
function TEST (line 525) | TEST(InlinedVectorTest, ShrinkToFitEdgeCases) {
function TEST (line 567) | TEST(IntVec, Insert) {
function TEST (line 654) | TEST(IntPairVec, Insert) {
function TEST (line 681) | TEST(RefCountedVec, InsertConstructorDestructor) {
function TEST (line 709) | TEST(IntVec, Resize) {
function TEST (line 740) | TEST(IntVec, InitWithLength) {
function TEST (line 751) | TEST(IntVec, CopyConstructorAndAssignment) {
function TEST (line 770) | TEST(IntVec, AliasingCopyAssignment) {
function TEST (line 780) | TEST(IntVec, MoveConstructorAndAssignment) {
class NotTriviallyDestructible (line 817) | class NotTriviallyDestructible {
method NotTriviallyDestructible (line 819) | NotTriviallyDestructible() : p_(new int(1)) {}
method NotTriviallyDestructible (line 820) | explicit NotTriviallyDestructible(int i) : p_(new int(i)) {}
method NotTriviallyDestructible (line 822) | NotTriviallyDestructible(const NotTriviallyDestructible& other)
method NotTriviallyDestructible (line 825) | NotTriviallyDestructible& operator=(const NotTriviallyDestructible& ot...
function TEST (line 838) | TEST(AliasingTest, Emplace) {
function TEST (line 853) | TEST(AliasingTest, InsertWithCount) {
function TEST (line 889) | TEST(OverheadTest, Storage) {
function TEST (line 918) | TEST(IntVec, Clear) {
function TEST (line 931) | TEST(IntVec, Reserve) {
function TEST (line 954) | TEST(StringVec, SelfRefPushBack) {
function TEST (line 969) | TEST(StringVec, SelfRefPushBackWithMove) {
function TEST (line 984) | TEST(StringVec, SelfMove) {
function TEST (line 1002) | TEST(IntVec, Swap) {
function TYPED_TEST_P (line 1027) | TYPED_TEST_P(InstanceTest, Swap) {
function TEST (line 1077) | TEST(IntVec, EqualAndNotEqual) {
function TEST (line 1116) | TEST(IntVec, RelationalOps) {
function TYPED_TEST_P (line 1137) | TYPED_TEST_P(InstanceTest, CountConstructorsDestructors) {
function TYPED_TEST_P (line 1206) | TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnCopyConstructio...
function TYPED_TEST_P (line 1233) | TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnMoveConstructio...
function TYPED_TEST_P (line 1278) | TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnAssignment) {
function TYPED_TEST_P (line 1313) | TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnMoveAssignment) {
function TEST (line 1367) | TEST(CountElemAssign, SimpleTypeWithInlineBacking) {
function TEST (line 1386) | TEST(CountElemAssign, SimpleTypeWithAllocation) {
function TYPED_TEST_P (line 1400) | TYPED_TEST_P(InstanceTest, CountElemAssignInlineBacking) {
function InstanceCountElemAssignWithAllocationTest (line 1419) | void InstanceCountElemAssignWithAllocationTest() {
function TEST (line 1433) | TEST(CountElemAssign, WithAllocationCopyableInstance) {
function TEST (line 1436) | TEST(CountElemAssign, WithAllocationCopyableMovableInstance) {
function TEST (line 1440) | TEST(RangedConstructor, SimpleType) {
function InstanceRangedConstructorTestForContainer (line 1463) | void InstanceRangedConstructorTestForContainer() {
function InstanceRangedConstructorTestWithCapacity (line 1478) | void InstanceRangedConstructorTestWithCapacity() {
function TYPED_TEST_P (line 1503) | TYPED_TEST_P(InstanceTest, RangedConstructor) {
function TEST (line 1511) | TEST(RangedConstructor, ElementsAreConstructed) {
function TEST (line 1521) | TEST(RangedAssign, SimpleType) {
function InstanceValuesEqual (line 1558) | static bool InstanceValuesEqual(const Instance& lhs, const Instance& rhs) {
function InstanceRangedAssignTestForContainer (line 1565) | void InstanceRangedAssignTestForContainer() {
function TYPED_TEST_P (line 1603) | TYPED_TEST_P(InstanceTest, RangedAssign) {
function TEST (line 1617) | TEST(InitializerListConstructor, SimpleTypeWithInlineBacking) {
function TEST (line 1622) | TEST(InitializerListConstructor, SimpleTypeWithReallocationRequired) {
function TEST (line 1627) | TEST(InitializerListConstructor, DisparateTypesInList) {
function TEST (line 1634) | TEST(InitializerListConstructor, ComplexTypeWithInlineBacking) {
function TEST (line 1643) | TEST(InitializerListConstructor, ComplexTypeWithReallocationRequired) {
function TEST (line 1650) | TEST(InitializerListAssign, SimpleTypeFitsInlineBacking) {
function TEST (line 1668) | TEST(InitializerListAssign, SimpleTypeDoesNotFitInlineBacking) {
function TEST (line 1683) | TEST(InitializerListAssign, DisparateTypesInList) {
function TYPED_TEST_P (line 1701) | TYPED_TEST_P(InstanceTest, InitializerListAssign) {
function TEST (line 1734) | TEST(DynamicVec, DynamicVecCompiles) {
function TEST (line 1739) | TEST(DynamicVec, CreateNonEmptyDynamicVec) {
function TEST (line 1744) | TEST(DynamicVec, EmplaceBack) {
function TEST (line 1750) | TEST(DynamicVec, EmplaceBackAfterHeapAllocation) {
function TEST (line 1757) | TEST(DynamicVec, EmptyIteratorComparison) {
function TEST (line 1763) | TEST(AllocatorSupportTest, Constructors) {
function TEST (line 1779) | TEST(AllocatorSupportTest, CountAllocations) {
function TEST (line 1859) | TEST(AllocatorSupportTest, SwapBothAllocated) {
function TEST (line 1888) | TEST(AllocatorSupportTest, SwapOneAllocated) {
function TEST (line 1916) | TEST(AllocatorSupportTest, ScopedAllocatorWorksInlined) {
function TEST (line 1944) | TEST(AllocatorSupportTest, ScopedAllocatorWorksAllocated) {
function TEST (line 1969) | TEST(AllocatorSupportTest, SizeAllocConstructor) {
function TEST (line 1995) | TEST(InlinedVectorTest, MinimumAllocatorCompilesUsingTraits) {
function TEST (line 2019) | TEST(InlinedVectorTest, AbslHashValueWorks) {
class MoveConstructibleOnlyInstance (line 2038) | class MoveConstructibleOnlyInstance
method MoveConstructibleOnlyInstance (line 2041) | explicit MoveConstructibleOnlyInstance(int x) : BaseCountedInstance(x) {}
method MoveConstructibleOnlyInstance (line 2042) | MoveConstructibleOnlyInstance(MoveConstructibleOnlyInstance&& other) =
method MoveConstructibleOnlyInstance (line 2044) | MoveConstructibleOnlyInstance& operator=(
function TEST (line 2052) | TEST(NonAssignableMoveAssignmentTest, AllocatedToInline) {
function TEST (line 2071) | TEST(NonAssignableMoveAssignmentTest, InlineToAllocated) {
function TEST (line 2090) | TEST(NonAssignableMoveAssignmentTest, InlineToInline) {
function TEST (line 2107) | TEST(NonAssignableMoveAssignmentTest, AllocatedToAllocated) {
function TEST (line 2129) | TEST(NonAssignableMoveAssignmentTest, AssignThis) {
class NonSwappableInstance (line 2148) | class NonSwappableInstance : public absl::test_internal::BaseCountedInst...
method NonSwappableInstance (line 2150) | explicit NonSwappableInstance(int x) : BaseCountedInstance(x) {}
method NonSwappableInstance (line 2151) | NonSwappableInstance(const NonSwappableInstance& other) = default;
method NonSwappableInstance (line 2152) | NonSwappableInstance& operator=(const NonSwappableInstance& other) = d...
method NonSwappableInstance (line 2153) | NonSwappableInstance(NonSwappableInstance&& other) = default;
method NonSwappableInstance (line 2154) | NonSwappableInstance& operator=(NonSwappableInstance&& other) = default;
function TEST (line 2159) | TEST(NonSwappableSwapTest, InlineAndAllocatedTransferStorageAndMove) {
function TEST (line 2177) | TEST(NonSwappableSwapTest, InlineAndInlineMoveIndividualElements) {
function TEST (line 2194) | TEST(NonSwappableSwapTest, AllocatedAndAllocatedOnlyTransferStorage) {
function TEST (line 2216) | TEST(NonSwappableSwapTest, SwapThis) {
type MySpan (line 2241) | struct MySpan {
function TEST (line 2246) | TEST(StorageTest, InlinedCapacityAutoIncrease) {
function TEST (line 2260) | TEST(IntVec, EraseIf) {
function TEST (line 2266) | TEST(IntVec, EraseIfMatchesNone) {
function TEST (line 2272) | TEST(IntVec, EraseIfMatchesAll) {
FILE: absl/container/internal/btree.h
function namespace (line 75) | namespace absl {
function init_leaf (line 949) | void init_leaf(field_type position, field_type max_count,
function init_internal (line 960) | void init_internal(field_type position, btree_node *parent) {
function deallocate (line 969) | static void deallocate(const size_type size, btree_node *node,
function value_destroy (line 985) | void value_destroy(const field_type i, allocator_type *alloc) {
function value_destroy_n (line 990) | void value_destroy_n(const field_type i, const field_type n,
function transfer (line 999) | static void transfer(slot_type *dest, slot_type *src, allocator_type *al...
function transfer (line 1006) | void transfer(const size_type dest_i, const size_type src_i,
function transfer_n (line 1014) | void transfer_n(const size_type n, const size_type dest_i,
function transfer_n_backward (line 1027) | void transfer_n_backward(const size_type n, const size_type dest_i,
function class (line 1062) | class btree_iterator_generation_info_enabled {
function class (line 1090) | class btree_iterator_generation_info_disabled {
function explicit (line 1138) | explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
function reference (line 1202) | reference operator*() const {
function pointer (line 1212) | pointer operator->() const { return &operator*(); }
function Equals (line 1264) | bool Equals(const const_iterator other) const {
function increment (line 1295) | void increment() {
function decrement (line 1305) | void decrement() {
function update_generation (line 1322) | void update_generation() {
function node_type (line 1342) | struct EmptyNodeType : node_type {
function node_type (line 1358) | static node_type *EmptyNode() {
type node_stats (line 1368) | struct node_stats {
function btree (line 1422) | btree(const btree &other) : btree(other, other.allocator()) {}
function iterator (line 1454) | iterator begin() { return iterator(leftmost()); }
function iterator (line 1456) | iterator end() { return iterator(rightmost(), rightmost()->finish()); }
function reverse_iterator (line 1460) | reverse_iterator rbegin() { return reverse_iterator(end()); }
function reverse_iterator (line 1464) | reverse_iterator rend() { return reverse_iterator(begin()); }
function verify (line 1596) | void verify() const;
function size_type (line 1604) | size_type height() const {
function size_type (line 1625) | size_type nodes() const {
function average_bytes_per_value (line 1644) | static double average_bytes_per_value() {
function node_type (line 1677) | node_type *root() { return root_; }
function node_type (line 1678) | const node_type *root() const { return root_; }
function node_type (line 1680) | node_type *rightmost() { return rightmost_.template get<2>(); }
function node_type (line 1681) | const node_type *rightmost() const { return rightmost_.template get<2>(); }
function key_compare (line 1685) | key_compare *mutable_key_comp() noexcept {
function node_type (line 1690) | node_type *leftmost() { return root()->parent(); }
function node_type (line 1691) | const node_type *leftmost() const { return root()->parent(); }
function allocator_type (line 1694) | allocator_type *mutable_allocator() noexcept {
function node_type (line 1703) | node_type *allocate(size_type size) {
function node_type (line 1710) | node_type *new_internal_node(field_type position, node_type *parent) {
function node_type (line 1715) | node_type *new_leaf_node(field_type position, node_type *parent) {
function node_type (line 1720) | node_type *new_leaf_root_node(field_type max_count) {
function iterator (line 1745) | iterator internal_end(iterator iter) {
function const_iterator (line 1748) | const_iterator internal_end(const_iterator iter) const {
function node_stats (line 1791) | node_stats internal_stats(const node_type *node) const {
function replace_leaf_root_node (line 2934) | const auto replace_leaf_root_node = [&](field_type new_node_size) {
type btree_access (line 3101) | struct btree_access {
FILE: absl/container/internal/btree_container.h
function namespace (line 32) | namespace absl {
function ABSL_ATTRIBUTE_LIFETIME_BOUND (line 175) | const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 185) | iterator erase(const_iterator iter) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 188) | iterator erase(iterator iter) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 191) | iterator erase(const_iterator first,
function extract_and_get_next_return_type (line 202) | extract_and_get_next_return_type extract_and_get_next(const_iterator pos...
function iterator (line 758) | iterator insert(const value_type &v) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 761) | iterator insert(value_type &&v) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 764) | iterator insert(const_iterator hint,
function iterator (line 768) | iterator insert(const_iterator hint,
function insert (line 776) | void insert(std::initializer_list<init_type> init) {
function iterator (line 795) | iterator insert(node_type &&node) ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 803) | iterator insert(const_iterator hint,
FILE: absl/container/internal/chunked_queue.h
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/common.h
function namespace (line 51) | namespace absl {
function Destroy (line 215) | struct CommonAccess {
function Reset (line 227) | void Reset(Node* node) {
FILE: absl/container/internal/common_policy_traits.h
function namespace (line 27) | namespace absl {
FILE: absl/container/internal/common_policy_traits_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/compressed_tuple.h
function namespace (line 50) | namespace absl {
FILE: absl/container/internal/compressed_tuple_test.cc
type CallType (line 34) | enum class CallType { kMutableRef, kConstRef, kMutableMove, kConstMove }
type Empty (line 37) | struct Empty {
method CallType (line 38) | constexpr CallType value() & { return CallType::kMutableRef; }
method CallType (line 39) | constexpr CallType value() const& { return CallType::kConstRef; }
method CallType (line 40) | constexpr CallType value() && { return CallType::kMutableMove; }
method CallType (line 41) | constexpr CallType value() const&& { return CallType::kConstMove; }
function T (line 46) | constexpr T& AsLValue(T&& t) {
type NotEmpty (line 51) | struct NotEmpty {
type TwoValues (line 56) | struct TwoValues {
type absl (line 62) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 63) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/container_memory.h
function namespace (line 42) | namespace absl {
function SanitizerPoisonMemoryRegion (line 240) | inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
function SanitizerUnpoisonMemoryRegion (line 251) | inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
function SanitizerPoisonObject (line 263) | void SanitizerPoisonObject(const T* object) {
function SanitizerUnpoisonObject (line 268) | void SanitizerUnpoisonObject(const T* object) {
function namespace (line 272) | namespace memory_internal {
function value_type (line 380) | static const value_type& element(const slot_type* slot) {
function K (line 384) | static K& mutable_key(slot_type* slot) {
function K (line 392) | static const K& key(const slot_type* slot) {
function construct (line 397) | void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
function construct (line 410) | void construct(Allocator* alloc, slot_type* slot, slot_type* other) {
function construct (line 423) | void construct(Allocator* alloc, slot_type* slot,
function const (line 517) | size_t operator()(size_t seed) const {
FILE: absl/container/internal/container_memory_test.cc
type absl (line 34) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hash_function_defaults.h
function namespace (line 62) | namespace absl {
type StringHashEq (line 113) | struct StringHashEq {
function StringHashEq (line 119) | struct HashEq<std::string> : StringHashEq {}
function StringHashEq (line 121) | struct HashEq<absl::string_view> : StringHashEq {}
function StringHashEq (line 123) | struct HashEq<absl::Cord> : StringHashEq {}
function const (line 129) | size_t operator()(std::basic_string_view<TChar> v) const {
function const (line 137) | bool operator()(std::basic_string_view<TChar> lhs,
function wchar_t (line 151) | struct HashEq<std::wstring> : BasicStringHashEq<wchar_t> {}
function wchar_t (line 153) | struct HashEq<std::wstring_view> : BasicStringHashEq<wchar_t> {}
type HashEq (line 155) | struct HashEq
type HashEq (line 157) | struct HashEq
type HashEq (line 159) | struct HashEq
type HashEq (line 161) | struct HashEq
type Hash (line 166) | struct Hash {
type Eq (line 173) | struct Eq {
function T (line 184) | const T* ToPtr(const std::unique_ptr<U, D>& ptr) {
function T (line 188) | const T* ToPtr(const std::shared_ptr<U>& ptr) {
FILE: absl/container/internal/hash_function_defaults_test.cc
type absl (line 32) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 617) | ABSL_NAMESPACE_BEGIN
type Hash (line 589) | enum Hash : size_t {
type Hashable (line 601) | struct Hashable {
method HashableBy (line 602) | static constexpr bool HashableBy(Hash h) { return h & H; }
type std (line 605) | namespace std {
type hash<Hashable<H>> (line 607) | struct hash<Hashable<H>> {
type absl (line 616) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 617) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hash_generator_testing.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hash_generator_testing.h
function namespace (line 41) | namespace absl {
FILE: absl/container/internal/hash_policy_testing.h
function namespace (line 32) | namespace absl {
function StatefulTestingHash (line 97) | struct StatefulTestingHash
function StatefulTestingEqual (line 106) | struct StatefulTestingEqual
FILE: absl/container/internal/hash_policy_testing_test.cc
type absl (line 19) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 20) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hash_policy_traits.h
function namespace (line 28) | namespace absl {
FILE: absl/container/internal/hash_policy_traits_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hashtable_control_bytes.h
function namespace (line 48) | namespace absl {
FILE: absl/container/internal/hashtable_control_bytes_test.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hashtable_debug.h
function namespace (line 40) | namespace absl {
FILE: absl/container/internal/hashtable_debug_hooks.h
function namespace (line 28) | namespace absl {
FILE: absl/container/internal/hashtablez_sampler.cc
type absl (line 41) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 42) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hashtablez_sampler.h
function namespace (line 59) | namespace absl {
FILE: absl/container/internal/hashtablez_sampler_force_weak_definition.cc
type absl (line 19) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 20) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/hashtablez_sampler_test.cc
type absl (line 44) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 45) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/heterogeneous_lookup_testing.h
function namespace (line 25) | namespace absl {
FILE: absl/container/internal/inlined_vector.h
function namespace (line 36) | namespace absl {
function Deallocate (line 122) | static void Deallocate(A& allocator, Pointer<A> pointer,
function ConstructNext (line 161) | void ConstructNext(A& allocator, Pointer<A> construct_at) {
function AssignNext (line 166) | void AssignNext(Pointer<A> assign_at) {
function ptr_ (line 178) | ptr_(p) {}
function ConstructNext (line 180) | void ConstructNext(A& allocator, Pointer<A> construct_at) {
function AssignNext (line 184) | void AssignNext(Pointer<A> assign_at) { *assign_at = *ptr_; }
function ConstructNext (line 195) | void ConstructNext(A& allocator, Pointer<A> construct_at) {
function AssignNext (line 199) | void AssignNext(Pointer<A> assign_at) { *assign_at = ValueType<A>(); }
function DidAllocate (line 221) | bool DidAllocate() { return GetData() != nullptr; }
function DidConstruct (line 266) | bool DidConstruct() { return GetData() != nullptr; }
function Commit (line 273) | void Commit() && {
type MemcpyPolicy (line 286) | struct MemcpyPolicy {}
type ElementwiseAssignPolicy (line 287) | struct ElementwiseAssignPolicy {}
type ElementwiseSwapPolicy (line 288) | struct ElementwiseSwapPolicy {}
type ElementwiseConstructPolicy (line 289) | struct ElementwiseConstructPolicy {}
function SizeType (line 324) | static SizeType<A> NextCapacity(SizeType<A> current_capacity) {
function SizeType (line 328) | static SizeType<A> ComputeCapacity(SizeType<A> current_capacity,
function explicit (line 339) | explicit Storage(const A& allocator)
function ABSL_ATTRIBUTE_NO_SANITIZE_CFI (line 396) | ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
function SetIsAllocated (line 453) | void SetIsAllocated() {
function UnsetIsAllocated (line 457) | void UnsetIsAllocated() {
function SetSize (line 461) | void SetSize(SizeType<A> size) {
function SetAllocatedSize (line 466) | void SetAllocatedSize(SizeType<A> size) {
function SetInlinedSize (line 470) | void SetInlinedSize(SizeType<A> size) {
function AddSize (line 474) | void AddSize(SizeType<A> count) {
function SubtractSize (line 478) | void SubtractSize(SizeType<A> count) {
function SetAllocation (line 484) | void SetAllocation(Allocation<A> allocation) {
function MemcpyFrom (line 489) | void MemcpyFrom(const Storage& other_storage) {
function DeallocateIfAllocated (line 521) | void DeallocateIfAllocated() {
type Allocated (line 533) | struct Allocated {
type Inlined (line 544) | struct Inlined {
FILE: absl/container/internal/layout.h
function namespace (line 206) | namespace absl {
function namespace (line 277) | namespace adl_barrier {
function ElementIndex (line 381) | constexpr size_t ElementIndex() {
function explicit (line 400) | constexpr explicit LayoutImpl(IntToSize<RuntimeSizeSeq>... sizes)
function Alignment (line 405) | static constexpr size_t Alignment() {
function Offset (line 418) | size_t Offset() const {
function Size (line 456) | size_t Size() const {
FILE: absl/container/internal/layout_benchmark.cc
function MyAlign (line 34) | constexpr size_t MyAlign(size_t n, size_t m) { return (n + m - 1) & ~(m ...
function BM_OffsetConstantHeadroom (line 38) | void BM_OffsetConstantHeadroom(benchmark::State& state) {
function BM_OffsetConstantStatic (line 45) | void BM_OffsetConstantStatic(benchmark::State& state) {
function BM_OffsetConstant (line 54) | void BM_OffsetConstant(benchmark::State& state) {
function BM_OffsetConstantIndirect (line 64) | void BM_OffsetConstantIndirect(benchmark::State& state) {
function BM_OffsetPartialHeadroom (line 91) | void BM_OffsetPartialHeadroom(benchmark::State& state) {
function BM_OffsetPartialStatic (line 101) | void BM_OffsetPartialStatic(benchmark::State& state) {
function BM_OffsetPartial (line 113) | void BM_OffsetPartial(benchmark::State& state) {
function BM_OffsetVariableHeadroom (line 142) | void BM_OffsetVariableHeadroom(benchmark::State& state) {
function BM_OffsetVariable (line 156) | void BM_OffsetVariable(benchmark::State& state) {
function BM_AllocSizeHeadroom (line 192) | void BM_AllocSizeHeadroom(benchmark::State& state) {
function BM_AllocSizeStatic (line 202) | void BM_AllocSizeStatic(benchmark::State& state) {
function BM_AllocSize (line 213) | void BM_AllocSize(benchmark::State& state) {
function BM_AllocSizeIndirect (line 230) | void BM_AllocSizeIndirect(benchmark::State& state) {
FILE: absl/container/internal/layout_test.cc
type absl (line 37) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 38) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/node_slot_policy.h
function namespace (line 44) | namespace absl {
FILE: absl/container/internal/node_slot_policy_test.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/raw_hash_map.h
function namespace (line 30) | namespace absl {
FILE: absl/container/internal/raw_hash_set.cc
type absl (line 39) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 40) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/raw_hash_set.h
function namespace (line 228) | namespace absl {
type InvalidCapacity (line 379) | enum InvalidCapacity : size_t {
function ctrl_t (line 391) | inline ctrl_t* DefaultIterControl() { return &kDefaultIterControl; }
function ctrl_t (line 399) | inline ctrl_t* SooControl() {
function IsSooControl (line 405) | inline bool IsSooControl(const ctrl_t* ctrl) { return ctrl == SooControl...
function IsEmptyGeneration (line 412) | inline bool IsEmptyGeneration(const GenerationType* generation) {
function SooCapacity (line 423) | constexpr size_t SooCapacity() { return 1; }
type soo_tag_t (line 425) | struct soo_tag_t {}
type full_soo_tag_t (line 427) | struct full_soo_tag_t {}
type non_soo_tag_t (line 429) | struct non_soo_tag_t {}
type uninitialized_tag_t (line 431) | struct uninitialized_tag_t {}
type no_seed_empty_tag_t (line 433) | struct no_seed_empty_tag_t {}
function class (line 438) | class PerTableSeed {
function class (line 464) | class HashtableSize {
function H1 (line 545) | inline size_t H1(size_t hash) { return hash; }
function h2_t (line 550) | inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
function RehashProbabilityConstant (line 559) | inline size_t RehashProbabilityConstant() { return 16; }
function class (line 561) | class CommonFieldsGenerationInfoEnabled {
function class (line 633) | class CommonFieldsGenerationInfoDisabled {
function class (line 656) | class HashSetIteratorGenerationInfoEnabled {
function class (line 673) | class HashSetIteratorGenerationInfoDisabled {
function class (line 712) | class GrowthInfo {
function IsValidCapacity (line 788) | constexpr bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && ...
function IsSmallCapacity (line 791) | constexpr bool IsSmallCapacity(size_t capacity) { return capacity <= 1; }
function NumClonedBytes (line 798) | constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
function NumControlBytes (line 801) | constexpr size_t NumControlBytes(size_t capacity) {
function ControlOffset (line 807) | constexpr size_t ControlOffset(bool has_infoz) {
function AlignUpTo (line 813) | constexpr size_t AlignUpTo(size_t offset, size_t align) {
function class (line 818) | class RawHashSetLayout {
type HashtableFreeFunctionsAccess (line 859) | struct HashtableFreeFunctionsAccess
function T (line 865) | T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
function set (line 866) | void set(T* ptr) { p = ptr; }
type HeapPtrs (line 871) | struct HeapPtrs {
function MaxSooSlotSize (line 888) | constexpr size_t MaxSooSlotSize() { return sizeof(HeapPtrs); }
function control (line 892) | union HeapOrSoo {
function GrowthInfo (line 918) | inline GrowthInfo& GetGrowthInfoFromControl(ctrl_t* control) {
function class (line 928) | class CommonFields : public CommonFieldsGenerationInfo {
function should_rehash_for_bug_detection_on_move (line 1086) | bool should_rehash_for_bug_detection_on_move() const {
function alloc_size (line 1095) | size_t alloc_size(size_t slot_size, size_t slot_align) const {
function move_non_heap_or_soo_fields (line 1101) | void move_non_heap_or_soo_fields(CommonFields& that) {
function HasInfozMask (line 1131) | static constexpr size_t HasInfozMask() {
type FindInfo (line 1404) | struct FindInfo {
function is_single_group (line 1411) | constexpr bool is_single_group(size_t capacity) {
function probe_seq (line 1416) | inline probe_seq<Group::kWidth> probe_h1(size_t capacity, size_t h1) {
function probe_seq (line 1419) | inline probe_seq<Group::kWidth> probe(size_t capacity, size_t hash) {
function probe_seq (line 1422) | inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t...
function BackingArrayAlignment (line 1490) | constexpr size_t BackingArrayAlignment(size_t align_of_slot) {
function ShouldSampleHashtablezInfoForAlloc (line 1502) | bool ShouldSampleHashtablezInfoForAlloc() {
function DeallocateBackingArray (line 1520) | void DeallocateBackingArray(
type PolicyFunctions (line 1535) | struct PolicyFunctions {
function MaxStorableSize (line 1600) | constexpr size_t MaxStorableSize() {
function ctrl_t (line 2124) | ctrl_t* control() const { return inner_.control(); }
function slot_type (line 2125) | slot_type* slot() const { return inner_.slot(); }
function raw_hash_set (line 2270) | raw_hash_set(const raw_hash_set& that)
function ABSL_ATTRIBUTE_NOINLINE (line 2288) | ABSL_ATTRIBUTE_NOINLINE raw_hash_set(raw_hash_set&& that) noexcept(
function iterator (line 2354) | iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function iterator (line 2363) | iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
function const_iterator (line 2374) | const_iterator cbegin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
function capacity (line 2387) | size_t capacity() const {
function ABSL_ATTRIBUTE_REINITIALIZES (line 2400) | ABSL_ATTRIBUTE_REINITIALIZES void clear() {
FILE: absl/container/internal/raw_hash_set_allocator_test.cc
type absl (line 32) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/raw_hash_set_benchmark.cc
type absl (line 36) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 37) | ABSL_NAMESPACE_BEGIN
function CodegenAbslRawHashSetInt64Find (line 682) | auto CodegenAbslRawHashSetInt64Find(absl::container_internal::IntTable* ...
function CodegenAbslRawHashSetInt64FindNeEnd (line 687) | bool CodegenAbslRawHashSetInt64FindNeEnd(
function CodegenAbslRawHashSetStringFindNeEnd (line 693) | bool CodegenAbslRawHashSetStringFindNeEnd(
function CodegenAbslRawHashSetInt64Insert (line 698) | auto CodegenAbslRawHashSetInt64Insert(absl::container_internal::IntTable...
function CodegenAbslRawHashSetInt64Contains (line 704) | bool CodegenAbslRawHashSetInt64Contains(
function CodegenAbslRawHashSetInt64Iterate (line 709) | void CodegenAbslRawHashSetInt64Iterate(
FILE: absl/container/internal/raw_hash_set_probe_benchmark.cc
type OutputStyle (line 43) | enum class OutputStyle { kRegular, kBenchmark }
function OutputStyle (line 51) | OutputStyle output() {
type Policy (line 56) | struct Policy {
method construct (line 66) | static void construct(allocator_type* alloc, slot_type* slot,
method destroy (line 72) | static void destroy(allocator_type* alloc, slot_type* slot) {
method slot_type (line 76) | static slot_type& element(slot_type* slot) { return *slot; }
method apply (line 79) | static auto apply(F&& f, const slot_type& arg)
method get_hash_slot_fn (line 85) | static constexpr auto get_hash_slot_fn() {
class RandomizedAllocator (line 99) | class RandomizedAllocator {
method RandomizedAllocator (line 103) | RandomizedAllocator() = default;
method RandomizedAllocator (line 105) | RandomizedAllocator(RandomizedAllocator<U>) {}
method T (line 107) | static T* allocate(size_t n) {
method deallocate (line 122) | static void deallocate(T* p, size_t n) {
type DefaultHash (line 138) | struct DefaultHash {
type Table (line 146) | struct Table : absl::container_internal::raw_hash_set<
type LoadSizes (line 151) | struct LoadSizes {
function LoadSizes (line 156) | LoadSizes GetMinMaxLoadSizes() {
type Ratios (line 182) | struct Ratios {
function Ratios (line 191) | Ratios CollectMeanProbeLengths() {
function PointerForAlignment (line 216) | uintptr_t PointerForAlignment() {
type Ptr (line 227) | struct Ptr
type StringSize (line 240) | enum class StringSize { kSmall, kMedium, kLarge, kExtraLarge }
type String (line 244) | struct String {
method Make (line 246) | static std::string Make(uint32_t v) {
type Sequential (line 266) | struct Sequential {
method T (line 267) | T operator()() const { return current++; }
type Sequential<Ptr<Align>*> (line 272) | struct Sequential<Ptr<Align>*> {
type Sequential<String<size>> (line 282) | struct Sequential<String<size>> {
type Sequential<std::pair<T, U>> (line 288) | struct Sequential<std::pair<T, U>> {
method RealT (line 311) | RealT get_t() const {
method RealU (line 316) | RealU get_u() const {
type AlmostSequential (line 323) | struct AlmostSequential {
type Uniform (line 333) | struct Uniform {
method T (line 335) | T operator()(T) const {
type Gaussian (line 340) | struct Gaussian {
method T (line 342) | T operator()(T) const {
type Zipf (line 351) | struct Zipf {
method T (line 353) | T operator()(T) const {
type Random (line 359) | struct Random {
method T (line 360) | T operator()() const { return Dist{}(T{}); }
type Random<Ptr<Align>*, Dist> (line 364) | struct Random<Ptr<Align>*, Dist> {
type Random<String<size>, Dist> (line 371) | struct Random<String<size>, Dist> {
type Random<std::pair<T, U>, Dist> (line 378) | struct Random<std::pair<T, U>, Dist> {
function Name (line 388) | std::string Name(uint32_t*) { return "u32"; }
function Name (line 389) | std::string Name(uint64_t*) { return "u64"; }
function Name (line 392) | std::string Name(Ptr<Align>**) {
function Name (line 397) | std::string Name(String<size>*) {
function Name (line 413) | std::string Name(std::pair<T, U>*) {
function Name (line 420) | std::string Name(Sequential<T>*) {
function Name (line 425) | std::string Name(AlmostSequential<T, P>*) {
function Name (line 430) | std::string Name(Random<T, Uniform>*) {
function Name (line 435) | std::string Name(Random<T, Gaussian>*) {
function Name (line 440) | std::string Name(Random<T, Zipf>*) {
function Name (line 445) | std::string Name() {
function CanRunBenchmark (line 452) | bool CanRunBenchmark(absl::string_view name) {
type Result (line 461) | struct Result {
function RunForTypeAndDistribution (line 468) | void RunForTypeAndDistribution(std::vector<Result>& results) {
function RunForType (line 481) | void RunForType(std::vector<Result>& results) {
function main (line 495) | int main(int argc, char** argv) {
FILE: absl/container/internal/raw_hash_set_resize_impl_test.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/raw_hash_set_test.cc
type absl (line 75) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 76) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/test_allocator.h
function namespace (line 27) | namespace absl {
FILE: absl/container/internal/test_instance_tracker.cc
type absl (line 17) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 18) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/test_instance_tracker.h
function namespace (line 23) | namespace absl {
FILE: absl/container/internal/test_instance_tracker_test.cc
function TEST (line 26) | TEST(TestInstanceTracker, CopyableMovable) {
function TEST (line 62) | TEST(TestInstanceTracker, CopyableOnly) {
function TEST (line 96) | TEST(TestInstanceTracker, MovableOnly) {
function TEST (line 122) | TEST(TestInstanceTracker, ExistingInstances) {
function TEST (line 160) | TEST(TestInstanceTracker, Comparisons) {
FILE: absl/container/internal/tracked.h
function namespace (line 25) | namespace absl {
FILE: absl/container/internal/unordered_map_members_test.h
function namespace (line 23) | namespace absl {
FILE: absl/container/internal/unordered_map_modifiers_test.h
function namespace (line 25) | namespace absl {
FILE: absl/container/internal/unordered_map_test.cc
type absl (line 23) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/internal/unordered_set_members_test.h
function namespace (line 23) | namespace absl {
FILE: absl/container/internal/unordered_set_modifiers_test.h
function namespace (line 23) | namespace absl {
FILE: absl/container/internal/unordered_set_test.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/linked_hash_map.h
function namespace (line 51) | namespace absl {
function linked_hash_map (line 221) | linked_hash_map(const linked_hash_map& other)
function size_type (line 281) | size_type max_size() const noexcept { return ~size_type{}; }
function iterator (line 287) | iterator end() { return list_.end(); }
function reverse_iterator (line 292) | reverse_iterator rbegin() { return list_.rbegin(); }
function reverse_iterator (line 293) | reverse_iterator rend() { return list_.rend(); }
function reference (line 298) | reference front() { return list_.front(); }
function reference (line 299) | reference back() { return list_.back(); }
function pop_front (line 303) | void pop_front() { erase(begin()); }
function pop_back (line 304) | void pop_back() { erase(std::prev(end())); }
function ABSL_ATTRIBUTE_REINITIALIZES (line 306) | ABSL_ATTRIBUTE_REINITIALIZES void clear() {
function reserve (line 311) | void reserve(size_t n) { set_.reserve(n); }
function iterator (line 331) | iterator erase(const_iterator position) {
function iterator (line 338) | iterator erase(iterator position) {
function iterator (line 342) | iterator erase(iterator first, iterator last) {
function iterator (line 347) | iterator erase(const_iterator first, const_iterator last) {
function iterator (line 422) | iterator insert(const_iterator, const value_type& v) {
function iterator (line 425) | iterator insert(const_iterator, value_type&& v) {
function insert (line 429) | void insert(std::initializer_list<value_type> ilist) {
function insert_return_type (line 438) | insert_return_type insert(node_type&& node) {
function iterator (line 448) | iterator insert(const_iterator, node_type&& node) {
function node_type (line 548) | node_type extract(const_iterator position) {
function swap (line 585) | void swap(linked_hash_map& other) noexcept {
FILE: absl/container/linked_hash_map_benchmark.cc
type BenchmarkData (line 28) | struct BenchmarkData {
method BenchmarkData (line 31) | explicit BenchmarkData(int size,
function BenchmarkTryEmplaceStrings (line 41) | void BenchmarkTryEmplaceStrings(benchmark::State& state,
function BenchmarkInsertOrAssignStrings (line 65) | void BenchmarkInsertOrAssignStrings(
function BM_TryEmplaceShortStrings_Hit (line 92) | void BM_TryEmplaceShortStrings_Hit(benchmark::State& state) {
function BM_TryEmplaceLongStrings_Hit (line 98) | void BM_TryEmplaceLongStrings_Hit(benchmark::State& state) {
function BM_TryEmplaceShortStrings_Miss (line 104) | void BM_TryEmplaceShortStrings_Miss(benchmark::State& state) {
function BM_TryEmplaceLongStrings_Miss (line 110) | void BM_TryEmplaceLongStrings_Miss(benchmark::State& state) {
function BM_InsertOrAssignShortStrings_Hit (line 116) | void BM_InsertOrAssignShortStrings_Hit(benchmark::State& state) {
function BM_InsertOrAssignLongStrings_Hit (line 122) | void BM_InsertOrAssignLongStrings_Hit(benchmark::State& state) {
function BM_InsertOrAssignShortStrings_Miss (line 128) | void BM_InsertOrAssignShortStrings_Miss(benchmark::State& state) {
function BM_InsertOrAssignLongStrings_Miss (line 134) | void BM_InsertOrAssignLongStrings_Miss(benchmark::State& state) {
FILE: absl/container/linked_hash_map_test.cc
type absl (line 40) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 41) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/linked_hash_set.h
function namespace (line 47) | namespace absl {
function linked_hash_set (line 211) | linked_hash_set(const linked_hash_set& other)
function size_type (line 270) | size_type max_size() const noexcept { return ~size_type{}; }
function iterator (line 276) | iterator end() { return list_.end(); }
function reverse_iterator (line 281) | reverse_iterator rbegin() { return list_.rbegin(); }
function reverse_iterator (line 282) | reverse_iterator rend() { return list_.rend(); }
function reference (line 287) | reference front() { return list_.front(); }
function reference (line 288) | reference back() { return list_.back(); }
function pop_front (line 292) | void pop_front() { erase(begin()); }
function pop_back (line 293) | void pop_back() { erase(std::prev(end())); }
function ABSL_ATTRIBUTE_REINITIALIZES (line 295) | ABSL_ATTRIBUTE_REINITIALIZES void clear() {
function reserve (line 300) | void reserve(size_t n) { set_.reserve(n); }
function iterator (line 320) | iterator erase(const_iterator position) {
function iterator (line 327) | iterator erase(const_iterator first, const_iterator last) {
function insert (line 396) | void insert(std::initializer_list<key_type> ilist) {
function insert_return_type (line 405) | insert_return_type insert(node_type&& node) {
function iterator (line 415) | iterator insert(const_iterator, node_type&& node) {
function node_type (line 446) | node_type extract(const_iterator position) {
function swap (line 463) | void swap(linked_hash_set& other) noexcept {
FILE: absl/container/linked_hash_set_benchmark.cc
function BenchmarkInsertStrings (line 28) | void BenchmarkInsertStrings(benchmark::State& state,
function BM_InsertShortStrings_Hit (line 60) | void BM_InsertShortStrings_Hit(benchmark::State& state) {
function BM_InsertLongStrings_Hit (line 66) | void BM_InsertLongStrings_Hit(benchmark::State& state) {
function BM_InsertShortStrings_Miss (line 72) | void BM_InsertShortStrings_Miss(benchmark::State& state) {
function BM_InsertLongStrings_Miss (line 78) | void BM_InsertLongStrings_Miss(benchmark::State& state) {
FILE: absl/container/linked_hash_set_test.cc
type absl (line 38) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 39) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/node_hash_map.h
function namespace (line 55) | namespace absl {
function namespace (line 597) | namespace container_internal {
function delete_element (line 659) | void delete_element(Allocator* alloc, value_type* pair) {
FILE: absl/container/node_hash_map_test.cc
type absl (line 39) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 40) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/node_hash_set.h
function namespace (line 53) | namespace absl {
function namespace (line 506) | namespace container_internal {
function delete_element (line 558) | void delete_element(Allocator* alloc, T* elem) {
FILE: absl/container/node_hash_set_test.cc
type absl (line 38) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 39) | ABSL_NAMESPACE_BEGIN
FILE: absl/container/sample_element_size_test.cc
type absl (line 28) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 29) | ABSL_NAMESPACE_BEGIN
FILE: absl/copts/copts.py
function GccStyleFilterAndCombine (line 150) | def GccStyleFilterAndCombine(default_flags, test_flags):
FILE: absl/copts/generate_copts.py
function file_header_lines (line 15) | def file_header_lines():
function flatten (line 23) | def flatten(*lists):
function relative_filename (line 27) | def relative_filename(filename):
class CMakeStyle (line 33) | class CMakeStyle(object):
method separator (line 36) | def separator(self):
method list_introducer (line 39) | def list_introducer(self, name):
method list_closer (line 42) | def list_closer(self):
method docstring (line 45) | def docstring(self):
method filename (line 48) | def filename(self):
class StarlarkStyle (line 52) | class StarlarkStyle(object):
method separator (line 55) | def separator(self):
method list_introducer (line 58) | def list_introducer(self, name):
method list_closer (line 61) | def list_closer(self):
method docstring (line 64) | def docstring(self):
method filename (line 69) | def filename(self):
function copt_list (line 73) | def copt_list(name, arg_list, style):
function generate_copt_file (line 86) | def generate_copt_file(style):
function main (line 100) | def main(argv):
FILE: absl/crc/crc32c.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
type crc_internal (line 38) | namespace crc_internal {
function crc32c_t (line 40) | crc32c_t UnextendCrc32cByZeroes(crc32c_t initial_crc, size_t length) {
function crc32c_t (line 48) | crc32c_t ExtendCrc32cInternal(crc32c_t initial_crc,
function crc32c_t (line 57) | crc32c_t ExtendCrc32cByZeroes(crc32c_t initial_crc, size_t length) {
function crc32c_t (line 63) | crc32c_t ConcatCrc32c(crc32c_t lhs_crc, crc32c_t rhs_crc, size_t rhs_l...
function crc32c_t (line 69) | crc32c_t RemoveCrc32cPrefix(crc32c_t crc_a, crc32c_t crc_ab, size_t le...
function crc32c_t (line 73) | crc32c_t MemcpyCrc32c(void* dest, const void* src, size_t count,
function crc32c_t (line 86) | crc32c_t RemoveCrc32cSuffix(crc32c_t full_string_crc, crc32c_t suffix_...
FILE: absl/crc/crc32c.h
function crc32c_t (line 49) | crc32c_t final {
function namespace (line 75) | namespace crc_internal {
function crc32c_t (line 97) | inline crc32c_t ExtendCrc32c(crc32c_t initial_crc,
FILE: absl/crc/crc32c_benchmark.cc
function TestString (line 25) | std::string TestString(size_t len) {
function BM_Calculate (line 34) | void BM_Calculate(benchmark::State& state) {
function BM_Extend (line 51) | void BM_Extend(benchmark::State& state) {
function BM_ExtendCacheMiss (line 72) | void BM_ExtendCacheMiss(benchmark::State& state) {
function BM_ExtendByZeroes (line 90) | void BM_ExtendByZeroes(benchmark::State& state) {
function BM_UnextendByZeroes (line 105) | void BM_UnextendByZeroes(benchmark::State& state) {
function BM_Concat (line 121) | void BM_Concat(benchmark::State& state) {
function BM_Memcpy (line 143) | void BM_Memcpy(benchmark::State& state) {
function BM_RemoveSuffix (line 165) | void BM_RemoveSuffix(benchmark::State& state) {
FILE: absl/crc/crc32c_test.cc
function TEST (line 35) | TEST(CRC32C, RFC3720) {
function TestString (line 72) | std::string TestString(size_t len) {
function TEST (line 81) | TEST(CRC32C, Compute) {
function TEST (line 86) | TEST(CRC32C, Extend) {
function TEST (line 95) | TEST(CRC32C, ExtendByZeroes) {
function TEST (line 112) | TEST(CRC32C, ExtendByZeroesAllLengthBits) {
function TEST (line 134) | TEST(CRC32C, UnextendByZeroes) {
function TEST (line 175) | TEST(CRC32C, Concat) {
function TEST (line 187) | TEST(CRC32C, Memcpy) {
function TEST (line 203) | TEST(CRC32C, RemovePrefix) {
function TEST (line 215) | TEST(CRC32C, RemoveSuffix) {
function TEST (line 227) | TEST(CRC32C, InsertionOperator) {
function TEST (line 245) | TEST(CRC32C, AbslStringify) {
FILE: absl/crc/internal/cpu_detect.cc
function __cpuid (line 48) | static void __cpuid(int cpu_info[4], int info_type) {
type absl (line 57) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 58) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/cpu_detect.h
function ABSL_NAMESPACE_BEGIN (line 21) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc.cc
type absl (line 52) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 53) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc.h
function namespace (line 35) | namespace absl {
FILE: absl/crc/internal/crc32_x86_arm_combined_simd.h
function namespace (line 53) | namespace absl {
FILE: absl/crc/internal/crc32c.h
function namespace (line 21) | namespace absl {
FILE: absl/crc/internal/crc32c_inline.h
function namespace (line 24) | namespace absl {
FILE: absl/crc/internal/crc_cord_state.cc
type absl (line 23) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc_cord_state.h
function namespace (line 25) | namespace absl {
FILE: absl/crc/internal/crc_cord_state_test.cc
function TEST (line 27) | TEST(CrcCordState, Default) {
function TEST (line 35) | TEST(CrcCordState, Normalize) {
function TEST (line 57) | TEST(CrcCordState, Copy) {
function TEST (line 69) | TEST(CrcCordState, UnsharedSelfCopy) {
function TEST (line 81) | TEST(CrcCordState, Move) {
function TEST (line 91) | TEST(CrcCordState, UnsharedSelfMove) {
function TEST (line 103) | TEST(CrcCordState, PoisonDefault) {
function TEST (line 109) | TEST(CrcCordState, PoisonData) {
FILE: absl/crc/internal/crc_internal.h
function namespace (line 25) | namespace absl {
FILE: absl/crc/internal/crc_memcpy.h
function namespace (line 34) | namespace absl {
FILE: absl/crc/internal/crc_memcpy_fallback.cc
type absl (line 23) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc_memcpy_test.cc
type CrcEngine (line 35) | enum CrcEngine {
class CrcMemcpyTest (line 45) | class CrcMemcpyTest : public testing::Test {
method CrcMemcpyTest (line 47) | CrcMemcpyTest() {
class EngineParamTestTemplate (line 69) | class EngineParamTestTemplate : public CrcSmallTest,
method EngineParamTestTemplate (line 72) | EngineParamTestTemplate() {
method ParamsT (line 85) | ParamsT GetParam() const {
type TestParams (line 91) | struct TestParams {
function TEST_P (line 99) | TEST_P(EngineParamTest, SmallCorrectnessCheckSourceAlignment) {
function TEST_P (line 133) | TEST_P(EngineParamTest, SmallCorrectnessCheckDestAlignment) {
FILE: absl/crc/internal/crc_memcpy_x86_arm_combined.cc
type absl (line 68) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 69) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc_non_temporal_memcpy.cc
type absl (line 23) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/crc_x86_arm_combined.cc
type absl (line 37) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 38) | ABSL_NAMESPACE_BEGIN
FILE: absl/crc/internal/gen_crc32c_consts.py
function poly_mul (line 20) | def poly_mul(a, b):
function poly_div (line 29) | def poly_div(a, b):
function poly_reduce (line 38) | def poly_reduce(a, b):
function poly_exp (line 43) | def poly_exp(a, b, g):
function bitreflect (line 54) | def bitreflect(a, num_bits):
function print_crc32c_powers (line 70) | def print_crc32c_powers():
FILE: absl/crc/internal/non_temporal_arm_intrinsics.h
type int64x2_t (line 25) | typedef int64x2_t __m128i;
function _mm_sfence (line 32) | static inline __attribute__((always_inline)) void _mm_sfence(void) {
function __m128i (line 47) | static inline __attribute__((always_inline)) __m128i _mm_loadu_si128(
function _mm_stream_si128 (line 56) | static inline __attribute__((always_inline)) void _mm_stream_si128(__m12...
function __m128i (line 67) | static inline __attribute__((always_inline)) __m128i _mm_set_epi8(
FILE: absl/crc/internal/non_temporal_memcpy_test.cc
type TestParam (line 26) | struct TestParam {
class NonTemporalMemcpyTest (line 32) | class NonTemporalMemcpyTest : public testing::TestWithParam<TestParam> {
method SetUp (line 34) | void SetUp() override {
function TEST_P (line 51) | TEST_P(NonTemporalMemcpyTest, SSEEquality) {
function TEST_P (line 61) | TEST_P(NonTemporalMemcpyTest, AVXEquality) {
FILE: absl/debugging/failure_signal_handler.cc
function RaiseToDefaultHandler (line 93) | static void RaiseToDefaultHandler(int signo) {
type FailureSignalData (line 98) | struct FailureSignalData {
type sigaction (line 102) | struct sigaction
type sigaction (line 104) | struct sigaction
function RaiseToPreviousHandler (line 126) | static void RaiseToPreviousHandler(int signo) {
type debugging_internal (line 144) | namespace debugging_internal {
function SetupAlternateStackOnce (line 159) | static bool SetupAlternateStackOnce() {
function MaybeSetupAlternateStack (line 221) | static int MaybeSetupAlternateStack() {
function InstallOneFailureHandler (line 230) | static void InstallOneFailureHandler(FailureSignalData* data,
function InstallOneFailureHandler (line 249) | static void InstallOneFailureHandler(FailureSignalData* data,
function WriteSignalMessage (line 257) | static void WriteSignalMessage(int signo, int cpu,
type WriterFnStruct (line 280) | struct WriterFnStruct {
function WriterFnWrapper (line 288) | static void WriterFnWrapper(const char* data, void* arg) {
function ABSL_ATTRIBUTE_NOINLINE (line 295) | ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace(
function WriteFailureInfo (line 314) | static void WriteFailureInfo(int signo, void* ucontext, int cpu,
function PortableSleepForSeconds (line 325) | static void PortableSleepForSeconds(int seconds) {
function ImmediateAbortSignalHandler (line 343) | static void ImmediateAbortSignalHandler(int) { RaiseToDefaultHandler(SIG...
function GetCpuNumber (line 351) | static int GetCpuNumber() {
function AbslFailureSignalHandler (line 369) | static void AbslFailureSignalHandler(int signo, siginfo_t*, void* uconte...
function InstallFailureSignalHandler (line 426) | void InstallFailureSignalHandler(const FailureSignalHandlerOptions& opti...
FILE: absl/debugging/failure_signal_handler.h
function namespace (line 49) | namespace absl {
FILE: absl/debugging/failure_signal_handler_test.cc
function InstallHandlerAndRaise (line 44) | void InstallHandlerAndRaise(int signo) {
function TEST_P (line 49) | TEST_P(FailureSignalHandlerDeathTest, AbslFailureSignal) {
function WriteToErrorFile (line 65) | void WriteToErrorFile(const char* msg) {
function GetTmpDir (line 73) | std::string GetTmpDir() {
function InstallHandlerWithWriteToFileAndRaise (line 89) | void InstallHandlerWithWriteToFileAndRaise(const char* file, int signo) {
function TEST_P (line 98) | TEST_P(FailureSignalHandlerDeathTest, AbslFatalSignalsWithWriterFn) {
function SignalParamToString (line 145) | std::string SignalParamToString(const ::testing::TestParamInfo<int>& inf...
function main (line 162) | int main(int argc, char** argv) {
FILE: absl/debugging/internal/address_is_readable.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 43) | ABSL_NAMESPACE_BEGIN
type absl (line 42) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 43) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/address_is_readable.h
function namespace (line 20) | namespace absl {
FILE: absl/debugging/internal/addresses.h
function namespace (line 22) | namespace absl {
FILE: absl/debugging/internal/bounded_utf8_length_sequence.h
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/bounded_utf8_length_sequence_test.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/decode_rust_punycode.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/decode_rust_punycode.h
function namespace (line 21) | namespace absl {
FILE: absl/debugging/internal/decode_rust_punycode_test.cc
type absl (line 25) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 26) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/demangle.cc
type absl (line 35) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 36) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/demangle.h
function namespace (line 21) | namespace absl {
FILE: absl/debugging/internal/demangle_rust.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
function DemangleRustSymbolEncoding (line 918) | bool DemangleRustSymbolEncoding(const char* mangled, char* out,
FILE: absl/debugging/internal/demangle_rust.h
function namespace (line 22) | namespace absl {
FILE: absl/debugging/internal/demangle_rust_test.cc
type absl (line 23) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 24) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/demangle_test.cc
type absl (line 27) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 28) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/elf_mem_image.cc
type absl (line 44) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 45) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/elf_mem_image.h
function class (line 55) | class ElfMemImage {
FILE: absl/debugging/internal/examine_stack.cc
type absl (line 45) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 46) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/examine_stack.h
function namespace (line 22) | namespace absl {
FILE: absl/debugging/internal/stack_consumption.cc
type absl (line 32) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 197) | ABSL_NAMESPACE_BEGIN
type absl (line 196) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 33) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 197) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/stack_consumption.h
function namespace (line 32) | namespace absl {
FILE: absl/debugging/internal/stack_consumption_test.cc
type absl (line 25) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 26) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/symbolize.h
function namespace (line 40) | namespace absl {
function namespace (line 77) | namespace absl {
FILE: absl/debugging/internal/utf8_for_code_point.cc
type absl (line 21) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 22) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/utf8_for_code_point.h
function namespace (line 22) | namespace absl {
FILE: absl/debugging/internal/utf8_for_code_point_test.cc
type absl (line 22) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 23) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/vdso_support.cc
type absl (line 65) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 66) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/internal/vdso_support.h
function namespace (line 55) | namespace absl {
FILE: absl/debugging/leak_check.cc
function ABSL_ATTRIBUTE_WEAK (line 31) | ABSL_ATTRIBUTE_WEAK int __lsan_is_turned_off() { return 0; }
type absl (line 34) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
function LeakCheckerIsActive (line 39) | bool LeakCheckerIsActive() {
function LeakCheckerIsActive (line 43) | bool LeakCheckerIsActive() { return true; }
function FindAndReportLeaks (line 46) | bool FindAndReportLeaks() { return __lsan_do_recoverable_leak_check() ...
function DoIgnoreLeak (line 47) | void DoIgnoreLeak(const void* ptr) { __lsan_ignore_object(ptr); }
function RegisterLivePointers (line 48) | void RegisterLivePointers(const void* ptr, size_t size) {
function UnRegisterLivePointers (line 51) | void UnRegisterLivePointers(const void* ptr, size_t size) {
function ABSL_NAMESPACE_BEGIN (line 62) | ABSL_NAMESPACE_BEGIN
function LeakCheckerIsActive (line 64) | bool LeakCheckerIsActive() { return false; }
function DoIgnoreLeak (line 65) | void DoIgnoreLeak(const void*) { }
function RegisterLivePointers (line 66) | void RegisterLivePointers(const void*, size_t) { }
function UnRegisterLivePointers (line 67) | void UnRegisterLivePointers(const void*, size_t) { }
type absl (line 61) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
function LeakCheckerIsActive (line 39) | bool LeakCheckerIsActive() {
function LeakCheckerIsActive (line 43) | bool LeakCheckerIsActive() { return true; }
function FindAndReportLeaks (line 46) | bool FindAndReportLeaks() { return __lsan_do_recoverable_leak_check() ...
function DoIgnoreLeak (line 47) | void DoIgnoreLeak(const void* ptr) { __lsan_ignore_object(ptr); }
function RegisterLivePointers (line 48) | void RegisterLivePointers(const void* ptr, size_t size) {
function UnRegisterLivePointers (line 51) | void UnRegisterLivePointers(const void* ptr, size_t size) {
function ABSL_NAMESPACE_BEGIN (line 62) | ABSL_NAMESPACE_BEGIN
function LeakCheckerIsActive (line 64) | bool LeakCheckerIsActive() { return false; }
function DoIgnoreLeak (line 65) | void DoIgnoreLeak(const void*) { }
function RegisterLivePointers (line 66) | void RegisterLivePointers(const void*, size_t) { }
function UnRegisterLivePointers (line 67) | void UnRegisterLivePointers(const void*, size_t) { }
FILE: absl/debugging/leak_check.h
function namespace (line 54) | namespace absl {
FILE: absl/debugging/leak_check_fail_test.cc
function TEST (line 23) | TEST(LeakCheckTest, LeakMemory) {
function TEST (line 32) | TEST(LeakCheckTest, LeakMemoryAfterDisablerScope) {
FILE: absl/debugging/leak_check_test.cc
function TEST (line 24) | TEST(LeakCheckTest, IgnoreLeakSuppressesLeakedMemoryErrors) {
function TEST (line 32) | TEST(LeakCheckTest, LeakCheckDisablerIgnoresLeak) {
FILE: absl/debugging/stacktrace.cc
type absl (line 68) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 69) | ABSL_NAMESPACE_BEGIN
function ABSL_ATTRIBUTE_NOINLINE (line 120) | ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackFrames(
function ABSL_ATTRIBUTE_NOINLINE (line 127) | ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
function ABSL_ATTRIBUTE_NOINLINE (line 135) | ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
function ABSL_ATTRIBUTE_NOINLINE (line 144) | ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int GetStackTrace(
function ABSL_ATTRIBUTE_NOINLINE (line 151) | ABSL_ATTRIBUTE_NOINLINE ABSL_ATTRIBUTE_NO_TAIL_CALL int
function SetStackUnwinder (line 159) | void SetStackUnwinder(Unwinder w) {
function DefaultStackUnwinder (line 163) | int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip,
function ABSL_ATTRIBUTE_WEAK (line 185) | ABSL_ATTRIBUTE_WEAK bool internal_stacktrace::ShouldFixUpStack() {
function ABSL_ATTRIBUTE_WEAK (line 199) | ABSL_ATTRIBUTE_WEAK void internal_stacktrace::FixUpStack(void**, uintp...
FILE: absl/debugging/stacktrace.h
function namespace (line 39) | namespace absl {
FILE: absl/debugging/stacktrace_benchmark.cc
type absl (line 34) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 35) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/stacktrace_test.cc
type StackTrace (line 61) | struct StackTrace {
function ABSL_ATTRIBUTE_NOINLINE (line 70) | ABSL_ATTRIBUTE_NOINLINE void Unwind(void* p) {
function ABSL_ATTRIBUTE_NOINLINE (line 79) | ABSL_ATTRIBUTE_NOINLINE void HugeFrame() {
function TEST (line 85) | TEST(StackTrace, HugeFrame) {
function ABSL_ATTRIBUTE_NOINLINE (line 93) | ABSL_ATTRIBUTE_NOINLINE static void FixupNoFixupEquivalenceNoInline() {
function TEST (line 196) | TEST(StackTrace, FixupNoFixupEquivalence) { FixupNoFixupEquivalenceNoInl...
function TEST (line 198) | TEST(StackTrace, FixupLowStackUsage) {
function TEST (line 248) | TEST(StackTrace, CustomUnwinderPerformsFixup) {
function SigUsr2Handler (line 315) | void SigUsr2Handler(int, siginfo_t*, void* uc) {
function SigUsr1Handler (line 336) | void SigUsr1Handler(int, siginfo_t*, void*) {
function ABSL_ATTRIBUTE_NOINLINE (line 341) | ABSL_ATTRIBUTE_NOINLINE void RaiseSignal() {
function ABSL_ATTRIBUTE_NOINLINE (line 347) | ABSL_ATTRIBUTE_NOINLINE void TestNestedSignal() {
function TEST (line 374) | TEST(StackTrace, NestedSignal) {
FILE: absl/debugging/symbolize.cc
type absl (line 49) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 50) | ABSL_NAMESPACE_BEGIN
FILE: absl/debugging/symbolize.h
function namespace (line 57) | namespace absl {
FILE: absl/debugging/symbolize_test.cc
function ABSL_SYMBOLIZE_TEST_NOINLINE (line 63) | ABSL_SYMBOLIZE_TEST_NOINLINE void nonstatic_func() {
function ABSL_SYMBOLIZE_TEST_NOINLINE (line 71) | ABSL_SYMBOLIZE_TEST_NOINLINE static void static_func() {
type Foo (line 80) | struct Foo {
function ABSL_SYMBOLIZE_TEST_NOINLINE (line 85) | ABSL_SYMBOLIZE_TEST_NOINLINE void Foo::func(int) {
function unlikely_func (line 95) | unlikely_func() {
function hot_func (line 99) | hot_func() { return 0; }
function startup_func (line 101) | startup_func() { return 0; }
function exit_func (line 103) | exit_func() { return 0; }
function regular_func (line 105) | int /*ABSL_ATTRIBUTE_SECTION_VARIABLE(.text)*/ regular_func() { return 0; }
function TEST (line 173) | TEST(Symbolize, Cached) {
function TEST (line 185) | TEST(Symbolize, Truncation) {
function TEST (line 204) | TEST(Symbolize, SymbolizeWithDemangling) {
function TEST (line 214) | TEST(Symbolize, SymbolizeSplitTextSections) {
function SymbolizeSignalHandler (line 229) | static void SymbolizeSignalHandler(int signo) {
function GetStackConsumptionUpperLimit (line 246) | static int GetStackConsumptionUpperLimit() {
function TEST (line 257) | TEST(Symbolize, SymbolizeStackConsumption) {
function TEST (line 275) | TEST(Symbolize, SymbolizeWithDemanglingStackConsumption) {
function FilterElfHeader (line 298) | static int FilterElfHeader(struct dl_phdr_info *info, size_t size, void ...
function TEST (line 324) | TEST(Symbolize, SymbolizeWithMultipleMaps) {
class TestSymbolDecorator (line 379) | class TestSymbolDecorator final
method Factory (line 382) | static absl::debugging_internal::SymbolDecoratorPtr Factory(int /*fd*/) {
method Decorate (line 389) | void Decorate(const void* /*pc*/, ptrdiff_t /*relocation*/, char* symb...
function TEST (line 397) | TEST(Symbolize, SetSymbolDecorator) {
function TEST (line 421) | TEST(Symbolize, ForEachSection) {
function ArmThumbOverlapThumb (line 513) | __attribute__((target("thumb"))) int ArmThumbOverlapThumb(int x) {
function ArmThumbOverlapArm (line 517) | __attribute__((target("arm"))) int ArmThumbOverlapArm(int x) {
function TEST (line 535) | TEST(Symbolize, Basics) {
function TEST (line 547) | TEST(Symbolize, Truncation) {
function TEST (line 566) | TEST(Symbolize, SymbolizeWithDemangling) {
function TEST (line 574) | TEST(Symbolize, Unimplemented) {
function main (line 583) | int main(int argc, char **argv) {
FILE: absl/flags/commandlineflag.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/commandlineflag.h
function ABSL_NAMESPACE_BEGIN (line 41) | ABSL_NAMESPACE_BEGIN
function class (line 72) | class CommandLineFlag {
FILE: absl/flags/commandlineflag_test.cc
function ABSL_FLAG (line 32) | ABSL_FLAG(int, int_flag, 201, "int_flag help");
function TEST_F (line 75) | TEST_F(CommandLineFlagTest, TestAttributesAccessMethods) {
function TEST_F (line 105) | TEST_F(CommandLineFlagTest, TestValueAccessMethods) {
function TEST_F (line 123) | TEST_F(CommandLineFlagTest, TestParseFromCurrentValue) {
function TEST_F (line 187) | TEST_F(CommandLineFlagTest, TestParseFromDefaultValue) {
function TEST_F (line 207) | TEST_F(CommandLineFlagTest, TestParseFromIfDefault) {
FILE: absl/flags/config_test.cc
function TEST (line 36) | TEST(FlagsConfigTest, Test) {
FILE: absl/flags/declare.h
function namespace (line 30) | namespace absl {
FILE: absl/flags/flag.h
function namespace (line 46) | namespace absl {
function absl (line 243) | static constexpr absl::string_view Value( \
function std (line 248) | static std::string NonConst() { return std::string(Value()); }
FILE: absl/flags/flag_benchmark.cc
type OptionalInt (line 39) | struct OptionalInt : AbslOptionalInt {
function AbslParseFlag (line 43) | bool AbslParseFlag(absl::string_view src, OptionalInt* flag,
function AbslUnparseFlag (line 53) | std::string AbslUnparseFlag(const OptionalInt& flag) {
type OptionalString (line 58) | struct OptionalString : AbslOptionalString {
function AbslParseFlag (line 62) | bool AbslParseFlag(absl::string_view src, OptionalString* flag,
function AbslUnparseFlag (line 72) | std::string AbslUnparseFlag(const OptionalString& flag) {
type UDT (line 76) | struct UDT {
method UDT (line 77) | UDT() = default;
method UDT (line 78) | UDT(const UDT&) {}
method UDT (line 79) | UDT& operator=(const UDT&) { return *this; }
function AbslParseFlag (line 82) | bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
function AbslUnparseFlag (line 83) | std::string AbslUnparseFlag(const UDT&) { return ""; }
type Accumulator (line 176) | struct Accumulator {
type Accumulator<String> (line 180) | struct Accumulator<String> {
type Accumulator<VectorOfStrings> (line 184) | struct Accumulator<VectorOfStrings> {
type Accumulator<OptionalInt> (line 188) | struct Accumulator<OptionalInt> {
type Accumulator<OptionalString> (line 192) | struct Accumulator<OptionalString> {
type Accumulator<UDT> (line 196) | struct Accumulator<UDT> {
function Accumulate (line 201) | void Accumulate(typename Accumulator<T>::type& a, const T& f) {
function Accumulate (line 204) | void Accumulate(bool& a, bool f) { a = a || f; }
function Accumulate (line 205) | void Accumulate(size_t& a, const std::string& f) { a += f.size(); }
function Accumulate (line 206) | void Accumulate(size_t& a, const std::vector<std::string>& f) { a += f.s...
function Accumulate (line 207) | void Accumulate(bool& a, const OptionalInt& f) { a |= f.has_value(); }
function Accumulate (line 208) | void Accumulate(bool& a, const OptionalString& f) { a |= f.has_value(); }
function Accumulate (line 209) | void Accumulate(bool& a, const UDT& f) {
function BM_ThreadedFindCommandLineFlag (line 227) | void BM_ThreadedFindCommandLineFlag(benchmark::State& state) {
FILE: absl/flags/flag_test.cc
function TestHelpMsg (line 54) | std::string TestHelpMsg() { return "dynamic help"; }
function TestLiteralHelpMsg (line 56) | std::string TestLiteralHelpMsg() { return "literal help"; }
function TestMakeDflt (line 59) | void TestMakeDflt(void* dst) {
function TestCallback (line 62) | void TestCallback() {}
type UDT (line 64) | struct UDT {
method UDT (line 65) | UDT() = default;
method UDT (line 66) | UDT(const UDT&) = default;
method UDT (line 67) | UDT& operator=(const UDT&) = default;
function AbslParseFlag (line 69) | bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
function AbslUnparseFlag (line 70) | std::string AbslUnparseFlag(const UDT&) { return ""; }
class FlagTest (line 72) | class FlagTest : public testing::Test {
method SetUpTestSuite (line 74) | static void SetUpTestSuite() {
method NormalizeFileName (line 82) | static std::string NormalizeFileName(absl::string_view fname) {
type S1 (line 93) | struct S1 {
method S1 (line 94) | S1() = default;
method S1 (line 95) | S1(const S1&) = default;
type S2 (line 100) | struct S2 {
method S2 (line 101) | S2() = default;
method S2 (line 102) | S2(const S2&) = default;
function TEST_F (line 107) | TEST_F(FlagTest, Traits) {
function TestConstructionFor (line 177) | bool TestConstructionFor(const absl::Flag<T>& f1, absl::Flag<T>& f2) {
function TEST_F (line 194) | TEST_F(FlagTest, TestConstruction) {
function TEST_F (line 231) | TEST_F(FlagTest, TestFlagDeclaration) {
type VerifyConsteval (line 274) | struct VerifyConsteval {
function TEST_F (line 439) | TEST_F(FlagTest, TestDefault) {
type NonTriviallyCopyableAggregate (line 517) | struct NonTriviallyCopyableAggregate {
method NonTriviallyCopyableAggregate (line 518) | NonTriviallyCopyableAggregate() = default;
method NonTriviallyCopyableAggregate (line 520) | NonTriviallyCopyableAggregate(const NonTriviallyCopyableAggregate& rhs)
method NonTriviallyCopyableAggregate (line 523) | NonTriviallyCopyableAggregate& operator=(
function AbslParseFlag (line 531) | bool AbslParseFlag(absl::string_view src, NonTriviallyCopyableAggregate* f,
function AbslUnparseFlag (line 535) | std::string AbslUnparseFlag(const NonTriviallyCopyableAggregate& ntc) {
function TEST_F (line 715) | TEST_F(FlagTest, TestNonConstexprDefault) {
function TEST_F (line 731) | TEST_F(FlagTest, TestNonConstexprHelp) {
function TEST_F (line 1252) | TEST_F(FlagTest, TestOptionalInt) {
function TEST_F (line 1271) | TEST_F(FlagTest, TestOptionalDouble) {
function TEST_F (line 1290) | TEST_F(FlagTest, TestOptionalString) {
function TEST_F (line 1311) | TEST_F(FlagTest, TestOptionalDuration) {
function TEST_F (line 1330) | TEST_F(FlagTest, TestOptionalOptional) {
function TEST_F (line 1360) | TEST_F(FlagTest, TestStdOptional) {
FILE: absl/flags/internal/commandlineflag.cc
type absl (line 18) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 19) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/internal/commandlineflag.h
function namespace (line 22) | namespace absl {
FILE: absl/flags/internal/flag.cc
type absl (line 50) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 51) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/internal/flag.h
function namespace (line 46) | namespace absl {
function Set (line 838) | void Set(const T& v) {
function class (line 857) | class FlagImplPeer {
type AlignedSpace (line 877) | struct AlignedSpace {
type FlagRegistrarEmpty (line 937) | struct FlagRegistrarEmpty {}
function flag_ (line 942) | flag_(flag) {
function FlagRegistrar (line 947) | FlagRegistrar OnUpdate(FlagCallbackFunc cb) && {
FILE: absl/flags/internal/parse.h
function UsageFlagsAction (line 38) | enum class UsageFlagsAction { kHandleUsage, kIgnoreUsage };
FILE: absl/flags/internal/path_util.h
function namespace (line 22) | namespace absl {
FILE: absl/flags/internal/path_util_test.cc
function TEST (line 24) | TEST(FlagsPathUtilTest, TestBasename) {
function TEST (line 36) | TEST(FlagsPathUtilTest, TestPackage) {
FILE: absl/flags/internal/private_handle_accessor.cc
type absl (line 26) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 27) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/internal/private_handle_accessor.h
function namespace (line 27) | namespace absl {
FILE: absl/flags/internal/program_name.cc
type absl (line 28) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 29) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/internal/program_name.h
function namespace (line 27) | namespace absl {
FILE: absl/flags/internal/program_name_test.cc
function TEST (line 28) | TEST(FlagsPathUtilTest, TestProgamNameInterfaces) {
FILE: absl/flags/internal/registry.h
function namespace (line 30) | namespace absl {
FILE: absl/flags/internal/sequence_lock.h
function namespace (line 28) | namespace absl {
FILE: absl/flags/internal/sequence_lock_test.cc
class ConcurrentSequenceLockTest (line 31) | class ConcurrentSequenceLockTest
method ConcurrentSequenceLockTest (line 34) | ConcurrentSequenceLockTest()
function TEST_P (line 43) | TEST_P(ConcurrentSequenceLockTest, ReadAndWrite) {
function MultiplicativeRange (line 107) | std::vector<int> MultiplicativeRange(int low, int high, int scale) {
function InterestingBufferSizes (line 126) | std::vector<int> InterestingBufferSizes() {
class SequenceLockTest (line 148) | class SequenceLockTest : public testing::TestWithParam<int> {}
function TEST_P (line 150) | TEST_P(SequenceLockTest, SingleThreaded) {
FILE: absl/flags/internal/usage.cc
type absl (line 59) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 60) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/internal/usage.h
function ABSL_NAMESPACE_BEGIN (line 31) | ABSL_NAMESPACE_BEGIN
FILE: absl/flags/marshalling.cc
type absl (line 40) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 41) | ABSL_NAMESPACE_BEGIN
function AbslParseFlag (line 228) | bool AbslParseFlag(absl::string_view text, absl::LogSeverity* dst,
function AbslUnparseFlag (line 270) | std::string AbslUnparseFlag(absl::LogSeverity v) {
FILE: absl/flags/marshalling.h
function namespace (line 211) | namespace absl {
function ParseFlag (line 307) | bool ParseFlag(absl::string_view input, T* dst, std::string* error) {
type class (line 328) | enum class
FILE: absl/flags/marshalling_test.cc
function TEST (line 30) | TEST(MarshallingTest, TestBoolParsing) {
function TEST (line 110) | TEST(MarshallingTest, TestInt16Parsing) {
function TEST (line 170) | TEST(MarshallingTest, TestUint16Parsing) {
function TEST (line 225) | TEST(MarshallingTest, TestInt32Parsing) {
function TEST (line 286) | TEST(MarshallingTest, TestUint32Parsing) {
function TEST (line 341) | TEST(MarshallingTest, TestInt64Parsing) {
function TEST (line 403) | TEST(MarshallingTest, TestUInt64Parsing) {
function TEST (line 456) | TEST(MarshallingTest, TestInt128Parsing) {
function TEST (line 518) | TEST(MarshallingTest, TestUint128Parsing) {
function TEST (line 575) | TEST(MarshallingTest, TestFloatParsing) {
function TEST (line 650) | TEST(MarshallingTest, TestDoubleParsing) {
function TEST (line 729) | TEST(MarshallingTest, TestStringParsing) {
function TEST (line 757) | TEST(MarshallingTest, TestVectorOfStringParsing) {
function TEST (line 779) | TEST(MarshallingTest, TestOptionalBoolParsing) {
function TEST (line 799) | TEST(MarshallingTest, TestOptionalIntParsing) {
function TEST (line 819) | TEST(MarshallingTest, TestOptionalDoubleParsing) {
function TEST (line 839) | TEST(MarshallingTest, TestOptionalStringParsing) {
function TEST (line 861) | TEST(MarshallingTest, TestBoolUnparsing) {
function TEST (line 868) | TEST(MarshallingTest, TestInt16Unparsing) {
function TEST (line 885) | TEST(MarshallingTest, TestUint16Unparsing) {
function TEST (line 898) | TEST(MarshallingTest, TestInt32Unparsing) {
function TEST (line 915) | TEST(MarshallingTest, TestUint32Unparsing) {
function TEST (line 928) | TEST(MarshallingTest, TestInt64Unparsing) {
function TEST (line 949) | TEST(MarshallingTest, TestUint64Unparsing) {
function TEST (line 964) | TEST(MarshallingTest, TestInt128Unparsing) {
function TEST (line 983) | TEST(MarshallingTest, TestUint128Unparsing) {
function TEST (line 998) | TEST(MarshallingTest, TestFloatUnparsing) {
function TEST (line 1013) | TEST(MarshallingTest, TestDoubleUnparsing) {
function TEST (line 1034) | TEST(MarshallingTest, TestStringUnparsing) {
function TEST (line 1044) | TEST(MarshallingTest, TestOptionalBoolUnparsing) {
function TEST (line 1058) | TEST(MarshallingTest, TestOptionalIntUnparsing) {
function TEST (line 1072) | TEST(MarshallingTest, TestOptionalDoubleUnparsing) {
function TEST (line 1086) | TEST(MarshallingTest, TestOptionalStringUnparsing) {
function TEST (line 1104) | TEST(MarshallingTest, TestStdOptionalUnparsing) {
function TestRoundtrip (line 1129) | void TestRoundtrip(T v) {
function TEST (line 1136) | TEST(MarshallingTest, TestFloatRoundTrip) {
function TEST (line 1165) | TEST(MarshallingTest, TestDoubleRoundTrip) {
FILE: absl/flags/parse.cc
type absl (line 62) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 63) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 168) | ABSL_NAMESPACE_BEGIN
function ParseAbseilFlagsOnly (line 926) | void ParseAbseilFlagsOnly(int argc, char* argv[],
function ReportUnrecognizedFlags (line 938) | void ReportUnrecognizedFlags(
function ParseCommandLine (line 945) | std::vector<char*> ParseCommandLine(int argc, char* argv[]) {
type absl (line 167) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 63) | ABSL_NAMESPACE_BEGIN
function ABSL_NAMESPACE_BEGIN (line 168) | ABSL_NAMESPACE_BEGIN
function ParseAbseilFlagsOnly (line 926) | void ParseAbseilFlagsOnly(int argc, char* argv[],
function ReportUnrecognizedFlags (line 938) | void ReportUnrecognizedFlags(
function ParseCommandLine (line 945) | std::vector<char*> ParseCommandLine(int argc, char* argv[]) {
FILE: absl/flags/parse.h
function namespace (line 32) | namespace absl {
function namespace (line 54) | namespace flags_internal {
FILE: absl/flags/parse_test.cc
type UDT (line 77) | struct UDT {
method UDT (line 78) | UDT() = default;
method UDT (line 79) | UDT(const UDT&) = default;
method UDT (line 80) | UDT& operator=(const UDT&) = default;
method UDT (line 81) | UDT(int v) : value(v) {}
function AbslParseFlag (line 86) | bool AbslParseFlag(absl::string_view in, UDT* udt, std::string* err) {
function AbslUnparseFlag (line 99) | std::string AbslUnparseFlag(const UDT& udt) {
function GetTestTmpDirEnvVar (line 103) | std::string GetTestTmpDirEnvVar(const char* const env_var_name) {
type FlagfileData (line 169) | struct FlagfileData {
function ABSL_FLAG (line 227) | ABSL_FLAG(int, int_flag, 1, "");
function TEST_F (line 315) | TEST_F(ParseTest, TestEmptyArgv) {
function TEST_F (line 326) | TEST_F(ParseTest, TestValidIntArg) {
function TEST_F (line 356) | TEST_F(ParseTest, TestValidDoubleArg) {
function TEST_F (line 386) | TEST_F(ParseTest, TestValidStringArg) {
function TEST_F (line 423) | TEST_F(ParseTest, TestValidBoolArg) {
function TEST_F (line 451) | TEST_F(ParseTest, TestValidUDTArg) {
function TEST_F (line 468) | TEST_F(ParseTest, TestValidMultipleArg) {
function TEST_F (line 490) | TEST_F(ParseTest, TestPositionalArgs) {
function TEST_F (line 554) | TEST_F(ParseDeathTest, TestUndefinedArg) {
function TEST_F (line 579) | TEST_F(ParseDeathTest, TestInvalidBoolFlagFormat) {
function TEST_F (line 599) | TEST_F(ParseDeathTest, TestInvalidNonBoolFlagFormat) {
function TEST_F (line 617) | TEST_F(ParseDeathTest, TestInvalidUDTFlagFormat) {
function TEST_F (line 638) | TEST_F(ParseDeathTest, TestFlagSuggestions) {
function TEST_F (line 663) | TEST_F(ParseTest, GetHints) {
function TEST_F (line 681) | TEST_F(ParseTest, TestLegacyFlags) {
function TEST_F (line 703) | TEST_F(ParseTest, TestSimpleValidFlagfile) {
function TEST_F (line 723) | TEST_F(ParseTest, TestValidMultiFlagfile) {
function TEST_F (line 737) | TEST_F(ParseTest, TestFlagfileMixedWithRegularFlags) {
function TEST_F (line 750) | TEST_F(ParseTest, TestFlagfileInFlagfile) {
function TEST_F (line 772) | TEST_F(ParseDeathTest, TestInvalidFlagfiles) {
function TEST_F (line 835) | TEST_F(ParseTest, TestReadingRequiredFlagsFromEnv) {
function TEST_F (line 848) | TEST_F(ParseDeathTest, TestReadingUnsetRequiredFlagsFromEnv) {
function TEST_F (line 857) | TEST_F(ParseDeathTest, TestRecursiveFlagsFromEnv) {
function TEST_F (line 868) | TEST_F(ParseTest, TestReadingOptionalFlagsFromEnv) {
function TEST_F (line 880) | TEST_F(ParseTest, TestReadingFlagsFromEnvMoxedWithRegularFlags) {
function TEST_F (line 896) | TEST_F(ParseDeathTest, TestSimpleHelpFlagHandling) {
function TEST_F (line 921) | TEST_F(ParseTest, TestSubstringHelpFlagHandling) {
function TEST_F (line 933) | TEST_F(ParseDeathTest, TestVersionHandling) {
function TEST_F (line 944) | TEST_F(ParseTest, TestCheckArgsHandling) {
function TEST_F (line 960) | TEST_F(ParseTest, WasPresentOnCommandLine) {
function TEST_F (line 980) | TEST_F(ParseTest, ParseAbseilFlagsOnlySuccess) {
function TEST_F (line 1017) | TEST_F(ParseDeathTest, ParseAbseilFlagsOnlyFailure) {
function TEST_F (line 1030) | TEST_F(ParseTest, UndefOkFlagsAreIgnored) {
function TEST_F (line 1054) | TEST_F(ParseTest, AllUndefOkFlagsAreIgnored) {
function TEST_F (line 1080) | TEST_F(ParseDeathTest, ExitOnUnrecognizedFlagPrintsHelp) {
FILE: absl/flags/reflection.cc
type absl (line 36) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 37) | ABSL_NAMESPACE_BEGIN
function CommandLineFlag (line 350) | CommandLineFlag* FindCommandLineFlag(absl::string_view name) {
function GetAllFlags (line 359) | absl::flat_hash_map<absl::string_view, absl::CommandLineFlag*> GetAllF...
FILE: absl/flags/reflection.h
function namespace (line 33) | namespace absl {
FILE: absl/flags/reflection_test.cc
function TearDown (line 43) | void TearDown() override { flag_saver_.reset(); }
function TEST_F (line 51) | TEST_F(ReflectionTest, TestFindCommandLineFlag) {
function TEST_F (line 67) | TEST_F(ReflectionTest, TestGetAllFlags) {
type CustomUDT (line 91) | struct CustomUDT {
method CustomUDT (line 92) | CustomUDT() : a(1), b(1) {}
method CustomUDT (line 93) | CustomUDT(int a_, int b_) : a(a_), b(b_) {}
function AbslParseFlag (line 102) | bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) {
function AbslUnparseFlag (line 114) | std::string AbslUnparseFlag(const CustomUDT& f) {
FILE: absl/flags/usage.cc
type absl (line 30) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 31) | ABSL_NAMESPACE_BEGIN
function SetProgramUsageMessage (line 42) | void SetProgramUsageMessage(absl::string_view new_usage_message) {
function ProgramUsageMessage (line 57) | absl::string_view ProgramUsageMessage() {
FILE: absl/flags/usage.h
function namespace (line 25) | namespace absl {
FILE: absl/flags/usage_config.cc
function ABSL_ATTRIBUTE_WEAK (line 38) | ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(
type absl (line 43) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 44) | ABSL_NAMESPACE_BEGIN
function SetFlagsUsageConfig (line 143) | void SetFlagsUsageConfig(FlagsUsageConfig usage_config) {
FILE: absl/flags/usage_config.h
function namespace (line 57) | namespace absl {
FILE: absl/flags/usage_config_test.cc
class FlagsUsageConfigTest (line 28) | class FlagsUsageConfigTest : public testing::Test {
method SetUp (line 30) | void SetUp() override {
function TstContainsHelpshortFlags (line 40) | bool TstContainsHelpshortFlags(absl::string_view f) {
function TstContainsHelppackageFlags (line 44) | bool TstContainsHelppackageFlags(absl::string_view f) {
function TstContainsHelpFlags (line 48) | bool TstContainsHelpFlags(absl::string_view f) {
function TstVersionString (line 52) | std::string TstVersionString() { return "program 1.0.0"; }
function TstNormalizeFilename (line 54) | std::string TstNormalizeFilename(absl::string_view filename) {
function TstReportUsageMessage (line 58) | void TstReportUsageMessage(absl::string_view msg) {}
function TEST_F (line 62) | TEST_F(FlagsUsageConfigTest, TestGetSetFlagsUsageConfig) {
function TEST_F (line 86) | TEST_F(FlagsUsageConfigTest, TestContainsHelpshortFlags) {
function TEST_F (line 112) | TEST_F(FlagsUsageConfigTest, TestContainsHelpFlags) {
function TEST_F (line 134) | TEST_F(FlagsUsageConfigTest, TestContainsHelppackageFlags) {
function TEST_F (line 157) | TEST_F(FlagsUsageConfigTest, TestVersionString) {
function TEST_F (line 178) | TEST_F(FlagsUsageConfigTest, TestNormalizeFilename) {
FILE: absl/functional/any_invocable.h
function namespace (line 49) | namespace absl {
FILE: absl/functional/any_invocable_test.cc
type _ (line 39) | struct _ {}
type Wrapper (line 42) | struct Wrapper {
type QualifiersForThisImpl (line 58) | struct QualifiersForThisImpl {
type QualifiersForThisImpl<Qualifiers&, This> (line 65) | struct QualifiersForThisImpl<Qualifiers&, This>
type QualifiersForThisImpl<Qualifiers&&, This> (line 69) | struct QualifiersForThisImpl<Qualifiers&&, This> {
type GiveQualifiersToFunImpl (line 82) | struct GiveQualifiersToFunImpl
type GiveQualifiersToFunImpl<T, R(P...)> (line 85) | struct GiveQualifiersToFunImpl<T, R(P...)> {
type GiveQualifiersToFunImpl<T&, R(P...)> (line 91) | struct GiveQualifiersToFunImpl<T&, R(P...)> {
type GiveQualifiersToFunImpl<T&&, R(P...)> (line 97) | struct GiveQualifiersToFunImpl<T&&, R(P...)> {
type GiveQualifiersToFunImpl<T, R(P...) noexcept> (line 103) | struct GiveQualifiersToFunImpl<T, R(P...) noexcept> {
type GiveQualifiersToFunImpl<T&, R(P...) noexcept> (line 109) | struct GiveQualifiersToFunImpl<T&, R(P...) noexcept> {
type GiveQualifiersToFunImpl<T&&, R(P...) noexcept> (line 116) | struct GiveQualifiersToFunImpl<T&&, R(P...) noexcept> {
type ObjSize (line 127) | enum class ObjSize { small, large }
type TypeErasedPadding (line 133) | struct TypeErasedPadding
type TypeErasedPadding<ObjSize::small> (line 136) | struct TypeErasedPadding<ObjSize::small> {}
type TypeErasedPadding<ObjSize::large> (line 139) | struct TypeErasedPadding<ObjSize::large> {
type Int (line 143) | struct Int {
method Int (line 144) | Int(int v) noexcept : value(v) {}
method Int (line 146) | Int(Int&&) noexcept {
method Int (line 153) | Int(Int&& v) noexcept = default;
method MemberFunctionAdd (line 157) | int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT
type Movable (line 164) | enum class Movable { no, yes, nothrow, trivial }
type NothrowCall (line 166) | enum class NothrowCall { no, yes }
type Destructible (line 168) | enum class Destructible { nothrow, trivial }
type ObjAlign (line 170) | enum class ObjAlign : std::size_t {
type add (line 179) | struct add
function Int (line 192) | Int operator()(int a, int b, int c) qual \
method Int (line 144) | Int(int v) noexcept : value(v) {}
method Int (line 146) | Int(Int&&) noexcept {
method Int (line 153) | Int(Int&& v) noexcept = default;
method MemberFunctionAdd (line 157) | int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT
type add<Movable::trivial, Destructible::nothrow, _ qual, CallExceptionSpec, \
Size, Alignment> (line 200) | struct alignas(static_cast<std::size_t>(Alignment)) ...
method add (line 203) | explicit add(int state_init) : state(state_init) {}
method add (line 204) | explicit add(std::initializer_list<int> state_init, int tail) ...
method add (line 209) | add(add&& other) = default;
method Int (line 210) | Int operator()(int a, int b, int c) qual ...
type add<Movable::no, Destructibility, Qual, CallExceptionSpec, Size,
Alignment> (line 234) | struct add<Movable::no, Destructibility, Qual, CallExceptionSpec, Size,
method add (line 240) | explicit add(int state_init) : Base(state_init) {}
method add (line 242) | explicit add(std::initializer_list<int> state_init, int tail)
method add (line 245) | add(add&&) = delete;
type add<Movable::yes, Destructibility, Qual, CallExceptionSpec, Size,
Alignment> (line 253) | struct add<Movable::yes, Destructibility, Qual, CallExceptionSpec, Size,
method add (line 259) | explicit add(int state_init) : Base(state_init) {}
method add (line 261) | explicit add(std::initializer_list<int> state_init, int tail)
method add (line 264) | add(add&& other) noexcept(false) : Base(other.state) {}
type add<Movable::nothrow, Destructibility, Qual, CallExceptionSpec, Size,
Alignment> (line 272) | struct add<Movable::nothrow, Destructibility, Qual, CallExceptionSpec, S...
method add (line 278) | explicit add(int state_init) : Base(state_init) {}
method add (line 280) | explicit add(std::initializer_list<int> state_init, int tail)
method add (line 283) | add(add&& other) noexcept : Base(other.state) {}
function Int (line 290) | Int add_function(Int&& a, int b, int c) noexcept { return a.value + b + ...
method Int (line 144) | Int(int v) noexcept : value(v) {}
method Int (line 146) | Int(Int&&) noexcept {
method Int (line 153) | Int(Int&& v) noexcept = default;
method MemberFunctionAdd (line 157) | int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT
function Int (line 292) | Int mult_function(Int&& a, int b, int c) noexcept { return a.value * b *...
method Int (line 144) | Int(int v) noexcept : value(v) {}
method Int (line 146) | Int(Int&&) noexcept {
method Int (line 153) | Int(Int&& v) noexcept = default;
method MemberFunctionAdd (line 157) | int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT
function Int (line 294) | Int square_function(Int const&& a) noexcept { return a.value * a.value; }
method Int (line 144) | Int(int v) noexcept : value(v) {}
method Int (line 146) | Int(Int&&) noexcept {
method Int (line 153) | Int(Int&& v) noexcept = default;
method MemberFunctionAdd (line 157) | int MemberFunctionAdd(int const& b, int c) noexcept { // NOLINT
function TYPED_TEST_P (line 303) | struct TestParams {
function TYPED_TEST_P (line 552) | TYPED_TEST_P(AnyInvTestBasic, Invocation) {
function TYPED_TEST_P (line 567) | TYPED_TEST_P(AnyInvTestBasic, InPlaceConstruction) {
function TYPED_TEST_P (line 577) | TYPED_TEST_P(AnyInvTestBasic, InPlaceConstructionInitializerList) {
function TYPED_TEST_P (line 587) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullFunPtrConstruction) {
function TYPED_TEST_P (line 597) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullFunPtrConstructionValueInit) {
function TYPED_TEST_P (line 607) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemFunPtrConstruction) {
function TYPED_TEST_P (line 617) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemFunPtrConstructionValueInit) {
function TYPED_TEST_P (line 627) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemObjPtrConstruction) {
function TYPED_TEST_P (line 637) | TYPED_TEST_P(AnyInvTestBasic, InPlaceNullMemObjPtrConstructionValueInit) {
function TYPED_TEST_P (line 647) | TYPED_TEST_P(AnyInvTestBasic, InPlaceVoidCovarianceConstruction) {
function TYPED_TEST_P (line 656) | TYPED_TEST_P(AnyInvTestBasic, MoveConstructionFromEmpty) {
function TYPED_TEST_P (line 667) | TYPED_TEST_P(AnyInvTestBasic, MoveConstructionFromNonEmpty) {
function TYPED_TEST_P (line 680) | TYPED_TEST_P(AnyInvTestBasic, ComparisonWithNullptrEmpty) {
function TYPED_TEST_P (line 692) | TYPED_TEST_P(AnyInvTestBasic, ComparisonWithNullptrNonempty) {
function TYPED_TEST_P (line 705) | TYPED_TEST_P(AnyInvTestBasic, ResultType) {
class AnyInvTestCombinatoric (line 714) | class AnyInvTestCombinatoric : public ::testing::Test {}
function TYPED_TEST_P (line 718) | TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignEmptyEmptyLhsRhs) {
function TYPED_TEST_P (line 729) | TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignEmptyLhsNonemptyRhs) {
function TYPED_TEST_P (line 742) | TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignNonemptyEmptyLhsRhs) {
function TYPED_TEST_P (line 754) | TYPED_TEST_P(AnyInvTestCombinatoric, MoveAssignNonemptyLhsNonemptyRhs) {
function TYPED_TEST_P (line 767) | TYPED_TEST_P(AnyInvTestCombinatoric, SelfMoveAssignEmpty) {
function TYPED_TEST_P (line 776) | TYPED_TEST_P(AnyInvTestCombinatoric, SelfMoveAssignNonempty) {
function TYPED_TEST_P (line 786) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullptrEmptyLhs) {
function TYPED_TEST_P (line 795) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullFunctionPtrEmptyLhs) {
function TYPED_TEST_P (line 806) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberFunctionPtrEmptyLhs) {
function TYPED_TEST_P (line 817) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberObjectPtrEmptyLhs) {
function TYPED_TEST_P (line 828) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberFunctionPtrEmptyLhs) {
function TYPED_TEST_P (line 838) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberObjectPtrEmptyLhs) {
function TYPED_TEST_P (line 848) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignFunctionReferenceDecayEmptyLh...
function TYPED_TEST_P (line 858) | TYPED_TEST_P(AnyInvTestCombinatoric,
function TYPED_TEST_P (line 874) | TYPED_TEST_P(AnyInvTestCombinatoric,
function TYPED_TEST_P (line 889) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullptrNonemptyLhs) {
function TYPED_TEST_P (line 898) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullFunctionPtrNonemptyLhs) {
function TYPED_TEST_P (line 909) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberFunctionPtrNonempty...
function TYPED_TEST_P (line 920) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignNullMemberObjectPtrNonemptyLh...
function TYPED_TEST_P (line 931) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberFunctionPtrNonemptyLhs) {
function TYPED_TEST_P (line 941) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignMemberObjectPtrNonemptyLhs) {
function TYPED_TEST_P (line 951) | TYPED_TEST_P(AnyInvTestCombinatoric, AssignFunctionReferenceDecayNonempt...
function TYPED_TEST_P (line 961) | TYPED_TEST_P(AnyInvTestCombinatoric,
function TYPED_TEST_P (line 977) | TYPED_TEST_P(AnyInvTestCombinatoric,
function TYPED_TEST_P (line 992) | TYPED_TEST_P(AnyInvTestCombinatoric, SwapEmptyLhsEmptyRhs) {
function TYPED_TEST_P (line 1024) | TYPED_TEST_P(AnyInvTestCombinatoric, SwapEmptyLhsNonemptyRhs) {
function TYPED_TEST_P (line 1061) | TYPED_TEST_P(AnyInvTestCombinatoric, SwapNonemptyLhsEmptyRhs) {
function TYPED_TEST_P (line 1098) | TYPED_TEST_P(AnyInvTestCombinatoric, SwapNonemptyLhsNonemptyRhs) {
class AnyInvTestMovable (line 1138) | class AnyInvTestMovable : public ::testing::Test {}
function TYPED_TEST_P (line 1142) | TYPED_TEST_P(AnyInvTestMovable, ConversionConstructionUserDefinedType) {
function TYPED_TEST_P (line 1152) | TYPED_TEST_P(AnyInvTestMovable, ConversionConstructionVoidCovariance) {
function TYPED_TEST_P (line 1161) | TYPED_TEST_P(AnyInvTestMovable, ConversionAssignUserDefinedTypeEmptyLhs) {
function TYPED_TEST_P (line 1172) | TYPED_TEST_P(AnyInvTestMovable, ConversionAssignUserDefinedTypeNonemptyL...
function TYPED_TEST_P (line 1183) | TYPED_TEST_P(AnyInvTestMovable, ConversionAssignVoidCovariance) {
class AnyInvTestNoexceptFalse (line 1194) | class AnyInvTestNoexceptFalse : public ::testing::Test {}
function TYPED_TEST_P (line 1198) | TYPED_TEST_P(AnyInvTestNoexceptFalse, ConversionConstructionConstraints) {
function TYPED_TEST_P (line 1209) | TYPED_TEST_P(AnyInvTestNoexceptFalse, ConversionAssignConstraints) {
class AnyInvTestNoexceptTrue (line 1221) | class AnyInvTestNoexceptTrue : public ::testing::Test {}
function TYPED_TEST_P (line 1225) | TYPED_TEST_P(AnyInvTestNoexceptTrue, ConversionConstructionConstraints) {
function TYPED_TEST_P (line 1236) | TYPED_TEST_P(AnyInvTestNoexceptTrue, ConversionAssignConstraints) {
class AnyInvTestNonRvalue (line 1248) | class AnyInvTestNonRvalue : public ::testing::Test {}
function TYPED_TEST_P (line 1252) | TYPED_TEST_P(AnyInvTestNonRvalue, ConversionConstructionReferenceWrapper) {
function TYPED_TEST_P (line 1267) | TYPED_TEST_P(AnyInvTestNonRvalue, NonMoveableResultType) {
function TYPED_TEST_P (line 1296) | TYPED_TEST_P(AnyInvTestNonRvalue, ConversionAssignReferenceWrapperEmptyL...
function TYPED_TEST_P (line 1315) | TYPED_TEST_P(AnyInvTestNonRvalue, ConversionAssignReferenceWrapperNonemp...
class AnyInvTestRvalue (line 1335) | class AnyInvTestRvalue : public ::testing::Test {}
function TYPED_TEST_P (line 1339) | TYPED_TEST_P(AnyInvTestRvalue, ConversionConstructionReferenceWrapper) {
function TYPED_TEST_P (line 1347) | TYPED_TEST_P(AnyInvTestRvalue, NonMoveableResultType) {
function TYPED_TEST_P (line 1375) | TYPED_TEST_P(AnyInvTestRvalue, ConversionAssignReferenceWrapper) {
function TYPED_TEST_P (line 1383) | TYPED_TEST_P(AnyInvTestRvalue, NonConstCrashesOnSecondCall) {
function TYPED_TEST_P (line 1402) | TYPED_TEST_P(AnyInvTestRvalue, QualifierIndependentObjectLifetime) {
FILE: absl/functional/bind_front.h
function namespace (line 48) | namespace absl {
FILE: absl/functional/bind_front_test.cc
function CharAt (line 29) | char CharAt(const char* s, size_t index) { return s[index]; }
function TEST (line 31) | TEST(BindTest, Basics) {
function TEST (line 37) | TEST(BindTest, Lambda) {
type Functor (line 45) | struct Functor {
function TEST (line 52) | TEST(BindTest, PerfectForwardingOfBoundArgs) {
type ArgDescribe (line 61) | struct ArgDescribe {
function TEST (line 68) | TEST(BindTest, PerfectForwardingOfFreeArgs) {
type NonCopyableFunctor (line 77) | struct NonCopyableFunctor {
method NonCopyableFunctor (line 78) | NonCopyableFunctor() = default;
method NonCopyableFunctor (line 79) | NonCopyableFunctor(const NonCopyableFunctor&) = delete;
method NonCopyableFunctor (line 80) | NonCopyableFunctor& operator=(const NonCopyableFunctor&) = delete;
method NonCopyableFunctor (line 81) | const NonCopyableFunctor* operator()() const { return this; }
function TEST (line 84) | TEST(BindTest, RefToFunctor) {
type Struct (line 92) | struct Struct {
function TEST (line 96) | TEST(BindTest, StoreByCopy) {
type NonCopyable (line 107) | struct NonCopyable {
method NonCopyable (line 108) | explicit NonCopyable(const std::string& s) : value(s) {}
method NonCopyable (line 109) | NonCopyable(const NonCopyable&) = delete;
method NonCopyable (line 110) | NonCopyable& operator=(const NonCopyable&) = delete;
function TEST (line 117) | TEST(BindTest, StoreByRef) {
function TEST (line 129) | TEST(BindTest, StoreByCRef) {
function TEST (line 146) | TEST(BindTest, StoreByRefInvokeByWrapper) {
function TEST (line 158) | TEST(BindTest, StoreByPointer) {
function Sink (line 168) | int Sink(std::unique_ptr<int> p) {
function Factory (line 172) | std::unique_ptr<int> Factory(int n) { return absl::make_unique<int>(n); }
function TEST (line 174) | TEST(BindTest, NonCopyableArg) {
function TEST (line 179) | TEST(BindTest, NonCopyableResult) {
type FalseCopyable (line 188) | struct FalseCopyable {
method FalseCopyable (line 189) | FalseCopyable() {}
method FalseCopyable (line 190) | FalseCopyable(const FalseCopyable& other) : m(other.m) {}
method FalseCopyable (line 191) | FalseCopyable(FalseCopyable&& other) : m(std::move(other.m)) {}
function GetMember (line 195) | int GetMember(FalseCopyable<std::unique_ptr<int>> x) { return *x.m; }
function TEST (line 197) | TEST(BindTest, WrappedMoveOnly) {
function Plus (line 204) | int Plus(int a, int b) { return a + b; }
function TEST (line 206) | TEST(BindTest, ConstExpr) {
type ManglingCall (line 218) | struct ManglingCall {
function TEST (line 222) | TEST(BindTest, Mangling) {
FILE: absl/functional/function_ref_test.cc
type absl (line 29) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 30) | ABSL_NAMESPACE_BEGIN
FILE: absl/functional/function_type_benchmark.cc
type absl (line 24) | namespace absl {
function ABSL_NAMESPACE_BEGIN (line 25) | ABSL_NAMESPACE_BEGIN
FILE: absl/functional/internal/any_invocable.h
function namespace (line 74) | namespace absl {
function class (line 374) | class TrivialDeleter {
function class (line 386) | class TrivialDeleter {
function IsCompatibleConversion (line 397) | constexpr bool IsCompatibleConversion(void*, void*) { return false; }
function else (line 451) | else if constexpr (IsAnyInvocable<DecayedT>::value) {
function Clear (line 505) | void Clear() {
type ConversionConstruct (line 581) | struct ConversionConstruct {}
function ReturnType (line 730) | static ReturnType InvokedAfterMove( ...
function ReturnType (line 751) | ReturnType operator()(P... args) cv ref noexcept(noex) { ...
FILE: absl/functional/internal/front_binder.h
function namespace (line 28) | namespace absl {
FILE: absl/functional/internal/function_ref.h
function namespace (line 25) | namespace absl {
FILE: absl/functional/overload.h
function namespace (line 44) | namespace absl {
FILE: absl/functional/overload_test.cc
function TEST (line 29) | TEST(OverloadTest, DispatchConsidersTypeWithAutoFallback) {
function TEST (line 43) | TEST(OverloadTest, DispatchConsidersNumberOfArguments) {
function TEST (line 55) | TEST(OverloadTest, SupportsConstantEvaluation) {
function TEST (line 67) | TEST(OverloadTest, PropogatesDefaults) {
function TEST (line 78) | TEST(OverloadTest, AmbiguousWithDefaultsNotInvocable) {
function TEST (line 88) | TEST(OverloadTest, AmbiguousDuplicatesNotInvocable) {
function TEST (line 97) | TEST(OverloadTest, AmbiguousConversionNotInvocable) {
function TEST (line 106) | TEST(OverloadTest, AmbiguousConversionWithAutoNotInvocable) {
function TEST (line 117) | TEST(OverloadTest, AmbiguousConversionWithAutoAndTemplateNotInvocable) {
function TEST (line 126) | TEST(OverloadTest, DispatchConsidersTypeWithTemplateFallback) {
function TEST (line 138) | TEST(OverloadTest, DispatchConsidersSfinae) {
function TEST (line 147) | TEST(OverloadTest, VariantVisitDispatchesCorrectly) {
function TEST (line 162) | TEST(OverloadTest, VariantVisitWithAutoFallbackDispatchesCorrectly) {
function TEST (line 178) | TEST(OverloadTest, UseWithParentheses) {
function TEST (line 193) | TEST(OverloadTest, HasConstexprConstructor) {
FILE: absl/hash/hash.h
function namespace (line 93) | namespace absl {
function class (line 321) | class HashState : public hash_internal::HashStateBase<HashState> {
function HashState (line 420) | HashState RunCombineUnorderedImpl(
function HashState (line 434) | HashState RunCombineUnordered(HashState state, CombinerT combiner) {
function Init (line 440) | void Init(HashState* state) {
FILE: absl/hash/hash_benchmark.cc
function RunBenchmark (line 41) | void RunBenchmark(benchmark::State& state, T value) {
class TypeErasedInterface (line 54) | class TypeErasedInterface {
method H (line 59) | H AbslHashValue(H state, const TypeErasedInterface& wrapper) {
type TypeErasedAbslHash (line 70) | struct TypeErasedAbslHash {
class Wrapper (line 71) | class Wrapper : public TypeErasedInterface {
method Wrapper (line 73) | explicit Wrapper(const T& value) : value_(value) {}
method HashValue (line 76) | void HashValue(absl::HashState state) const override {
function FlatCord (line 88) | absl::Cord FlatCord(size_t size) {
function FragmentedCord (line 94) | absl::Cord FragmentedCord(size_t size) {
function Vector (line 112) | std::vector<T> Vector(size_t count) {
type FastUnorderedSet (line 124) | struct FastUnorderedSet {
method FastUnorderedSet (line 125) | explicit FastUnorderedSet(size_t count) {
method H (line 133) | H AbslHashValue(H h, const FastUnorderedSet& fus) {
function FlatHashSet (line 141) | absl::flat_hash_set<T> FlatHashSet(size_t count) {
type LongCombine (line 150) | struct LongCombine {
method H (line 153) | H AbslHashValue(H state, const LongCombine& v) {
function MakeLongTuple (line 189) | auto MakeLongTuple() {
type PodPairInt64 (line 341) | struct PodPairInt64 {
method H (line 346) | H AbslHashValue(H h, const PodPairInt64& p) {
type PodRand (line 352) | struct PodRand {
method T (line 356) | T Get(size_t i) const {
type StringRand (line 364) | struct StringRand {
method Get (line 367) | absl::string_view Get(size_t i) const {
FILE: absl/hash/hash_instantiated_test.cc
class UnorderedSequence (line 56) | class UnorderedSequence {
method UnorderedSequence (line 58) | UnorderedSequence() = default;
method UnorderedSequence (line 60) | UnorderedSequence(std::initializer_list<TT> l)
method UnorderedSequence (line 65) | UnorderedSequence(ForwardIterator begin, ForwardIterator end)
method UnorderedSequence (line 69) | explicit UnorderedSequence(const T& v) : values_(&v, &v + 1) {}
method size (line 73) | size_t size() const { return values_.size(); }
method begin (line 74) | typename std::vector<T>::const_iterator begin() const {
method end (line 77) | typename std::vector<T>::const_iterator end() const { return values_.e...
method H (line 89) | H AbslHashValue(H h, const UnorderedSequence& u) {
class HashValueSequenceTest (line 99) | class HashValueSequenceTest : public testing::Test {}
function TYPED_TEST_P (line 102) | TYPED_TEST_P(HashValueSequenceTest, BasicUsage) {
class HashValueNestedSequenceTest (line 130) | class HashValueNestedSequenceTest : public testing::Test {}
function TYPED_TEST_P (line 133) | TYPED_TEST_P(HashValueNestedSequenceTest, BasicUsage) {
class HashValueAssociativeMapTest (line 167) | class HashValueAssociativeMapTest : public testing::Test {}
function TYPED_TEST_P (line 170) | TYPED_TEST_P(HashValueAssociativeMapTest, BasicUsage) {
class HashValueAssociativeMultimapTest (line 196) | class HashValueAssociativeMultimapTest : public testing::Test {}
functi
Copy disabled (too large)
Download .json
Condensed preview — 1585 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (11,222K chars).
[
{
"path": ".clang-format",
"chars": 51,
"preview": "---\nLanguage: Cpp\nBasedOnStyle: Google\n...\n"
},
{
"path": ".github/ISSUE_TEMPLATE/00-bug_report.yml",
"chars": 2050,
"preview": "name: Bug Report\ndescription: Let us know that something does not work as expected.\ntitle: \"[Bug]: Please title this bug"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 175,
"preview": "blank_issues_enabled: false\ncontact_links:\n - name: Question\n url: https://github.com/abseil/abseil-cpp/discussi"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 393,
"preview": "Thank you for your contribution to Abseil!\n\nBefore submitting this PR, please be sure to read our [contributing\nguidelin"
},
{
"path": ".gitignore",
"chars": 349,
"preview": "# Bzlmod lockfile\nMODULE.bazel.lock\n# Ignore all bazel-* symlinks.\n/bazel-*\n# Ignore Bazel verbose explanations\n--verbos"
},
{
"path": "ABSEIL_ISSUE_TEMPLATE.md",
"chars": 1095,
"preview": "Please submit a new Abseil Issue using the template below:\n\n## [Short title of proposed API change(s)]\n\n----------------"
},
{
"path": "AUTHORS",
"chars": 295,
"preview": "# This is the list of Abseil authors for copyright purposes.\n#\n# This does not necessarily list everyone who has contrib"
},
{
"path": "BUILD.bazel",
"chars": 1048,
"preview": "# Copyright 2020 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not u"
},
{
"path": "CMake/AbseilDll.cmake",
"chars": 27378,
"preview": "include(CMakeParseArguments)\ninclude(GNUInstallDirs)\n\nset(ABSL_INTERNAL_DLL_FILES\n \"algorithm/algorithm.h\"\n \"algorithm"
},
{
"path": "CMake/AbseilHelpers.cmake",
"chars": 15389,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "CMake/Googletest/CMakeLists.txt.in",
"chars": 378,
"preview": "cmake_minimum_required(VERSION 3.16)\n\nproject(googletest-external NONE)\n\ninclude(ExternalProject)\nExternalProject_Add(go"
},
{
"path": "CMake/Googletest/DownloadGTest.cmake",
"chars": 1648,
"preview": "# Integrates googletest at configure time. Based on the instructions at\n# https://github.com/google/googletest/tree/mas"
},
{
"path": "CMake/README.md",
"chars": 7119,
"preview": "# Abseil CMake Build Instructions\n\nAbseil comes with a CMake build script ([CMakeLists.txt](../CMakeLists.txt))\nthat can"
},
{
"path": "CMake/abslConfig.cmake.in",
"chars": 176,
"preview": "# absl CMake configuration file.\n\ninclude(CMakeFindDependencyMacro)\nfind_dependency(Threads)\n\n@PACKAGE_INIT@\n\ninclude (\""
},
{
"path": "CMake/install_test_project/CMakeLists.txt",
"chars": 834,
"preview": "#\n# Copyright 2019 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "CMake/install_test_project/simple.cc",
"chars": 1113,
"preview": "//\n// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "CMake/install_test_project/test.sh",
"chars": 3031,
"preview": "#!/bin/bash\n#\n# Copyright 2019 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n#"
},
{
"path": "CMakeLists.txt",
"chars": 10296,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "CONTRIBUTING.md",
"chars": 6870,
"preview": "# How to Contribute to Abseil\n\nWe'd love to accept your patches and contributions to this project. There are\njust a few "
},
{
"path": "FAQ.md",
"chars": 11852,
"preview": "# Abseil FAQ\n\n## Is Abseil the right home for my utility library?\n\nMost often the answer to the question is \"no.\" As bot"
},
{
"path": "LICENSE",
"chars": 11361,
"preview": "\n Apache License\n Version 2.0, January 2004\n "
},
{
"path": "MODULE.bazel",
"chars": 1376,
"preview": "# Copyright 2024 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not u"
},
{
"path": "PrivacyInfo.xcprivacy",
"chars": 381,
"preview": "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/P"
},
{
"path": "README.md",
"chars": 6564,
"preview": "# Abseil - C++ Common Libraries\n\nThe repository contains the Abseil C++ library code. Abseil is an open-source\ncollectio"
},
{
"path": "UPGRADES.md",
"chars": 641,
"preview": "# C++ Upgrade Tools\n\nAbseil may occasionally release API-breaking changes. As noted in our\n[Compatibility Guidelines][co"
},
{
"path": "absl/BUILD.bazel",
"chars": 1696,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/CMakeLists.txt",
"chars": 1285,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/abseil.podspec.gen.py",
"chars": 7831,
"preview": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"This script generates abseil.podspec from all BUILD.bazel files.\n\nThis"
},
{
"path": "absl/algorithm/BUILD.bazel",
"chars": 2199,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/algorithm/CMakeLists.txt",
"chars": 1354,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/algorithm/algorithm.h",
"chars": 2212,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/algorithm/algorithm_test.cc",
"chars": 1935,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/algorithm/container.h",
"chars": 84003,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/algorithm/container_test.cc",
"chars": 74279,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/BUILD.bazel",
"chars": 23820,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/base/CMakeLists.txt",
"chars": 14637,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/base/attributes.h",
"chars": 43357,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/attributes_test.cc",
"chars": 1373,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/bit_cast_test.cc",
"chars": 3492,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/c_header_test.c",
"chars": 1313,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/call_once.h",
"chars": 8421,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/call_once_test.cc",
"chars": 3208,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/casts.cc",
"chars": 1602,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/casts.h",
"chars": 12560,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/casts_test.cc",
"chars": 5546,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/config.h",
"chars": 34440,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/config_test.cc",
"chars": 1703,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/const_init.h",
"chars": 3431,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/dynamic_annotations.h",
"chars": 19155,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/exception_safety_testing_test.cc",
"chars": 28238,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/fast_type_id.h",
"chars": 2162,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/fast_type_id_test.cc",
"chars": 3499,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/atomic_hook.h",
"chars": 7511,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/atomic_hook_test.cc",
"chars": 3127,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/atomic_hook_test_helper.cc",
"chars": 1119,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/atomic_hook_test_helper.h",
"chars": 1121,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/cmake_thread_test.cc",
"chars": 845,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/cycleclock.cc",
"chars": 2062,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/cycleclock.h",
"chars": 4983,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/cycleclock_config.h",
"chars": 1886,
"preview": "// Copyright 2022 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/direct_mmap.h",
"chars": 5868,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/dynamic_annotations.h",
"chars": 15843,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/endian.h",
"chars": 9262,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/endian_test.cc",
"chars": 7840,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/errno_saver.h",
"chars": 1321,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/errno_saver_test.cc",
"chars": 1444,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/exception_safety_testing.cc",
"chars": 2237,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/exception_safety_testing.h",
"chars": 38348,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/exception_testing.h",
"chars": 1529,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/hardening.cc",
"chars": 1378,
"preview": "//\n// Copyright 2026 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/hardening.h",
"chars": 1964,
"preview": "//\n// Copyright 2026 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/hardening_test.cc",
"chars": 1224,
"preview": "// Copyright 2026 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/hide_ptr.h",
"chars": 1677,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/iterator_traits.h",
"chars": 2529,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/iterator_traits_test.cc",
"chars": 3942,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/iterator_traits_test_helper.h",
"chars": 2971,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/low_level_alloc.cc",
"chars": 24228,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/low_level_alloc.h",
"chars": 4926,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/low_level_alloc_test.cc",
"chars": 5608,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/low_level_scheduling.h",
"chars": 7454,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/nullability_traits.h",
"chars": 2304,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/nullability_traits_test.cc",
"chars": 3553,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/per_thread_tls.h",
"chars": 1758,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/poison.cc",
"chars": 2424,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/poison.h",
"chars": 2105,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/poison_test.cc",
"chars": 1323,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/pretty_function.h",
"chars": 1334,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/raw_logging.cc",
"chars": 8913,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/raw_logging.h",
"chars": 10256,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/scheduling_mode.h",
"chars": 2410,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/scoped_set_env.cc",
"chars": 2014,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/scoped_set_env.h",
"chars": 1187,
"preview": "//\n// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/scoped_set_env_test.cc",
"chars": 2559,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock.cc",
"chars": 9326,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock.h",
"chars": 11671,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/spinlock_akaros.inc",
"chars": 1359,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_benchmark.cc",
"chars": 2745,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_linux.inc",
"chars": 2387,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_posix.inc",
"chars": 1484,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_wait.cc",
"chars": 2826,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_wait.h",
"chars": 3850,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/spinlock_win32.inc",
"chars": 1369,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/strerror.cc",
"chars": 2645,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/strerror.h",
"chars": 1386,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/strerror_benchmark.cc",
"chars": 933,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/strerror_test.cc",
"chars": 2807,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/sysinfo.cc",
"chars": 15060,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/sysinfo.h",
"chars": 2702,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/sysinfo_test.cc",
"chars": 2317,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/thread_identity.cc",
"chars": 6586,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/thread_identity.h",
"chars": 14032,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/thread_identity_benchmark.cc",
"chars": 1307,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/thread_identity_test.cc",
"chars": 4556,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/tracing.cc",
"chars": 1297,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/tracing.h",
"chars": 3309,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/tracing_strong_test.cc",
"chars": 3705,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/tracing_weak_test.cc",
"chars": 1233,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/internal/tsan_mutex_interface.h",
"chars": 2521,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/unaligned_access.h",
"chars": 2543,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/internal/unique_small_name_test.cc",
"chars": 2288,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/unscaledcycleclock.cc",
"chars": 3471,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/unscaledcycleclock.h",
"chars": 3790,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/internal/unscaledcycleclock_config.h",
"chars": 2503,
"preview": "// Copyright 2022 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/log_severity.cc",
"chars": 1867,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/log_severity.h",
"chars": 7074,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/log_severity_test.cc",
"chars": 11355,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/macros.h",
"chars": 9256,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/no_destructor.h",
"chars": 7132,
"preview": "// Copyright 2023 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/no_destructor_benchmark.cc",
"chars": 5089,
"preview": "// Copyright 2023 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/no_destructor_test.cc",
"chars": 5661,
"preview": "// Copyright 2023 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/nullability.h",
"chars": 13760,
"preview": "// Copyright 2023 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/nullability_default_nonnull_test.cc",
"chars": 1189,
"preview": "// Copyright 2024 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/nullability_test.cc",
"chars": 3136,
"preview": "// Copyright 2023 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/optimization.h",
"chars": 12181,
"preview": "//\n// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you ma"
},
{
"path": "absl/base/optimization_test.cc",
"chars": 4490,
"preview": "// Copyright 2020 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/options.h",
"chars": 9292,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/policy_checks.h",
"chars": 4321,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/port.h",
"chars": 896,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/prefetch.h",
"chars": 7210,
"preview": "// Copyright 2023 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/prefetch_test.cc",
"chars": 2512,
"preview": "// Copyright 2023 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/base/raw_logging_test.cc",
"chars": 3235,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/spinlock_test_common.cc",
"chars": 9999,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/thread_annotations.h",
"chars": 11918,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/throw_delegate.cc",
"chars": 4726,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/throw_delegate.h",
"chars": 2888,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/base/throw_delegate_test.cc",
"chars": 4474,
"preview": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/cleanup/BUILD.bazel",
"chars": 1787,
"preview": "# Copyright 2021 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not u"
},
{
"path": "absl/cleanup/CMakeLists.txt",
"chars": 1169,
"preview": "# Copyright 2021 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not u"
},
{
"path": "absl/cleanup/cleanup.h",
"chars": 4722,
"preview": "// Copyright 2021 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/cleanup/cleanup_test.cc",
"chars": 8249,
"preview": "// Copyright 2021 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/cleanup/internal/cleanup.h",
"chars": 2720,
"preview": "// Copyright 2021 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/BUILD.bazel",
"chars": 35917,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/container/CMakeLists.txt",
"chars": 22581,
"preview": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not"
},
{
"path": "absl/container/btree_benchmark.cc",
"chars": 29972,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/btree_map.h",
"chars": 35204,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/btree_set.h",
"chars": 31296,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/btree_test.cc",
"chars": 120721,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/btree_test.h",
"chars": 4630,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/chunked_queue.h",
"chars": 25195,
"preview": "// Copyright 2025 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/chunked_queue_benchmark.cc",
"chars": 14448,
"preview": "// Copyright 2025 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/chunked_queue_test.cc",
"chars": 20467,
"preview": "// Copyright 2025 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/fixed_array.h",
"chars": 20118,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/fixed_array_benchmark.cc",
"chars": 2527,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/fixed_array_exception_safety_test.cc",
"chars": 6994,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/fixed_array_test.cc",
"chars": 26414,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/flat_hash_map.h",
"chars": 27932,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/flat_hash_map_test.cc",
"chars": 15742,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/flat_hash_set.h",
"chars": 22711,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/flat_hash_set_test.cc",
"chars": 13201,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/hash_container_defaults.h",
"chars": 1801,
"preview": "// Copyright 2024 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/container/inlined_vector.h",
"chars": 40337,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/inlined_vector_benchmark.cc",
"chars": 25675,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/inlined_vector_exception_safety_test.cc",
"chars": 17390,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/inlined_vector_test.cc",
"chars": 72334,
"preview": "// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/btree.h",
"chars": 119546,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/btree_container.h",
"chars": 37329,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/chunked_queue.h",
"chars": 6227,
"preview": "// Copyright 2025 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/common.h",
"chars": 9397,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/common_policy_traits.h",
"chars": 5522,
"preview": "// Copyright 2022 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/common_policy_traits_test.cc",
"chars": 4781,
"preview": "// Copyright 2022 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/compressed_tuple.h",
"chars": 10210,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/compressed_tuple_test.cc",
"chars": 14948,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/container_memory.h",
"chars": 21441,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/container_memory_test.cc",
"chars": 10985,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_function_defaults.h",
"chars": 9662,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_function_defaults_test.cc",
"chars": 18538,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_generator_testing.cc",
"chars": 1697,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_generator_testing.h",
"chars": 4824,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_policy_testing.h",
"chars": 4818,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_policy_testing_test.cc",
"chars": 1280,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_policy_traits.h",
"chars": 7791,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hash_policy_traits_test.cc",
"chars": 4152,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtable_control_bytes.h",
"chars": 20207,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/container/internal/hashtable_control_bytes_test.cc",
"chars": 10892,
"preview": "// Copyright 2025 The Abseil Authors\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may no"
},
{
"path": "absl/container/internal/hashtable_debug.h",
"chars": 3784,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtable_debug_hooks.h",
"chars": 2976,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtablez_sampler.cc",
"chars": 11149,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtablez_sampler.h",
"chars": 11207,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtablez_sampler_force_weak_definition.cc",
"chars": 1003,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
},
{
"path": "absl/container/internal/hashtablez_sampler_test.cc",
"chars": 17538,
"preview": "// Copyright 2018 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may n"
}
]
// ... and 1385 more files (download for full content)
About this extraction
This page contains the full source code of the abseil/abseil-cpp GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1585 files (10.3 MB), approximately 2.8M tokens, and a symbol index with 6636 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.