[ { "path": ".clang-format", "content": "---\nLanguage: Cpp\nBasedOnStyle: Google\n...\n" }, { "path": ".github/ISSUE_TEMPLATE/00-bug_report.yml", "content": "name: Bug Report\ndescription: Let us know that something does not work as expected.\ntitle: \"[Bug]: Please title this bug report\"\nbody:\n - type: textarea\n id: what-happened\n attributes:\n label: Describe the issue\n description: What happened, and what did you expect to happen?\n validations:\n required: true\n - type: textarea\n id: steps\n attributes:\n label: Steps to reproduce the problem\n 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.\n validations:\n required: true\n - type: textarea\n id: version\n attributes:\n label: What version of Abseil are you using?\n description: Please include the output of `git rev-parse HEAD` or the name of the LTS release that you are using.\n validations:\n required: true\n - type: textarea\n id: os\n attributes:\n label: What operating system and version are you using?\n description: If you are using a Linux distribution please include the name and version of the distribution as well.\n validations:\n required: true\n - type: textarea\n id: compiler\n attributes:\n label: What compiler and version are you using?\n description: Please include the output of `gcc -v` or `clang -v`, or the equivalent for your compiler.\n validations:\n required: true\n - type: textarea\n id: buildsystem\n attributes:\n label: What build system are you using?\n description: Please include the output of `bazel --version` or `cmake --version`, or the equivalent for your build system.\n validations:\n required: true\n - type: textarea\n id: additional\n attributes:\n label: Additional context\n description: Add any other context about the problem here.\n validations:\n required: false\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "blank_issues_enabled: false\ncontact_links:\n - name: Question\n url: https://github.com/abseil/abseil-cpp/discussions\n about: Have a question? Ask us anything! :-)\n" }, { "path": ".github/PULL_REQUEST_TEMPLATE.md", "content": "Thank you for your contribution to Abseil!\n\nBefore submitting this PR, please be sure to read our [contributing\nguidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md).\n\nIf you are a Googler, please also note that it is required that you send us a\nPiper CL instead of using the GitHub pull-request process. The code propagation\nprocess will deliver the change to GitHub.\n" }, { "path": ".gitignore", "content": "# Bzlmod lockfile\nMODULE.bazel.lock\n# Ignore all bazel-* symlinks.\n/bazel-*\n# Ignore Bazel verbose explanations\n--verbose_explanations\n# Ignore CMake usual build directory\nbuild\n# Ignore Vim files\n*.swp\n# Ignore QtCreator Project file\nCMakeLists.txt.user\n# Ignore VS Code files\n.vscode/*\n# Ignore generated python artifacts\n*.pyc\ncopts/__pycache__/\n" }, { "path": "ABSEIL_ISSUE_TEMPLATE.md", "content": "Please submit a new Abseil Issue using the template below:\n\n## [Short title of proposed API change(s)]\n\n--------------------------------------------------------------------------------\n--------------------------------------------------------------------------------\n\n## Background\n\n[Provide the background information that is required in order to evaluate the\nproposed API changes. No controversial claims should be made here. If there are\ndesign constraints that need to be considered, they should be presented here\n**along with justification for those constraints**. Linking to other docs is\ngood, but please keep the **pertinent information as self contained** as\npossible in this section.]\n\n## Proposed API Change (s)\n\n[Please clearly describe the API change(s) being proposed. If multiple changes,\nplease keep them clearly distinguished. When possible, **use example code\nsnippets to illustrate before-after API usages**. List pros-n-cons. Highlight\nthe main questions that you want to be answered. Given the Abseil project compatibility requirements, describe why the API change is safe.]\n" }, { "path": "AUTHORS", "content": "# This is the list of Abseil authors for copyright purposes.\n#\n# This does not necessarily list everyone who has contributed code, since in\n# some cases, their employer may be the copyright holder. To see the full list\n# of contributors, see the revision history in source control.\nGoogle Inc.\n" }, { "path": "BUILD.bazel", "content": "# Copyright 2020 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\npackage(default_visibility = [\"//visibility:public\"])\n\nlicenses([\"notice\"]) # Apache 2.0\n\n# Expose license for external usage through bazel.\nexports_files([\n \"AUTHORS\",\n \"LICENSE\",\n])\n\n# For building with clang-cl.\n# https://bazel.build/configure/windows#clang\nplatform(\n name = \"x64_windows-clang-cl\",\n constraint_values = [\n \"@platforms//cpu:x86_64\",\n \"@platforms//os:windows\",\n \"@bazel_tools//tools/cpp:clang-cl\",\n ],\n)\n" }, { "path": "CMake/AbseilDll.cmake", "content": "include(CMakeParseArguments)\ninclude(GNUInstallDirs)\n\nset(ABSL_INTERNAL_DLL_FILES\n \"algorithm/algorithm.h\"\n \"algorithm/container.h\"\n \"base/attributes.h\"\n \"base/call_once.h\"\n \"base/casts.cc\"\n \"base/casts.h\"\n \"base/config.h\"\n \"base/const_init.h\"\n \"base/dynamic_annotations.h\"\n \"base/fast_type_id.h\"\n \"base/internal/atomic_hook.h\"\n \"base/internal/cycleclock.cc\"\n \"base/internal/cycleclock.h\"\n \"base/internal/cycleclock_config.h\"\n \"base/internal/direct_mmap.h\"\n \"base/internal/dynamic_annotations.h\"\n \"base/internal/endian.h\"\n \"base/internal/errno_saver.h\"\n \"base/internal/hardening.cc\"\n \"base/internal/hardening.h\"\n \"base/internal/hide_ptr.h\"\n \"base/internal/iterator_traits.h\"\n \"base/internal/low_level_alloc.cc\"\n \"base/internal/low_level_alloc.h\"\n \"base/internal/low_level_scheduling.h\"\n \"base/internal/nullability_traits.h\"\n \"base/internal/per_thread_tls.h\"\n \"base/internal/poison.cc\"\n \"base/internal/poison.h\"\n \"base/internal/pretty_function.h\"\n \"base/internal/raw_logging.cc\"\n \"base/internal/raw_logging.h\"\n \"base/internal/scheduling_mode.h\"\n \"base/internal/scoped_set_env.cc\"\n \"base/internal/scoped_set_env.h\"\n \"base/internal/spinlock.cc\"\n \"base/internal/spinlock.h\"\n \"base/internal/spinlock_wait.cc\"\n \"base/internal/spinlock_wait.h\"\n \"base/internal/strerror.cc\"\n \"base/internal/strerror.h\"\n \"base/internal/sysinfo.cc\"\n \"base/internal/sysinfo.h\"\n \"base/internal/thread_identity.cc\"\n \"base/internal/thread_identity.h\"\n \"base/internal/tracing.cc\"\n \"base/internal/tracing.h\"\n \"base/internal/tsan_mutex_interface.h\"\n \"base/internal/unaligned_access.h\"\n \"base/internal/unscaledcycleclock.cc\"\n \"base/internal/unscaledcycleclock.h\"\n \"base/internal/unscaledcycleclock_config.h\"\n \"base/log_severity.cc\"\n \"base/log_severity.h\"\n \"base/macros.h\"\n \"base/no_destructor.h\"\n \"base/nullability.h\"\n \"base/optimization.h\"\n \"base/options.h\"\n \"base/policy_checks.h\"\n \"base/port.h\"\n \"base/prefetch.h\"\n \"base/thread_annotations.h\"\n \"base/throw_delegate.cc\"\n \"base/throw_delegate.h\"\n \"cleanup/cleanup.h\"\n \"cleanup/internal/cleanup.h\"\n \"container/btree_map.h\"\n \"container/btree_set.h\"\n \"container/chunked_queue.h\"\n \"container/fixed_array.h\"\n \"container/flat_hash_map.h\"\n \"container/flat_hash_set.h\"\n \"container/hash_container_defaults.h\"\n \"container/inlined_vector.h\"\n \"container/internal/btree.h\"\n \"container/internal/btree_container.h\"\n \"container/internal/chunked_queue.h\"\n \"container/internal/common.h\"\n \"container/internal/common_policy_traits.h\"\n \"container/internal/compressed_tuple.h\"\n \"container/internal/container_memory.h\"\n \"container/internal/hash_function_defaults.h\"\n \"container/internal/hash_policy_traits.h\"\n \"container/internal/hashtable_control_bytes.h\"\n \"container/internal/hashtable_debug.h\"\n \"container/internal/hashtable_debug_hooks.h\"\n \"container/internal/hashtablez_sampler.cc\"\n \"container/internal/hashtablez_sampler.h\"\n \"container/internal/hashtablez_sampler_force_weak_definition.cc\"\n \"container/internal/inlined_vector.h\"\n \"container/internal/layout.h\"\n \"container/internal/node_slot_policy.h\"\n \"container/internal/raw_hash_map.h\"\n \"container/internal/raw_hash_set.cc\"\n \"container/internal/raw_hash_set.h\"\n \"container/internal/raw_hash_set_resize_impl.h\"\n \"container/internal/tracked.h\"\n \"container/linked_hash_map.h\"\n \"container/linked_hash_set.h\"\n \"container/node_hash_map.h\"\n \"container/node_hash_set.h\"\n \"crc/crc32c.cc\"\n \"crc/crc32c.h\"\n \"crc/internal/cpu_detect.cc\"\n \"crc/internal/cpu_detect.h\"\n \"crc/internal/crc.cc\"\n \"crc/internal/crc.h\"\n \"crc/internal/crc32_x86_arm_combined_simd.h\"\n \"crc/internal/crc32c.h\"\n \"crc/internal/crc32c_inline.h\"\n \"crc/internal/crc_cord_state.cc\"\n \"crc/internal/crc_cord_state.h\"\n \"crc/internal/crc_internal.h\"\n \"crc/internal/crc_memcpy.h\"\n \"crc/internal/crc_memcpy_fallback.cc\"\n \"crc/internal/crc_memcpy_x86_arm_combined.cc\"\n \"crc/internal/crc_non_temporal_memcpy.cc\"\n \"crc/internal/crc_x86_arm_combined.cc\"\n \"crc/internal/non_temporal_arm_intrinsics.h\"\n \"crc/internal/non_temporal_memcpy.h\"\n \"debugging/failure_signal_handler.cc\"\n \"debugging/failure_signal_handler.h\"\n \"debugging/internal/address_is_readable.cc\"\n \"debugging/internal/address_is_readable.h\"\n \"debugging/internal/addresses.h\"\n \"debugging/internal/bounded_utf8_length_sequence.h\"\n \"debugging/internal/decode_rust_punycode.cc\"\n \"debugging/internal/decode_rust_punycode.h\"\n \"debugging/internal/demangle.cc\"\n \"debugging/internal/demangle.h\"\n \"debugging/internal/demangle_rust.cc\"\n \"debugging/internal/demangle_rust.h\"\n \"debugging/internal/elf_mem_image.cc\"\n \"debugging/internal/elf_mem_image.h\"\n \"debugging/internal/examine_stack.cc\"\n \"debugging/internal/examine_stack.h\"\n \"debugging/internal/stack_consumption.cc\"\n \"debugging/internal/stack_consumption.h\"\n \"debugging/internal/stacktrace_config.h\"\n \"debugging/internal/symbolize.h\"\n \"debugging/internal/utf8_for_code_point.cc\"\n \"debugging/internal/utf8_for_code_point.h\"\n \"debugging/internal/vdso_support.cc\"\n \"debugging/internal/vdso_support.h\"\n \"debugging/leak_check.h\"\n \"debugging/stacktrace.cc\"\n \"debugging/stacktrace.h\"\n \"debugging/symbolize.cc\"\n \"debugging/symbolize.h\"\n \"functional/any_invocable.h\"\n \"functional/bind_front.h\"\n \"functional/function_ref.h\"\n \"functional/internal/any_invocable.h\"\n \"functional/internal/front_binder.h\"\n \"functional/internal/function_ref.h\"\n \"functional/overload.h\"\n \"hash/hash.h\"\n \"hash/internal/city.cc\"\n \"hash/internal/city.h\"\n \"hash/internal/hash.cc\"\n \"hash/internal/hash.h\"\n \"hash/internal/spy_hash_state.h\"\n \"hash/internal/weakly_mixed_integer.h\"\n \"log/absl_check.h\"\n \"log/absl_log.h\"\n \"log/absl_vlog_is_on.h\"\n \"log/check.h\"\n \"log/die_if_null.cc\"\n \"log/die_if_null.h\"\n \"log/globals.cc\"\n \"log/globals.h\"\n \"log/initialize.cc\"\n \"log/initialize.h\"\n \"log/internal/append_truncated.h\"\n \"log/internal/check_impl.h\"\n \"log/internal/check_op.cc\"\n \"log/internal/check_op.h\"\n \"log/internal/conditions.cc\"\n \"log/internal/conditions.h\"\n \"log/internal/config.h\"\n \"log/internal/container.h\"\n \"log/internal/fnmatch.cc\"\n \"log/internal/fnmatch.h\"\n \"log/internal/globals.cc\"\n \"log/internal/globals.h\"\n \"log/internal/log_format.cc\"\n \"log/internal/log_format.h\"\n \"log/internal/log_impl.h\"\n \"log/internal/log_message.cc\"\n \"log/internal/log_message.h\"\n \"log/internal/log_sink_set.cc\"\n \"log/internal/log_sink_set.h\"\n \"log/internal/nullguard.cc\"\n \"log/internal/nullguard.h\"\n \"log/internal/nullstream.h\"\n \"log/internal/proto.cc\"\n \"log/internal/proto.h\"\n \"log/internal/strip.h\"\n \"log/internal/structured.h\"\n \"log/internal/structured_proto.cc\"\n \"log/internal/structured_proto.h\"\n \"log/internal/vlog_config.cc\"\n \"log/internal/vlog_config.h\"\n \"log/internal/voidify.h\"\n \"log/log.h\"\n \"log/log_entry.cc\"\n \"log/log_entry.h\"\n \"log/log_sink.cc\"\n \"log/log_sink.h\"\n \"log/log_sink_registry.h\"\n \"log/log_streamer.h\"\n \"log/structured.h\"\n \"log/vlog_is_on.h\"\n \"memory/memory.h\"\n \"meta/internal/requires.h\"\n \"meta/type_traits.h\"\n \"numeric/bits.h\"\n \"numeric/int128.cc\"\n \"numeric/int128.h\"\n \"numeric/internal/bits.h\"\n \"numeric/internal/representation.h\"\n \"profiling/hashtable.cc\"\n \"profiling/hashtable.h\"\n \"profiling/internal/exponential_biased.cc\"\n \"profiling/internal/exponential_biased.h\"\n \"profiling/internal/periodic_sampler.cc\"\n \"profiling/internal/periodic_sampler.h\"\n \"profiling/internal/profile_builder.cc\"\n \"profiling/internal/profile_builder.h\"\n \"profiling/internal/sample_recorder.h\"\n \"random/bernoulli_distribution.h\"\n \"random/beta_distribution.h\"\n \"random/bit_gen_ref.h\"\n \"random/discrete_distribution.cc\"\n \"random/discrete_distribution.h\"\n \"random/distributions.h\"\n \"random/exponential_distribution.h\"\n \"random/gaussian_distribution.cc\"\n \"random/gaussian_distribution.h\"\n \"random/internal/distribution_caller.h\"\n \"random/internal/entropy_pool.cc\"\n \"random/internal/entropy_pool.h\"\n \"random/internal/fast_uniform_bits.h\"\n \"random/internal/fastmath.h\"\n \"random/internal/generate_real.h\"\n \"random/internal/iostream_state_saver.h\"\n \"random/internal/nonsecure_base.h\"\n \"random/internal/pcg_engine.h\"\n \"random/internal/platform.h\"\n \"random/internal/randen.cc\"\n \"random/internal/randen.h\"\n \"random/internal/randen_detect.cc\"\n \"random/internal/randen_detect.h\"\n \"random/internal/randen_engine.h\"\n \"random/internal/randen_hwaes.cc\"\n \"random/internal/randen_hwaes.h\"\n \"random/internal/randen_round_keys.cc\"\n \"random/internal/randen_slow.cc\"\n \"random/internal/randen_slow.h\"\n \"random/internal/randen_traits.h\"\n \"random/internal/salted_seed_seq.h\"\n \"random/internal/seed_material.cc\"\n \"random/internal/seed_material.h\"\n \"random/internal/sequence_urbg.h\"\n \"random/internal/traits.h\"\n \"random/internal/uniform_helper.h\"\n \"random/internal/wide_multiply.h\"\n \"random/log_uniform_int_distribution.h\"\n \"random/poisson_distribution.h\"\n \"random/random.h\"\n \"random/seed_gen_exception.cc\"\n \"random/seed_gen_exception.h\"\n \"random/seed_sequences.cc\"\n \"random/seed_sequences.h\"\n \"random/uniform_int_distribution.h\"\n \"random/uniform_real_distribution.h\"\n \"random/zipf_distribution.h\"\n \"status/internal/status_internal.cc\"\n \"status/internal/status_internal.h\"\n \"status/internal/statusor_internal.h\"\n \"status/status.cc\"\n \"status/status.h\"\n \"status/status_payload_printer.cc\"\n \"status/status_payload_printer.h\"\n \"status/statusor.cc\"\n \"status/statusor.h\"\n \"strings/ascii.cc\"\n \"strings/ascii.h\"\n \"strings/charconv.cc\"\n \"strings/charconv.h\"\n \"strings/charset.h\"\n \"strings/cord.cc\"\n \"strings/cord.h\"\n \"strings/cord_analysis.cc\"\n \"strings/cord_analysis.h\"\n \"strings/cord_buffer.h\"\n \"strings/escaping.cc\"\n \"strings/escaping.h\"\n \"strings/has_absl_stringify.h\"\n \"strings/has_ostream_operator.h\"\n \"strings/internal/append_and_overwrite.h\"\n \"strings/internal/charconv_bigint.cc\"\n \"strings/internal/charconv_bigint.h\"\n \"strings/internal/charconv_parse.cc\"\n \"strings/internal/charconv_parse.h\"\n \"strings/internal/cord_data_edge.h\"\n \"strings/internal/cord_internal.cc\"\n \"strings/internal/cord_internal.h\"\n \"strings/internal/cord_rep_btree.cc\"\n \"strings/internal/cord_rep_btree.h\"\n \"strings/internal/cord_rep_btree_navigator.cc\"\n \"strings/internal/cord_rep_btree_navigator.h\"\n \"strings/internal/cord_rep_btree_reader.cc\"\n \"strings/internal/cord_rep_btree_reader.h\"\n \"strings/internal/cord_rep_consume.cc\"\n \"strings/internal/cord_rep_consume.h\"\n \"strings/internal/cord_rep_crc.cc\"\n \"strings/internal/cord_rep_crc.h\"\n \"strings/internal/cord_rep_flat.h\"\n \"strings/internal/cordz_functions.cc\"\n \"strings/internal/cordz_functions.h\"\n \"strings/internal/cordz_handle.cc\"\n \"strings/internal/cordz_handle.h\"\n \"strings/internal/cordz_info.cc\"\n \"strings/internal/cordz_info.h\"\n \"strings/internal/cordz_sample_token.cc\"\n \"strings/internal/cordz_sample_token.h\"\n \"strings/internal/cordz_statistics.h\"\n \"strings/internal/cordz_update_scope.h\"\n \"strings/internal/cordz_update_tracker.h\"\n \"strings/internal/damerau_levenshtein_distance.cc\"\n \"strings/internal/damerau_levenshtein_distance.h\"\n \"strings/internal/escaping.cc\"\n \"strings/internal/escaping.h\"\n \"strings/internal/generic_printer.cc\"\n \"strings/internal/generic_printer.h\"\n \"strings/internal/generic_printer_internal.h\"\n \"strings/internal/memutil.cc\"\n \"strings/internal/memutil.h\"\n \"strings/internal/ostringstream.cc\"\n \"strings/internal/ostringstream.h\"\n \"strings/internal/pow10_helper.cc\"\n \"strings/internal/pow10_helper.h\"\n \"strings/internal/resize_uninitialized.h\"\n \"strings/internal/stl_type_traits.h\"\n \"strings/internal/str_format/arg.cc\"\n \"strings/internal/str_format/arg.h\"\n \"strings/internal/str_format/bind.cc\"\n \"strings/internal/str_format/bind.h\"\n \"strings/internal/str_format/checker.h\"\n \"strings/internal/str_format/constexpr_parser.h\"\n \"strings/internal/str_format/extension.cc\"\n \"strings/internal/str_format/extension.h\"\n \"strings/internal/str_format/float_conversion.cc\"\n \"strings/internal/str_format/float_conversion.h\"\n \"strings/internal/str_format/output.cc\"\n \"strings/internal/str_format/output.h\"\n \"strings/internal/str_format/parser.cc\"\n \"strings/internal/str_format/parser.h\"\n \"strings/internal/str_join_internal.h\"\n \"strings/internal/str_split_internal.h\"\n \"strings/internal/string_constant.h\"\n \"strings/internal/stringify_sink.cc\"\n \"strings/internal/stringify_sink.h\"\n \"strings/internal/stringify_stream.h\"\n \"strings/internal/utf8.cc\"\n \"strings/internal/utf8.h\"\n \"strings/match.cc\"\n \"strings/match.h\"\n \"strings/numbers.cc\"\n \"strings/numbers.h\"\n \"strings/resize_and_overwrite.h\"\n \"strings/str_cat.cc\"\n \"strings/str_cat.h\"\n \"strings/str_format.h\"\n \"strings/str_join.h\"\n \"strings/str_replace.cc\"\n \"strings/str_replace.h\"\n \"strings/str_split.cc\"\n \"strings/str_split.h\"\n \"strings/strip.h\"\n \"strings/substitute.cc\"\n \"strings/substitute.h\"\n \"synchronization/barrier.cc\"\n \"synchronization/barrier.h\"\n \"synchronization/blocking_counter.cc\"\n \"synchronization/blocking_counter.h\"\n \"synchronization/internal/create_thread_identity.cc\"\n \"synchronization/internal/create_thread_identity.h\"\n \"synchronization/internal/futex.h\"\n \"synchronization/internal/futex_waiter.cc\"\n \"synchronization/internal/futex_waiter.h\"\n \"synchronization/internal/graphcycles.cc\"\n \"synchronization/internal/graphcycles.h\"\n \"synchronization/internal/kernel_timeout.cc\"\n \"synchronization/internal/kernel_timeout.h\"\n \"synchronization/internal/per_thread_sem.cc\"\n \"synchronization/internal/per_thread_sem.h\"\n \"synchronization/internal/pthread_waiter.cc\"\n \"synchronization/internal/pthread_waiter.h\"\n \"synchronization/internal/sem_waiter.cc\"\n \"synchronization/internal/sem_waiter.h\"\n \"synchronization/internal/stdcpp_waiter.cc\"\n \"synchronization/internal/stdcpp_waiter.h\"\n \"synchronization/internal/thread_pool.h\"\n \"synchronization/internal/waiter.h\"\n \"synchronization/internal/waiter_base.cc\"\n \"synchronization/internal/waiter_base.h\"\n \"synchronization/internal/win32_waiter.cc\"\n \"synchronization/internal/win32_waiter.h\"\n \"synchronization/mutex.cc\"\n \"synchronization/mutex.h\"\n \"synchronization/notification.cc\"\n \"synchronization/notification.h\"\n \"time/civil_time.cc\"\n \"time/civil_time.h\"\n \"time/clock.cc\"\n \"time/clock.h\"\n \"time/clock_interface.cc\"\n \"time/clock_interface.h\"\n \"time/duration.cc\"\n \"time/format.cc\"\n \"time/internal/cctz/include/cctz/civil_time.h\"\n \"time/internal/cctz/include/cctz/civil_time_detail.h\"\n \"time/internal/cctz/include/cctz/time_zone.h\"\n \"time/internal/cctz/include/cctz/zone_info_source.h\"\n \"time/internal/cctz/src/civil_time_detail.cc\"\n \"time/internal/cctz/src/time_zone_fixed.cc\"\n \"time/internal/cctz/src/time_zone_fixed.h\"\n \"time/internal/cctz/src/time_zone_format.cc\"\n \"time/internal/cctz/src/time_zone_if.cc\"\n \"time/internal/cctz/src/time_zone_if.h\"\n \"time/internal/cctz/src/time_zone_impl.cc\"\n \"time/internal/cctz/src/time_zone_impl.h\"\n \"time/internal/cctz/src/time_zone_info.cc\"\n \"time/internal/cctz/src/time_zone_info.h\"\n \"time/internal/cctz/src/time_zone_libc.cc\"\n \"time/internal/cctz/src/time_zone_libc.h\"\n \"time/internal/cctz/src/time_zone_lookup.cc\"\n \"time/internal/cctz/src/time_zone_posix.cc\"\n \"time/internal/cctz/src/time_zone_posix.h\"\n \"time/internal/cctz/src/tzfile.h\"\n \"time/internal/cctz/src/zone_info_source.cc\"\n \"time/simulated_clock.cc\"\n \"time/simulated_clock.h\"\n \"time/time.cc\"\n \"time/time.h\"\n \"types/any.h\"\n \"types/any_span.h\"\n \"types/compare.h\"\n \"types/internal/any_span.h\"\n \"types/internal/span.h\"\n \"types/optional.h\"\n \"types/optional_ref.h\"\n \"types/source_location.h\"\n \"types/span.h\"\n \"types/variant.h\"\n \"utility/utility.h\"\n \"debugging/leak_check.cc\"\n \"strings/string_view.h\"\n)\n\nif(MSVC)\n list(APPEND ABSL_INTERNAL_DLL_FILES\n \"time/internal/cctz/src/time_zone_name_win.cc\"\n \"time/internal/cctz/src/time_zone_name_win.h\"\n )\nelse()\n list(APPEND ABSL_INTERNAL_DLL_FILES\n \"flags/commandlineflag.cc\"\n \"flags/commandlineflag.h\"\n \"flags/config.h\"\n \"flags/declare.h\"\n \"flags/flag.h\"\n \"flags/internal/commandlineflag.cc\"\n \"flags/internal/commandlineflag.h\"\n \"flags/internal/flag.cc\"\n \"flags/internal/flag.h\"\n \"flags/internal/parse.h\"\n \"flags/internal/path_util.h\"\n \"flags/internal/private_handle_accessor.cc\"\n \"flags/internal/private_handle_accessor.h\"\n \"flags/internal/program_name.cc\"\n \"flags/internal/program_name.h\"\n \"flags/internal/registry.h\"\n \"flags/internal/sequence_lock.h\"\n \"flags/internal/usage.cc\"\n \"flags/internal/usage.h\"\n \"flags/marshalling.cc\"\n \"flags/marshalling.h\"\n \"flags/parse.cc\"\n \"flags/parse.h\"\n \"flags/reflection.cc\"\n \"flags/reflection.h\"\n \"flags/usage.cc\"\n \"flags/usage.h\"\n \"flags/usage_config.cc\"\n \"flags/usage_config.h\"\n \"log/flags.cc\"\n \"log/flags.h\"\n \"log/internal/flags.h\"\n )\nendif()\n\nset(ABSL_INTERNAL_DLL_TARGETS\n \"absl_check\"\n \"absl_log\"\n \"absl_vlog_is_on\"\n \"algorithm\"\n \"algorithm_container\"\n \"any\"\n \"any_invocable\"\n \"atomic_hook\"\n \"base\"\n \"base_internal\"\n \"bind_front\"\n \"bits\"\n \"btree\"\n \"check\"\n \"city\"\n \"civil_time\"\n \"compare\"\n \"compressed_tuple\"\n \"config\"\n \"container\"\n \"container_common\"\n \"container_memory\"\n \"cord\"\n \"cord_internal\"\n \"cordz_functions\"\n \"cordz_handle\"\n \"cordz_info\"\n \"cordz_sample_token\"\n \"core_headers\"\n \"counting_allocator\"\n \"crc_cord_state\"\n \"crc_cpu_detect\"\n \"crc_internal\"\n \"crc32c\"\n \"debugging\"\n \"debugging_internal\"\n \"demangle_internal\"\n \"die_if_null\"\n \"dynamic_annotations\"\n \"endian\"\n \"examine_stack\"\n \"exponential_biased\"\n \"failure_signal_handler\"\n \"fixed_array\"\n \"flat_hash_map\"\n \"flat_hash_set\"\n \"function_ref\"\n \"graphcycles_internal\"\n \"hash\"\n \"hash_function_defaults\"\n \"hash_policy_traits\"\n \"hashtable_debug\"\n \"hashtable_debug_hooks\"\n \"hashtablez_sampler\"\n \"inlined_vector\"\n \"inlined_vector_internal\"\n \"int128\"\n \"kernel_timeout_internal\"\n \"layout\"\n \"leak_check\"\n \"log_internal_check_impl\"\n \"log_internal_check_op\"\n \"log_internal_conditions\"\n \"log_internal_config\"\n \"log_internal_fnmatch\"\n \"log_internal_format\"\n \"log_internal_globals\"\n \"log_internal_log_impl\"\n \"log_internal_proto\"\n \"log_internal_message\"\n \"log_internal_log_sink_set\"\n \"log_internal_nullguard\"\n \"log_internal_nullstream\"\n \"log_internal_strip\"\n \"log_internal_voidify\"\n \"log_internal_append_truncated\"\n \"log_globals\"\n \"log_initialize\"\n \"log\"\n \"log_entry\"\n \"log_sink\"\n \"log_sink_registry\"\n \"log_streamer\"\n \"log_internal_structured\"\n \"log_severity\"\n \"log_structured\"\n \"low_level_hash\"\n \"malloc_internal\"\n \"memory\"\n \"meta\"\n \"node_hash_map\"\n \"node_hash_set\"\n \"node_slot_policy\"\n \"non_temporal_arm_intrinsics\"\n \"non_temporal_memcpy\"\n \"numeric\"\n \"optional\"\n \"periodic_sampler\"\n \"pow10_helper\"\n \"pretty_function\"\n \"random_bit_gen_ref\"\n \"random_distributions\"\n \"random_internal_distribution_caller\"\n \"random_internal_distributions\"\n \"random_internal_explicit_seed_seq\"\n \"random_internal_fastmath\"\n \"random_internal_fast_uniform_bits\"\n \"random_internal_generate_real\"\n \"random_internal_iostream_state_saver\"\n \"random_internal_nonsecure_base\"\n \"random_internal_pcg_engine\"\n \"random_internal_platform\"\n \"random_internal_pool_urbg\"\n \"random_internal_randen\"\n \"random_internal_randen_engine\"\n \"random_internal_randen_hwaes\"\n \"random_internal_randen_hwaes_impl\"\n \"random_internal_randen_slow\"\n \"random_internal_salted_seed_seq\"\n \"random_internal_seed_material\"\n \"random_internal_sequence_urbg\"\n \"random_internal_traits\"\n \"random_internal_uniform_helper\"\n \"random_internal_wide_multiply\"\n \"random_random\"\n \"random_seed_gen_exception\"\n \"random_seed_sequences\"\n \"raw_hash_map\"\n \"raw_hash_set\"\n \"raw_logging_internal\"\n \"sample_recorder\"\n \"scoped_set_env\"\n \"span\"\n \"spinlock_wait\"\n \"spy_hash_state\"\n \"stack_consumption\"\n \"stacktrace\"\n \"status\"\n \"statusor\"\n \"str_format\"\n \"str_format_internal\"\n \"strerror\"\n \"strings\"\n \"strings_internal\"\n \"string_view\"\n \"symbolize\"\n \"synchronization\"\n \"thread_pool\"\n \"throw_delegate\"\n \"time\"\n \"time_zone\"\n \"tracked\"\n \"type_traits\"\n \"utility\"\n \"variant\"\n \"vlog_config_internal\"\n \"vlog_is_on\"\n)\n\nif(NOT MSVC)\n list(APPEND ABSL_INTERNAL_DLL_TARGETS\n \"flags\"\n \"flags_commandlineflag\"\n \"flags_commandlineflag_internal\"\n \"flags_config\"\n \"flags_internal\"\n \"flags_marshalling\"\n \"flags_parse\"\n \"flags_path_util\"\n \"flags_private_handle_accessor\"\n \"flags_program_name\"\n \"flags_reflection\"\n \"flags_usage\"\n \"flags_usage_internal\"\n \"log_internal_flags\"\n \"log_flags\"\n )\nendif()\n\nset(ABSL_INTERNAL_TEST_DLL_FILES\n \"hash/hash_testing.h\"\n \"log/scoped_mock_log.cc\"\n \"log/scoped_mock_log.h\"\n \"random/internal/chi_square.cc\"\n \"random/internal/chi_square.h\"\n \"random/internal/distribution_test_util.cc\"\n \"random/internal/distribution_test_util.h\"\n \"random/internal/mock_helpers.h\"\n \"random/internal/mock_overload_set.h\"\n \"random/mocking_bit_gen.h\"\n \"random/mock_distributions.h\"\n \"status/status_matchers.h\"\n \"status/internal/status_matchers.cc\"\n \"status/internal/status_matchers.h\"\n \"strings/cordz_test_helpers.h\"\n \"strings/cord_test_helpers.h\"\n)\n\nset(ABSL_INTERNAL_TEST_DLL_TARGETS\n \"cord_test_helpers\"\n \"cordz_test_helpers\"\n \"hash_testing\"\n \"random_mocking_bit_gen\"\n \"random_internal_distribution_test_util\"\n \"random_internal_mock_overload_set\"\n \"scoped_mock_log\"\n \"status_matchers\"\n)\n\ninclude(CheckCXXSourceCompiles)\n\ncheck_cxx_source_compiles(\n [==[\n#ifdef _MSC_VER\n# if _MSVC_LANG < 201703L\n# error \"The compiler defaults or is configured for C++ < 17\"\n# endif\n#elif __cplusplus < 201703L\n# error \"The compiler defaults or is configured for C++ < 17\"\n#endif\nint main() { return 0; }\n]==]\n ABSL_INTERNAL_AT_LEAST_CXX17)\n\ncheck_cxx_source_compiles(\n [==[\n#ifdef _MSC_VER\n# if _MSVC_LANG < 202002L\n# error \"The compiler defaults or is configured for C++ < 20\"\n# endif\n#elif __cplusplus < 202002L\n# error \"The compiler defaults or is configured for C++ < 20\"\n#endif\nint main() { return 0; }\n]==]\n ABSL_INTERNAL_AT_LEAST_CXX20)\n\nif(ABSL_INTERNAL_AT_LEAST_CXX20)\n set(ABSL_INTERNAL_CXX_STD_FEATURE cxx_std_20)\nelseif(ABSL_INTERNAL_AT_LEAST_CXX17)\n set(ABSL_INTERNAL_CXX_STD_FEATURE cxx_std_17)\nelse()\n 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\")\nendif()\n\nfunction(absl_internal_dll_contains)\n cmake_parse_arguments(ABSL_INTERNAL_DLL\n \"\"\n \"OUTPUT;TARGET\"\n \"\"\n ${ARGN}\n )\n\n STRING(REGEX REPLACE \"^absl::\" \"\" _target ${ABSL_INTERNAL_DLL_TARGET})\n\n if (_target IN_LIST ABSL_INTERNAL_DLL_TARGETS)\n set(${ABSL_INTERNAL_DLL_OUTPUT} 1 PARENT_SCOPE)\n else()\n set(${ABSL_INTERNAL_DLL_OUTPUT} 0 PARENT_SCOPE)\n endif()\nendfunction()\n\nfunction(absl_internal_test_dll_contains)\n cmake_parse_arguments(ABSL_INTERNAL_TEST_DLL\n \"\"\n \"OUTPUT;TARGET\"\n \"\"\n ${ARGN}\n )\n\n STRING(REGEX REPLACE \"^absl::\" \"\" _target ${ABSL_INTERNAL_TEST_DLL_TARGET})\n\n if (_target IN_LIST ABSL_INTERNAL_TEST_DLL_TARGETS)\n set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 1 PARENT_SCOPE)\n else()\n set(${ABSL_INTERNAL_TEST_DLL_OUTPUT} 0 PARENT_SCOPE)\n endif()\nendfunction()\n\nfunction(absl_internal_dll_targets)\n cmake_parse_arguments(ABSL_INTERNAL_DLL\n \"\"\n \"OUTPUT\"\n \"DEPS\"\n ${ARGN}\n )\n\n set(_deps \"\")\n foreach(dep IN LISTS ABSL_INTERNAL_DLL_DEPS)\n absl_internal_dll_contains(TARGET ${dep} OUTPUT _dll_contains)\n absl_internal_test_dll_contains(TARGET ${dep} OUTPUT _test_dll_contains)\n if (_dll_contains)\n list(APPEND _deps abseil_dll)\n elseif (_test_dll_contains)\n list(APPEND _deps abseil_test_dll)\n else()\n list(APPEND _deps ${dep})\n endif()\n endforeach()\n\n # Because we may have added the DLL multiple times\n list(REMOVE_DUPLICATES _deps)\n set(${ABSL_INTERNAL_DLL_OUTPUT} \"${_deps}\" PARENT_SCOPE)\nendfunction()\n\nfunction(absl_make_dll)\n cmake_parse_arguments(ABSL_INTERNAL_MAKE_DLL\n \"\"\n \"TEST\"\n \"\"\n ${ARGN}\n )\n\n if (ABSL_INTERNAL_MAKE_DLL_TEST)\n set(_dll \"abseil_test_dll\")\n set(_dll_files ${ABSL_INTERNAL_TEST_DLL_FILES})\n set(_dll_libs \"abseil_dll\" \"GTest::gtest\" \"GTest::gmock\")\n set(_dll_compile_definitions \"GTEST_LINKED_AS_SHARED_LIBRARY=1\")\n set(_dll_includes ${absl_gtest_src_dir}/googletest/include ${absl_gtest_src_dir}/googlemock/include)\n set(_dll_consume \"ABSL_CONSUME_TEST_DLL\")\n set(_dll_build \"ABSL_BUILD_TEST_DLL\")\n else()\n set(_dll \"abseil_dll\")\n set(_dll_files ${ABSL_INTERNAL_DLL_FILES})\n set(_dll_libs\n Threads::Threads\n # TODO(#1495): Use $ once our\n # minimum CMake version >= 3.24\n $<$:-Wl,-framework,CoreFoundation>\n )\n set(_dll_compile_definitions \"\")\n set(_dll_includes \"\")\n set(_dll_consume \"ABSL_CONSUME_DLL\")\n set(_dll_build \"ABSL_BUILD_DLL\")\n endif()\n\n add_library(\n ${_dll}\n SHARED\n ${_dll_files}\n )\n target_link_libraries(\n ${_dll}\n PRIVATE\n ${_dll_libs}\n ${ABSL_DEFAULT_LINKOPTS}\n $<$:-llog>\n $<$:-ladvapi32>\n $<$:-ldbghelp>\n $<$:-lbcrypt>\n )\n set_target_properties(${_dll} PROPERTIES\n LINKER_LANGUAGE \"CXX\"\n SOVERSION ${ABSL_SOVERSION}\n )\n target_include_directories(\n ${_dll}\n PUBLIC\n \"$\"\n $\n PRIVATE\n ${_dll_includes}\n )\n\n target_compile_options(\n ${_dll}\n PRIVATE\n ${ABSL_DEFAULT_COPTS}\n )\n\n foreach(cflag ${ABSL_CC_LIB_COPTS})\n if(${cflag} MATCHES \"^(-Wno|/wd)\")\n # These flags are needed to suppress warnings that might fire in our headers.\n set(PC_CFLAGS \"${PC_CFLAGS} ${cflag}\")\n elseif(${cflag} MATCHES \"^(-W|/w[1234eo])\")\n # Don't impose our warnings on others.\n else()\n set(PC_CFLAGS \"${PC_CFLAGS} ${cflag}\")\n endif()\n endforeach()\n string(REPLACE \";\" \" \" PC_LINKOPTS \"${ABSL_CC_LIB_LINKOPTS}\")\n\n FILE(GENERATE OUTPUT \"${CMAKE_BINARY_DIR}/lib/pkgconfig/${_dll}.pc\" CONTENT \"\\\nprefix=${CMAKE_INSTALL_PREFIX}\\n\\\nexec_prefix=\\${prefix}\\n\\\nlibdir=${CMAKE_INSTALL_FULL_LIBDIR}\\n\\\nincludedir=${CMAKE_INSTALL_FULL_INCLUDEDIR}\\n\\\n\\n\\\nName: ${_dll}\\n\\\nDescription: Abseil DLL library\\n\\\nURL: https://abseil.io/\\n\\\nVersion: ${absl_VERSION}\\n\\\nLibs: -L\\${libdir} $<$>:-l${_dll}> ${PC_LINKOPTS}\\n\\\nCflags: -I\\${includedir}${PC_CFLAGS}\\n\")\n INSTALL(FILES \"${CMAKE_BINARY_DIR}/lib/pkgconfig/${_dll}.pc\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/pkgconfig\")\n\n target_compile_definitions(\n ${_dll}\n PUBLIC\n ${_dll_compile_definitions}\n PRIVATE\n ${_dll_build}\n NOMINMAX\n INTERFACE\n ${ABSL_CC_LIB_DEFINES}\n ${_dll_consume}\n )\n\n if(ABSL_PROPAGATE_CXX_STD)\n # Abseil libraries require C++17 as the current minimum standard. When\n # compiled with a higher minimum (either because it is the compiler's\n # default or explicitly requested), then Abseil requires that standard.\n target_compile_features(${_dll} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})\n endif()\n\n install(TARGETS ${_dll} EXPORT ${PROJECT_NAME}Targets\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}\n )\n\n add_library(absl::${_dll} ALIAS ${_dll})\nendfunction()\n" }, { "path": "CMake/AbseilHelpers.cmake", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\ninclude(CMakeParseArguments)\ninclude(AbseilConfigureCopts)\ninclude(AbseilDll)\n\n# The IDE folder for Abseil that will be used if Abseil is included in a CMake\n# project that sets\n# set_property(GLOBAL PROPERTY USE_FOLDERS ON)\n# For example, Visual Studio supports folders.\nif(NOT DEFINED ABSL_IDE_FOLDER)\n set(ABSL_IDE_FOLDER Abseil)\nendif()\n\nif(ABSL_USE_SYSTEM_INCLUDES)\n set(ABSL_INTERNAL_INCLUDE_WARNING_GUARD SYSTEM)\nelse()\n set(ABSL_INTERNAL_INCLUDE_WARNING_GUARD \"\")\nendif()\n\n# absl_cc_library()\n#\n# CMake function to imitate Bazel's cc_library rule.\n#\n# Parameters:\n# NAME: name of target (see Note)\n# HDRS: List of public header files for the library\n# SRCS: List of source files for the library\n# DEPS: List of other libraries to be linked in to the binary targets\n# COPTS: List of private compile options\n# DEFINES: List of public defines\n# LINKOPTS: List of link options\n# PUBLIC: Add this so that this library will be exported under absl::\n# Also in IDE, target will appear in Abseil folder while non PUBLIC will be in Abseil/internal.\n# TESTONLY: When added, this target will only be built if both\n# BUILD_TESTING=ON and ABSL_BUILD_TESTING=ON.\n#\n# Note:\n# By default, absl_cc_library will always create a library named absl_${NAME},\n# and alias target absl::${NAME}. The absl:: form should always be used.\n# This is to reduce namespace pollution.\n#\n# absl_cc_library(\n# NAME\n# awesome\n# HDRS\n# \"a.h\"\n# SRCS\n# \"a.cc\"\n# )\n# absl_cc_library(\n# NAME\n# fantastic_lib\n# SRCS\n# \"b.cc\"\n# DEPS\n# absl::awesome # not \"awesome\" !\n# PUBLIC\n# )\n#\n# absl_cc_library(\n# NAME\n# main_lib\n# ...\n# DEPS\n# absl::fantastic_lib\n# )\n#\n# TODO(b/320467376): Implement \"ALWAYSLINK\".\nfunction(absl_cc_library)\n cmake_parse_arguments(ABSL_CC_LIB\n \"DISABLE_INSTALL;PUBLIC;TESTONLY\"\n \"NAME\"\n \"HDRS;SRCS;COPTS;DEFINES;LINKOPTS;DEPS\"\n ${ARGN}\n )\n\n if(ABSL_CC_LIB_TESTONLY AND\n NOT ((BUILD_TESTING AND ABSL_BUILD_TESTING) OR\n (ABSL_BUILD_TEST_HELPERS AND ABSL_CC_LIB_PUBLIC)))\n return()\n endif()\n\n if(ABSL_ENABLE_INSTALL)\n set(_NAME \"${ABSL_CC_LIB_NAME}\")\n else()\n set(_NAME \"absl_${ABSL_CC_LIB_NAME}\")\n endif()\n\n # Check if this is a header-only library\n # Note that as of February 2019, many popular OS's (for example, Ubuntu\n # 16.04 LTS) only come with cmake 3.5 by default. For this reason, we can't\n # use list(FILTER...)\n set(ABSL_CC_SRCS \"${ABSL_CC_LIB_SRCS}\")\n foreach(src_file IN LISTS ABSL_CC_SRCS)\n if(${src_file} MATCHES \".*\\\\.(h|inc)\")\n list(REMOVE_ITEM ABSL_CC_SRCS \"${src_file}\")\n endif()\n endforeach()\n\n if(ABSL_CC_SRCS STREQUAL \"\")\n set(ABSL_CC_LIB_IS_INTERFACE 1)\n else()\n set(ABSL_CC_LIB_IS_INTERFACE 0)\n endif()\n\n # Determine this build target's relationship to the DLL. It's one of four things:\n # 1. \"dll\" -- This target is part of the DLL\n # 2. \"dll_dep\" -- This target is not part of the DLL, but depends on the DLL.\n # Note that we assume any target not in the DLL depends on the\n # DLL. This is not a technical necessity but a convenience\n # which happens to be true, because nearly every target is\n # part of the DLL.\n # 3. \"shared\" -- This is a shared library, perhaps on a non-windows platform\n # where DLL doesn't make sense.\n # 4. \"static\" -- This target does not depend on the DLL and should be built\n # statically.\n if (${ABSL_BUILD_DLL})\n if(ABSL_ENABLE_INSTALL)\n absl_internal_dll_contains(TARGET ${_NAME} OUTPUT _in_dll)\n absl_internal_test_dll_contains(TARGET ${_NAME} OUTPUT _in_test_dll)\n else()\n absl_internal_dll_contains(TARGET ${ABSL_CC_LIB_NAME} OUTPUT _in_dll)\n absl_internal_test_dll_contains(TARGET ${ABSL_CC_LIB_NAME} OUTPUT _in_test_dll)\n endif()\n if (${_in_dll} OR ${_in_test_dll})\n # This target should be replaced by the DLL\n set(_build_type \"dll\")\n set(ABSL_CC_LIB_IS_INTERFACE 1)\n else()\n # Building a DLL, but this target is not part of the DLL\n set(_build_type \"dll_dep\")\n endif()\n elseif(BUILD_SHARED_LIBS)\n set(_build_type \"shared\")\n else()\n set(_build_type \"static\")\n endif()\n\n # Generate a pkg-config file for every library:\n if(ABSL_ENABLE_INSTALL)\n if(absl_VERSION)\n set(PC_VERSION \"${absl_VERSION}\")\n else()\n set(PC_VERSION \"head\")\n endif()\n if(NOT _build_type STREQUAL \"dll\")\n set(LNK_LIB \"${LNK_LIB} -labsl_${_NAME}\")\n endif()\n foreach(dep ${ABSL_CC_LIB_DEPS})\n if(${dep} MATCHES \"^absl::(.*)\")\n # for DLL builds many libs are not created, but add\n # the pkgconfigs nevertheless, pointing to the dll.\n if(_build_type STREQUAL \"dll\")\n # hide this MATCHES in an if-clause so it doesn't overwrite\n # the CMAKE_MATCH_1 from (${dep} MATCHES \"^absl::(.*)\")\n if(NOT PC_DEPS MATCHES \"abseil_dll\")\n # Join deps with commas.\n if(PC_DEPS)\n set(PC_DEPS \"${PC_DEPS},\")\n endif()\n # don't duplicate dll-dep if it exists already\n set(PC_DEPS \"${PC_DEPS} abseil_dll = ${PC_VERSION}\")\n set(LNK_LIB \"${LNK_LIB} -labseil_dll\")\n endif()\n else()\n # Join deps with commas.\n if(PC_DEPS)\n set(PC_DEPS \"${PC_DEPS},\")\n endif()\n set(PC_DEPS \"${PC_DEPS} absl_${CMAKE_MATCH_1} = ${PC_VERSION}\")\n endif()\n endif()\n endforeach()\n foreach(cflag ${ABSL_CC_LIB_COPTS})\n # Strip out the CMake-specific `SHELL:` prefix, which is used to construct\n # a group of space-separated options.\n # https://cmake.org/cmake/help/v3.30/command/target_compile_options.html#option-de-duplication\n string(REGEX REPLACE \"^SHELL:\" \"\" cflag \"${cflag}\")\n if(${cflag} MATCHES \"^-Xarch_\")\n # An -Xarch_ flag implies that its successor only applies to the\n # specified platform. Such option groups are each specified in a single\n # `SHELL:`-prefixed string in the COPTS list, which we simply ignore.\n elseif(${cflag} MATCHES \"^(-Wno-|/wd)\")\n # These flags are needed to suppress warnings that might fire in our headers.\n set(PC_CFLAGS \"${PC_CFLAGS} ${cflag}\")\n elseif(${cflag} MATCHES \"^(-W|/w[1234eo])\")\n # Don't impose our warnings on others.\n elseif(${cflag} MATCHES \"^-m\")\n # Don't impose CPU instruction requirements on others, as\n # the code performs feature detection on runtime.\n else()\n set(PC_CFLAGS \"${PC_CFLAGS} ${cflag}\")\n endif()\n endforeach()\n string(REPLACE \";\" \" \" PC_LINKOPTS \"${ABSL_CC_LIB_LINKOPTS}\")\n FILE(GENERATE OUTPUT \"${CMAKE_BINARY_DIR}/lib/pkgconfig/absl_${_NAME}.pc\" CONTENT \"\\\nprefix=${CMAKE_INSTALL_PREFIX}\\n\\\nexec_prefix=\\${prefix}\\n\\\nlibdir=${CMAKE_INSTALL_FULL_LIBDIR}\\n\\\nincludedir=${CMAKE_INSTALL_FULL_INCLUDEDIR}\\n\\\n\\n\\\nName: absl_${_NAME}\\n\\\nDescription: Abseil ${_NAME} library\\n\\\nURL: https://abseil.io/\\n\\\nVersion: ${PC_VERSION}\\n\\\nRequires:${PC_DEPS}\\n\\\nLibs: -L\\${libdir} $<$>:${LNK_LIB}> ${PC_LINKOPTS}\\n\\\nCflags: -I\\${includedir}${PC_CFLAGS}\\n\")\n INSTALL(FILES \"${CMAKE_BINARY_DIR}/lib/pkgconfig/absl_${_NAME}.pc\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/pkgconfig\")\n endif()\n\n if(NOT ABSL_CC_LIB_IS_INTERFACE)\n if(_build_type STREQUAL \"dll_dep\")\n # This target depends on the DLL. When adding dependencies to this target,\n # any depended-on-target which is contained inside the DLL is replaced\n # with a dependency on the DLL.\n add_library(${_NAME} STATIC \"\")\n target_sources(${_NAME} PRIVATE ${ABSL_CC_LIB_SRCS} ${ABSL_CC_LIB_HDRS})\n absl_internal_dll_targets(\n DEPS ${ABSL_CC_LIB_DEPS}\n OUTPUT _dll_deps\n )\n target_link_libraries(${_NAME}\n PUBLIC ${_dll_deps}\n PRIVATE\n ${ABSL_CC_LIB_LINKOPTS}\n ${ABSL_DEFAULT_LINKOPTS}\n )\n\n if (ABSL_CC_LIB_TESTONLY)\n set(_gtest_link_define \"GTEST_LINKED_AS_SHARED_LIBRARY=1\")\n else()\n set(_gtest_link_define)\n endif()\n\n target_compile_definitions(${_NAME}\n PUBLIC\n ABSL_CONSUME_DLL\n \"${_gtest_link_define}\"\n )\n\n elseif(_build_type STREQUAL \"static\" OR _build_type STREQUAL \"shared\")\n add_library(${_NAME} \"\")\n target_sources(${_NAME} PRIVATE ${ABSL_CC_LIB_SRCS} ${ABSL_CC_LIB_HDRS})\n if(APPLE)\n set_target_properties(${_NAME} PROPERTIES\n INSTALL_RPATH \"@loader_path\")\n elseif(UNIX)\n set_target_properties(${_NAME} PROPERTIES\n INSTALL_RPATH \"$ORIGIN\")\n endif()\n target_link_libraries(${_NAME}\n PUBLIC ${ABSL_CC_LIB_DEPS}\n PRIVATE\n ${ABSL_CC_LIB_LINKOPTS}\n ${ABSL_DEFAULT_LINKOPTS}\n )\n else()\n message(FATAL_ERROR \"Invalid build type: ${_build_type}\")\n endif()\n\n # Linker language can be inferred from sources, but in the case of DLLs we\n # don't have any .cc files so it would be ambiguous. We could set it\n # explicitly only in the case of DLLs but, because \"CXX\" is always the\n # correct linker language for static or for shared libraries, we set it\n # unconditionally.\n set_property(TARGET ${_NAME} PROPERTY LINKER_LANGUAGE \"CXX\")\n\n target_include_directories(${_NAME} ${ABSL_INTERNAL_INCLUDE_WARNING_GUARD}\n PUBLIC\n \"$\"\n $\n )\n target_compile_options(${_NAME}\n PRIVATE ${ABSL_CC_LIB_COPTS})\n target_compile_definitions(${_NAME} PUBLIC ${ABSL_CC_LIB_DEFINES})\n\n # Add all Abseil targets to a a folder in the IDE for organization.\n if(ABSL_CC_LIB_PUBLIC)\n set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER})\n elseif(ABSL_CC_LIB_TESTONLY)\n set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)\n else()\n set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/internal)\n endif()\n\n if(ABSL_PROPAGATE_CXX_STD)\n # Abseil libraries require C++17 as the current minimum standard. When\n # compiled with a higher standard (either because it is the compiler's\n # default or explicitly requested), then Abseil requires that standard.\n target_compile_features(${_NAME} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})\n endif()\n\n # When being installed, we lose the absl_ prefix. We want to put it back\n # to have properly named lib files. This is a no-op when we are not being\n # installed.\n if(ABSL_ENABLE_INSTALL)\n set_target_properties(${_NAME} PROPERTIES\n OUTPUT_NAME \"absl_${_NAME}\"\n SOVERSION \"${ABSL_SOVERSION}\"\n )\n endif()\n else()\n # Generating header-only library\n add_library(${_NAME} INTERFACE)\n target_include_directories(${_NAME} ${ABSL_INTERNAL_INCLUDE_WARNING_GUARD}\n INTERFACE\n \"$\"\n $\n )\n\n if (_build_type STREQUAL \"dll\")\n if(${_in_dll})\n set(ABSL_CC_LIB_DEPS abseil_dll)\n endif()\n if(${_in_test_dll})\n set(ABSL_CC_LIB_DEPS abseil_test_dll)\n endif()\n endif()\n\n target_link_libraries(${_NAME}\n INTERFACE\n ${ABSL_CC_LIB_DEPS}\n ${ABSL_CC_LIB_LINKOPTS}\n ${ABSL_DEFAULT_LINKOPTS}\n )\n target_compile_definitions(${_NAME} INTERFACE ${ABSL_CC_LIB_DEFINES})\n\n if(ABSL_PROPAGATE_CXX_STD)\n # Abseil libraries require C++17 as the current minimum standard.\n # Top-level application CMake projects should ensure a consistent C++\n # standard for all compiled sources by setting CMAKE_CXX_STANDARD.\n target_compile_features(${_NAME} INTERFACE ${ABSL_INTERNAL_CXX_STD_FEATURE})\n endif()\n endif()\n\n if(ABSL_ENABLE_INSTALL)\n install(TARGETS ${_NAME} EXPORT ${PROJECT_NAME}Targets\n RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}\n LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}\n ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}\n )\n endif()\n\n add_library(absl::${ABSL_CC_LIB_NAME} ALIAS ${_NAME})\nendfunction()\n\n# absl_cc_test()\n#\n# CMake function to imitate Bazel's cc_test rule.\n#\n# Parameters:\n# NAME: name of target (see Usage below)\n# SRCS: List of source files for the binary\n# DEPS: List of other libraries to be linked in to the binary targets\n# COPTS: List of private compile options\n# DEFINES: List of public defines\n# LINKOPTS: List of link options\n#\n# Note:\n# By default, absl_cc_test will always create a binary named absl_${NAME}.\n# This will also add it to ctest list as absl_${NAME}.\n#\n# Usage:\n# absl_cc_library(\n# NAME\n# awesome\n# HDRS\n# \"a.h\"\n# SRCS\n# \"a.cc\"\n# PUBLIC\n# )\n#\n# absl_cc_test(\n# NAME\n# awesome_test\n# SRCS\n# \"awesome_test.cc\"\n# DEPS\n# absl::awesome\n# GTest::gmock\n# GTest::gtest_main\n# )\nfunction(absl_cc_test)\n if(NOT (BUILD_TESTING AND ABSL_BUILD_TESTING))\n return()\n endif()\n\n cmake_parse_arguments(ABSL_CC_TEST\n \"\"\n \"NAME\"\n \"SRCS;COPTS;DEFINES;LINKOPTS;DEPS\"\n ${ARGN}\n )\n\n set(_NAME \"absl_${ABSL_CC_TEST_NAME}\")\n\n add_executable(${_NAME} \"\")\n target_sources(${_NAME} PRIVATE ${ABSL_CC_TEST_SRCS})\n target_include_directories(${_NAME}\n PUBLIC ${ABSL_COMMON_INCLUDE_DIRS}\n PRIVATE ${absl_gtest_src_dir}/googletest/include ${absl_gtest_src_dir}/googlemock/include\n )\n\n if (${ABSL_BUILD_DLL})\n target_compile_definitions(${_NAME}\n PUBLIC\n ${ABSL_CC_TEST_DEFINES}\n ABSL_CONSUME_DLL\n ABSL_CONSUME_TEST_DLL\n GTEST_LINKED_AS_SHARED_LIBRARY=1\n )\n\n # Replace dependencies on targets inside the DLL with abseil_dll itself.\n absl_internal_dll_targets(\n DEPS ${ABSL_CC_TEST_DEPS}\n OUTPUT ABSL_CC_TEST_DEPS\n )\n absl_internal_dll_targets(\n DEPS ${ABSL_CC_TEST_LINKOPTS}\n OUTPUT ABSL_CC_TEST_LINKOPTS\n )\n else()\n target_compile_definitions(${_NAME}\n PUBLIC\n ${ABSL_CC_TEST_DEFINES}\n )\n endif()\n target_compile_options(${_NAME}\n PRIVATE ${ABSL_CC_TEST_COPTS}\n )\n\n target_link_libraries(${_NAME}\n PUBLIC ${ABSL_CC_TEST_DEPS}\n PRIVATE ${ABSL_CC_TEST_LINKOPTS}\n )\n # Add all Abseil targets to a folder in the IDE for organization.\n set_property(TARGET ${_NAME} PROPERTY FOLDER ${ABSL_IDE_FOLDER}/test)\n\n if(ABSL_PROPAGATE_CXX_STD)\n # Abseil libraries require C++17 as the current minimum standard.\n # Top-level application CMake projects should ensure a consistent C++\n # standard for all compiled sources by setting CMAKE_CXX_STANDARD.\n target_compile_features(${_NAME} PUBLIC ${ABSL_INTERNAL_CXX_STD_FEATURE})\n endif()\n\n add_test(NAME ${_NAME} COMMAND ${_NAME})\nendfunction()\n" }, { "path": "CMake/Googletest/CMakeLists.txt.in", "content": "cmake_minimum_required(VERSION 3.16)\n\nproject(googletest-external NONE)\n\ninclude(ExternalProject)\nExternalProject_Add(googletest\n URL \"${absl_gtest_download_url}\" # May be empty\n SOURCE_DIR \"${absl_gtest_src_dir}\"\n BINARY_DIR \"${absl_gtest_build_dir}\"\n CONFIGURE_COMMAND \"\"\n BUILD_COMMAND \"\"\n INSTALL_COMMAND \"\"\n TEST_COMMAND \"\"\n)\n" }, { "path": "CMake/Googletest/DownloadGTest.cmake", "content": "# Integrates googletest at configure time. Based on the instructions at\n# https://github.com/google/googletest/tree/master/googletest#incorporating-into-an-existing-cmake-project\n\n# Set up the external googletest project, downloading the latest from Github\n# master if requested.\nconfigure_file(\n ${CMAKE_CURRENT_LIST_DIR}/CMakeLists.txt.in\n ${CMAKE_BINARY_DIR}/googletest-external/CMakeLists.txt\n)\n\nset(ABSL_SAVE_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})\nset(ABSL_SAVE_CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})\nif (BUILD_SHARED_LIBS)\n set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)\n set(CMAKE_CXX_FLAGS \"${CMAKE_CXX_FLAGS} -DGTEST_CREATE_SHARED_LIBRARY=1\")\nendif()\n\n# Configure and build the googletest source.\nexecute_process(COMMAND ${CMAKE_COMMAND} -G \"${CMAKE_GENERATOR}\" .\n RESULT_VARIABLE result\n WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-external )\nif(result)\n message(FATAL_ERROR \"CMake step for googletest failed: ${result}\")\nendif()\n\nexecute_process(COMMAND ${CMAKE_COMMAND} --build .\n RESULT_VARIABLE result\n WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/googletest-external)\nif(result)\n message(FATAL_ERROR \"Build step for googletest failed: ${result}\")\nendif()\n\nset(CMAKE_CXX_FLAGS ${ABSL_SAVE_CMAKE_CXX_FLAGS})\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${ABSL_SAVE_CMAKE_RUNTIME_OUTPUT_DIRECTORY})\n\n# Prevent overriding the parent project's compiler/linker settings on Windows\nset(gtest_force_shared_crt ON CACHE BOOL \"\" FORCE)\n\n# Add googletest directly to our build. This defines the gtest and gtest_main\n# targets.\nadd_subdirectory(${absl_gtest_src_dir} ${absl_gtest_build_dir} EXCLUDE_FROM_ALL)\n" }, { "path": "CMake/README.md", "content": "# Abseil CMake Build Instructions\n\nAbseil comes with a CMake build script ([CMakeLists.txt](../CMakeLists.txt))\nthat can be used on a wide range of platforms (\"C\" stands for cross-platform.).\nIf you don't have CMake installed already, you can download it for free from\n.\n\nCMake works by generating native makefiles or build projects that can\nbe used in the compiler environment of your choice.\n\nFor API/ABI compatibility reasons, we strongly recommend building Abseil in a\nsubdirectory of your project or as an embedded dependency.\n\n## Incorporating Abseil Into a CMake Project\n\nThe recommendations below are similar to those for using CMake within the\ngoogletest framework\n()\n\n### Step-by-Step Instructions\n\n1. If you want to build the Abseil tests, integrate the Abseil dependency\n[Google Test](https://github.com/google/googletest) into your CMake\nproject. To disable Abseil tests, you have to pass either\n`-DBUILD_TESTING=OFF` or `-DABSL_BUILD_TESTING=OFF` when configuring your\nproject with CMake.\n\n2. Download Abseil and copy it into a subdirectory in your CMake project or add\nAbseil as a [git submodule](https://git-scm.com/docs/git-submodule) in your\nCMake project.\n\n3. You can then use the CMake command\n[`add_subdirectory()`](https://cmake.org/cmake/help/latest/command/add_subdirectory.html)\nto include Abseil directly in your CMake project.\n\n4. Add the **absl::** target you wish to use to the\n[`target_link_libraries()`](https://cmake.org/cmake/help/latest/command/target_link_libraries.html)\nsection of your executable or of your library.
\nHere is a short CMakeLists.txt example of an application project using Abseil.\n\n```cmake\ncmake_minimum_required(VERSION 3.16)\nproject(my_app_project)\n\n# Pick the C++ standard to compile with.\n# Abseil currently supports C++17 and C++20.\nset(CMAKE_CXX_STANDARD 17)\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\nadd_subdirectory(abseil-cpp)\n\nadd_executable(my_exe source.cpp)\ntarget_link_libraries(my_exe absl::base absl::synchronization absl::strings)\n```\n\nNote that if you are developing a library designed for use by other clients, you\nshould instead leave `CMAKE_CXX_STANDARD` unset (or only set if being built as\nthe current top-level CMake project) and configure the minimum required C++\nstandard at the target level. If you require a later minimum C++ standard than\nAbseil does, it's a good idea to also enforce that `CMAKE_CXX_STANDARD` (which\nwill control Abseil library targets) is set to at least that minimum. For\nexample:\n\n```cmake\ncmake_minimum_required(VERSION 3.16)\nproject(my_lib_project)\n\n# Leave C++ standard up to the root application, so set it only if this is the\n# current top-level CMake project.\nif(CMAKE_SOURCE_DIR STREQUAL my_lib_project_SOURCE_DIR)\n set(CMAKE_CXX_STANDARD 17)\n set(CMAKE_CXX_STANDARD_REQUIRED ON)\nendif()\n\nadd_subdirectory(abseil-cpp)\n\nadd_library(my_lib source.cpp)\ntarget_link_libraries(my_lib absl::base absl::synchronization absl::strings)\n\n# Enforce that my_lib requires C++17. Important to document for clients that they\n# must set CMAKE_CXX_STANDARD to 17 or higher for proper Abseil ABI compatibility\n# (since otherwise, Abseil library targets could be compiled with a lower C++\n# standard than my_lib).\ntarget_compile_features(my_lib PUBLIC cxx_std_17)\nif(CMAKE_CXX_STANDARD LESS 17)\n message(FATAL_ERROR\n \"my_lib_project requires CMAKE_CXX_STANDARD >= 17 (got: ${CMAKE_CXX_STANDARD})\")\nendif()\n```\n\nThen the top-level application project that uses your library is responsible for\nsetting a consistent `CMAKE_CXX_STANDARD` that is sufficiently high.\n\n### Running Abseil Tests with CMake\n\nUse the `-DABSL_BUILD_TESTING=ON` flag to run Abseil tests. Note that\nBUILD_TESTING must also be on (the default).\n\nYou will need to provide Abseil with a Googletest dependency. There are two\noptions for how to do this:\n\n* Use `-DABSL_USE_GOOGLETEST_HEAD`. This will automatically download the latest\nGoogletest source into the build directory at configure time. Googletest will\nthen be compiled directly alongside Abseil's tests.\n* Manually integrate Googletest with your build. See\nhttps://github.com/google/googletest/blob/master/googletest/README.md#using-cmake\nfor more information on using Googletest in a CMake project.\n\nFor example, to run just the Abseil tests, you could use this script:\n\n```\ncd path/to/abseil-cpp\nmkdir build\ncd build\ncmake -DABSL_BUILD_TESTING=ON -DABSL_USE_GOOGLETEST_HEAD=ON ..\nmake -j\nctest\n```\n\nCurrently, we only run our tests with CMake in a Linux environment, but we are\nworking on the rest of our supported platforms. See\nhttps://github.com/abseil/abseil-cpp/projects/1 and\nhttps://github.com/abseil/abseil-cpp/issues/109 for more information.\n\n### Available Abseil CMake Public Targets\n\nHere's a non-exhaustive list of Abseil CMake public targets:\n\n```cmake\nabsl::algorithm\nabsl::base\nabsl::debugging\nabsl::flat_hash_map\nabsl::flags\nabsl::memory\nabsl::meta\nabsl::numeric\nabsl::random_random\nabsl::strings\nabsl::synchronization\nabsl::time\nabsl::utility\n```\n\n## Traditional CMake Set-Up\n\nFor larger projects, it may make sense to use the traditional CMake set-up where you build and install projects separately.\n\nFirst, you'd need to build and install Google Test:\n```\ncmake -S /source/googletest -B /build/googletest -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/installation/dir -DBUILD_GMOCK=ON\ncmake --build /build/googletest --target install\n```\n\nThen 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.\n```\ncmake -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\ncmake --build /temporary/build/abseil-cpp\n```\n\n(`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.)\n\nRun the tests:\n```\nctest --test-dir /temporary/build/abseil-cpp\n```\n\nAnd finally install:\n```\ncmake --build /temporary/build/abseil-cpp --target install\n```\n\n# CMake Option Synopsis\n\n## Enable Standard CMake Installation\n\n`-DABSL_ENABLE_INSTALL=ON`\n\n## Google Test Options\n\n`-DABSL_BUILD_TESTING=ON` must be set to enable testing\n\n- Have Abseil download and build Google Test for you: `-DABSL_USE_EXTERNAL_GOOGLETEST=OFF` (default)\n - Download and build latest Google Test: `-DABSL_USE_GOOGLETEST_HEAD=ON`\n - Download specific Google Test version (ZIP archive): `-DABSL_GOOGLETEST_DOWNLOAD_URL=https://.../version.zip`\n - Use Google Test from specific local directory: `-DABSL_LOCAL_GOOGLETEST_DIR=/path/to/googletest`\n- Use Google Test included elsewhere in your project: `-DABSL_USE_EXTERNAL_GOOGLETEST=ON`\n- Use standard CMake `find_package(CTest)` to find installed Google Test: `-DABSL_USE_EXTERNAL_GOOGLETEST=ON -DABSL_FIND_GOOGLETEST=ON`\n" }, { "path": "CMake/abslConfig.cmake.in", "content": "# absl CMake configuration file.\n\ninclude(CMakeFindDependencyMacro)\nfind_dependency(Threads)\n\n@PACKAGE_INIT@\n\ninclude (\"${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake\")\n" }, { "path": "CMake/install_test_project/CMakeLists.txt", "content": "#\n# Copyright 2019 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# A simple CMakeLists.txt for testing cmake installation\n\ncmake_minimum_required(VERSION 3.16)\nproject(absl_cmake_testing CXX)\n\nadd_executable(simple simple.cc)\n\nfind_package(absl REQUIRED)\n\ntarget_link_libraries(simple absl::strings absl::config)\n" }, { "path": "CMake/install_test_project/simple.cc", "content": "//\n// Copyright 2019 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include \n#include \"absl/base/config.h\"\n#include \"absl/strings/substitute.h\"\n\n#if !defined(ABSL_LTS_RELEASE_VERSION) || ABSL_LTS_RELEASE_VERSION != 99998877\n#error ABSL_LTS_RELEASE_VERSION is not set correctly.\n#endif\n\n#if !defined(ABSL_LTS_RELEASE_PATCH_LEVEL) || ABSL_LTS_RELEASE_PATCH_LEVEL != 0\n#error ABSL_LTS_RELEASE_PATCH_LEVEL is not set correctly.\n#endif\n\nint main(int argc, char** argv) {\n for (int i = 0; i < argc; ++i) {\n std::cout << absl::Substitute(\"Arg $0: $1\\n\", i, argv[i]);\n }\n}\n" }, { "path": "CMake/install_test_project/test.sh", "content": "#!/bin/bash\n#\n# Copyright 2019 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# Unit and integration tests for Abseil LTS CMake installation\n\n# Fail on any error. Treat unset variables an error. Print commands as executed.\nset -euox pipefail\n\nabsl_dir=/abseil-cpp\nabsl_build_dir=/buildfs\ngoogletest_builddir=/googletest_builddir\ngoogletest_archive=\"googletest-${ABSL_GOOGLETEST_VERSION}.tar.gz\"\nproject_dir=\"${absl_dir}/CMake/install_test_project\"\nproject_build_dir=/buildfs/project-build\n\nbuild_shared_libs=\"OFF\"\nif [ \"${LINK_TYPE:-}\" = \"DYNAMIC\" ]; then\n build_shared_libs=\"ON\"\nfi\n\n# Build and install GoogleTest\nmkdir \"${googletest_builddir}\"\npushd \"${googletest_builddir}\"\ncurl -L \"${ABSL_GOOGLETEST_DOWNLOAD_URL}\" --output \"${googletest_archive}\"\ntar -xz -f \"${googletest_archive}\"\npushd \"googletest-${ABSL_GOOGLETEST_VERSION}\"\nmkdir build\npushd build\ncmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=\"${build_shared_libs}\" ..\nmake -j $(nproc)\nmake install\nldconfig\npopd\npopd\npopd\n\n# Run the LTS transformations\n./create_lts.py 99998877\n\n# Build and install Abseil\npushd \"${absl_build_dir}\"\ncmake \"${absl_dir}\" \\\n -DABSL_USE_EXTERNAL_GOOGLETEST=ON \\\n -DABSL_FIND_GOOGLETEST=ON \\\n -DCMAKE_BUILD_TYPE=Release \\\n -DABSL_BUILD_TESTING=ON \\\n -DBUILD_SHARED_LIBS=\"${build_shared_libs}\"\nmake -j $(nproc)\nctest -j $(nproc) --output-on-failure\nmake install\nldconfig\npopd\n\n# Test the project against the installed Abseil\nmkdir -p \"${project_build_dir}\"\npushd \"${project_build_dir}\"\ncmake \"${project_dir}\"\ncmake --build . --target simple\n\noutput=\"$(${project_build_dir}/simple \"printme\" 2>&1)\"\nif [[ \"${output}\" != *\"Arg 1: printme\"* ]]; then\n echo \"Faulty output on simple project:\"\n echo \"${output}\"\n exit 1\nfi\n\npopd\n\nif ! grep absl::strings \"/usr/local/lib/cmake/absl/abslTargets.cmake\"; then\n cat \"/usr/local/lib/cmake/absl/abslTargets.cmake\"\n echo \"CMake targets named incorrectly\"\n exit 1\nfi\n\npushd \"${HOME}\"\ncat > hello-abseil.cc << EOF\n#include \n\n#include \"absl/strings/str_format.h\"\n\nint main(int argc, char **argv) {\n absl::PrintF(\"Hello Abseil!\\n\");\n return EXIT_SUCCESS;\n}\nEOF\n\nif [ \"${LINK_TYPE:-}\" != \"DYNAMIC\" ]; then\n pc_args=($(pkg-config --cflags --libs --static absl_str_format))\n g++ -static -o hello-abseil hello-abseil.cc \"${pc_args[@]}\"\nelse\n pc_args=($(pkg-config --cflags --libs absl_str_format))\n g++ -o hello-abseil hello-abseil.cc \"${pc_args[@]}\"\nfi\nhello=\"$(./hello-abseil)\"\n[[ \"${hello}\" == \"Hello Abseil!\" ]]\n\npopd\n\necho \"Install test complete!\"\nexit 0\n" }, { "path": "CMakeLists.txt", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\n# https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md\n# As of 2024-07-01, CMake 3.16 is the minimum supported version.\ncmake_minimum_required(VERSION 3.16)\n\n# Allow the user to specify the CMAKE_MSVC_DEBUG_INFORMATION_FORMAT\nif (POLICY CMP0141)\n cmake_policy(SET CMP0141 NEW)\nendif (POLICY CMP0141)\n\nproject(absl LANGUAGES CXX)\nset(ABSL_SOVERSION 0)\ninclude(CTest)\n\n# Output directory is correct by default for most build setups. However, when\n# building Abseil as a DLL, it is important to have the DLL in the same\n# directory as the executable using it. Thus, we put all executables in a single\n# /bin directory.\nset(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)\n\n# when absl is included as subproject (i.e. using add_subdirectory(abseil-cpp))\n# in the source tree of a project that uses it, install rules are disabled.\nif(NOT CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)\n option(ABSL_ENABLE_INSTALL \"Enable install rule\" OFF)\nelse()\n option(ABSL_ENABLE_INSTALL \"Enable install rule\" ON)\nendif()\n\nset(CMAKE_INSTALL_RPATH \"$ORIGIN\")\nset(CMAKE_INSTALL_RPATH_USE_LINK_PATH ON)\nset(CMAKE_BUILD_RPATH_USE_ORIGIN ON)\n\noption(ABSL_PROPAGATE_CXX_STD\n \"Use CMake C++ standard meta features (e.g. cxx_std_17) that propagate to targets that link to Abseil\"\n ON)\n\noption(ABSL_USE_SYSTEM_INCLUDES\n \"Silence warnings in Abseil headers by marking them as SYSTEM includes\"\n OFF)\n\nlist(APPEND CMAKE_MODULE_PATH\n ${CMAKE_CURRENT_LIST_DIR}/CMake\n ${CMAKE_CURRENT_LIST_DIR}/absl/copts\n)\n\noption(ABSL_MSVC_STATIC_RUNTIME\n \"Link static runtime libraries\"\n OFF)\nif(ABSL_MSVC_STATIC_RUNTIME)\n set(CMAKE_MSVC_RUNTIME_LIBRARY \"MultiThreaded$<$:Debug>\")\nelse()\n set(CMAKE_MSVC_RUNTIME_LIBRARY \"MultiThreaded$<$:Debug>DLL\")\nendif()\n\ninclude(CMakePackageConfigHelpers)\ninclude(GNUInstallDirs)\ninclude(AbseilDll)\ninclude(AbseilHelpers)\n\n\n##\n## Using absl targets\n##\n## all public absl targets are\n## exported with the absl:: prefix\n##\n## e.g absl::base absl::synchronization absl::strings ....\n##\n## DO NOT rely on the internal targets outside of the prefix\n\n\n# include current path\nlist(APPEND ABSL_COMMON_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})\n\nif(\"${CMAKE_CXX_COMPILER_ID}\" MATCHES \"Clang\")\n set(ABSL_USING_CLANG ON)\nelse()\n set(ABSL_USING_CLANG OFF)\nendif()\n\n# find dependencies\n## pthread\nfind_package(Threads REQUIRED)\n\ninclude(CMakeDependentOption)\n\noption(ABSL_BUILD_TESTING\n \"If ON, Abseil will build all of Abseil's own tests.\" OFF)\n\noption(ABSL_BUILD_TEST_HELPERS\n \"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.\"\n OFF)\n\noption(ABSL_USE_EXTERNAL_GOOGLETEST\n \"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)\n\ncmake_dependent_option(ABSL_FIND_GOOGLETEST\n \"If ON, Abseil will use find_package(GTest) rather than assuming that GoogleTest is already provided by the including project.\"\n ON\n \"ABSL_USE_EXTERNAL_GOOGLETEST\"\n OFF)\n\n\noption(ABSL_USE_GOOGLETEST_HEAD\n \"If ON, abseil will download HEAD from GoogleTest at config time.\" OFF)\n\nset(ABSL_GOOGLETEST_DOWNLOAD_URL \"\" CACHE STRING \"If set, download GoogleTest from this URL\")\n\nset(ABSL_LOCAL_GOOGLETEST_DIR \"/usr/src/googletest\" CACHE PATH\n \"If ABSL_USE_GOOGLETEST_HEAD is OFF and ABSL_GOOGLETEST_URL is not set, specifies the directory of a local GoogleTest checkout.\"\n )\n\noption(ABSL_BUILD_MONOLITHIC_SHARED_LIBS\n \"Build Abseil as a single shared library (always enabled for Windows)\"\n OFF\n)\nif(NOT BUILD_SHARED_LIBS AND ABSL_BUILD_MONOLITHIC_SHARED_LIBS)\n message(WARNING \"Not building a shared library because BUILD_SHARED_LIBS is not set. Ignoring ABSL_BUILD_MONOLITHIC_SHARED_LIBS.\")\nendif()\n\nif((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)\n if (ABSL_USE_EXTERNAL_GOOGLETEST)\n if (ABSL_FIND_GOOGLETEST)\n find_package(GTest REQUIRED)\n elseif(NOT TARGET GTest::gtest)\n if(TARGET gtest)\n # When Google Test is included directly rather than through find_package, the aliases are missing.\n add_library(GTest::gtest ALIAS gtest)\n add_library(GTest::gtest_main ALIAS gtest_main)\n add_library(GTest::gmock ALIAS gmock)\n add_library(GTest::gmock_main ALIAS gmock_main)\n else()\n 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.\")\n endif()\n endif()\n else()\n set(absl_gtest_build_dir ${CMAKE_BINARY_DIR}/googletest-build)\n if(ABSL_USE_GOOGLETEST_HEAD AND ABSL_GOOGLETEST_DOWNLOAD_URL)\n message(FATAL_ERROR \"Do not set both ABSL_USE_GOOGLETEST_HEAD and ABSL_GOOGLETEST_DOWNLOAD_URL\")\n endif()\n if(ABSL_USE_GOOGLETEST_HEAD)\n set(absl_gtest_download_url \"https://github.com/google/googletest/archive/main.zip\")\n elseif(ABSL_GOOGLETEST_DOWNLOAD_URL)\n set(absl_gtest_download_url ${ABSL_GOOGLETEST_DOWNLOAD_URL})\n endif()\n if(absl_gtest_download_url)\n set(absl_gtest_src_dir ${CMAKE_BINARY_DIR}/googletest-src)\n else()\n set(absl_gtest_src_dir ${ABSL_LOCAL_GOOGLETEST_DIR})\n endif()\n include(CMake/Googletest/DownloadGTest.cmake)\n endif()\nendif()\n\nadd_subdirectory(absl)\n\nif(ABSL_ENABLE_INSTALL)\n # absl:lts-remove-begin(system installation is supported for LTS releases)\n # We don't support system-wide installation\n list(APPEND SYSTEM_INSTALL_DIRS \"/usr/local\" \"/usr\" \"/opt/\" \"/opt/local\" \"c:/Program Files/${PROJECT_NAME}\")\n if(NOT DEFINED CMAKE_INSTALL_PREFIX OR CMAKE_INSTALL_PREFIX IN_LIST SYSTEM_INSTALL_DIRS)\n message(WARNING \"\\\n The default and system-level install directories are unsupported except in LTS \\\n releases of Abseil. Please set CMAKE_INSTALL_PREFIX to install Abseil in your \\\n source or build tree directly.\\\n \")\n endif()\n # absl:lts-remove-end\n\n # install as a subdirectory only\n install(EXPORT ${PROJECT_NAME}Targets\n NAMESPACE absl::\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}\"\n )\n\n configure_package_config_file(\n CMake/abslConfig.cmake.in\n \"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake\"\n INSTALL_DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}\"\n )\n install(FILES \"${PROJECT_BINARY_DIR}/${PROJECT_NAME}Config.cmake\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}\"\n )\n\n # Abseil only has a version in LTS releases. This mechanism is accomplished\n # Abseil's internal Copybara (https://github.com/google/copybara) workflows and\n # isn't visible in the CMake buildsystem itself.\n if(absl_VERSION)\n write_basic_package_version_file(\n \"${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake\"\n COMPATIBILITY ExactVersion\n )\n\n install(FILES \"${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake\"\n DESTINATION \"${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}\"\n )\n endif() # absl_VERSION\n\n # Install the headers except for \"options.h\" which is installed separately.\n install(DIRECTORY absl\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}\n FILES_MATCHING\n PATTERN \"*.inc\"\n PATTERN \"*.h\"\n PATTERN \"options.h\" EXCLUDE\n PATTERN \"copts\" EXCLUDE\n PATTERN \"testdata\" EXCLUDE\n )\n\n # Rewrite options.h to use the compiled ABI.\n file(READ \"absl/base/options.h\" ABSL_INTERNAL_OPTIONS_H_CONTENTS)\n\n # Handle features that require at least C++20.\n if (ABSL_INTERNAL_AT_LEAST_CXX20)\n foreach(FEATURE \"ORDERING\" \"SOURCE_LOCATION\")\n string(REPLACE\n \"#define ABSL_OPTION_USE_STD_${FEATURE} 2\"\n \"#define ABSL_OPTION_USE_STD_${FEATURE} 1\"\n ABSL_INTERNAL_OPTIONS_H_PINNED\n \"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}\")\n set(ABSL_INTERNAL_OPTIONS_H_CONTENTS \"${ABSL_INTERNAL_OPTIONS_H_PINNED}\")\n endforeach()\n endif()\n\n # Handle features that require at least C++17.\n if (ABSL_INTERNAL_AT_LEAST_CXX17)\n foreach(FEATURE \"ANY\" \"OPTIONAL\" \"STRING_VIEW\" \"VARIANT\")\n string(REPLACE\n \"#define ABSL_OPTION_USE_STD_${FEATURE} 2\"\n \"#define ABSL_OPTION_USE_STD_${FEATURE} 1\"\n ABSL_INTERNAL_OPTIONS_H_PINNED\n \"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}\")\n set(ABSL_INTERNAL_OPTIONS_H_CONTENTS \"${ABSL_INTERNAL_OPTIONS_H_PINNED}\")\n endforeach()\n endif()\n\n # Any feature that still has the value of 2 (because it was not handled above)\n # should be set to 0.\n string(REGEX REPLACE\n \"#define ABSL_OPTION_USE_STD_([^ ]*) 2\"\n \"#define ABSL_OPTION_USE_STD_\\\\1 0\"\n ABSL_INTERNAL_OPTIONS_H_PINNED\n \"${ABSL_INTERNAL_OPTIONS_H_CONTENTS}\")\n\n # If the file already exists, check if it matches the new contents.\n # This avoids writing the file if it is already up-to-date when the CMake\n # generation is triggered and triggering unnecessary rebuilds.\n set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE TRUE)\n if (EXISTS \"${CMAKE_BINARY_DIR}/options-pinned.h\")\n file(READ \"${CMAKE_BINARY_DIR}/options-pinned.h\" ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS)\n if (\"${ABSL_INTERNAL_OPTIONS_H_PINNED}\" STREQUAL \"${ABSL_INTERNAL_OPTIONS_PINNED_H_CONTENTS}\")\n set(ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE FALSE)\n endif()\n endif()\n\n # If the file needs an update, generate it.\n if (ABSL_INTERNAL_OPTIONS_H_PINNED_NEEDS_UPDATE)\n file(GENERATE OUTPUT \"${CMAKE_BINARY_DIR}/options-pinned.h\" CONTENT \"${ABSL_INTERNAL_OPTIONS_H_PINNED}\")\n endif()\n\n install(FILES \"${CMAKE_BINARY_DIR}/options-pinned.h\"\n DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/absl/base\n RENAME \"options.h\")\n\nendif() # ABSL_ENABLE_INSTALL\n" }, { "path": "CONTRIBUTING.md", "content": "# How to Contribute to Abseil\n\nWe'd love to accept your patches and contributions to this project. There are\njust a few small guidelines you need to follow.\n\nNOTE: If you are new to GitHub, please start by reading [Pull Request\nhowto](https://help.github.com/articles/about-pull-requests/)\n\n## Contributor License Agreement\n\nContributions to this project must be accompanied by a Contributor License\nAgreement. You (or your employer) retain the copyright to your contribution,\nthis simply gives us permission to use and redistribute your contributions as\npart of the project. Head over to to see\nyour current agreements on file or to sign a new one.\n\nYou generally only need to submit a CLA once, so if you've already submitted one\n(even if it was for a different project), you probably don't need to do it\nagain.\n\n## Contribution Guidelines\n\nPotential contributors sometimes ask us if the Abseil project is the appropriate\nhome for their utility library code or for specific functions implementing\nmissing portions of the standard. Often, the answer to this question is \"no\".\nWe’d like to articulate our thinking on this issue so that our choices can be\nunderstood by everyone and so that contributors can have a better intuition\nabout whether Abseil might be interested in adopting a new library.\n\n### Priorities\n\nAlthough our mission is to augment the C++ standard library, our goal is not to\nprovide a full forward-compatible implementation of the latest standard. For us\nto consider a library for inclusion in Abseil, it is not enough that a library\nis useful. We generally choose to release a library when it meets at least one\nof the following criteria:\n\n* **Widespread usage** - Using our internal codebase to help gauge usage, most\n of the libraries we've released have tens of thousands of users.\n* **Anticipated widespread usage** - Pre-adoption of some standard-compliant\n APIs may not have broad adoption initially but can be expected to pick up\n usage when it replaces legacy APIs. `absl::from_chars`, for example,\n replaces existing code that converts strings to numbers and will therefore\n likely see usage growth.\n* **High impact** - APIs that provide a key solution to a specific problem,\n such as `absl::FixedArray`, have higher impact than usage numbers may signal\n and are released because of their importance.\n* **Direct support for a library that falls under one of the above** - When we\n want access to a smaller library as an implementation detail for a\n higher-priority library we plan to release, we may release it, as we did\n with portions of `absl/meta/type_traits.h`. One consequence of this is that\n the presence of a library in Abseil does not necessarily mean that other\n similar libraries would be a high priority.\n\n### API Freeze Consequences\n\nVia the\n[Abseil Compatibility Guidelines](https://abseil.io/about/compatibility), we\nhave promised a large degree of API stability. In particular, we will not make\nbackward-incompatible changes to released APIs without also shipping a tool or\nprocess that can upgrade our users' code. We are not yet at the point of easily\nreleasing such tools. Therefore, at this time, shipping a library establishes an\nAPI contract which is borderline unchangeable. (We can add new functionality,\nbut we cannot easily change existing behavior.) This constraint forces us to\nvery carefully review all APIs that we ship.\n\n\n## Coding Style\n\nTo keep the source consistent, readable, diffable and easy to merge, we use a\nfairly rigid coding style, as defined by the\n[google-styleguide](https://github.com/google/styleguide) project. All patches\nwill be expected to conform to the style outlined\n[here](https://google.github.io/styleguide/cppguide.html).\n\n## Guidelines for Pull Requests\n\n* If you are a Googler, it is required that you send us a Piper CL instead of\n using the GitHub pull-request process. The code propagation process will\n deliver the change to GitHub.\n\n* Create **small PRs** that are narrowly focused on **addressing a single\n concern**. We often receive PRs that are trying to fix several things at a\n time, but if only one fix is considered acceptable, nothing gets merged and\n both author's & review's time is wasted. Create more PRs to address\n different concerns and everyone will be happy.\n\n* For speculative changes, consider opening an [Abseil\n issue](https://github.com/abseil/abseil-cpp/issues) and discussing it first.\n If you are suggesting a behavioral or API change, consider starting with an\n [Abseil proposal template](ABSEIL_ISSUE_TEMPLATE.md).\n\n* Provide a good **PR description** as a record of **what** change is being\n made and **why** it was made. Link to a GitHub issue if it exists.\n\n* Don't fix code style and formatting unless you are already changing that\n line to address an issue. Formatting of modified lines may be done using\n `git clang-format`. PRs with irrelevant changes won't be merged. If\n you do want to fix formatting or style, do that in a separate PR.\n\n* Unless your PR is trivial, you should expect there will be reviewer comments\n that you'll need to address before merging. We expect you to be reasonably\n responsive to those comments, otherwise the PR will be closed after 2-3\n weeks of inactivity.\n\n* Maintain **clean commit history** and use **meaningful commit messages**.\n PRs with messy commit history are difficult to review and won't be merged.\n Use `rebase -i upstream/master` to curate your commit history and/or to\n bring in latest changes from master (but avoid rebasing in the middle of a\n code review).\n\n* Keep your PR up to date with upstream/master (if there are merge conflicts,\n we can't really merge your change).\n\n* **All tests need to be passing** before your change can be merged. We\n recommend you **run tests locally** (see below)\n\n* Exceptions to the rules can be made if there's a compelling reason for doing\n so. That is - the rules are here to serve us, not the other way around, and\n the rules need to be serving their intended purpose to be valuable.\n\n* All submissions, including submissions by project members, require review.\n\n## Running Tests\n\nIf you have [Bazel](https://bazel.build/) installed, use `bazel test\n--test_tag_filters=\"-benchmark\" ...` to run the unit tests.\n\nIf you are running the Linux operating system and have\n[Docker](https://www.docker.com/) installed, you can also run the `linux_*.sh`\nscripts under the `ci/`(https://github.com/abseil/abseil-cpp/tree/master/ci)\ndirectory to test Abseil under a variety of conditions.\n\n## Abseil Committers\n\nThe current members of the Abseil engineering team are the only committers at\npresent.\n\n## Release Process\n\nAbseil lives at head, where latest-and-greatest code can be found.\n" }, { "path": "FAQ.md", "content": "# Abseil FAQ\n\n## Is Abseil the right home for my utility library?\n\nMost often the answer to the question is \"no.\" As both the\n[About Abseil](https://abseil.io/about/) page and our\n[contributing guidelines](https://github.com/abseil/abseil-cpp/blob/master/CONTRIBUTING.md#contribution-guidelines)\nexplain, Abseil contains a variety of core C++ library code that is widely used\nat [Google](https://www.google.com/). As such, Abseil's primary purpose is to be\nused as a dependency by Google's open source C++ projects. While we do hope that\nAbseil is also useful to the C++ community at large, this added constraint also\nmeans that we are unlikely to accept a contribution of utility code that isn't\nalready widely used by Google.\n\n## How do I set the C++ dialect used to build Abseil?\n\nThe short answer is that whatever mechanism you choose, you need to make sure\nthat you set this option consistently at the global level for your entire\nproject. If, for example, you want to set the C++ dialect to C++17, with\n[Bazel](https://bazel.build/) as the build system and `gcc` or `clang` as the\ncompiler, there are several ways to do this: * Pass `--cxxopt=-std=c++17` on the\ncommand line (for example, `bazel build --cxxopt=-std=c++17 ...`) * Set the\nenvironment variable `BAZEL_CXXOPTS` (for example, `BAZEL_CXXOPTS=-std=c++17`) *\nAdd `build --cxxopt=-std=c++17` to your\n[`.bazelrc` file](https://docs.bazel.build/versions/master/guide.html#bazelrc)\n\nIf you are using CMake as the build system, you'll need to add a line like\n`set(CMAKE_CXX_STANDARD 17)` to your top level `CMakeLists.txt` file. If you are\ndeveloping a library designed to be used by other clients, you should instead\nleave `CMAKE_CXX_STANDARD` unset and configure the minimum C++ standard required\nby each of your library targets via `target_compile_features`. See the\n[CMake build instructions](https://github.com/abseil/abseil-cpp/blob/master/CMake/README.md)\nfor more information.\n\nFor a longer answer to this question and to understand why some other approaches\ndon't work, see the answer to [\"What is ABI and why don't you recommend using a\npre-compiled version of\nAbseil?\"](#what-is-abi-and-why-dont-you-recommend-using-a-pre-compiled-version-of-abseil)\n\n## What is ABI and why don't you recommend using a pre-compiled version of Abseil?\n\nFor the purposes of this discussion,\n[ABI](https://en.wikipedia.org/wiki/Application_binary_interface) refers to the\ncompiled representation of code interfaces. This contrasts with\n[API](https://en.wikipedia.org/wiki/Application_programming_interface), which\nrefers to the interfaces defined in the source code. [Abseil has a strong\npromise of API compatibility, but does not make any promise of ABI\ncompatibility](https://abseil.io/about/compatibility). Let's take a look at what\nthis means in practice.\n\nYou might be tempted to do something like this in a\n[Bazel](https://bazel.build/) `BUILD` file:\n\n```\n# DON'T DO THIS!!!\ncc_library(\n name = \"my_library\",\n srcs = [\"my_library.cc\"],\n copts = [\"-std=c++17\"], # May create a mixed-mode compile!\n deps = [\"@com_google_absl//absl/strings\"],\n)\n```\n\nApplying `-std=c++17` to an individual target in your `BUILD` file is going to\ncompile that specific target in C++17 mode, but it isn't going to ensure the\nAbseil library is built in C++17 mode, since the Abseil library itself is a\ndifferent build target. If your code includes an Abseil header, then your\nprogram may contain conflicting definitions of the same\nclass/function/variable/enum, etc. As a rule, all compile options that affect\nthe ABI of a program need to be applied to the entire build on a global basis.\n\nC++ has something called the\n[One Definition Rule](https://en.wikipedia.org/wiki/One_Definition_Rule) (ODR).\nC++ doesn't allow multiple definitions of the same class/function/variable/enum,\netc. ODR violations sometimes result in linker errors, but linkers do not always\ncatch violations. Uncaught ODR violations can result in strange runtime\nbehaviors or crashes that can be hard to debug.\n\nIf you build the Abseil library and your code using different compile options\nthat affect ABI, there is a good chance you will run afoul of the One Definition\nRule. Examples of GCC compile options that affect ABI include (but aren't\nlimited to) language dialect (e.g. `-std=`), optimization level (e.g. `-O2`),\ncode generation flags (e.g. `-fexceptions`), and preprocessor defines (e.g.\n`-DNDEBUG`).\n\nIf you use a pre-compiled version of Abseil, (for example, from your Linux\ndistribution package manager or from something like\n[vcpkg](https://github.com/microsoft/vcpkg)) you have to be very careful to\nensure ABI compatibility across the components of your program. The only way you\ncan be sure your program is going to be correct regarding ABI is to ensure\nyou've used the exact same compile options as were used to build the\npre-compiled library. This does not mean that Abseil cannot work as part of a\nLinux distribution since a knowledgeable binary packager will have ensured that\nall packages have been built with consistent compile options. This is one of the\nreasons we warn against - though do not outright reject - using Abseil as a\npre-compiled library.\n\nAnother possible way that you might run afoul of ABI issues is if you\naccidentally include two versions of Abseil in your program. Multiple versions\nof Abseil can end up within the same binary if your program uses the Abseil\nlibrary and another library also transitively depends on Abseil (resulting in\nwhat is sometimes called the diamond dependency problem). In cases such as this\nyou must structure your build so that all libraries use the same version of\nAbseil.\n[Abseil's strong promise of API compatibility between releases](https://abseil.io/about/compatibility)\nmeans the latest \"HEAD\" release of Abseil is almost certainly the right choice\nif you are doing as we recommend and building all of your code from source.\n\nFor these reasons we recommend you avoid pre-compiled code and build the Abseil\nlibrary yourself in a consistent manner with the rest of your code.\n\n## What is \"live at head\" and how do I do it?\n\nFrom Abseil's point-of-view, \"live at head\" means that every Abseil source\nrelease (which happens on an almost daily basis) is either API compatible with\nthe previous release, or comes with an automated tool that you can run over code\nto make it compatible. In practice, the need to use an automated tool is\nextremely rare. This means that upgrading from one source release to another\nshould be a routine practice that can and should be performed often.\n\nWe recommend you update to the\n[latest commit in the `master` branch of Abseil](https://github.com/abseil/abseil-cpp/commits/master)\nas often as possible. Not only will you pick up bug fixes more quickly, but if\nyou have good automated testing, you will catch and be able to fix any\n[Hyrum's Law](https://www.hyrumslaw.com/) dependency problems on an incremental\nbasis instead of being overwhelmed by them and having difficulty isolating them\nif you wait longer between updates.\n\nIf you are using the [Bazel](https://bazel.build/) build system with\n[Bzlmod](https://bazel.build/external/overview#bzlmod), you can use a\n`git_override` in your `MODULE.bazel` file to track the latest commit.\n\nFor example, to update to the latest commit, you would add (or update) the\nfollowing snippet in your `MODULE.bazel` file:\n\n```starlark\nbazel_dep(name = \"abseil-cpp\", version = \"20260107.1\")\n\ngit_override(\n module_name = \"abseil-cpp\",\n remote = \"https://github.com/abseil/abseil-cpp.git\",\n # Replace the following line with the latest commit.\n commit = \"6ec9964c325db0610a376b3cb81de073ea6ada90\",\n)\n```\n\nYou can commit the updated `MODULE.bazel` file to your source control every time\nyou update, and if you have good automated testing, you might even consider\nautomating this.\n\n## Why do I see strange behaviors when I use Abseil hash tables?\n\nAbseil's hash function uses a random seed.\n\nMany programmers believe incorrectly that this is a defense against\n[hash flooding](https://en.wikipedia.org/wiki/Collision_attack#Hash_flooding).\nWhile it does make a hash flooding attack more difficult, Abseil's hash function\nprioritizes speed over thorough mixing (and thus is not cryptographically\nsecure), and the current seed implementation is also not cryptographically\nsecure. If you are storing a large amount of attacker-controlled data, the most\nreliable defense against hash-flooding is to use a container that does not have\n`O(n)` worst-case behavior.\n\nThe real reason for hash randomization is to prevent\n[Hyrum's Law](https://www.hyrumslaw.com/) dependencies on iteration order. This\nhas allowed us to roll out steady improvements to the implementation without\nbreaking users who may have otherwise written code that was dependent on\nordering or other characteristics.\n\nThe current implementation uses a global seed, which, if linked incorrectly\n(e.g., static Abseil in multiple DSOs), can cause the ODR violations. If more\nthan one seed is linked, different calls to the hash function may return\ndifferent values, rendering hash elements inaccessible, causing crashes, or\nother arbitrarily bad behaviors.\n\nWe are often asked for a knob to disable hash randomization. The answer is a\nhard \"no\", even under test or under a flag, because people will find a way to\nforce it and allow their code or tests to depend on it. At Google-scale, the\ncompute costs that are saved by preserving the ability to improve the\nimplementation far outweigh the inconvenience of learning how to write code\nresilient to change.\n\n## How do I use the LLVM Sanitizers with Abseil?\n\nLLVM Sanitizers are a suite of powerful, dynamic analysis tools that\nautomatically detect various critical bugs during program execution. They work\nby instrumenting the compiled binary and linking a runtime library to intercept\noperations and report issues.\n\nWe receive many incorrect bug reports from users trying to use the sanitizers.\nThe most common cause of these issues is ODR violations in the form of an\ninstrumentation mismatch. This happens when users try to link libraries compiled\nwith sanitizer instrumentation with uninstrumented libraries. It is important\nthat all code in the application is built with the same sanitizer configuration.\n\nThe easiest way to do this is to use [Bazel](https://bazel.build) and pass the\nsanitizer options on the commandline, but it is important not to overlook the\nimportance of avoiding precompiled system libraries, including the C++ standard\nlibrary. For instance,\n[MemorySanitizer requires an instrumented `libc++`](https://github.com/google/sanitizers/wiki/MemorySanitizerLibcxxHowTo).\n\nSince most users are not going to build `libc++` with Bazel, here is a\nMemorySanitizer recipe that currently works (and could easily be tweaked for\nThreadSanitizer and friends):\n\n```shell\n# From the root of the LLVM source tree, configure libc++ to be instrumented with MSAN:\ncmake -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\"\n\n# Build and install it into ${HOME}/llvm-msan\nninja -C build_msan install-cxx install-cxxabi install-unwind\n\n# Then build (or test) your code like this:\nbazel 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 ...\n```\n\nYou should consider adding these options to a\n[`.bazelrc`](https://bazel.build/run/bazelrc) file to avoid retyping them.\n" }, { "path": "LICENSE", "content": "\n Apache License\n Version 2.0, January 2004\n https://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n https://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n" }, { "path": "MODULE.bazel", "content": "# Copyright 2024 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# https://bazel.build/external/overview#bzlmod\n\nmodule(\n name = \"abseil-cpp\",\n version = \"head\",\n compatibility_level = 1,\n)\n\ncc_configure = use_extension(\"@rules_cc//cc:extensions.bzl\",\n \"cc_configure_extension\",\n dev_dependency = True)\nuse_repo(cc_configure, \"local_config_cc\")\n\nbazel_dep(name = \"rules_cc\", version = \"0.2.9\")\nbazel_dep(name = \"bazel_skylib\", version = \"1.8.1\")\nbazel_dep(name = \"platforms\", version = \"1.0.0\")\n\nbazel_dep(\n name = \"google_benchmark\",\n version = \"1.9.5\",\n dev_dependency = True,\n)\n\n# Note: Googletest is NOT a dev_dependency. Some Abseil test utilities\n# intended to be used by Abseil users depend on GoogleTest.\nbazel_dep(\n name = \"googletest\",\n version = \"1.17.0.bcr.2\",\n)\n" }, { "path": "PrivacyInfo.xcprivacy", "content": "\n\n\n\n NSPrivacyTracking\n \n NSPrivacyCollectedDataTypes\n \n NSPrivacyTrackingDomains\n \n NSPrivacyAccessedAPITypes\n \n\n\n" }, { "path": "README.md", "content": "# Abseil - C++ Common Libraries\n\nThe repository contains the Abseil C++ library code. Abseil is an open-source\ncollection of C++ code (compliant to C++17) designed to augment the C++\nstandard library.\n\n## Table of Contents\n\n- [About Abseil](#about)\n- [Quickstart](#quickstart)\n- [Building Abseil](#build)\n- [Support](#support)\n- [Codemap](#codemap)\n- [Releases](#releases)\n- [License](#license)\n- [Links](#links)\n\n\n## About Abseil\n\nAbseil is an open-source collection of C++ library code designed to augment\nthe C++ standard library. The Abseil library code is collected from Google's\nown C++ code base, has been extensively tested and used in production, and\nis the same code we depend on in our daily coding lives.\n\nIn some cases, Abseil provides pieces missing from the C++ standard; in\nothers, Abseil provides alternatives to the standard for special needs\nwe've found through usage in the Google code base. We denote those cases\nclearly within the library code we provide you.\n\nAbseil is not meant to be a competitor to the standard library; we've\njust found that many of these utilities serve a purpose within our code\nbase, and we now want to provide those resources to the C++ community as\na whole.\n\n\n## Quickstart\n\nIf you want to just get started, make sure you at least run through the\n[Abseil Quickstart](https://abseil.io/docs/cpp/quickstart). The Quickstart\ncontains information about setting up your development environment, downloading\nthe Abseil code, running tests, and getting a simple binary working.\n\n\n## Building Abseil\n\n[Bazel](https://bazel.build) and [CMake](https://cmake.org/) are the official\nbuild systems for Abseil.\nSee the [quickstart](https://abseil.io/docs/cpp/quickstart) for more information\non building Abseil using the Bazel build system.\nIf you require CMake support, please check the [CMake build\ninstructions](CMake/README.md) and [CMake\nQuickstart](https://abseil.io/docs/cpp/quickstart-cmake).\n\n\n## Support\n\nAbseil follows Google's [Foundational C++ Support\nPolicy](https://opensource.google/documentation/policies/cplusplus-support). See\n[this\ntable](https://github.com/google/oss-policies-info/blob/main/foundational-cxx-support-matrix.md)\nfor a list of currently supported versions compilers, platforms, and build\ntools.\n\n\n## Codemap\n\nAbseil contains the following C++ library components:\n\n* [`base`](absl/base/)\n
The `base` library contains initialization code and other code which\n all other Abseil code depends on. Code within `base` may not depend on any\n other code (other than the C++ standard library).\n* [`algorithm`](absl/algorithm/)\n
The `algorithm` library contains additions to the C++ ``\n library and container-based versions of such algorithms.\n* [`cleanup`](absl/cleanup/)\n
The `cleanup` library contains the control-flow-construct-like type\n `absl::Cleanup` which is used for executing a callback on scope exit.\n* [`container`](absl/container/)\n
The `container` library contains additional STL-style containers,\n including Abseil's unordered \"Swiss table\" containers.\n* [`crc`](absl/crc/) The `crc` library contains code for\n computing error-detecting cyclic redundancy checks on data.\n* [`debugging`](absl/debugging/)\n
The `debugging` library contains code useful for enabling leak\n checks, and stacktrace and symbolization utilities.\n* [`flags`](absl/flags/)\n
The `flags` library contains code for handling command line flags for\n libraries and binaries built with Abseil.\n* [`hash`](absl/hash/)\n
The `hash` library contains the hashing framework and default hash\n functor implementations for hashable types in Abseil.\n* [`log`](absl/log/)\n
The `log` library contains `LOG` and `CHECK` macros and facilities\n for writing logged messages out to disk, `stderr`, or user-extensible\n destinations.\n* [`memory`](absl/memory/)\n
The `memory` library contains memory management facilities that augment\n C++'s `` library.\n* [`meta`](absl/meta/)\n
The `meta` library contains type checks\n similar to those available in the C++ `` library.\n* [`numeric`](absl/numeric/)\n
The `numeric` library contains 128-bit integer types as well as\n implementations of C++20's bitwise math functions.\n* [`profiling`](absl/profiling/)\n
The `profiling` library contains utility code for profiling C++\n entities. It is currently a private dependency of other Abseil libraries.\n* [`random`](absl/random/)\n
The `random` library contains functions for generating pseudorandom\n values.\n* [`status`](absl/status/)\n
The `status` library contains abstractions for error handling,\n specifically `absl::Status` and `absl::StatusOr`.\n* [`strings`](absl/strings/)\n
The `strings` library contains a variety of strings routines and\n utilities.\n* [`synchronization`](absl/synchronization/)\n
The `synchronization` library contains concurrency primitives (Abseil's\n `absl::Mutex` class, an alternative to `std::mutex`) and a variety of\n synchronization abstractions.\n* [`time`](absl/time/)\n
The `time` library contains abstractions for computing with absolute\n points in time, durations of time, and formatting and parsing time within\n time zones.\n* [`types`](absl/types/)\n
The `types` library contains non-container utility types.\n* [`utility`](absl/utility/)\n
The `utility` library contains utility and helper code.\n\n\n## Releases\n\nAbseil recommends users \"live-at-head\" (update to the latest commit from the\nmaster branch as often as possible). However, we realize this philosophy doesn't\nwork for every project, so we also provide [Long Term Support\nReleases](https://github.com/abseil/abseil-cpp/releases) to which we backport\nfixes for severe bugs. See our [release\nmanagement](https://abseil.io/about/releases) document for more details.\n\n\n## License\n\nThe Abseil C++ library is licensed under the terms of the Apache\nlicense. See [LICENSE](LICENSE) for more information.\n\n\n## Links\n\nFor more information about Abseil:\n\n* Consult our [Abseil Introduction](https://abseil.io/about/intro)\n* Read [Why Adopt Abseil](https://abseil.io/about/philosophy) to understand our\n design philosophy.\n* Peruse our\n [Abseil Compatibility Guarantees](https://abseil.io/about/compatibility) to\n understand both what we promise to you, and what we expect of you in return.\n" }, { "path": "UPGRADES.md", "content": "# C++ Upgrade Tools\n\nAbseil may occasionally release API-breaking changes. As noted in our\n[Compatibility Guidelines][compatibility-guide], we will aim to provide a tool\nto do the work of effecting such API-breaking changes, when absolutely\nnecessary.\n\nThese tools will be listed on the [C++ Upgrade Tools][upgrade-tools] guide on\nhttps://abseil.io.\n\nFor more information, the [C++ Automated Upgrade Guide][api-upgrades-guide]\noutlines this process.\n\n[compatibility-guide]: https://abseil.io/about/compatibility\n[api-upgrades-guide]: https://abseil.io/docs/cpp/tools/api-upgrades\n[upgrade-tools]: https://abseil.io/docs/cpp/tools/upgrades/\n\n" }, { "path": "absl/BUILD.bazel", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nload(\"@bazel_skylib//lib:selects.bzl\", \"selects\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nlicenses([\"notice\"])\n\nconfig_setting(\n name = \"clang_compiler\",\n flag_values = {\n \"@bazel_tools//tools/cpp:compiler\": \"clang\",\n },\n visibility = [\":__subpackages__\"],\n)\n\nconfig_setting(\n name = \"mingw_unspecified_compiler\",\n flag_values = {\n \"@bazel_tools//tools/cpp:compiler\": \"mingw\",\n },\n visibility = [\":__subpackages__\"],\n)\n\nconfig_setting(\n name = \"mingw-gcc_compiler\",\n flag_values = {\n \"@bazel_tools//tools/cpp:compiler\": \"mingw-gcc\",\n },\n visibility = [\":__subpackages__\"],\n)\n\nconfig_setting(\n name = \"fuchsia\",\n constraint_values = [\n \"@platforms//os:fuchsia\",\n ],\n visibility = [\":__subpackages__\"],\n)\n\nselects.config_setting_group(\n name = \"mingw_compiler\",\n match_any = [\n \":mingw_unspecified_compiler\",\n \":mingw-gcc_compiler\",\n ],\n visibility = [\":__subpackages__\"],\n)\n\n# Expose internals to privileged external repositories.\npackage_group(\n name = \"friends\",\n packages = [],\n)\n" }, { "path": "absl/CMakeLists.txt", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nadd_subdirectory(base)\nadd_subdirectory(algorithm)\nadd_subdirectory(cleanup)\nadd_subdirectory(container)\nadd_subdirectory(crc)\nadd_subdirectory(debugging)\nadd_subdirectory(flags)\nadd_subdirectory(functional)\nadd_subdirectory(hash)\nadd_subdirectory(log)\nadd_subdirectory(memory)\nadd_subdirectory(meta)\nadd_subdirectory(numeric)\nadd_subdirectory(profiling)\nadd_subdirectory(random)\nadd_subdirectory(status)\nadd_subdirectory(strings)\nadd_subdirectory(synchronization)\nadd_subdirectory(time)\nadd_subdirectory(types)\nadd_subdirectory(utility)\n\nif (ABSL_BUILD_DLL)\n absl_make_dll()\n if ((BUILD_TESTING AND ABSL_BUILD_TESTING) OR ABSL_BUILD_TEST_HELPERS)\n absl_make_dll(TEST ON)\n endif()\nendif()\n" }, { "path": "absl/abseil.podspec.gen.py", "content": "#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"This script generates abseil.podspec from all BUILD.bazel files.\n\nThis is expected to run on abseil git repository with Bazel 1.0 on Linux.\nIt recursively analyzes BUILD.bazel files using query command of Bazel to\ndump its build rules in XML format. From these rules, it constructs podspec\nstructure.\n\"\"\"\n\nimport argparse\nimport collections\nimport os\nimport re\nimport subprocess\nimport xml.etree.ElementTree\n\n# Template of root podspec.\nSPEC_TEMPLATE = \"\"\"\n# This file has been automatically generated from a script.\n# Please make modifications to `abseil.podspec.gen.py` instead.\nPod::Spec.new do |s|\n s.name = 'abseil'\n s.version = '${version}'\n s.summary = 'Abseil Common Libraries (C++) from Google'\n s.homepage = 'https://abseil.io'\n s.license = 'Apache License, Version 2.0'\n s.authors = { 'Abseil Team' => 'abseil-io@googlegroups.com' }\n s.source = {\n :git => 'https://github.com/abseil/abseil-cpp.git',\n :tag => '${tag}',\n }\n s.resource_bundles = {\n s.module_name => 'PrivacyInfo.xcprivacy',\n }\n s.module_name = 'absl'\n s.header_mappings_dir = 'absl'\n s.header_dir = 'absl'\n s.libraries = 'c++'\n s.compiler_flags = '-Wno-everything'\n s.pod_target_xcconfig = {\n 'USER_HEADER_SEARCH_PATHS' => '$(inherited) \"$(PODS_TARGET_SRCROOT)\"',\n 'USE_HEADERMAP' => 'NO',\n 'ALWAYS_SEARCH_USER_PATHS' => 'NO',\n 'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',\n }\n s.ios.deployment_target = '12.0'\n s.osx.deployment_target = '10.13'\n s.tvos.deployment_target = '12.0'\n s.watchos.deployment_target = '4.0'\n s.visionos.deployment_target = '1.0'\n s.subspec 'xcprivacy' do |ss|\n ss.resource_bundles = {\n ss.module_name => 'PrivacyInfo.xcprivacy',\n }\n end\n\"\"\"\n\n# Rule object representing the rule of Bazel BUILD.\nRule = collections.namedtuple(\n \"Rule\", \"type name package srcs hdrs textual_hdrs deps visibility testonly\")\n\n\ndef get_elem_value(elem, name):\n \"\"\"Returns the value of XML element with the given name.\"\"\"\n for child in elem:\n if child.attrib.get(\"name\") != name:\n continue\n if child.tag == \"string\":\n return child.attrib.get(\"value\")\n if child.tag == \"boolean\":\n return child.attrib.get(\"value\") == \"true\"\n if child.tag == \"list\":\n return [nested_child.attrib.get(\"value\") for nested_child in child]\n raise \"Cannot recognize tag: \" + child.tag\n return None\n\n\ndef normalize_paths(paths):\n \"\"\"Returns the list of normalized path.\"\"\"\n # e.g. [\"//absl/strings:dir/header.h\"] -> [\"absl/strings/dir/header.h\"]\n return [path.lstrip(\"/\").replace(\":\", \"/\") for path in paths]\n\n\ndef parse_rule(elem, package):\n \"\"\"Returns a rule from bazel XML rule.\"\"\"\n return Rule(\n type=elem.attrib[\"class\"],\n name=get_elem_value(elem, \"name\"),\n package=package,\n srcs=normalize_paths(get_elem_value(elem, \"srcs\") or []),\n hdrs=normalize_paths(get_elem_value(elem, \"hdrs\") or []),\n textual_hdrs=normalize_paths(get_elem_value(elem, \"textual_hdrs\") or []),\n deps=get_elem_value(elem, \"deps\") or [],\n visibility=get_elem_value(elem, \"visibility\") or [],\n testonly=get_elem_value(elem, \"testonly\") or False)\n\n\ndef read_build(package):\n \"\"\"Runs bazel query on given package file and returns all cc rules.\"\"\"\n result = subprocess.check_output(\n [\"bazel\", \"query\", package + \":all\", \"--output\", \"xml\"])\n root = xml.etree.ElementTree.fromstring(result)\n return [\n parse_rule(elem, package)\n for elem in root\n if elem.tag == \"rule\" and elem.attrib[\"class\"].startswith(\"cc_\")\n ]\n\n\ndef collect_rules(root_path):\n \"\"\"Collects and returns all rules from root path recursively.\"\"\"\n rules = []\n for cur, _, _ in os.walk(root_path):\n build_path = os.path.join(cur, \"BUILD.bazel\")\n if os.path.exists(build_path):\n rules.extend(read_build(\"//\" + cur))\n return rules\n\n\ndef relevant_rule(rule):\n \"\"\"Returns true if a given rule is relevant when generating a podspec.\"\"\"\n return (\n # cc_library only (ignore cc_test, cc_binary)\n rule.type == \"cc_library\" and\n # ignore empty rule\n (rule.hdrs + rule.textual_hdrs + rule.srcs) and\n # ignore test-only rule\n not rule.testonly)\n\n\ndef get_spec_var(depth):\n \"\"\"Returns the name of variable for spec with given depth.\"\"\"\n return \"s\" if depth == 0 else \"s{}\".format(depth)\n\n\ndef get_spec_name(label):\n \"\"\"Converts the label of bazel rule to the name of podspec.\"\"\"\n assert label.startswith(\"//absl/\"), \"{} doesn't start with //absl/\".format(\n label)\n # e.g. //absl/apple/banana -> abseil/apple/banana\n return \"abseil/\" + label[7:]\n\n\ndef write_podspec(f, rules, args):\n \"\"\"Writes a podspec from given rules and args.\"\"\"\n rule_dir = build_rule_directory(rules)[\"abseil\"]\n # Write root part with given arguments\n spec = re.sub(r\"\\$\\{(\\w+)\\}\", lambda x: args[x.group(1)],\n SPEC_TEMPLATE).lstrip()\n f.write(spec)\n # Write all target rules\n write_podspec_map(f, rule_dir, 0)\n f.write(\"end\\n\")\n\n\ndef build_rule_directory(rules):\n \"\"\"Builds a tree-style rule directory from given rules.\"\"\"\n rule_dir = {}\n for rule in rules:\n cur = rule_dir\n for frag in get_spec_name(rule.package).split(\"/\"):\n cur = cur.setdefault(frag, {})\n cur[rule.name] = rule\n return rule_dir\n\n\ndef write_podspec_map(f, cur_map, depth):\n \"\"\"Writes podspec from rule map recursively.\"\"\"\n for key, value in sorted(cur_map.items()):\n indent = \" \" * (depth + 1)\n f.write(\"{indent}{var0}.subspec '{key}' do |{var1}|\\n\".format(\n indent=indent,\n key=key,\n var0=get_spec_var(depth),\n var1=get_spec_var(depth + 1)))\n if isinstance(value, dict):\n write_podspec_map(f, value, depth + 1)\n else:\n write_podspec_rule(f, value, depth + 1)\n f.write(\"{indent}end\\n\".format(indent=indent))\n\n\ndef write_podspec_rule(f, rule, depth):\n \"\"\"Writes podspec from given rule.\"\"\"\n indent = \" \" * (depth + 1)\n spec_var = get_spec_var(depth)\n # Puts all files in hdrs, textual_hdrs, and srcs into source_files.\n # Since CocoaPods treats header_files a bit differently from bazel,\n # this won't generate a header_files field so that all source_files\n # are considered as header files.\n srcs = sorted(set(rule.hdrs + rule.textual_hdrs + rule.srcs))\n write_indented_list(\n f, \"{indent}{var}.source_files = \".format(indent=indent, var=spec_var),\n srcs)\n # Writes dependencies of this rule.\n for dep in sorted(rule.deps):\n name = get_spec_name(dep.replace(\":\", \"/\"))\n f.write(\"{indent}{var}.dependency '{dep}'\\n\".format(\n indent=indent, var=spec_var, dep=name))\n # Writes dependency to xcprivacy\n f.write(\n \"{indent}{var}.dependency '{dep}'\\n\".format(\n indent=indent, var=spec_var, dep=\"abseil/xcprivacy\"\n )\n )\n\n\ndef write_indented_list(f, leading, values):\n \"\"\"Writes leading values in an indented style.\"\"\"\n f.write(leading)\n f.write((\",\\n\" + \" \" * len(leading)).join(\"'{}'\".format(v) for v in values))\n f.write(\"\\n\")\n\n\ndef generate(args):\n \"\"\"Generates a podspec file from all BUILD files under absl directory.\"\"\"\n rules = filter(relevant_rule, collect_rules(\"absl\"))\n with open(args.output, \"wt\") as f:\n write_podspec(f, rules, vars(args))\n\n\ndef main():\n parser = argparse.ArgumentParser(\n description=\"Generates abseil.podspec from BUILD.bazel\")\n parser.add_argument(\n \"-v\", \"--version\", help=\"The version of podspec\", required=True)\n parser.add_argument(\n \"-t\",\n \"--tag\",\n default=None,\n help=\"The name of git tag (default: version)\")\n parser.add_argument(\n \"-o\",\n \"--output\",\n default=\"abseil.podspec\",\n help=\"The name of output file (default: abseil.podspec)\")\n args = parser.parse_args()\n if args.tag is None:\n args.tag = args.version\n generate(args)\n\n\nif __name__ == \"__main__\":\n main()\n" }, { "path": "absl/algorithm/BUILD.bazel", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nload(\"@rules_cc//cc:cc_library.bzl\", \"cc_library\")\nload(\"@rules_cc//cc:cc_test.bzl\", \"cc_test\")\nload(\n \"//absl:copts/configure_copts.bzl\",\n \"ABSL_DEFAULT_COPTS\",\n \"ABSL_DEFAULT_LINKOPTS\",\n \"ABSL_TEST_COPTS\",\n)\n\npackage(\n default_visibility = [\"//visibility:public\"],\n features = [\n \"header_modules\",\n \"layering_check\",\n \"parse_headers\",\n ],\n)\n\nlicenses([\"notice\"])\n\ncc_library(\n name = \"algorithm\",\n hdrs = [\"algorithm.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \"//absl/base:config\",\n ],\n)\n\ncc_test(\n name = \"algorithm_test\",\n size = \"small\",\n srcs = [\"algorithm_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":algorithm\",\n \"//absl/base:config\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"container\",\n hdrs = [\n \"container.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":algorithm\",\n \"//absl/base:config\",\n \"//absl/base:core_headers\",\n \"//absl/meta:type_traits\",\n ],\n)\n\ncc_test(\n name = \"container_test\",\n srcs = [\"container_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":container\",\n \"//absl/base\",\n \"//absl/base:config\",\n \"//absl/base:core_headers\",\n \"//absl/memory\",\n \"//absl/random\",\n \"//absl/types:span\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n" }, { "path": "absl/algorithm/CMakeLists.txt", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nabsl_cc_library(\n NAME\n algorithm\n HDRS\n \"algorithm.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n PUBLIC\n)\n\nabsl_cc_test(\n NAME\n algorithm_test\n SRCS\n \"algorithm_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::algorithm\n absl::config\n GTest::gmock_main\n)\n\nabsl_cc_library(\n NAME\n algorithm_container\n HDRS\n \"container.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::algorithm\n absl::config\n absl::core_headers\n absl::meta\n PUBLIC\n)\n\nabsl_cc_test(\n NAME\n container_test\n SRCS\n \"container_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::algorithm_container\n absl::config\n absl::core_headers\n absl::memory\n absl::random_random\n absl::span\n GTest::gmock_main\n)\n" }, { "path": "absl/algorithm/algorithm.h", "content": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// -----------------------------------------------------------------------------\n// File: algorithm.h\n// -----------------------------------------------------------------------------\n//\n// This header file contains Google extensions to the standard C++\n// header.\n\n#ifndef ABSL_ALGORITHM_ALGORITHM_H_\n#define ABSL_ALGORITHM_ALGORITHM_H_\n\n#include \n#include \n#include \n\n#include \"absl/base/config.h\"\n\nnamespace absl {\nABSL_NAMESPACE_BEGIN\n\n// equal()\n// rotate()\n//\n// Historical note: Abseil once provided implementations of these algorithms\n// prior to their adoption in C++14. New code should prefer to use the std\n// variants.\n//\n// See the documentation for the STL header for more information:\n// https://en.cppreference.com/w/cpp/header/algorithm\nusing std::equal;\nusing std::rotate;\n\n// linear_search()\n//\n// Performs a linear search for `value` using the iterator `first` up to\n// but not including `last`, returning true if [`first`, `last`) contains an\n// element equal to `value`.\n//\n// A linear search is of O(n) complexity which is guaranteed to make at most\n// n = (`last` - `first`) comparisons. A linear search over short containers\n// may be faster than a binary search, even when the container is sorted.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool linear_search(\n InputIterator first, InputIterator last, const EqualityComparable& value) {\n return std::find(first, last, value) != last;\n}\n\nABSL_NAMESPACE_END\n} // namespace absl\n\n#endif // ABSL_ALGORITHM_ALGORITHM_H_\n" }, { "path": "absl/algorithm/algorithm_test.cc", "content": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include \"absl/algorithm/algorithm.h\"\n\n#include \n#include \n\n#include \"gtest/gtest.h\"\n#include \"absl/base/config.h\"\n\nnamespace {\n\nclass LinearSearchTest : public testing::Test {\n protected:\n LinearSearchTest() : container_{1, 2, 3} {}\n\n static bool Is3(int n) { return n == 3; }\n static bool Is4(int n) { return n == 4; }\n\n std::vector container_;\n};\n\nTEST_F(LinearSearchTest, linear_search) {\n EXPECT_TRUE(absl::linear_search(container_.begin(), container_.end(), 3));\n EXPECT_FALSE(absl::linear_search(container_.begin(), container_.end(), 4));\n}\n\nTEST_F(LinearSearchTest, linear_searchConst) {\n const std::vector *const const_container = &container_;\n EXPECT_TRUE(\n absl::linear_search(const_container->begin(), const_container->end(), 3));\n EXPECT_FALSE(\n absl::linear_search(const_container->begin(), const_container->end(), 4));\n}\n\n#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \\\n ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L\n\nTEST_F(LinearSearchTest, Constexpr) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::linear_search(kArray.begin(), kArray.end(), 3));\n static_assert(!absl::linear_search(kArray.begin(), kArray.end(), 4));\n}\n\n#endif // defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&\n // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L\n\n} // namespace\n" }, { "path": "absl/algorithm/container.h", "content": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// -----------------------------------------------------------------------------\n// File: container.h\n// -----------------------------------------------------------------------------\n//\n// This header file provides Container-based versions of algorithmic functions\n// within the C++ standard library. The following standard library sets of\n// functions are covered within this file:\n//\n// * Algorithmic functions\n// * Algorithmic functions\n// * functions\n//\n// The standard library functions operate on iterator ranges; the functions\n// within this API operate on containers, though many return iterator ranges.\n//\n// All functions within this API are named with a `c_` prefix. Calls such as\n// `absl::c_xx(container, ...) are equivalent to std:: functions such as\n// `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on\n// iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`)\n// have no equivalent here.\n//\n// For template parameter and variable naming, `C` indicates the container type\n// to which the function is applied, `Pred` indicates the predicate object type\n// to be used by the function and `T` indicates the applicable element type.\n\n#ifndef ABSL_ALGORITHM_CONTAINER_H_\n#define ABSL_ALGORITHM_CONTAINER_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"absl/algorithm/algorithm.h\"\n#include \"absl/base/config.h\"\n#include \"absl/base/macros.h\"\n#include \"absl/meta/type_traits.h\"\n\nnamespace absl {\nABSL_NAMESPACE_BEGIN\nnamespace container_algorithm_internal {\n\n// NOTE: it is important to defer to ADL lookup for building with C++ modules,\n// especially for headers like which are not visible from this file\n// but specialize std::begin and std::end.\nusing std::begin;\nusing std::end;\n\n// The type of the iterator given by begin(c) (possibly std::begin(c)).\n// ContainerIter> gives vector::const_iterator,\n// while ContainerIter> gives vector::iterator.\ntemplate \nusing ContainerIter = decltype(begin(std::declval()));\n\n// An MSVC bug involving template parameter substitution requires us to use\n// decltype() here instead of just std::pair.\ntemplate \nusing ContainerIterPairType = decltype(std::make_pair(\n std::declval>(), std::declval>()));\n\ntemplate \nusing ContainerDifferenceType = decltype(std::distance(\n std::declval>(), std::declval>()));\n\ntemplate \nusing ContainerPointerType =\n typename std::iterator_traits>::pointer;\n\n// container_algorithm_internal::c_begin and\n// container_algorithm_internal::c_end are abbreviations for proper ADL\n// lookup of std::begin and std::end, i.e.\n// using std::begin;\n// using std::end;\n// std::foo(begin(c), end(c));\n// becomes\n// std::foo(container_algorithm_internal::c_begin(c),\n// container_algorithm_internal::c_end(c));\n// These are meant for internal use only.\n\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 ContainerIter c_begin(C& c) {\n return begin(c);\n}\n\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 ContainerIter c_end(C& c) {\n return end(c);\n}\n\ntemplate \nstruct IsUnorderedContainer : std::false_type {};\n\ntemplate \nstruct IsUnorderedContainer<\n std::unordered_map> : std::true_type {};\n\ntemplate \nstruct IsUnorderedContainer>\n : std::true_type {};\n\n} // namespace container_algorithm_internal\n\n// PUBLIC API\n\n//------------------------------------------------------------------------------\n// Abseil algorithm.h functions\n//------------------------------------------------------------------------------\n\n// c_linear_search()\n//\n// Container-based version of absl::linear_search() for performing a linear\n// search within a container.\n//\n// For a generalization that uses a predicate, see absl::c_any_of().\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_linear_search(\n const C& c, EqualityComparable&& value) {\n return absl::linear_search(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(value));\n}\n\n//------------------------------------------------------------------------------\n// algorithms\n//------------------------------------------------------------------------------\n\n// c_distance()\n//\n// Container-based version of the `std::distance()` function to\n// return the number of elements within a container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerDifferenceType\n c_distance(const C& c) {\n return std::distance(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n//------------------------------------------------------------------------------\n// Non-modifying sequence operations\n//------------------------------------------------------------------------------\n\n// c_all_of()\n//\n// Container-based version of the `std::all_of()` function to\n// test if all elements within a container satisfy a condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_all_of(const C& c, Pred&& pred) {\n return std::all_of(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_any_of()\n//\n// Container-based version of the `std::any_of()` function to\n// test if any element in a container fulfills a condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_any_of(const C& c, Pred&& pred) {\n return std::any_of(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_none_of()\n//\n// Container-based version of the `std::none_of()` function to\n// test if no elements in a container fulfill a condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_none_of(const C& c, Pred&& pred) {\n return std::none_of(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_for_each()\n//\n// Container-based version of the `std::for_each()` function to\n// apply a function to a container's elements.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t c_for_each(C&& c,\n Function&& f) {\n return std::for_each(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(f));\n}\n\n// c_find()\n//\n// Container-based version of the `std::find()` function to find\n// the first element containing the passed value within a container value.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find(C& c, T&& value) {\n return std::find(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(value));\n}\n\n// c_contains()\n//\n// Container-based version of the `std::ranges::contains()` C++23\n// function to search a container for a value.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains(const Sequence& sequence,\n T&& value) {\n return absl::c_find(sequence, std::forward(value)) !=\n container_algorithm_internal::c_end(sequence);\n}\n\n// c_find_if()\n//\n// Container-based version of the `std::find_if()` function to find\n// the first element in a container matching the given condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_if(C& c, Pred&& pred) {\n return std::find_if(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_find_if_not()\n//\n// Container-based version of the `std::find_if_not()` function to\n// find the first element in a container not matching the given condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_if_not(C& c, Pred&& pred) {\n return std::find_if_not(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_find_end()\n//\n// Container-based version of the `std::find_end()` function to\n// find the last subsequence within a container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_end(Sequence1& sequence, Sequence2& subsequence) {\n return std::find_end(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(subsequence),\n container_algorithm_internal::c_end(subsequence));\n}\n\n// Overload of c_find_end() for using a predicate evaluation other than `==` as\n// the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_end(Sequence1& sequence, Sequence2& subsequence,\n BinaryPredicate&& pred) {\n return std::find_end(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(subsequence),\n container_algorithm_internal::c_end(subsequence),\n std::forward(pred));\n}\n\n// c_find_first_of()\n//\n// Container-based version of the `std::find_first_of()` function to\n// find the first element within the container that is also within the options\n// container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_first_of(C1& container, const C2& options) {\n return std::find_first_of(container_algorithm_internal::c_begin(container),\n container_algorithm_internal::c_end(container),\n container_algorithm_internal::c_begin(options),\n container_algorithm_internal::c_end(options));\n}\n\n// Overload of c_find_first_of() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_find_first_of(C1& container, const C2& options, BinaryPredicate&& pred) {\n return std::find_first_of(container_algorithm_internal::c_begin(container),\n container_algorithm_internal::c_end(container),\n container_algorithm_internal::c_begin(options),\n container_algorithm_internal::c_end(options),\n std::forward(pred));\n}\n\n// c_adjacent_find()\n//\n// Container-based version of the `std::adjacent_find()` function to\n// find equal adjacent elements within a container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_adjacent_find(Sequence& sequence) {\n return std::adjacent_find(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_adjacent_find() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_adjacent_find(Sequence& sequence, BinaryPredicate&& pred) {\n return std::adjacent_find(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(pred));\n}\n\n// c_count()\n//\n// Container-based version of the `std::count()` function to count\n// values that match within a container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerDifferenceType\n c_count(const C& c, T&& value) {\n return std::count(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(value));\n}\n\n// c_count_if()\n//\n// Container-based version of the `std::count_if()` function to\n// count values matching a condition within a container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerDifferenceType\n c_count_if(const C& c, Pred&& pred) {\n return std::count_if(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_mismatch()\n//\n// Container-based version of the `std::mismatch()` function to\n// return the first element where two ordered containers differ. Applies `==` to\n// the first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIterPairType\n c_mismatch(C1& c1, C2& c2) {\n return std::mismatch(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2));\n}\n\n// Overload of c_mismatch() for using a predicate evaluation other than `==` as\n// the function's test condition. Applies `pred`to the first N elements of `c1`\n// and `c2`, where N = min(size(c1), size(c2)).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIterPairType\n c_mismatch(C1& c1, C2& c2, BinaryPredicate pred) {\n return std::mismatch(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), pred);\n}\n\n// c_equal()\n//\n// Container-based version of the `std::equal()` function to\n// test whether two containers are equal.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_equal(const C1& c1, const C2& c2) {\n return std::equal(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2));\n}\n\n// Overload of c_equal() for using a predicate evaluation other than `==` as\n// the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_equal(const C1& c1, const C2& c2,\n BinaryPredicate&& pred) {\n return std::equal(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2),\n std::forward(pred));\n}\n\n// c_is_permutation()\n//\n// Container-based version of the `std::is_permutation()` function\n// to test whether a container is a permutation of another.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_permutation(const C1& c1,\n const C2& c2) {\n return std::is_permutation(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2));\n}\n\n// Overload of c_is_permutation() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_permutation(\n const C1& c1, const C2& c2, BinaryPredicate&& pred) {\n return std::is_permutation(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2),\n std::forward(pred));\n}\n\n// c_search()\n//\n// Container-based version of the `std::search()` function to search\n// a container for a subsequence.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_search(Sequence1& sequence, Sequence2& subsequence) {\n return std::search(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(subsequence),\n container_algorithm_internal::c_end(subsequence));\n}\n\n// Overload of c_search() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_search(Sequence1& sequence, Sequence2& subsequence,\n BinaryPredicate&& pred) {\n return std::search(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(subsequence),\n container_algorithm_internal::c_end(subsequence),\n std::forward(pred));\n}\n\n// c_contains_subrange()\n//\n// Container-based version of the `std::ranges::contains_subrange()`\n// C++23 function to search a container for a subsequence.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains_subrange(\n Sequence1& sequence, Sequence2& subsequence) {\n return absl::c_search(sequence, subsequence) !=\n container_algorithm_internal::c_end(sequence);\n}\n\n// Overload of c_contains_subrange() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_contains_subrange(\n Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {\n return absl::c_search(sequence, subsequence,\n std::forward(pred)) !=\n container_algorithm_internal::c_end(sequence);\n}\n\n// c_search_n()\n//\n// Container-based version of the `std::search_n()` function to\n// search a container for the first sequence of N elements.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_search_n(Sequence& sequence, Size count, T&& value) {\n return std::search_n(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), count,\n std::forward(value));\n}\n\n// Overload of c_search_n() for using a predicate evaluation other than\n// `==` as the function's test condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_search_n(Sequence& sequence, Size count, T&& value,\n BinaryPredicate&& pred) {\n return std::search_n(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), count,\n std::forward(value),\n std::forward(pred));\n}\n\n//------------------------------------------------------------------------------\n// Modifying sequence operations\n//------------------------------------------------------------------------------\n\n// c_copy()\n//\n// Container-based version of the `std::copy()` function to copy a\n// container's elements into an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_copy(const InputSequence& input, OutputIterator output) {\n return std::copy(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input), output);\n}\n\n// c_copy_n()\n//\n// Container-based version of the `std::copy_n()` function to copy a\n// container's first N elements into an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_copy_n(const C& input, Size n, OutputIterator output) {\n return std::copy_n(container_algorithm_internal::c_begin(input), n, output);\n}\n\n// c_copy_if()\n//\n// Container-based version of the `std::copy_if()` function to copy\n// a container's elements satisfying some condition into an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_copy_if(const InputSequence& input, OutputIterator output, Pred&& pred) {\n return std::copy_if(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input), output,\n std::forward(pred));\n}\n\n// c_copy_backward()\n//\n// Container-based version of the `std::copy_backward()` function to\n// copy a container's elements in reverse order into an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 BidirectionalIterator\nc_copy_backward(const C& src, BidirectionalIterator dest) {\n return std::copy_backward(container_algorithm_internal::c_begin(src),\n container_algorithm_internal::c_end(src), dest);\n}\n\n// c_move()\n//\n// Container-based version of the `std::move()` function to move\n// a container's elements into an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_move(C&& src,\n OutputIterator dest) {\n return std::move(container_algorithm_internal::c_begin(src),\n container_algorithm_internal::c_end(src), dest);\n}\n\n// c_move_backward()\n//\n// Container-based version of the `std::move_backward()` function to\n// move a container's elements into an iterator in reverse order.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 BidirectionalIterator\nc_move_backward(C&& src, BidirectionalIterator dest) {\n return std::move_backward(container_algorithm_internal::c_begin(src),\n container_algorithm_internal::c_end(src), dest);\n}\n\n// c_swap_ranges()\n//\n// Container-based version of the `std::swap_ranges()` function to\n// swap a container's elements with another container's elements. Swaps the\n// first N elements of `c1` and `c2`, where N = min(size(c1), size(c2)).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_swap_ranges(C1& c1, C2& c2) {\n auto first1 = container_algorithm_internal::c_begin(c1);\n auto last1 = container_algorithm_internal::c_end(c1);\n auto first2 = container_algorithm_internal::c_begin(c2);\n auto last2 = container_algorithm_internal::c_end(c2);\n\n using std::swap;\n for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {\n swap(*first1, *first2);\n }\n return first2;\n}\n\n// c_transform()\n//\n// Container-based version of the `std::transform()` function to\n// transform a container's elements using the unary operation, storing the\n// result in an iterator pointing to the last transformed element in the output\n// range.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_transform(\n const InputSequence& input, OutputIterator output, UnaryOp&& unary_op) {\n return std::transform(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input), output,\n std::forward(unary_op));\n}\n\n// Overload of c_transform() for performing a transformation using a binary\n// predicate. Applies `binary_op` to the first N elements of `c1` and `c2`,\n// where N = min(size(c1), size(c2)).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_transform(const InputSequence1& input1, const InputSequence2& input2,\n OutputIterator output, BinaryOp&& binary_op) {\n auto first1 = container_algorithm_internal::c_begin(input1);\n auto last1 = container_algorithm_internal::c_end(input1);\n auto first2 = container_algorithm_internal::c_begin(input2);\n auto last2 = container_algorithm_internal::c_end(input2);\n for (; first1 != last1 && first2 != last2;\n ++first1, (void)++first2, ++output) {\n *output = binary_op(*first1, *first2);\n }\n\n return output;\n}\n\n// c_replace()\n//\n// Container-based version of the `std::replace()` function to\n// replace a container's elements of some value with a new value. The container\n// is modified in place.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_replace(Sequence& sequence,\n const T& old_value,\n const T& new_value) {\n std::replace(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), old_value,\n new_value);\n}\n\n// c_replace_if()\n//\n// Container-based version of the `std::replace_if()` function to\n// replace a container's elements of some value with a new value based on some\n// condition. The container is modified in place.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_replace_if(C& c, Pred&& pred,\n T&& new_value) {\n std::replace_if(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred), std::forward(new_value));\n}\n\n// c_replace_copy()\n//\n// Container-based version of the `std::replace_copy()` function to\n// replace a container's elements of some value with a new value and return the\n// results within an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_replace_copy(\n const C& c, OutputIterator result, T&& old_value, T&& new_value) {\n return std::replace_copy(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result,\n std::forward(old_value),\n std::forward(new_value));\n}\n\n// c_replace_copy_if()\n//\n// Container-based version of the `std::replace_copy_if()` function\n// to replace a container's elements of some value with a new value based on\n// some condition, and return the results within an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_replace_copy_if(\n const C& c, OutputIterator result, Pred&& pred, const T& new_value) {\n return std::replace_copy_if(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result,\n std::forward(pred), new_value);\n}\n\n// c_fill()\n//\n// Container-based version of the `std::fill()` function to fill a\n// container with some value.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_fill(C& c, const T& value) {\n std::fill(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), value);\n}\n\n// c_fill_n()\n//\n// Container-based version of the `std::fill_n()` function to fill\n// the first N elements in a container with some value.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_fill_n(C& c, Size n,\n const T& value) {\n std::fill_n(container_algorithm_internal::c_begin(c), n, value);\n}\n\n// c_generate()\n//\n// Container-based version of the `std::generate()` function to\n// assign a container's elements to the values provided by the given generator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_generate(C& c, Generator&& gen) {\n std::generate(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(gen));\n}\n\n// c_generate_n()\n//\n// Container-based version of the `std::generate_n()` function to\n// assign a container's first N elements to the values provided by the given\n// generator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_generate_n(C& c, Size n, Generator&& gen) {\n return std::generate_n(container_algorithm_internal::c_begin(c), n,\n std::forward(gen));\n}\n\n// Note: `c_xx()` container versions for `remove()`, `remove_if()`,\n// and `unique()` are omitted, because it's not clear whether or not such\n// functions should call erase on their supplied sequences afterwards. Either\n// behavior would be surprising for a different set of users.\n\n// c_remove_copy()\n//\n// Container-based version of the `std::remove_copy()` function to\n// copy a container's elements while removing any elements matching the given\n// `value`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_remove_copy(const C& c, OutputIterator result, const T& value) {\n return std::remove_copy(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result,\n value);\n}\n\n// c_remove_copy_if()\n//\n// Container-based version of the `std::remove_copy_if()` function\n// to copy a container's elements while removing any elements matching the given\n// condition.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_remove_copy_if(const C& c, OutputIterator result, Pred&& pred) {\n return std::remove_copy_if(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result,\n std::forward(pred));\n}\n\n// c_unique_copy()\n//\n// Container-based version of the `std::unique_copy()` function to\n// copy a container's elements while removing any elements containing duplicate\n// values.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_unique_copy(const C& c, OutputIterator result) {\n return std::unique_copy(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result);\n}\n\n// Overload of c_unique_copy() for using a predicate evaluation other than\n// `==` for comparing uniqueness of the element values.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_unique_copy(const C& c, OutputIterator result, BinaryPredicate&& pred) {\n return std::unique_copy(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result,\n std::forward(pred));\n}\n\n// c_reverse()\n//\n// Container-based version of the `std::reverse()` function to\n// reverse a container's elements.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_reverse(Sequence& sequence) {\n std::reverse(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// c_reverse_copy()\n//\n// Container-based version of the `std::reverse()` function to\n// reverse a container's elements and write them to an iterator range.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_reverse_copy(const C& sequence, OutputIterator result) {\n return std::reverse_copy(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n result);\n}\n\n// c_rotate()\n//\n// Container-based version of the `std::rotate()` function to\n// shift a container's elements leftward such that the `middle` element becomes\n// the first element in the container.\ntemplate >\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 Iterator c_rotate(C& sequence,\n Iterator middle) {\n return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,\n container_algorithm_internal::c_end(sequence));\n}\n\n// c_rotate_copy()\n//\n// Container-based version of the `std::rotate_copy()` function to\n// shift a container's elements leftward such that the `middle` element becomes\n// the first element in a new iterator range.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_rotate_copy(const C& sequence,\n container_algorithm_internal::ContainerIter middle,\n OutputIterator result) {\n return std::rotate_copy(container_algorithm_internal::c_begin(sequence),\n middle, container_algorithm_internal::c_end(sequence),\n result);\n}\n\n// c_shuffle()\n//\n// Container-based version of the `std::shuffle()` function to\n// randomly shuffle elements within the container using a `gen()` uniform random\n// number generator.\ntemplate \nvoid c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {\n std::shuffle(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(gen));\n}\n\n// c_sample()\n//\n// Container-based version of the `std::sample()` function to\n// randomly sample elements from the container without replacement using a\n// `gen()` uniform random number generator and write them to an iterator range.\ntemplate \nOutputIterator c_sample(const C& c, OutputIterator result, Distance n,\n UniformRandomBitGenerator&& gen) {\n return std::sample(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), result, n,\n std::forward(gen));\n}\n\n//------------------------------------------------------------------------------\n// Partition functions\n//------------------------------------------------------------------------------\n\n// c_is_partitioned()\n//\n// Container-based version of the `std::is_partitioned()` function\n// to test whether all elements in the container for which `pred` returns `true`\n// precede those for which `pred` is `false`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_partitioned(const C& c,\n Pred&& pred) {\n return std::is_partitioned(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_partition()\n//\n// Container-based version of the `std::partition()` function\n// to rearrange all elements in a container in such a way that all elements for\n// which `pred` returns `true` precede all those for which it returns `false`,\n// returning an iterator to the first element of the second group.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_partition(C& c, Pred&& pred) {\n return std::partition(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_stable_partition()\n//\n// Container-based version of the `std::stable_partition()` function\n// to rearrange all elements in a container in such a way that all elements for\n// which `pred` returns `true` precede all those for which it returns `false`,\n// preserving the relative ordering between the two groups. The function returns\n// an iterator to the first element of the second group.\ntemplate \ncontainer_algorithm_internal::ContainerIter c_stable_partition(C& c,\n Pred&& pred) {\n return std::stable_partition(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n// c_partition_copy()\n//\n// Container-based version of the `std::partition_copy()` function\n// to partition a container's elements and return them into two iterators: one\n// for which `pred` returns `true`, and one for which `pred` returns `false.`\n\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 std::pair\nc_partition_copy(const C& c, OutputIterator1 out_true,\n OutputIterator2 out_false, Pred&& pred) {\n return std::partition_copy(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c), out_true,\n out_false, std::forward(pred));\n}\n\n// c_partition_point()\n//\n// Container-based version of the `std::partition_point()` function\n// to return the first element of an already partitioned container for which\n// the given `pred` is not `true`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_partition_point(C& c, Pred&& pred) {\n return std::partition_point(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(pred));\n}\n\n//------------------------------------------------------------------------------\n// Sorting functions\n//------------------------------------------------------------------------------\n\n// c_sort()\n//\n// Container-based version of the `std::sort()` function\n// to sort elements in ascending order of their values.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort(C& c) {\n std::sort(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_sort() for performing a `comp` comparison other than the\n// default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort(C& c, LessThan&& comp) {\n std::sort(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_stable_sort()\n//\n// Container-based version of the `std::stable_sort()` function\n// to sort elements in ascending order of their values, preserving the order\n// of equivalents.\ntemplate \nvoid c_stable_sort(C& c) {\n std::stable_sort(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_stable_sort() for performing a `comp` comparison other than the\n// default `operator<`.\ntemplate \nvoid c_stable_sort(C& c, LessThan&& comp) {\n std::stable_sort(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_is_sorted()\n//\n// Container-based version of the `std::is_sorted()` function\n// to evaluate whether the given container is sorted in ascending order.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_sorted(const C& c) {\n return std::is_sorted(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// c_is_sorted() overload for performing a `comp` comparison other than the\n// default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_sorted(const C& c,\n LessThan&& comp) {\n return std::is_sorted(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_partial_sort()\n//\n// Container-based version of the `std::partial_sort()` function\n// to rearrange elements within a container such that elements before `middle`\n// are sorted in ascending order.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_partial_sort(\n RandomAccessContainer& sequence,\n container_algorithm_internal::ContainerIter middle) {\n std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_partial_sort() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_partial_sort(\n RandomAccessContainer& sequence,\n container_algorithm_internal::ContainerIter middle,\n LessThan&& comp) {\n std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_partial_sort_copy()\n//\n// Container-based version of the `std::partial_sort_copy()`\n// function to sort the elements in the given range `result` within the larger\n// `sequence` in ascending order (and using `result` as the output parameter).\n// At most min(result.last - result.first, sequence.last - sequence.first)\n// elements from the sequence will be stored in the result.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {\n return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(result),\n container_algorithm_internal::c_end(result));\n}\n\n// Overload of c_partial_sort_copy() for performing a `comp` comparison other\n// than the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,\n LessThan&& comp) {\n return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n container_algorithm_internal::c_begin(result),\n container_algorithm_internal::c_end(result),\n std::forward(comp));\n}\n\n// c_is_sorted_until()\n//\n// Container-based version of the `std::is_sorted_until()` function\n// to return the first element within a container that is not sorted in\n// ascending order as an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_is_sorted_until(C& c) {\n return std::is_sorted_until(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_is_sorted_until() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_is_sorted_until(C& c, LessThan&& comp) {\n return std::is_sorted_until(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_nth_element()\n//\n// Container-based version of the `std::nth_element()` function\n// to rearrange the elements within a container such that the `nth` element\n// would be in that position in an ordered sequence; other elements may be in\n// any order, except that all preceding `nth` will be less than that element,\n// and all following `nth` will be greater than that element.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_nth_element(\n RandomAccessContainer& sequence,\n container_algorithm_internal::ContainerIter nth) {\n std::nth_element(container_algorithm_internal::c_begin(sequence), nth,\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_nth_element() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_nth_element(\n RandomAccessContainer& sequence,\n container_algorithm_internal::ContainerIter nth,\n LessThan&& comp) {\n std::nth_element(container_algorithm_internal::c_begin(sequence), nth,\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// Binary Search\n//------------------------------------------------------------------------------\n\n// c_lower_bound()\n//\n// Container-based version of the `std::lower_bound()` function\n// to return an iterator pointing to the first element in a sorted container\n// which does not compare less than `value`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_lower_bound(Sequence& sequence, const T& value) {\n return std::lower_bound(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value);\n}\n\n// Overload of c_lower_bound() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_lower_bound(Sequence& sequence, const T& value, LessThan&& comp) {\n return std::lower_bound(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value,\n std::forward(comp));\n}\n\n// c_upper_bound()\n//\n// Container-based version of the `std::upper_bound()` function\n// to return an iterator pointing to the first element in a sorted container\n// which is greater than `value`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_upper_bound(Sequence& sequence, const T& value) {\n return std::upper_bound(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value);\n}\n\n// Overload of c_upper_bound() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_upper_bound(Sequence& sequence, const T& value, LessThan&& comp) {\n return std::upper_bound(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value,\n std::forward(comp));\n}\n\n// c_equal_range()\n//\n// Container-based version of the `std::equal_range()` function\n// to return an iterator pair pointing to the first and last elements in a\n// sorted container which compare equal to `value`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIterPairType\n c_equal_range(Sequence& sequence, const T& value) {\n return std::equal_range(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value);\n}\n\n// Overload of c_equal_range() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIterPairType\n c_equal_range(Sequence& sequence, const T& value, LessThan&& comp) {\n return std::equal_range(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value,\n std::forward(comp));\n}\n\n// c_binary_search()\n//\n// Container-based version of the `std::binary_search()` function\n// to test if any element in the sorted container contains a value equivalent to\n// 'value'.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_binary_search(\n const Sequence& sequence, const T& value) {\n return std::binary_search(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n value);\n}\n\n// Overload of c_binary_search() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_binary_search(\n const Sequence& sequence, const T& value, LessThan&& comp) {\n return std::binary_search(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n value, std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// Merge functions\n//------------------------------------------------------------------------------\n\n// c_merge()\n//\n// Container-based version of the `std::merge()` function\n// to merge two sorted containers into a single sorted iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_merge(const C1& c1, const C2& c2, OutputIterator result) {\n return std::merge(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), result);\n}\n\n// Overload of c_merge() for performing a `comp` comparison other than\n// the default `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_merge(const C1& c1, const C2& c2, OutputIterator result, LessThan&& comp) {\n return std::merge(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), result,\n std::forward(comp));\n}\n\n// c_inplace_merge()\n//\n// Container-based version of the `std::inplace_merge()` function\n// to merge a supplied iterator `middle` into a container.\ntemplate \nvoid c_inplace_merge(C& c,\n container_algorithm_internal::ContainerIter middle) {\n std::inplace_merge(container_algorithm_internal::c_begin(c), middle,\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_inplace_merge() for performing a merge using a `comp` other\n// than `operator<`.\ntemplate \nvoid c_inplace_merge(C& c,\n container_algorithm_internal::ContainerIter middle,\n LessThan&& comp) {\n std::inplace_merge(container_algorithm_internal::c_begin(c), middle,\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_includes()\n//\n// Container-based version of the `std::includes()` function\n// to test whether a sorted container `c1` entirely contains another sorted\n// container `c2`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_includes(const C1& c1,\n const C2& c2) {\n return std::includes(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2));\n}\n\n// Overload of c_includes() for performing a merge using a `comp` other than\n// `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_includes(const C1& c1, const C2& c2,\n LessThan&& comp) {\n return std::includes(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2),\n std::forward(comp));\n}\n\n// c_set_union()\n//\n// Container-based version of the `std::set_union()` function\n// to return an iterator containing the union of two containers; duplicate\n// values are not copied into the output.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_set_union(const C1& c1, const C2& c2, OutputIterator output) {\n return std::set_union(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output);\n}\n\n// Overload of c_set_union() for performing a merge using a `comp` other than\n// `operator<`.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_union(\n const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {\n return std::set_union(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output,\n std::forward(comp));\n}\n\n// c_set_intersection()\n//\n// Container-based version of the `std::set_intersection()` function\n// to return an iterator containing the intersection of two sorted containers.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_set_intersection(const C1& c1, const C2& c2, OutputIterator output) {\n // In debug builds, ensure that both containers are sorted with respect to the\n // default comparator. std::set_intersection requires the containers be sorted\n // using operator<.\n ABSL_ASSERT(absl::c_is_sorted(c1));\n ABSL_ASSERT(absl::c_is_sorted(c2));\n return std::set_intersection(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output);\n}\n\n// Overload of c_set_intersection() for performing a merge using a `comp` other\n// than `operator<`.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_intersection(\n const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {\n // In debug builds, ensure that both containers are sorted with respect to the\n // default comparator. std::set_intersection requires the containers be sorted\n // using the same comparator.\n ABSL_ASSERT(absl::c_is_sorted(c1, comp));\n ABSL_ASSERT(absl::c_is_sorted(c2, comp));\n return std::set_intersection(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output,\n std::forward(comp));\n}\n\n// c_set_difference()\n//\n// Container-based version of the `std::set_difference()` function\n// to return an iterator containing elements present in the first container but\n// not in the second.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_set_difference(const C1& c1, const C2& c2, OutputIterator output) {\n return std::set_difference(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output);\n}\n\n// Overload of c_set_difference() for performing a merge using a `comp` other\n// than `operator<`.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_difference(\n const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {\n return std::set_difference(container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output,\n std::forward(comp));\n}\n\n// c_set_symmetric_difference()\n//\n// Container-based version of the `std::set_symmetric_difference()`\n// function to return an iterator containing elements present in either one\n// container or the other, but not both.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator\nc_set_symmetric_difference(const C1& c1, const C2& c2, OutputIterator output) {\n return std::set_symmetric_difference(\n container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output);\n}\n\n// Overload of c_set_symmetric_difference() for performing a merge using a\n// `comp` other than `operator<`.\ntemplate ::value,\n void>::type,\n typename = typename std::enable_if<\n !container_algorithm_internal::IsUnorderedContainer::value,\n void>::type>\nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIterator c_set_symmetric_difference(\n const C1& c1, const C2& c2, OutputIterator output, LessThan&& comp) {\n return std::set_symmetric_difference(\n container_algorithm_internal::c_begin(c1),\n container_algorithm_internal::c_end(c1),\n container_algorithm_internal::c_begin(c2),\n container_algorithm_internal::c_end(c2), output,\n std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// Heap functions\n//------------------------------------------------------------------------------\n\n// c_push_heap()\n//\n// Container-based version of the `std::push_heap()` function\n// to push a value onto a container heap.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_push_heap(\n RandomAccessContainer& sequence) {\n std::push_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_push_heap() for performing a push operation on a heap using a\n// `comp` other than `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_push_heap(\n RandomAccessContainer& sequence, LessThan&& comp) {\n std::push_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_pop_heap()\n//\n// Container-based version of the `std::pop_heap()` function\n// to pop a value from a heap container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_pop_heap(\n RandomAccessContainer& sequence) {\n std::pop_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_pop_heap() for performing a pop operation on a heap using a\n// `comp` other than `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_pop_heap(\n RandomAccessContainer& sequence, LessThan&& comp) {\n std::pop_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_make_heap()\n//\n// Container-based version of the `std::make_heap()` function\n// to make a container a heap.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_make_heap(\n RandomAccessContainer& sequence) {\n std::make_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_make_heap() for performing heap comparisons using a\n// `comp` other than `operator<`\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_make_heap(\n RandomAccessContainer& sequence, LessThan&& comp) {\n std::make_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_sort_heap()\n//\n// Container-based version of the `std::sort_heap()` function\n// to sort a heap into ascending order (after which it is no longer a heap).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort_heap(\n RandomAccessContainer& sequence) {\n std::sort_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_sort_heap() for performing heap comparisons using a\n// `comp` other than `operator<`\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_sort_heap(\n RandomAccessContainer& sequence, LessThan&& comp) {\n std::sort_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_is_heap()\n//\n// Container-based version of the `std::is_heap()` function\n// to check whether the given container is a heap.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_heap(\n const RandomAccessContainer& sequence) {\n return std::is_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_is_heap() for performing heap comparisons using a\n// `comp` other than `operator<`\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_is_heap(\n const RandomAccessContainer& sequence, LessThan&& comp) {\n return std::is_heap(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_is_heap_until()\n//\n// Container-based version of the `std::is_heap_until()` function\n// to find the first element in a given container which is not in heap order.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_is_heap_until(RandomAccessContainer& sequence) {\n return std::is_heap_until(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_is_heap_until() for performing heap comparisons using a\n// `comp` other than `operator<`\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20\n container_algorithm_internal::ContainerIter\n c_is_heap_until(RandomAccessContainer& sequence, LessThan&& comp) {\n return std::is_heap_until(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// Min/max\n//------------------------------------------------------------------------------\n\n// c_min_element()\n//\n// Container-based version of the `std::min_element()` function\n// to return an iterator pointing to the element with the smallest value, using\n// `operator<` to make the comparisons.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIter\n c_min_element(Sequence& sequence) {\n return std::min_element(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_min_element() for performing a `comp` comparison other than\n// `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIter\n c_min_element(Sequence& sequence, LessThan&& comp) {\n return std::min_element(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_max_element()\n//\n// Container-based version of the `std::max_element()` function\n// to return an iterator pointing to the element with the largest value, using\n// `operator<` to make the comparisons.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIter\n c_max_element(Sequence& sequence) {\n return std::max_element(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence));\n}\n\n// Overload of c_max_element() for performing a `comp` comparison other than\n// `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIter\n c_max_element(Sequence& sequence, LessThan&& comp) {\n return std::max_element(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(comp));\n}\n\n// c_minmax_element()\n//\n// Container-based version of the `std::minmax_element()` function\n// to return a pair of iterators pointing to the elements containing the\n// smallest and largest values, respectively, using `operator<` to make the\n// comparisons.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIterPairType\n c_minmax_element(C& c) {\n return std::minmax_element(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_minmax_element() for performing `comp` comparisons other than\n// `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX17\n container_algorithm_internal::ContainerIterPairType\n c_minmax_element(C& c, LessThan&& comp) {\n return std::minmax_element(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// Lexicographical Comparisons\n//------------------------------------------------------------------------------\n\n// c_lexicographical_compare()\n//\n// Container-based version of the `std::lexicographical_compare()`\n// function to lexicographically compare (e.g. sort words alphabetically) two\n// container sequences. The comparison is performed using `operator<`. Note\n// that capital letters (\"A-Z\") have ASCII values less than lowercase letters\n// (\"a-z\").\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_lexicographical_compare(\n const Sequence1& sequence1, const Sequence2& sequence2) {\n return std::lexicographical_compare(\n container_algorithm_internal::c_begin(sequence1),\n container_algorithm_internal::c_end(sequence1),\n container_algorithm_internal::c_begin(sequence2),\n container_algorithm_internal::c_end(sequence2));\n}\n\n// Overload of c_lexicographical_compare() for performing a lexicographical\n// comparison using a `comp` operator instead of `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_lexicographical_compare(\n const Sequence1& sequence1, const Sequence2& sequence2, LessThan&& comp) {\n return std::lexicographical_compare(\n container_algorithm_internal::c_begin(sequence1),\n container_algorithm_internal::c_end(sequence1),\n container_algorithm_internal::c_begin(sequence2),\n container_algorithm_internal::c_end(sequence2),\n std::forward(comp));\n}\n\n// c_next_permutation()\n//\n// Container-based version of the `std::next_permutation()` function\n// to rearrange a container's elements into the next lexicographically greater\n// permutation.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_next_permutation(C& c) {\n return std::next_permutation(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_next_permutation() for performing a lexicographical\n// comparison using a `comp` operator instead of `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_next_permutation(C& c,\n LessThan&& comp) {\n return std::next_permutation(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n// c_prev_permutation()\n//\n// Container-based version of the `std::prev_permutation()` function\n// to rearrange a container's elements into the next lexicographically lesser\n// permutation.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_prev_permutation(C& c) {\n return std::prev_permutation(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c));\n}\n\n// Overload of c_prev_permutation() for performing a lexicographical\n// comparison using a `comp` operator instead of `operator<`.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 bool c_prev_permutation(C& c,\n LessThan&& comp) {\n return std::prev_permutation(container_algorithm_internal::c_begin(c),\n container_algorithm_internal::c_end(c),\n std::forward(comp));\n}\n\n//------------------------------------------------------------------------------\n// algorithms\n//------------------------------------------------------------------------------\n\n// c_iota()\n//\n// Container-based version of the `std::iota()` function\n// to compute successive values of `value`, as if incremented with `++value`\n// after each element is written, and write them to the container.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 void c_iota(Sequence& sequence,\n const T& value) {\n std::iota(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence), value);\n}\n\n// c_accumulate()\n//\n// Container-based version of the `std::accumulate()` function\n// to accumulate the element values of a container to `init` and return that\n// accumulation by value.\n//\n// Note: Due to a language technicality this function has return type\n// absl::decay_t. As a user of this function you can casually read\n// this as \"returns T by value\" and assume it does the right thing.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t c_accumulate(\n const Sequence& sequence, T&& init) {\n return std::accumulate(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(init));\n}\n\n// Overload of c_accumulate() for using a binary operations other than\n// addition for computing the accumulation.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t c_accumulate(\n const Sequence& sequence, T&& init, BinaryOp&& binary_op) {\n return std::accumulate(container_algorithm_internal::c_begin(sequence),\n container_algorithm_internal::c_end(sequence),\n std::forward(init),\n std::forward(binary_op));\n}\n\n// c_inner_product()\n//\n// Container-based version of the `std::inner_product()` function\n// to compute the cumulative inner product of container element pairs.\n//\n// Note: Due to a language technicality this function has return type\n// absl::decay_t. As a user of this function you can casually read\n// this as \"returns T by value\" and assume it does the right thing.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t c_inner_product(\n const Sequence1& factors1, const Sequence2& factors2, T&& sum) {\n return std::inner_product(container_algorithm_internal::c_begin(factors1),\n container_algorithm_internal::c_end(factors1),\n container_algorithm_internal::c_begin(factors2),\n std::forward(sum));\n}\n\n// Overload of c_inner_product() for using binary operations other than\n// `operator+` (for computing the accumulation) and `operator*` (for computing\n// the product between the two container's element pair).\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 decay_t c_inner_product(\n const Sequence1& factors1, const Sequence2& factors2, T&& sum,\n BinaryOp1&& op1, BinaryOp2&& op2) {\n return std::inner_product(container_algorithm_internal::c_begin(factors1),\n container_algorithm_internal::c_end(factors1),\n container_algorithm_internal::c_begin(factors2),\n std::forward(sum), std::forward(op1),\n std::forward(op2));\n}\n\n// c_adjacent_difference()\n//\n// Container-based version of the `std::adjacent_difference()`\n// function to compute the difference between each element and the one preceding\n// it and write it to an iterator.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIt\nc_adjacent_difference(const InputSequence& input, OutputIt output_first) {\n return std::adjacent_difference(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input),\n output_first);\n}\n\n// Overload of c_adjacent_difference() for using a binary operation other than\n// subtraction to compute the adjacent difference.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIt c_adjacent_difference(\n const InputSequence& input, OutputIt output_first, BinaryOp&& op) {\n return std::adjacent_difference(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input),\n output_first, std::forward(op));\n}\n\n// c_partial_sum()\n//\n// Container-based version of the `std::partial_sum()` function\n// to compute the partial sum of the elements in a sequence and write them\n// to an iterator. The partial sum is the sum of all element values so far in\n// the sequence.\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIt\nc_partial_sum(const InputSequence& input, OutputIt output_first) {\n return std::partial_sum(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input),\n output_first);\n}\n\n// Overload of c_partial_sum() for using a binary operation other than addition\n// to compute the \"partial sum\".\ntemplate \nABSL_INTERNAL_CONSTEXPR_SINCE_CXX20 OutputIt c_partial_sum(\n const InputSequence& input, OutputIt output_first, BinaryOp&& op) {\n return std::partial_sum(container_algorithm_internal::c_begin(input),\n container_algorithm_internal::c_end(input),\n output_first, std::forward(op));\n}\n\nABSL_NAMESPACE_END\n} // namespace absl\n\n#endif // ABSL_ALGORITHM_CONTAINER_H_\n" }, { "path": "absl/algorithm/container_test.cc", "content": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n#include \"absl/algorithm/container.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gmock/gmock.h\"\n#include \"gtest/gtest.h\"\n#include \"absl/base/casts.h\"\n#include \"absl/base/config.h\"\n#include \"absl/base/macros.h\"\n#include \"absl/memory/memory.h\"\n#include \"absl/random/random.h\"\n#include \"absl/types/span.h\"\n\nnamespace {\n\nusing ::testing::Each;\nusing ::testing::ElementsAre;\nusing ::testing::Gt;\nusing ::testing::IsNull;\nusing ::testing::IsSubsetOf;\nusing ::testing::Lt;\nusing ::testing::Pointee;\nusing ::testing::SizeIs;\nusing ::testing::Truly;\nusing ::testing::UnorderedElementsAre;\n\n// Most of these tests just check that the code compiles, not that it\n// does the right thing. That's fine since the functions just forward\n// to the STL implementation.\nclass NonMutatingTest : public testing::Test {\n protected:\n std::unordered_set container_ = {1, 2, 3};\n std::list sequence_ = {1, 2, 3};\n std::vector vector_ = {1, 2, 3};\n int array_[3] = {1, 2, 3};\n};\n\nstruct AccumulateCalls {\n void operator()(int value) { calls.push_back(value); }\n std::vector calls;\n};\n\nbool Predicate(int value) { return value < 3; }\nbool BinPredicate(int v1, int v2) { return v1 < v2; }\nbool Equals(int v1, int v2) { return v1 == v2; }\nbool IsOdd(int x) { return x % 2 != 0; }\n\nTEST_F(NonMutatingTest, Distance) {\n EXPECT_EQ(container_.size(),\n static_cast(absl::c_distance(container_)));\n EXPECT_EQ(sequence_.size(), static_cast(absl::c_distance(sequence_)));\n EXPECT_EQ(vector_.size(), static_cast(absl::c_distance(vector_)));\n EXPECT_EQ(ABSL_ARRAYSIZE(array_),\n static_cast(absl::c_distance(array_)));\n\n // Works with a temporary argument.\n EXPECT_EQ(vector_.size(),\n static_cast(absl::c_distance(std::vector(vector_))));\n}\n\nTEST_F(NonMutatingTest, Distance_OverloadedBeginEnd) {\n // Works with classes which have custom ADL-selected overloads of std::begin\n // and std::end.\n std::initializer_list a = {1, 2, 3};\n std::valarray b = {1, 2, 3};\n EXPECT_EQ(3, absl::c_distance(a));\n EXPECT_EQ(3, absl::c_distance(b));\n\n // It is assumed that other c_* functions use the same mechanism for\n // ADL-selecting begin/end overloads.\n}\n\nTEST_F(NonMutatingTest, ForEach) {\n AccumulateCalls c = absl::c_for_each(container_, AccumulateCalls());\n // Don't rely on the unordered_set's order.\n std::sort(c.calls.begin(), c.calls.end());\n EXPECT_EQ(vector_, c.calls);\n\n // Works with temporary container, too.\n AccumulateCalls c2 =\n absl::c_for_each(std::unordered_set(container_), AccumulateCalls());\n std::sort(c2.calls.begin(), c2.calls.end());\n EXPECT_EQ(vector_, c2.calls);\n}\n\nTEST_F(NonMutatingTest, FindReturnsCorrectType) {\n auto it = absl::c_find(container_, 3);\n EXPECT_EQ(3, *it);\n absl::c_find(absl::implicit_cast&>(sequence_), 3);\n}\n\nTEST_F(NonMutatingTest, Contains) {\n EXPECT_TRUE(absl::c_contains(container_, 3));\n EXPECT_FALSE(absl::c_contains(container_, 4));\n}\n\nTEST_F(NonMutatingTest, FindIf) { absl::c_find_if(container_, Predicate); }\n\nTEST_F(NonMutatingTest, FindIfNot) {\n absl::c_find_if_not(container_, Predicate);\n}\n\nTEST_F(NonMutatingTest, FindEnd) {\n absl::c_find_end(sequence_, vector_);\n absl::c_find_end(vector_, sequence_);\n}\n\nTEST_F(NonMutatingTest, FindEndWithPredicate) {\n absl::c_find_end(sequence_, vector_, BinPredicate);\n absl::c_find_end(vector_, sequence_, BinPredicate);\n}\n\nTEST_F(NonMutatingTest, FindFirstOf) {\n absl::c_find_first_of(container_, sequence_);\n absl::c_find_first_of(sequence_, container_);\n absl::c_find_first_of(sequence_, std::array{1, 2});\n}\n\nTEST_F(NonMutatingTest, FindFirstOfWithPredicate) {\n absl::c_find_first_of(container_, sequence_, BinPredicate);\n absl::c_find_first_of(sequence_, container_, BinPredicate);\n absl::c_find_first_of(sequence_, std::array{1, 2}, BinPredicate);\n}\n\nTEST_F(NonMutatingTest, AdjacentFind) { absl::c_adjacent_find(sequence_); }\n\nTEST_F(NonMutatingTest, AdjacentFindWithPredicate) {\n absl::c_adjacent_find(sequence_, BinPredicate);\n}\n\nTEST_F(NonMutatingTest, Count) { EXPECT_EQ(1, absl::c_count(container_, 3)); }\n\nTEST_F(NonMutatingTest, CountIf) {\n EXPECT_EQ(2, absl::c_count_if(container_, Predicate));\n const std::unordered_set& const_container = container_;\n EXPECT_EQ(2, absl::c_count_if(const_container, Predicate));\n}\n\nTEST_F(NonMutatingTest, Mismatch) {\n // Testing necessary as absl::c_mismatch executes logic.\n {\n auto result = absl::c_mismatch(vector_, sequence_);\n EXPECT_EQ(result.first, vector_.end());\n EXPECT_EQ(result.second, sequence_.end());\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_);\n EXPECT_EQ(result.first, sequence_.end());\n EXPECT_EQ(result.second, vector_.end());\n }\n\n sequence_.back() = 5;\n {\n auto result = absl::c_mismatch(vector_, sequence_);\n EXPECT_EQ(result.first, std::prev(vector_.end()));\n EXPECT_EQ(result.second, std::prev(sequence_.end()));\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_);\n EXPECT_EQ(result.first, std::prev(sequence_.end()));\n EXPECT_EQ(result.second, std::prev(vector_.end()));\n }\n\n sequence_.pop_back();\n {\n auto result = absl::c_mismatch(vector_, sequence_);\n EXPECT_EQ(result.first, std::prev(vector_.end()));\n EXPECT_EQ(result.second, sequence_.end());\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_);\n EXPECT_EQ(result.first, sequence_.end());\n EXPECT_EQ(result.second, std::prev(vector_.end()));\n }\n {\n struct NoNotEquals {\n constexpr bool operator==(NoNotEquals) const { return true; }\n constexpr bool operator!=(NoNotEquals) const = delete;\n };\n std::vector first;\n std::list second;\n\n // Check this still compiles.\n absl::c_mismatch(first, second);\n }\n}\n\nTEST_F(NonMutatingTest, MismatchWithPredicate) {\n // Testing necessary as absl::c_mismatch executes logic.\n {\n auto result = absl::c_mismatch(vector_, sequence_, BinPredicate);\n EXPECT_EQ(result.first, vector_.begin());\n EXPECT_EQ(result.second, sequence_.begin());\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_, BinPredicate);\n EXPECT_EQ(result.first, sequence_.begin());\n EXPECT_EQ(result.second, vector_.begin());\n }\n\n sequence_.front() = 0;\n {\n auto result = absl::c_mismatch(vector_, sequence_, BinPredicate);\n EXPECT_EQ(result.first, vector_.begin());\n EXPECT_EQ(result.second, sequence_.begin());\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_, BinPredicate);\n EXPECT_EQ(result.first, std::next(sequence_.begin()));\n EXPECT_EQ(result.second, std::next(vector_.begin()));\n }\n\n sequence_.clear();\n {\n auto result = absl::c_mismatch(vector_, sequence_, BinPredicate);\n EXPECT_EQ(result.first, vector_.begin());\n EXPECT_EQ(result.second, sequence_.end());\n }\n {\n auto result = absl::c_mismatch(sequence_, vector_, BinPredicate);\n EXPECT_EQ(result.first, sequence_.end());\n EXPECT_EQ(result.second, vector_.begin());\n }\n}\n\nTEST_F(NonMutatingTest, Equal) {\n EXPECT_TRUE(absl::c_equal(vector_, sequence_));\n EXPECT_TRUE(absl::c_equal(sequence_, vector_));\n EXPECT_TRUE(absl::c_equal(sequence_, array_));\n EXPECT_TRUE(absl::c_equal(array_, vector_));\n\n // Test that behavior appropriately differs from that of equal().\n std::vector vector_plus = {1, 2, 3};\n vector_plus.push_back(4);\n EXPECT_FALSE(absl::c_equal(vector_plus, sequence_));\n EXPECT_FALSE(absl::c_equal(sequence_, vector_plus));\n EXPECT_FALSE(absl::c_equal(array_, vector_plus));\n}\n\nTEST_F(NonMutatingTest, EqualWithPredicate) {\n EXPECT_TRUE(absl::c_equal(vector_, sequence_, Equals));\n EXPECT_TRUE(absl::c_equal(sequence_, vector_, Equals));\n EXPECT_TRUE(absl::c_equal(array_, sequence_, Equals));\n EXPECT_TRUE(absl::c_equal(vector_, array_, Equals));\n\n // Test that behavior appropriately differs from that of equal().\n std::vector vector_plus = {1, 2, 3};\n vector_plus.push_back(4);\n EXPECT_FALSE(absl::c_equal(vector_plus, sequence_, Equals));\n EXPECT_FALSE(absl::c_equal(sequence_, vector_plus, Equals));\n EXPECT_FALSE(absl::c_equal(vector_plus, array_, Equals));\n}\n\nTEST_F(NonMutatingTest, IsPermutation) {\n auto vector_permut_ = vector_;\n std::next_permutation(vector_permut_.begin(), vector_permut_.end());\n EXPECT_TRUE(absl::c_is_permutation(vector_permut_, sequence_));\n EXPECT_TRUE(absl::c_is_permutation(sequence_, vector_permut_));\n\n // Test that behavior appropriately differs from that of is_permutation().\n std::vector vector_plus = {1, 2, 3};\n vector_plus.push_back(4);\n EXPECT_FALSE(absl::c_is_permutation(vector_plus, sequence_));\n EXPECT_FALSE(absl::c_is_permutation(sequence_, vector_plus));\n}\n\nTEST_F(NonMutatingTest, IsPermutationWithPredicate) {\n auto vector_permut_ = vector_;\n std::next_permutation(vector_permut_.begin(), vector_permut_.end());\n EXPECT_TRUE(absl::c_is_permutation(vector_permut_, sequence_, Equals));\n EXPECT_TRUE(absl::c_is_permutation(sequence_, vector_permut_, Equals));\n\n // Test that behavior appropriately differs from that of is_permutation().\n std::vector vector_plus = {1, 2, 3};\n vector_plus.push_back(4);\n EXPECT_FALSE(absl::c_is_permutation(vector_plus, sequence_, Equals));\n EXPECT_FALSE(absl::c_is_permutation(sequence_, vector_plus, Equals));\n}\n\nTEST_F(NonMutatingTest, Search) {\n absl::c_search(sequence_, vector_);\n absl::c_search(vector_, sequence_);\n absl::c_search(array_, sequence_);\n}\n\nTEST_F(NonMutatingTest, SearchWithPredicate) {\n absl::c_search(sequence_, vector_, BinPredicate);\n absl::c_search(vector_, sequence_, BinPredicate);\n}\n\nTEST_F(NonMutatingTest, ContainsSubrange) {\n EXPECT_TRUE(absl::c_contains_subrange(sequence_, vector_));\n EXPECT_TRUE(absl::c_contains_subrange(vector_, sequence_));\n EXPECT_TRUE(absl::c_contains_subrange(array_, sequence_));\n}\n\nTEST_F(NonMutatingTest, ContainsSubrangeWithPredicate) {\n EXPECT_TRUE(absl::c_contains_subrange(sequence_, vector_, Equals));\n EXPECT_TRUE(absl::c_contains_subrange(vector_, sequence_, Equals));\n}\n\nTEST_F(NonMutatingTest, SearchN) { absl::c_search_n(sequence_, 3, 1); }\n\nTEST_F(NonMutatingTest, SearchNWithPredicate) {\n absl::c_search_n(sequence_, 3, 1, BinPredicate);\n}\n\nTEST_F(NonMutatingTest, LowerBound) {\n std::list::iterator i = absl::c_lower_bound(sequence_, 3);\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(2, std::distance(sequence_.begin(), i));\n EXPECT_EQ(3, *i);\n}\n\nTEST_F(NonMutatingTest, LowerBoundWithPredicate) {\n std::vector v(vector_);\n std::sort(v.begin(), v.end(), std::greater());\n std::vector::iterator i = absl::c_lower_bound(v, 3, std::greater());\n EXPECT_TRUE(i == v.begin());\n EXPECT_EQ(3, *i);\n}\n\nTEST_F(NonMutatingTest, UpperBound) {\n std::list::iterator i = absl::c_upper_bound(sequence_, 1);\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(1, std::distance(sequence_.begin(), i));\n EXPECT_EQ(2, *i);\n}\n\nTEST_F(NonMutatingTest, UpperBoundWithPredicate) {\n std::vector v(vector_);\n std::sort(v.begin(), v.end(), std::greater());\n std::vector::iterator i = absl::c_upper_bound(v, 1, std::greater());\n EXPECT_EQ(3, i - v.begin());\n EXPECT_TRUE(i == v.end());\n}\n\nTEST_F(NonMutatingTest, EqualRange) {\n std::pair::iterator, std::list::iterator> p =\n absl::c_equal_range(sequence_, 2);\n EXPECT_EQ(1, std::distance(sequence_.begin(), p.first));\n EXPECT_EQ(2, std::distance(sequence_.begin(), p.second));\n}\n\nTEST_F(NonMutatingTest, EqualRangeArray) {\n auto p = absl::c_equal_range(array_, 2);\n EXPECT_EQ(1, std::distance(std::begin(array_), p.first));\n EXPECT_EQ(2, std::distance(std::begin(array_), p.second));\n}\n\nTEST_F(NonMutatingTest, EqualRangeWithPredicate) {\n std::vector v(vector_);\n std::sort(v.begin(), v.end(), std::greater());\n std::pair::iterator, std::vector::iterator> p =\n absl::c_equal_range(v, 2, std::greater());\n EXPECT_EQ(1, std::distance(v.begin(), p.first));\n EXPECT_EQ(2, std::distance(v.begin(), p.second));\n}\n\nTEST_F(NonMutatingTest, BinarySearch) {\n EXPECT_TRUE(absl::c_binary_search(vector_, 2));\n EXPECT_TRUE(absl::c_binary_search(std::vector(vector_), 2));\n}\n\nTEST_F(NonMutatingTest, BinarySearchWithPredicate) {\n std::vector v(vector_);\n std::sort(v.begin(), v.end(), std::greater());\n EXPECT_TRUE(absl::c_binary_search(v, 2, std::greater()));\n EXPECT_TRUE(\n absl::c_binary_search(std::vector(v), 2, std::greater()));\n}\n\nTEST_F(NonMutatingTest, MinElement) {\n std::list::iterator i = absl::c_min_element(sequence_);\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(*i, 1);\n}\n\nTEST_F(NonMutatingTest, MinElementWithPredicate) {\n std::list::iterator i =\n absl::c_min_element(sequence_, std::greater());\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(*i, 3);\n}\n\nTEST_F(NonMutatingTest, MaxElement) {\n std::list::iterator i = absl::c_max_element(sequence_);\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(*i, 3);\n}\n\nTEST_F(NonMutatingTest, MaxElementWithPredicate) {\n std::list::iterator i =\n absl::c_max_element(sequence_, std::greater());\n ASSERT_TRUE(i != sequence_.end());\n EXPECT_EQ(*i, 1);\n}\n\nTEST_F(NonMutatingTest, LexicographicalCompare) {\n EXPECT_FALSE(absl::c_lexicographical_compare(sequence_, sequence_));\n\n std::vector v;\n v.push_back(1);\n v.push_back(2);\n v.push_back(4);\n\n EXPECT_TRUE(absl::c_lexicographical_compare(sequence_, v));\n EXPECT_TRUE(absl::c_lexicographical_compare(std::list(sequence_), v));\n}\n\nTEST_F(NonMutatingTest, LexicographicalCopmareWithPredicate) {\n EXPECT_FALSE(absl::c_lexicographical_compare(sequence_, sequence_,\n std::greater()));\n\n std::vector v;\n v.push_back(1);\n v.push_back(2);\n v.push_back(4);\n\n EXPECT_TRUE(\n absl::c_lexicographical_compare(v, sequence_, std::greater()));\n EXPECT_TRUE(absl::c_lexicographical_compare(\n std::vector(v), std::list(sequence_), std::greater()));\n}\n\nTEST_F(NonMutatingTest, Includes) {\n std::set s(vector_.begin(), vector_.end());\n s.insert(4);\n EXPECT_TRUE(absl::c_includes(s, vector_));\n}\n\nTEST_F(NonMutatingTest, IncludesWithPredicate) {\n std::vector v = {3, 2, 1};\n std::set> s(v.begin(), v.end());\n s.insert(4);\n EXPECT_TRUE(absl::c_includes(s, v, std::greater()));\n}\n\nclass NumericMutatingTest : public testing::Test {\n protected:\n std::list list_ = {1, 2, 3};\n std::vector output_;\n};\n\nTEST_F(NumericMutatingTest, Iota) {\n absl::c_iota(list_, 5);\n std::list expected{5, 6, 7};\n EXPECT_EQ(list_, expected);\n}\n\nTEST_F(NonMutatingTest, Accumulate) {\n EXPECT_EQ(absl::c_accumulate(sequence_, 4), 1 + 2 + 3 + 4);\n}\n\nTEST_F(NonMutatingTest, AccumulateWithBinaryOp) {\n EXPECT_EQ(absl::c_accumulate(sequence_, 4, std::multiplies()),\n 1 * 2 * 3 * 4);\n}\n\nTEST_F(NonMutatingTest, AccumulateLvalueInit) {\n int lvalue = 4;\n EXPECT_EQ(absl::c_accumulate(sequence_, lvalue), 1 + 2 + 3 + 4);\n}\n\nTEST_F(NonMutatingTest, AccumulateWithBinaryOpLvalueInit) {\n int lvalue = 4;\n EXPECT_EQ(absl::c_accumulate(sequence_, lvalue, std::multiplies()),\n 1 * 2 * 3 * 4);\n}\n\nTEST_F(NonMutatingTest, InnerProduct) {\n EXPECT_EQ(absl::c_inner_product(sequence_, vector_, 1000),\n 1000 + 1 * 1 + 2 * 2 + 3 * 3);\n}\n\nTEST_F(NonMutatingTest, InnerProductWithBinaryOps) {\n EXPECT_EQ(absl::c_inner_product(sequence_, vector_, 10,\n std::multiplies(), std::plus()),\n 10 * (1 + 1) * (2 + 2) * (3 + 3));\n}\n\nTEST_F(NonMutatingTest, InnerProductLvalueInit) {\n int lvalue = 1000;\n EXPECT_EQ(absl::c_inner_product(sequence_, vector_, lvalue),\n 1000 + 1 * 1 + 2 * 2 + 3 * 3);\n}\n\nTEST_F(NonMutatingTest, InnerProductWithBinaryOpsLvalueInit) {\n int lvalue = 10;\n EXPECT_EQ(absl::c_inner_product(sequence_, vector_, lvalue,\n std::multiplies(), std::plus()),\n 10 * (1 + 1) * (2 + 2) * (3 + 3));\n}\n\nTEST_F(NumericMutatingTest, AdjacentDifference) {\n auto last = absl::c_adjacent_difference(list_, std::back_inserter(output_));\n *last = 1000;\n std::vector expected{1, 2 - 1, 3 - 2, 1000};\n EXPECT_EQ(output_, expected);\n}\n\nTEST_F(NumericMutatingTest, AdjacentDifferenceWithBinaryOp) {\n auto last = absl::c_adjacent_difference(list_, std::back_inserter(output_),\n std::multiplies());\n *last = 1000;\n std::vector expected{1, 2 * 1, 3 * 2, 1000};\n EXPECT_EQ(output_, expected);\n}\n\nTEST_F(NumericMutatingTest, PartialSum) {\n auto last = absl::c_partial_sum(list_, std::back_inserter(output_));\n *last = 1000;\n std::vector expected{1, 1 + 2, 1 + 2 + 3, 1000};\n EXPECT_EQ(output_, expected);\n}\n\nTEST_F(NumericMutatingTest, PartialSumWithBinaryOp) {\n auto last = absl::c_partial_sum(list_, std::back_inserter(output_),\n std::multiplies());\n *last = 1000;\n std::vector expected{1, 1 * 2, 1 * 2 * 3, 1000};\n EXPECT_EQ(output_, expected);\n}\n\nTEST_F(NonMutatingTest, LinearSearch) {\n EXPECT_TRUE(absl::c_linear_search(container_, 3));\n EXPECT_FALSE(absl::c_linear_search(container_, 4));\n}\n\nTEST_F(NonMutatingTest, AllOf) {\n const std::vector& v = vector_;\n EXPECT_FALSE(absl::c_all_of(v, [](int x) { return x > 1; }));\n EXPECT_TRUE(absl::c_all_of(v, [](int x) { return x > 0; }));\n}\n\nTEST_F(NonMutatingTest, AnyOf) {\n const std::vector& v = vector_;\n EXPECT_TRUE(absl::c_any_of(v, [](int x) { return x > 2; }));\n EXPECT_FALSE(absl::c_any_of(v, [](int x) { return x > 5; }));\n}\n\nTEST_F(NonMutatingTest, NoneOf) {\n const std::vector& v = vector_;\n EXPECT_FALSE(absl::c_none_of(v, [](int x) { return x > 2; }));\n EXPECT_TRUE(absl::c_none_of(v, [](int x) { return x > 5; }));\n}\n\nTEST_F(NonMutatingTest, MinMaxElementLess) {\n std::pair::const_iterator, std::vector::const_iterator>\n p = absl::c_minmax_element(vector_, std::less());\n EXPECT_TRUE(p.first == vector_.begin());\n EXPECT_TRUE(p.second == vector_.begin() + 2);\n}\n\nTEST_F(NonMutatingTest, MinMaxElementGreater) {\n std::pair::const_iterator, std::vector::const_iterator>\n p = absl::c_minmax_element(vector_, std::greater());\n EXPECT_TRUE(p.first == vector_.begin() + 2);\n EXPECT_TRUE(p.second == vector_.begin());\n}\n\nTEST_F(NonMutatingTest, MinMaxElementNoPredicate) {\n std::pair::const_iterator, std::vector::const_iterator>\n p = absl::c_minmax_element(vector_);\n EXPECT_TRUE(p.first == vector_.begin());\n EXPECT_TRUE(p.second == vector_.begin() + 2);\n}\n\nclass SortingTest : public testing::Test {\n protected:\n std::list sorted_ = {1, 2, 3, 4};\n std::list unsorted_ = {2, 4, 1, 3};\n std::list reversed_ = {4, 3, 2, 1};\n};\n\nTEST_F(SortingTest, IsSorted) {\n EXPECT_TRUE(absl::c_is_sorted(sorted_));\n EXPECT_FALSE(absl::c_is_sorted(unsorted_));\n EXPECT_FALSE(absl::c_is_sorted(reversed_));\n}\n\nTEST_F(SortingTest, IsSortedWithPredicate) {\n EXPECT_FALSE(absl::c_is_sorted(sorted_, std::greater()));\n EXPECT_FALSE(absl::c_is_sorted(unsorted_, std::greater()));\n EXPECT_TRUE(absl::c_is_sorted(reversed_, std::greater()));\n}\n\nTEST_F(SortingTest, IsSortedUntil) {\n EXPECT_EQ(1, *absl::c_is_sorted_until(unsorted_));\n EXPECT_EQ(4, *absl::c_is_sorted_until(unsorted_, std::greater()));\n}\n\nTEST_F(SortingTest, NthElement) {\n std::vector unsorted = {2, 4, 1, 3};\n absl::c_nth_element(unsorted, unsorted.begin() + 2);\n EXPECT_THAT(unsorted, ElementsAre(Lt(3), Lt(3), 3, Gt(3)));\n absl::c_nth_element(unsorted, unsorted.begin() + 2, std::greater());\n EXPECT_THAT(unsorted, ElementsAre(Gt(2), Gt(2), 2, Lt(2)));\n}\n\nTEST(MutatingTest, IsPartitioned) {\n EXPECT_TRUE(\n absl::c_is_partitioned(std::vector{1, 3, 5, 2, 4, 6}, IsOdd));\n EXPECT_FALSE(\n absl::c_is_partitioned(std::vector{1, 2, 3, 4, 5, 6}, IsOdd));\n EXPECT_FALSE(\n absl::c_is_partitioned(std::vector{2, 4, 6, 1, 3, 5}, IsOdd));\n}\n\nTEST(MutatingTest, Partition) {\n std::vector actual = {1, 2, 3, 4, 5};\n absl::c_partition(actual, IsOdd);\n EXPECT_THAT(actual, Truly([](const std::vector& c) {\n return absl::c_is_partitioned(c, IsOdd);\n }));\n}\n\nTEST(MutatingTest, StablePartition) {\n std::vector actual = {1, 2, 3, 4, 5};\n absl::c_stable_partition(actual, IsOdd);\n EXPECT_THAT(actual, ElementsAre(1, 3, 5, 2, 4));\n}\n\nTEST(MutatingTest, PartitionCopy) {\n const std::vector initial = {1, 2, 3, 4, 5};\n std::vector odds, evens;\n auto ends = absl::c_partition_copy(initial, back_inserter(odds),\n back_inserter(evens), IsOdd);\n *ends.first = 7;\n *ends.second = 6;\n EXPECT_THAT(odds, ElementsAre(1, 3, 5, 7));\n EXPECT_THAT(evens, ElementsAre(2, 4, 6));\n}\n\nTEST(MutatingTest, PartitionPoint) {\n const std::vector initial = {1, 3, 5, 2, 4};\n auto middle = absl::c_partition_point(initial, IsOdd);\n EXPECT_EQ(2, *middle);\n}\n\nTEST(MutatingTest, CopyMiddle) {\n const std::vector initial = {4, -1, -2, -3, 5};\n const std::list input = {1, 2, 3};\n const std::vector expected = {4, 1, 2, 3, 5};\n\n std::list test_list(initial.begin(), initial.end());\n absl::c_copy(input, ++test_list.begin());\n EXPECT_EQ(std::list(expected.begin(), expected.end()), test_list);\n\n std::vector test_vector = initial;\n absl::c_copy(input, test_vector.begin() + 1);\n EXPECT_EQ(expected, test_vector);\n}\n\nTEST(MutatingTest, CopyFrontInserter) {\n const std::list initial = {4, 5};\n const std::list input = {1, 2, 3};\n const std::list expected = {3, 2, 1, 4, 5};\n\n std::list test_list = initial;\n absl::c_copy(input, std::front_inserter(test_list));\n EXPECT_EQ(expected, test_list);\n}\n\nTEST(MutatingTest, CopyBackInserter) {\n const std::vector initial = {4, 5};\n const std::list input = {1, 2, 3};\n const std::vector expected = {4, 5, 1, 2, 3};\n\n std::list test_list(initial.begin(), initial.end());\n absl::c_copy(input, std::back_inserter(test_list));\n EXPECT_EQ(std::list(expected.begin(), expected.end()), test_list);\n\n std::vector test_vector = initial;\n absl::c_copy(input, std::back_inserter(test_vector));\n EXPECT_EQ(expected, test_vector);\n}\n\nTEST(MutatingTest, CopyN) {\n const std::vector initial = {1, 2, 3, 4, 5};\n const std::vector expected = {1, 2};\n std::vector actual;\n absl::c_copy_n(initial, 2, back_inserter(actual));\n EXPECT_EQ(expected, actual);\n}\n\nTEST(MutatingTest, CopyIf) {\n const std::list input = {1, 2, 3};\n std::vector output;\n absl::c_copy_if(input, std::back_inserter(output),\n [](int i) { return i != 2; });\n EXPECT_THAT(output, ElementsAre(1, 3));\n}\n\nTEST(MutatingTest, CopyBackward) {\n std::vector actual = {1, 2, 3, 4, 5};\n std::vector expected = {1, 2, 1, 2, 3};\n absl::c_copy_backward(absl::MakeSpan(actual.data(), 3), actual.end());\n EXPECT_EQ(expected, actual);\n}\n\nTEST(MutatingTest, Move) {\n std::vector> src;\n src.emplace_back(absl::make_unique(1));\n src.emplace_back(absl::make_unique(2));\n src.emplace_back(absl::make_unique(3));\n src.emplace_back(absl::make_unique(4));\n src.emplace_back(absl::make_unique(5));\n\n std::vector> dest = {};\n absl::c_move(src, std::back_inserter(dest));\n EXPECT_THAT(src, Each(IsNull()));\n EXPECT_THAT(dest, ElementsAre(Pointee(1), Pointee(2), Pointee(3), Pointee(4),\n Pointee(5)));\n}\n\nTEST(MutatingTest, MoveBackward) {\n std::vector> actual;\n actual.emplace_back(absl::make_unique(1));\n actual.emplace_back(absl::make_unique(2));\n actual.emplace_back(absl::make_unique(3));\n actual.emplace_back(absl::make_unique(4));\n actual.emplace_back(absl::make_unique(5));\n auto subrange = absl::MakeSpan(actual.data(), 3);\n absl::c_move_backward(subrange, actual.end());\n EXPECT_THAT(actual, ElementsAre(IsNull(), IsNull(), Pointee(1), Pointee(2),\n Pointee(3)));\n}\n\nTEST(MutatingTest, MoveWithRvalue) {\n auto MakeRValueSrc = [] {\n std::vector> src;\n src.emplace_back(absl::make_unique(1));\n src.emplace_back(absl::make_unique(2));\n src.emplace_back(absl::make_unique(3));\n return src;\n };\n\n std::vector> dest = MakeRValueSrc();\n absl::c_move(MakeRValueSrc(), std::back_inserter(dest));\n EXPECT_THAT(dest, ElementsAre(Pointee(1), Pointee(2), Pointee(3), Pointee(1),\n Pointee(2), Pointee(3)));\n}\n\nTEST(MutatingTest, SwapRanges) {\n std::vector odds = {2, 4, 6};\n std::vector evens = {1, 3, 5};\n absl::c_swap_ranges(odds, evens);\n EXPECT_THAT(odds, ElementsAre(1, 3, 5));\n EXPECT_THAT(evens, ElementsAre(2, 4, 6));\n\n odds.pop_back();\n absl::c_swap_ranges(odds, evens);\n EXPECT_THAT(odds, ElementsAre(2, 4));\n EXPECT_THAT(evens, ElementsAre(1, 3, 6));\n\n absl::c_swap_ranges(evens, odds);\n EXPECT_THAT(odds, ElementsAre(1, 3));\n EXPECT_THAT(evens, ElementsAre(2, 4, 6));\n}\n\nTEST_F(NonMutatingTest, Transform) {\n std::vector x{0, 2, 4}, y, z;\n auto end = absl::c_transform(x, back_inserter(y), std::negate());\n EXPECT_EQ(std::vector({0, -2, -4}), y);\n *end = 7;\n EXPECT_EQ(std::vector({0, -2, -4, 7}), y);\n\n y = {1, 3, 0};\n end = absl::c_transform(x, y, back_inserter(z), std::plus());\n EXPECT_EQ(std::vector({1, 5, 4}), z);\n *end = 7;\n EXPECT_EQ(std::vector({1, 5, 4, 7}), z);\n\n z.clear();\n y.pop_back();\n end = absl::c_transform(x, y, std::back_inserter(z), std::plus());\n EXPECT_EQ(std::vector({1, 5}), z);\n *end = 7;\n EXPECT_EQ(std::vector({1, 5, 7}), z);\n\n z.clear();\n std::swap(x, y);\n end = absl::c_transform(x, y, std::back_inserter(z), std::plus());\n EXPECT_EQ(std::vector({1, 5}), z);\n *end = 7;\n EXPECT_EQ(std::vector({1, 5, 7}), z);\n}\n\nTEST(MutatingTest, Replace) {\n const std::vector initial = {1, 2, 3, 1, 4, 5};\n const std::vector expected = {4, 2, 3, 4, 4, 5};\n\n std::vector test_vector = initial;\n absl::c_replace(test_vector, 1, 4);\n EXPECT_EQ(expected, test_vector);\n\n std::list test_list(initial.begin(), initial.end());\n absl::c_replace(test_list, 1, 4);\n EXPECT_EQ(std::list(expected.begin(), expected.end()), test_list);\n}\n\nTEST(MutatingTest, ReplaceIf) {\n std::vector actual = {1, 2, 3, 4, 5};\n const std::vector expected = {0, 2, 0, 4, 0};\n\n absl::c_replace_if(actual, IsOdd, 0);\n EXPECT_EQ(expected, actual);\n}\n\nTEST(MutatingTest, ReplaceCopy) {\n const std::vector initial = {1, 2, 3, 1, 4, 5};\n const std::vector expected = {4, 2, 3, 4, 4, 5};\n\n std::vector actual;\n absl::c_replace_copy(initial, back_inserter(actual), 1, 4);\n EXPECT_EQ(expected, actual);\n}\n\nTEST(MutatingTest, Sort) {\n std::vector test_vector = {2, 3, 1, 4};\n absl::c_sort(test_vector);\n EXPECT_THAT(test_vector, ElementsAre(1, 2, 3, 4));\n}\n\nTEST(MutatingTest, SortWithPredicate) {\n std::vector test_vector = {2, 3, 1, 4};\n absl::c_sort(test_vector, std::greater());\n EXPECT_THAT(test_vector, ElementsAre(4, 3, 2, 1));\n}\n\n// For absl::c_stable_sort tests. Needs an operator< that does not cover all\n// fields so that the test can check the sort preserves order of equal elements.\nstruct Element {\n int key;\n int value;\n friend bool operator<(const Element& e1, const Element& e2) {\n return e1.key < e2.key;\n }\n // Make gmock print useful diagnostics.\n friend std::ostream& operator<<(std::ostream& o, const Element& e) {\n return o << \"{\" << e.key << \", \" << e.value << \"}\";\n }\n};\n\nMATCHER_P2(IsElement, key, value, \"\") {\n return arg.key == key && arg.value == value;\n}\n\nTEST(MutatingTest, StableSort) {\n std::vector test_vector = {{1, 1}, {2, 1}, {2, 0}, {1, 0}, {2, 2}};\n absl::c_stable_sort(test_vector);\n EXPECT_THAT(test_vector,\n ElementsAre(IsElement(1, 1), IsElement(1, 0), IsElement(2, 1),\n IsElement(2, 0), IsElement(2, 2)));\n}\n\nTEST(MutatingTest, StableSortWithPredicate) {\n std::vector test_vector = {{1, 1}, {2, 1}, {2, 0}, {1, 0}, {2, 2}};\n absl::c_stable_sort(test_vector, [](const Element& e1, const Element& e2) {\n return e2 < e1;\n });\n EXPECT_THAT(test_vector,\n ElementsAre(IsElement(2, 1), IsElement(2, 0), IsElement(2, 2),\n IsElement(1, 1), IsElement(1, 0)));\n}\n\nTEST(MutatingTest, ReplaceCopyIf) {\n const std::vector initial = {1, 2, 3, 4, 5};\n const std::vector expected = {0, 2, 0, 4, 0};\n\n std::vector actual;\n absl::c_replace_copy_if(initial, back_inserter(actual), IsOdd, 0);\n EXPECT_EQ(expected, actual);\n}\n\nTEST(MutatingTest, Fill) {\n std::vector actual(5);\n absl::c_fill(actual, 1);\n EXPECT_THAT(actual, ElementsAre(1, 1, 1, 1, 1));\n}\n\nTEST(MutatingTest, FillN) {\n std::vector actual(5, 0);\n absl::c_fill_n(actual, 2, 1);\n EXPECT_THAT(actual, ElementsAre(1, 1, 0, 0, 0));\n}\n\nTEST(MutatingTest, Generate) {\n std::vector actual(5);\n int x = 0;\n absl::c_generate(actual, [&x]() { return ++x; });\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));\n}\n\nTEST(MutatingTest, GenerateN) {\n std::vector actual(5, 0);\n int x = 0;\n absl::c_generate_n(actual, 3, [&x]() { return ++x; });\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 0, 0));\n}\n\nTEST(MutatingTest, RemoveCopy) {\n std::vector actual;\n absl::c_remove_copy(std::vector{1, 2, 3}, back_inserter(actual), 2);\n EXPECT_THAT(actual, ElementsAre(1, 3));\n}\n\nTEST(MutatingTest, RemoveCopyIf) {\n std::vector actual;\n absl::c_remove_copy_if(std::vector{1, 2, 3}, back_inserter(actual),\n IsOdd);\n EXPECT_THAT(actual, ElementsAre(2));\n}\n\nTEST(MutatingTest, UniqueCopy) {\n std::vector actual;\n absl::c_unique_copy(std::vector{1, 2, 2, 2, 3, 3, 2},\n back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 2));\n}\n\nTEST(MutatingTest, UniqueCopyWithPredicate) {\n std::vector actual;\n absl::c_unique_copy(std::vector{1, 2, 3, -1, -2, -3, 1},\n back_inserter(actual),\n [](int x, int y) { return (x < 0) == (y < 0); });\n EXPECT_THAT(actual, ElementsAre(1, -1, 1));\n}\n\nTEST(MutatingTest, Reverse) {\n std::vector test_vector = {1, 2, 3, 4};\n absl::c_reverse(test_vector);\n EXPECT_THAT(test_vector, ElementsAre(4, 3, 2, 1));\n\n std::list test_list = {1, 2, 3, 4};\n absl::c_reverse(test_list);\n EXPECT_THAT(test_list, ElementsAre(4, 3, 2, 1));\n}\n\nTEST(MutatingTest, ReverseCopy) {\n std::vector actual;\n absl::c_reverse_copy(std::vector{1, 2, 3, 4}, back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(4, 3, 2, 1));\n}\n\nTEST(MutatingTest, Rotate) {\n std::vector actual = {1, 2, 3, 4};\n auto it = absl::c_rotate(actual, actual.begin() + 2);\n EXPECT_THAT(actual, testing::ElementsAreArray({3, 4, 1, 2}));\n EXPECT_EQ(*it, 1);\n}\n\nTEST(MutatingTest, RotateCopy) {\n std::vector initial = {1, 2, 3, 4};\n std::vector actual;\n auto end =\n absl::c_rotate_copy(initial, initial.begin() + 2, back_inserter(actual));\n *end = 5;\n EXPECT_THAT(actual, ElementsAre(3, 4, 1, 2, 5));\n}\n\nTEST(MutatingTest, Shuffle) {\n std::vector actual = {1, 2, 3, 4, 5};\n absl::c_shuffle(actual, absl::InsecureBitGen());\n EXPECT_THAT(actual, UnorderedElementsAre(1, 2, 3, 4, 5));\n}\n\nTEST(MutatingTest, Sample) {\n std::vector actual;\n absl::c_sample(std::vector{1, 2, 3, 4, 5}, std::back_inserter(actual), 3,\n absl::InsecureBitGen());\n EXPECT_THAT(actual, IsSubsetOf({1, 2, 3, 4, 5}));\n EXPECT_THAT(actual, SizeIs(3));\n}\n\nTEST(MutatingTest, PartialSort) {\n std::vector sequence{5, 3, 42, 0};\n absl::c_partial_sort(sequence, sequence.begin() + 2);\n EXPECT_THAT(absl::MakeSpan(sequence.data(), 2), ElementsAre(0, 3));\n absl::c_partial_sort(sequence, sequence.begin() + 2, std::greater());\n EXPECT_THAT(absl::MakeSpan(sequence.data(), 2), ElementsAre(42, 5));\n}\n\nTEST(MutatingTest, PartialSortCopy) {\n const std::vector initial = {5, 3, 42, 0};\n std::vector actual(2);\n absl::c_partial_sort_copy(initial, actual);\n EXPECT_THAT(actual, ElementsAre(0, 3));\n absl::c_partial_sort_copy(initial, actual, std::greater());\n EXPECT_THAT(actual, ElementsAre(42, 5));\n}\n\nTEST(MutatingTest, Merge) {\n std::vector actual;\n absl::c_merge(std::vector{1, 3, 5}, std::vector{2, 4},\n back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));\n}\n\nTEST(MutatingTest, MergeWithComparator) {\n std::vector actual;\n absl::c_merge(std::vector{5, 3, 1}, std::vector{4, 2},\n back_inserter(actual), std::greater());\n EXPECT_THAT(actual, ElementsAre(5, 4, 3, 2, 1));\n}\n\nTEST(MutatingTest, InplaceMerge) {\n std::vector actual = {1, 3, 5, 2, 4};\n absl::c_inplace_merge(actual, actual.begin() + 3);\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));\n}\n\nTEST(MutatingTest, InplaceMergeWithComparator) {\n std::vector actual = {5, 3, 1, 4, 2};\n absl::c_inplace_merge(actual, actual.begin() + 3, std::greater());\n EXPECT_THAT(actual, ElementsAre(5, 4, 3, 2, 1));\n}\n\nclass SetOperationsTest : public testing::Test {\n protected:\n std::vector a_ = {1, 2, 3};\n std::vector b_ = {1, 3, 5};\n\n std::vector a_reversed_ = {3, 2, 1};\n std::vector b_reversed_ = {5, 3, 1};\n};\n\nTEST_F(SetOperationsTest, SetUnion) {\n std::vector actual;\n absl::c_set_union(a_, b_, back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(1, 2, 3, 5));\n}\n\nTEST_F(SetOperationsTest, SetUnionWithComparator) {\n std::vector actual;\n absl::c_set_union(a_reversed_, b_reversed_, back_inserter(actual),\n std::greater());\n EXPECT_THAT(actual, ElementsAre(5, 3, 2, 1));\n}\n\nTEST_F(SetOperationsTest, SetIntersection) {\n std::vector actual;\n absl::c_set_intersection(a_, b_, back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(1, 3));\n}\n\nTEST_F(SetOperationsTest, SetIntersectionWithComparator) {\n std::vector actual;\n absl::c_set_intersection(a_reversed_, b_reversed_, back_inserter(actual),\n std::greater());\n EXPECT_THAT(actual, ElementsAre(3, 1));\n}\n\nTEST_F(SetOperationsTest, SetDifference) {\n std::vector actual;\n absl::c_set_difference(a_, b_, back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(2));\n}\n\nTEST_F(SetOperationsTest, SetDifferenceWithComparator) {\n std::vector actual;\n absl::c_set_difference(a_reversed_, b_reversed_, back_inserter(actual),\n std::greater());\n EXPECT_THAT(actual, ElementsAre(2));\n}\n\nTEST_F(SetOperationsTest, SetSymmetricDifference) {\n std::vector actual;\n absl::c_set_symmetric_difference(a_, b_, back_inserter(actual));\n EXPECT_THAT(actual, ElementsAre(2, 5));\n}\n\nTEST_F(SetOperationsTest, SetSymmetricDifferenceWithComparator) {\n std::vector actual;\n absl::c_set_symmetric_difference(a_reversed_, b_reversed_,\n back_inserter(actual), std::greater());\n EXPECT_THAT(actual, ElementsAre(5, 2));\n}\n\nTEST(HeapOperationsTest, WithoutComparator) {\n std::vector heap = {1, 2, 3};\n EXPECT_FALSE(absl::c_is_heap(heap));\n absl::c_make_heap(heap);\n EXPECT_TRUE(absl::c_is_heap(heap));\n heap.push_back(4);\n EXPECT_EQ(3, absl::c_is_heap_until(heap) - heap.begin());\n absl::c_push_heap(heap);\n EXPECT_EQ(4, heap[0]);\n absl::c_pop_heap(heap);\n EXPECT_EQ(4, heap[3]);\n absl::c_make_heap(heap);\n absl::c_sort_heap(heap);\n EXPECT_THAT(heap, ElementsAre(1, 2, 3, 4));\n EXPECT_FALSE(absl::c_is_heap(heap));\n}\n\nTEST(HeapOperationsTest, WithComparator) {\n using greater = std::greater;\n std::vector heap = {3, 2, 1};\n EXPECT_FALSE(absl::c_is_heap(heap, greater()));\n absl::c_make_heap(heap, greater());\n EXPECT_TRUE(absl::c_is_heap(heap, greater()));\n heap.push_back(0);\n EXPECT_EQ(3, absl::c_is_heap_until(heap, greater()) - heap.begin());\n absl::c_push_heap(heap, greater());\n EXPECT_EQ(0, heap[0]);\n absl::c_pop_heap(heap, greater());\n EXPECT_EQ(0, heap[3]);\n absl::c_make_heap(heap, greater());\n absl::c_sort_heap(heap, greater());\n EXPECT_THAT(heap, ElementsAre(3, 2, 1, 0));\n EXPECT_FALSE(absl::c_is_heap(heap, greater()));\n}\n\nTEST(MutatingTest, PermutationOperations) {\n std::vector initial = {1, 2, 3, 4};\n std::vector permuted = initial;\n\n absl::c_next_permutation(permuted);\n EXPECT_TRUE(absl::c_is_permutation(initial, permuted));\n EXPECT_TRUE(absl::c_is_permutation(initial, permuted, std::equal_to()));\n\n std::vector permuted2 = initial;\n absl::c_prev_permutation(permuted2, std::greater());\n EXPECT_EQ(permuted, permuted2);\n\n absl::c_prev_permutation(permuted);\n EXPECT_EQ(initial, permuted);\n}\n\n#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \\\n ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L\n\nTEST(ConstexprTest, Distance) {\n // Works at compile time with constexpr containers.\n static_assert(absl::c_distance(std::array()) == 3);\n}\n\nTEST(ConstexprTest, MinElement) {\n constexpr std::array kArray = {1, 2, 3};\n static_assert(*absl::c_min_element(kArray) == 1);\n}\n\nTEST(ConstexprTest, MinElementWithPredicate) {\n constexpr std::array kArray = {1, 2, 3};\n static_assert(*absl::c_min_element(kArray, std::greater()) == 3);\n}\n\nTEST(ConstexprTest, MaxElement) {\n constexpr std::array kArray = {1, 2, 3};\n static_assert(*absl::c_max_element(kArray) == 3);\n}\n\nTEST(ConstexprTest, MaxElementWithPredicate) {\n constexpr std::array kArray = {1, 2, 3};\n static_assert(*absl::c_max_element(kArray, std::greater()) == 1);\n}\n\nTEST(ConstexprTest, MinMaxElement) {\n static constexpr std::array kArray = {1, 2, 3};\n constexpr auto kMinMaxPair = absl::c_minmax_element(kArray);\n static_assert(*kMinMaxPair.first == 1);\n static_assert(*kMinMaxPair.second == 3);\n}\n\nTEST(ConstexprTest, MinMaxElementWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3};\n constexpr auto kMinMaxPair =\n absl::c_minmax_element(kArray, std::greater());\n static_assert(*kMinMaxPair.first == 3);\n static_assert(*kMinMaxPair.second == 1);\n}\n#endif // defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&\n // ABSL_INTERNAL_CPLUSPLUS_LANG >= 201703L\n\n#if defined(ABSL_INTERNAL_CPLUSPLUS_LANG) && \\\n ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L\n\nTEST(ConstexprTest, LinearSearch) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_linear_search(kArray, 3));\n static_assert(!absl::c_linear_search(kArray, 4));\n}\n\nTEST(ConstexprTest, AllOf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(!absl::c_all_of(kArray, [](int x) { return x > 1; }));\n static_assert(absl::c_all_of(kArray, [](int x) { return x > 0; }));\n}\n\nTEST(ConstexprTest, AnyOf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_any_of(kArray, [](int x) { return x > 2; }));\n static_assert(!absl::c_any_of(kArray, [](int x) { return x > 5; }));\n}\n\nTEST(ConstexprTest, NoneOf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(!absl::c_none_of(kArray, [](int x) { return x > 2; }));\n static_assert(absl::c_none_of(kArray, [](int x) { return x > 5; }));\n}\n\nTEST(ConstexprTest, ForEach) {\n static constexpr std::array kArray = [] {\n std::array array = {1, 2, 3};\n absl::c_for_each(array, [](int& x) { x += 1; });\n return array;\n }();\n static_assert(kArray == std::array{2, 3, 4});\n}\n\nTEST(ConstexprTest, Find) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_find(kArray, 1) == kArray.begin());\n static_assert(absl::c_find(kArray, 4) == kArray.end());\n}\n\nTEST(ConstexprTest, Contains) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_contains(kArray, 1));\n static_assert(!absl::c_contains(kArray, 4));\n}\n\nTEST(ConstexprTest, FindIf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_find_if(kArray, [](int x) { return x > 2; }) ==\n kArray.begin() + 2);\n static_assert(absl::c_find_if(kArray, [](int x) { return x > 5; }) ==\n kArray.end());\n}\n\nTEST(ConstexprTest, FindIfNot) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_find_if_not(kArray, [](int x) { return x > 1; }) ==\n kArray.begin());\n static_assert(absl::c_find_if_not(kArray, [](int x) { return x > 0; }) ==\n kArray.end());\n}\n\nTEST(ConstexprTest, FindEnd) {\n static constexpr std::array kHaystack = {1, 2, 3, 2, 3};\n static constexpr std::array kNeedle = {2, 3};\n static_assert(absl::c_find_end(kHaystack, kNeedle) == kHaystack.begin() + 3);\n}\n\nTEST(ConstexprTest, FindFirstOf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_find_first_of(kArray, kArray) == kArray.begin());\n}\n\nTEST(ConstexprTest, AdjacentFind) {\n static constexpr std::array kArray = {1, 2, 2, 3};\n static_assert(absl::c_adjacent_find(kArray) == kArray.begin() + 1);\n}\n\nTEST(ConstexprTest, AdjacentFindWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_adjacent_find(kArray, std::less()) ==\n kArray.begin());\n}\n\nTEST(ConstexprTest, Count) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_count(kArray, 1) == 1);\n static_assert(absl::c_count(kArray, 2) == 1);\n static_assert(absl::c_count(kArray, 3) == 1);\n static_assert(absl::c_count(kArray, 4) == 0);\n}\n\nTEST(ConstexprTest, CountIf) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_count_if(kArray, [](int x) { return x > 0; }) == 3);\n static_assert(absl::c_count_if(kArray, [](int x) { return x > 1; }) == 2);\n}\n\nTEST(ConstexprTest, Mismatch) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_mismatch(kArray1, kArray2) ==\n std::pair{kArray1.end(), kArray2.end()});\n static_assert(absl::c_mismatch(kArray1, kArray3) ==\n std::pair{kArray1.begin(), kArray3.begin()});\n}\n\nTEST(ConstexprTest, MismatchWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_mismatch(kArray1, kArray2, std::not_equal_to()) ==\n std::pair{kArray1.begin(), kArray2.begin()});\n static_assert(absl::c_mismatch(kArray1, kArray3, std::not_equal_to()) ==\n std::pair{kArray1.end(), kArray3.end()});\n}\n\nTEST(ConstexprTest, Equal) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_equal(kArray1, kArray2));\n static_assert(!absl::c_equal(kArray1, kArray3));\n}\n\nTEST(ConstexprTest, EqualWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(!absl::c_equal(kArray1, kArray2, std::not_equal_to()));\n static_assert(absl::c_equal(kArray1, kArray3, std::not_equal_to()));\n}\n\nTEST(ConstexprTest, IsPermutation) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {3, 2, 1};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_is_permutation(kArray1, kArray2));\n static_assert(!absl::c_is_permutation(kArray1, kArray3));\n}\n\nTEST(ConstexprTest, IsPermutationWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {3, 2, 1};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_is_permutation(kArray1, kArray2, std::equal_to()));\n static_assert(\n !absl::c_is_permutation(kArray1, kArray3, std::equal_to()));\n}\n\nTEST(ConstexprTest, Search) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_search(kArray1, kArray2) == kArray1.begin());\n static_assert(absl::c_search(kArray1, kArray3) == kArray1.end());\n}\n\nTEST(ConstexprTest, SearchWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_search(kArray1, kArray2, std::not_equal_to()) ==\n kArray1.end());\n static_assert(absl::c_search(kArray1, kArray3, std::not_equal_to()) ==\n kArray1.begin());\n}\n\nTEST(ConstexprTest, ContainsSubrange) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(absl::c_contains_subrange(kArray1, kArray2));\n static_assert(!absl::c_contains_subrange(kArray1, kArray3));\n}\n\nTEST(ConstexprTest, ContainsSubrangeWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 3};\n static constexpr std::array kArray3 = {2, 3, 4};\n static_assert(\n !absl::c_contains_subrange(kArray1, kArray2, std::not_equal_to<>()));\n static_assert(\n absl::c_contains_subrange(kArray1, kArray3, std::not_equal_to<>()));\n}\n\nTEST(ConstexprTest, SearchN) {\n static constexpr std::array kArray = {1, 2, 2, 3};\n static_assert(absl::c_search_n(kArray, 1, 1) == kArray.begin());\n static_assert(absl::c_search_n(kArray, 2, 2) == kArray.begin() + 1);\n static_assert(absl::c_search_n(kArray, 1, 4) == kArray.end());\n}\n\nTEST(ConstexprTest, SearchNWithPredicate) {\n static constexpr std::array kArray = {1, 2, 2, 3};\n static_assert(absl::c_search_n(kArray, 1, 1, std::not_equal_to()) ==\n kArray.begin() + 1);\n static_assert(absl::c_search_n(kArray, 2, 2, std::not_equal_to()) ==\n kArray.end());\n static_assert(absl::c_search_n(kArray, 1, 4, std::not_equal_to()) ==\n kArray.begin());\n}\n\nTEST(ConstexprTest, Copy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayCopy = [] {\n std::array array;\n absl::c_copy(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayCopy == kArray);\n}\n\nTEST(ConstexprTest, CopyN) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayCopy = [] {\n std::array array;\n absl::c_copy_n(kArray, 2, array.begin());\n return array;\n }();\n static_assert(kArrayCopy == std::array{1, 2});\n}\n\nTEST(ConstexprTest, CopyIf) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr auto kArrayCopy = [] {\n std::array array;\n absl::c_copy_if(kArray, array.begin(), [](int x) { return x > 1; });\n return array;\n }();\n static_assert(kArrayCopy == std::array{2, 3, 4});\n}\n\nTEST(ConstexprTest, CopyBackward) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayCopy = [] {\n std::array array;\n absl::c_copy_backward(kArray, array.end());\n return array;\n }();\n static_assert(kArrayCopy == kArray);\n}\n\nTEST(ConstexprTest, Move) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayMove = [] {\n std::array array;\n absl::c_move(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayMove == kArray);\n}\n\nTEST(ConstexprTest, MoveBackward) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayMove = [] {\n std::array array;\n absl::c_move_backward(kArray, array.end());\n return array;\n }();\n static_assert(kArrayMove == kArray);\n}\n\nTEST(ConstexprTest, SwapRanges) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {4, 5, 6};\n\n static constexpr auto kSwapped = [] {\n std::array arr1 = kArray1;\n std::array arr2 = kArray2;\n absl::c_swap_ranges(arr1, arr2);\n return std::make_pair(arr1, arr2);\n }();\n\n static_assert(kSwapped.first == kArray2);\n static_assert(kSwapped.second == kArray1);\n}\n\nTEST(ConstexprTest, Transform) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayTransform = [] {\n std::array array;\n absl::c_transform(kArray, array.begin(), [](int x) { return x + 1; });\n return array;\n }();\n static_assert(kArrayTransform == std::array{2, 3, 4});\n}\n\nTEST(ConstexprTest, Replace) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReplace = [] {\n std::array array = kArray;\n absl::c_replace(array, 1, 4);\n return array;\n }();\n static_assert(kArrayReplace == std::array{4, 2, 3});\n}\n\nTEST(ConstexprTest, ReplaceIf) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReplaceIf = [] {\n std::array array = kArray;\n absl::c_replace_if(array, [](int x) { return x == 1; }, 4);\n return array;\n }();\n static_assert(kArrayReplaceIf == std::array{4, 2, 3});\n}\n\nTEST(ConstexprTest, ReplaceCopy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReplaceCopy = [] {\n std::array array;\n absl::c_replace_copy(kArray, array.begin(), 1, 4);\n return array;\n }();\n static_assert(kArrayReplaceCopy == std::array{4, 2, 3});\n}\n\nTEST(ConstexprTest, ReplaceCopyIf) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReplaceCopyIf = [] {\n std::array array;\n absl::c_replace_copy_if(\n kArray, array.begin(), [](int x) { return x == 1; }, 4);\n return array;\n }();\n static_assert(kArrayReplaceCopyIf == std::array{4, 2, 3});\n}\n\nTEST(ConstexprTest, Fill) {\n static constexpr auto kArrayFill = [] {\n std::array array;\n absl::c_fill(array, 4);\n return array;\n }();\n static_assert(kArrayFill == std::array{4, 4, 4});\n}\n\nTEST(ConstexprTest, FillN) {\n static constexpr auto kArrayFillN = [] {\n std::array array = {0, 0, 0};\n absl::c_fill_n(array, 2, 4);\n return array;\n }();\n static_assert(kArrayFillN == std::array{4, 4, 0});\n}\n\nTEST(ConstexprTest, Generate) {\n static constexpr auto kArrayGenerate = [] {\n std::array array;\n absl::c_generate(array, []() { return 4; });\n return array;\n }();\n static_assert(kArrayGenerate == std::array{4, 4, 4});\n}\n\nTEST(ConstexprTest, GenerateN) {\n static constexpr auto kArrayGenerateN = [] {\n std::array array = {0, 0, 0};\n absl::c_generate_n(array, 2, []() { return 4; });\n return array;\n }();\n static_assert(kArrayGenerateN == std::array{4, 4, 0});\n}\n\nTEST(ConstexprTest, RemoveCopy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayRemoveCopy = [] {\n std::array array;\n absl::c_remove_copy(kArray, array.begin(), 1);\n return array;\n }();\n static_assert(kArrayRemoveCopy == std::array{2, 3});\n}\n\nTEST(ConstexprTest, RemoveCopyIf) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayRemoveCopyIf = [] {\n std::array array;\n absl::c_remove_copy_if(kArray, array.begin(), [](int x) { return x == 1; });\n return array;\n }();\n static_assert(kArrayRemoveCopyIf == std::array{2, 3});\n}\n\nTEST(ConstexprTest, UniqueCopy) {\n static constexpr std::array kArray = {1, 2, 2, 3};\n static constexpr auto kArrayUniqueCopy = [] {\n std::array array;\n absl::c_unique_copy(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayUniqueCopy == std::array{1, 2, 3});\n}\n\nTEST(ConstexprTest, UniqueCopyWithPredicate) {\n static constexpr std::array kArray = {1, 2, 2, 3};\n static constexpr auto kArrayUniqueCopy = [] {\n std::array array;\n absl::c_unique_copy(kArray, array.begin(), std::equal_to<>());\n return array;\n }();\n static_assert(kArrayUniqueCopy == std::array{1, 2, 3});\n}\n\nTEST(ConstexprTest, Reverse) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReverse = [] {\n std::array array = kArray;\n absl::c_reverse(array);\n return array;\n }();\n static_assert(kArrayReverse == std::array{3, 2, 1});\n}\n\nTEST(ConstexprTest, ReverseCopy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayReverseCopy = [] {\n std::array array;\n absl::c_reverse_copy(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayReverseCopy == std::array{3, 2, 1});\n}\n\nTEST(ConstexprTest, Rotate) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayRotate = [] {\n std::array array = kArray;\n absl::c_rotate(array, array.begin() + 1);\n return array;\n }();\n static_assert(kArrayRotate == std::array{2, 3, 1});\n}\n\nTEST(ConstexprTest, RotateCopy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayRotateCopy = [] {\n std::array array;\n absl::c_rotate_copy(kArray, kArray.begin() + 1, array.begin());\n return array;\n }();\n static_assert(kArrayRotateCopy == std::array{2, 3, 1});\n}\n\nTEST(ConstexprTest, IsPartitioned) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(!absl::c_is_partitioned(kArray, [](int x) { return x > 1; }));\n\n static constexpr std::array kPartitionedArray = {2, 3, 1};\n static_assert(\n absl::c_is_partitioned(kPartitionedArray, [](int x) { return x > 1; }));\n}\n\nTEST(ConstexprTest, Partition) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayPartition = [] {\n std::array array = kArray;\n absl::c_partition(array, [](int x) { return x > 1; });\n return array;\n }();\n static_assert(\n absl::c_is_partitioned(kArrayPartition, [](int x) { return x > 1; }));\n}\n\nTEST(ConstexprTest, PartitionCopy) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kPartitioned = [] {\n std::array true_part;\n std::array false_part;\n absl::c_partition_copy(kArray, true_part.begin(), false_part.begin(),\n [](int x) { return x > 1; });\n return std::make_pair(true_part, false_part);\n }();\n static_assert(kPartitioned.first == std::array{2, 3});\n static_assert(kPartitioned.second == std::array{1});\n}\n\nTEST(ConstexprTest, PartitionPoint) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kPartitionPoint =\n absl::c_partition_point(kArray, [](int x) { return x > 1; });\n static_assert(kPartitionPoint == kArray.end());\n}\n\nTEST(ConstexprTest, Sort) {\n static constexpr std::array kArray = {2, 1, 3};\n static constexpr auto kArraySort = [] {\n std::array array = kArray;\n absl::c_sort(array);\n return array;\n }();\n static_assert(kArraySort == std::array{1, 2, 3});\n}\n\nTEST(ConstexprTest, SortWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArraySort = [] {\n std::array array = kArray;\n absl::c_sort(array, std::greater<>());\n return array;\n }();\n static_assert(kArraySort == std::array{3, 2, 1});\n}\n\nTEST(ConstexprTest, IsSorted) {\n static constexpr std::array kSortedArray = {1, 2, 3};\n static_assert(absl::c_is_sorted(kSortedArray));\n static constexpr std::array kUnsortedArray = {1, 3, 2};\n static_assert(!absl::c_is_sorted(kUnsortedArray));\n}\n\nTEST(ConstexprTest, IsSortedWithPredicate) {\n static constexpr std::array kSortedArray = {3, 2, 1};\n static_assert(absl::c_is_sorted(kSortedArray, std::greater<>()));\n static constexpr std::array kUnsortedArray = {1, 3, 2};\n static_assert(!absl::c_is_sorted(kUnsortedArray, std::greater<>()));\n}\n\nTEST(ConstexprTest, PartialSort) {\n static constexpr std::array kArray = {3, 1, 4, 2};\n static constexpr auto kArrayPartialSort = [] {\n std::array array = kArray;\n absl::c_partial_sort(array, array.begin() + 2);\n return array;\n }();\n static_assert(kArrayPartialSort[0] == 1);\n static_assert(kArrayPartialSort[1] == 2);\n}\n\nTEST(ConstexprTest, PartialSortWithPredicate) {\n static constexpr std::array kArray = {3, 1, 4, 2};\n static constexpr auto kArrayPartialSort = [] {\n std::array array = kArray;\n absl::c_partial_sort(array, array.begin() + 2, std::greater<>());\n return array;\n }();\n static_assert(kArrayPartialSort[0] == 4);\n static_assert(kArrayPartialSort[1] == 3);\n}\n\nTEST(ConstexprTest, PartialSortCopy) {\n static constexpr std::array kArray = {3, 1, 4, 2};\n static constexpr auto kArrayPartialSort = [] {\n std::array array;\n absl::c_partial_sort_copy(kArray, array);\n return array;\n }();\n static_assert(kArrayPartialSort[0] == 1);\n static_assert(kArrayPartialSort[1] == 2);\n}\n\nTEST(ConstexprTest, PartialSortCopyWithPredicate) {\n static constexpr std::array kArray = {3, 1, 4, 2};\n static constexpr auto kArrayPartialSort = [] {\n std::array array;\n absl::c_partial_sort_copy(kArray, array, std::greater<>());\n return array;\n }();\n static_assert(kArrayPartialSort[0] == 4);\n static_assert(kArrayPartialSort[1] == 3);\n}\n\nTEST(ConstexprTest, IsSortedUntil) {\n static constexpr std::array kSortedArray = {1, 2, 3};\n static_assert(absl::c_is_sorted_until(kSortedArray) == kSortedArray.end());\n static constexpr std::array kUnsortedArray = {1, 3, 2};\n static_assert(absl::c_is_sorted_until(kUnsortedArray) ==\n kUnsortedArray.begin() + 2);\n}\n\nTEST(ConstexprTest, IsSortedUntilWithPredicate) {\n static constexpr std::array kSortedArray = {3, 2, 1};\n static_assert(absl::c_is_sorted_until(kSortedArray, std::greater<>()) ==\n kSortedArray.end());\n static constexpr std::array kUnsortedArray = {1, 3, 2};\n static_assert(absl::c_is_sorted_until(kUnsortedArray, std::greater<>()) ==\n kUnsortedArray.begin() + 1);\n}\n\nTEST(ConstexprTest, NthElement) {\n static constexpr std::array kArray = {2, 1, 3, 4};\n static constexpr auto kArrayNthElement = [] {\n std::array array = kArray;\n absl::c_nth_element(array, array.begin() + 2);\n return array;\n }();\n static_assert(kArrayNthElement[2] == 3);\n static_assert(kArrayNthElement[0] <= kArrayNthElement[2]);\n static_assert(kArrayNthElement[1] <= kArrayNthElement[2]);\n static_assert(kArrayNthElement[3] >= kArrayNthElement[2]);\n}\n\nTEST(ConstexprTest, NthElementWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr auto kArrayNthElement = [] {\n std::array array = kArray;\n absl::c_nth_element(array, array.begin() + 2, std::greater<>());\n return array;\n }();\n static_assert(kArrayNthElement[2] == 2);\n static_assert(std::greater<>()(kArrayNthElement[0], kArrayNthElement[2]) ||\n kArrayNthElement[0] == kArrayNthElement[2]);\n static_assert(std::greater<>()(kArrayNthElement[1], kArrayNthElement[2]) ||\n kArrayNthElement[1] == kArrayNthElement[2]);\n static_assert(std::greater<>()(kArrayNthElement[2], kArrayNthElement[3]) ||\n kArrayNthElement[2] == kArrayNthElement[3]);\n}\n\nTEST(ConstexprTest, LowerBound) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr auto kLowerBound = absl::c_lower_bound(kArray, 2);\n static_assert(kLowerBound == kArray.begin() + 1);\n}\n\nTEST(ConstexprTest, LowerBoundWithPredicate) {\n static constexpr std::array kArray = {4, 3, 2, 1};\n static constexpr auto kLowerBound =\n absl::c_lower_bound(kArray, 2, std::greater<>());\n static_assert(kLowerBound == kArray.begin() + 2);\n}\n\nTEST(ConstexprTest, UpperBound) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr auto kUpperBound = absl::c_upper_bound(kArray, 2);\n static_assert(kUpperBound == kArray.begin() + 2);\n}\n\nTEST(ConstexprTest, UpperBoundWithPredicate) {\n static constexpr std::array kArray = {4, 3, 2, 1};\n static constexpr auto kUpperBound =\n absl::c_upper_bound(kArray, 2, std::greater<>());\n static_assert(kUpperBound == kArray.begin() + 3);\n}\n\nTEST(ConstexprTest, EqualRange) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr auto kEqualRange = absl::c_equal_range(kArray, 2);\n static_assert(kEqualRange.first == kArray.begin() + 1);\n static_assert(kEqualRange.second == kArray.begin() + 2);\n}\n\nTEST(ConstexprTest, EqualRangeWithPredicate) {\n static constexpr std::array kArray = {4, 3, 2, 1};\n static constexpr auto kEqualRange =\n absl::c_equal_range(kArray, 2, std::greater<>());\n static_assert(kEqualRange.first == kArray.begin() + 2);\n static_assert(kEqualRange.second == kArray.begin() + 3);\n}\n\nTEST(ConstexprTest, BinarySearch) {\n static constexpr std::array kArray = {1, 2, 3, 4};\n static constexpr bool kBinarySearch = absl::c_binary_search(kArray, 2);\n static_assert(kBinarySearch);\n}\n\nTEST(ConstexprTest, BinarySearchWithPredicate) {\n static constexpr std::array kArray = {4, 3, 2, 1};\n static constexpr bool kBinarySearch =\n absl::c_binary_search(kArray, 2, std::greater<>());\n static_assert(kBinarySearch);\n}\n\nTEST(ConstexprTest, Merge) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {4, 5, 6};\n static constexpr auto kArrayMerge = [] {\n std::array array;\n absl::c_merge(kArray1, kArray2, array.begin());\n return array;\n }();\n static_assert(kArrayMerge == std::array{1, 2, 3, 4, 5, 6});\n}\n\nTEST(ConstexprTest, MergeWithPredicate) {\n static constexpr std::array kArray1 = {3, 2, 1};\n static constexpr std::array kArray2 = {6, 5, 4};\n static constexpr auto kArrayMerge = [] {\n std::array array;\n absl::c_merge(kArray1, kArray2, array.begin(), std::greater<>());\n return array;\n }();\n static_assert(kArrayMerge == std::array{6, 5, 4, 3, 2, 1});\n}\n\nTEST(ConstexprTest, Includes) {\n static constexpr std::array kArray1 = {1, 2, 3, 4, 5, 6};\n static constexpr std::array kArray2 = {2, 3, 5};\n static constexpr bool kIncludes = absl::c_includes(kArray1, kArray2);\n static_assert(kIncludes);\n}\n\nTEST(ConstexprTest, IncludesWithPredicate) {\n static constexpr std::array kArray1 = {6, 5, 4, 3, 2, 1};\n static constexpr std::array kArray2 = {5, 3, 2};\n static constexpr bool kIncludes =\n absl::c_includes(kArray1, kArray2, std::greater<>());\n static_assert(kIncludes);\n}\n\nTEST(ConstexprTest, SetUnion) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 3, 4};\n static constexpr auto kArraySetUnion = [] {\n std::array array;\n absl::c_set_union(kArray1, kArray2, array.begin());\n return array;\n }();\n static_assert(kArraySetUnion == std::array{1, 2, 3, 4});\n}\n\nTEST(ConstexprTest, SetUnionWithPredicate) {\n static constexpr std::array kArray1 = {3, 2, 1};\n static constexpr std::array kArray2 = {4, 3, 1};\n static constexpr auto kArraySetUnion = [] {\n std::array array;\n absl::c_set_union(kArray1, kArray2, array.begin(), std::greater<>());\n return array;\n }();\n static_assert(kArraySetUnion == std::array{4, 3, 2, 1});\n}\n\nTEST(ConstexprTest, SetIntersection) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 3, 4};\n static constexpr auto kArraySetIntersection = [] {\n std::array array;\n absl::c_set_intersection(kArray1, kArray2, array.begin());\n return array;\n }();\n static_assert(kArraySetIntersection == std::array{1, 3});\n}\n\nTEST(ConstexprTest, SetIntersectionWithPredicate) {\n static constexpr std::array kArray1 = {3, 2, 1};\n static constexpr std::array kArray2 = {4, 3, 1};\n static constexpr auto kArraySetIntersection = [] {\n std::array array;\n absl::c_set_intersection(kArray1, kArray2, array.begin(), std::greater<>());\n return array;\n }();\n static_assert(kArraySetIntersection == std::array{3, 1});\n}\n\nTEST(ConstexprTest, SetDifference) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 3, 4};\n static constexpr auto kArraySetDifference = [] {\n std::array array;\n absl::c_set_difference(kArray1, kArray2, array.begin());\n return array;\n }();\n static_assert(kArraySetDifference == std::array{2});\n}\n\nTEST(ConstexprTest, SetDifferenceWithPredicate) {\n static constexpr std::array kArray1 = {3, 2, 1};\n static constexpr std::array kArray2 = {4, 3, 1};\n static constexpr auto kArraySetDifference = [] {\n std::array array;\n absl::c_set_difference(kArray1, kArray2, array.begin(), std::greater<>());\n return array;\n }();\n static_assert(kArraySetDifference == std::array{2});\n}\n\nTEST(ConstexprTest, SetSymmetricDifference) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 3, 4};\n static constexpr auto kArraySetSymmetricDifference = [] {\n std::array array;\n absl::c_set_symmetric_difference(kArray1, kArray2, array.begin());\n return array;\n }();\n static_assert(kArraySetSymmetricDifference == std::array{2, 4});\n}\n\nTEST(ConstexprTest, SetSymmetricDifferenceWithPredicate) {\n static constexpr std::array kArray1 = {3, 2, 1};\n static constexpr std::array kArray2 = {4, 3, 1};\n static constexpr auto kArraySetSymmetricDifference = [] {\n std::array array;\n absl::c_set_symmetric_difference(kArray1, kArray2, array.begin(),\n std::greater<>());\n return array;\n }();\n static_assert(kArraySetSymmetricDifference == std::array{4, 2});\n}\n\nTEST(ConstexprTest, PushHeap) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3, 4};\n absl::c_push_heap(array);\n return array;\n }();\n static_assert(kArray[0] == 4);\n}\n\nTEST(ConstexprTest, PushHeapWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {4, 3, 2, 1};\n absl::c_push_heap(array, std::greater<>());\n return array;\n }();\n static_assert(kArray[0] == 1);\n}\n\nTEST(ConstexprTest, PopHeap) {\n static constexpr auto kArray = [] {\n std::array array = {4, 3, 2, 1};\n absl::c_pop_heap(array);\n return array;\n }();\n static_assert(kArray[3] == 4);\n}\n\nTEST(ConstexprTest, PopHeapWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3, 4};\n absl::c_pop_heap(array, std::greater<>());\n return array;\n }();\n static_assert(kArray[3] == 1);\n}\n\nTEST(ConstexprTest, MakeHeap) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3, 4};\n absl::c_make_heap(array);\n return array;\n }();\n static_assert(absl::c_is_heap(kArray));\n}\n\nTEST(ConstexprTest, MakeHeapWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {4, 3, 2, 1};\n absl::c_make_heap(array, std::greater<>());\n return array;\n }();\n static_assert(absl::c_is_heap(kArray, std::greater<>()));\n}\n\nTEST(ConstexprTest, SortHeap) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3, 4};\n absl::c_make_heap(array);\n absl::c_sort_heap(array);\n return array;\n }();\n static_assert(kArray == std::array{1, 2, 3, 4});\n}\n\nTEST(ConstexprTest, SortHeapWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {4, 3, 2, 1};\n absl::c_make_heap(array, std::greater<>());\n absl::c_sort_heap(array, std::greater<>());\n return array;\n }();\n static_assert(kArray == std::array{4, 3, 2, 1});\n}\n\nTEST(ConstexprTest, IsHeap) {\n static constexpr std::array kHeap = {4, 2, 3, 1};\n static_assert(absl::c_is_heap(kHeap));\n static constexpr std::array kNotHeap = {1, 2, 3, 4};\n static_assert(!absl::c_is_heap(kNotHeap));\n}\n\nTEST(ConstexprTest, IsHeapWithPredicate) {\n static constexpr std::array kHeap = {1, 2, 3, 4};\n static_assert(absl::c_is_heap(kHeap, std::greater<>()));\n static constexpr std::array kNotHeap = {4, 3, 2, 1};\n static_assert(!absl::c_is_heap(kNotHeap, std::greater<>()));\n}\n\nTEST(ConstexprTest, IsHeapUntil) {\n static constexpr std::array kHeap = {4, 2, 3, 1};\n static_assert(absl::c_is_heap_until(kHeap) == kHeap.end());\n static constexpr std::array kNotHeap = {4, 2, 3, 5};\n static_assert(absl::c_is_heap_until(kNotHeap) == kNotHeap.begin() + 3);\n}\n\nTEST(ConstexprTest, IsHeapUntilWithPredicate) {\n static constexpr std::array kHeap = {1, 2, 3, 4};\n static_assert(absl::c_is_heap_until(kHeap, std::greater<>()) == kHeap.end());\n static constexpr std::array kNotHeap = {1, 2, 3, 0};\n static_assert(absl::c_is_heap_until(kNotHeap, std::greater<>()) ==\n kNotHeap.begin() + 3);\n}\n\nTEST(ConstexprTest, LexicographicalCompare) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 4};\n static constexpr std::array kArray3 = {1, 2, 3};\n static_assert(absl::c_lexicographical_compare(kArray1, kArray2));\n static_assert(!absl::c_lexicographical_compare(kArray2, kArray1));\n static_assert(!absl::c_lexicographical_compare(kArray1, kArray3));\n}\n\nTEST(ConstexprTest, LexicographicalCompareWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {1, 2, 4};\n static constexpr std::array kArray3 = {1, 2, 3};\n static_assert(\n !absl::c_lexicographical_compare(kArray1, kArray2, std::greater<>()));\n static_assert(\n absl::c_lexicographical_compare(kArray2, kArray1, std::greater<>()));\n static_assert(\n !absl::c_lexicographical_compare(kArray1, kArray3, std::greater<>()));\n}\n\nTEST(ConstexprTest, NextPermutation) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3};\n absl::c_next_permutation(array);\n return array;\n }();\n static_assert(kArray == std::array{1, 3, 2});\n}\n\nTEST(ConstexprTest, NextPermutationWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {3, 2, 1};\n absl::c_next_permutation(array, std::greater<>());\n return array;\n }();\n static_assert(kArray == std::array{3, 1, 2});\n}\n\nTEST(ConstexprTest, PrevPermutation) {\n static constexpr auto kArray = [] {\n std::array array = {1, 3, 2};\n absl::c_prev_permutation(array);\n return array;\n }();\n static_assert(kArray == std::array{1, 2, 3});\n}\n\nTEST(ConstexprTest, PrevPermutationWithPredicate) {\n static constexpr auto kArray = [] {\n std::array array = {1, 2, 3};\n absl::c_prev_permutation(array, std::greater<>());\n return array;\n }();\n static_assert(kArray == std::array{1, 3, 2});\n}\n\nTEST(ConstexprTest, Iota) {\n static constexpr auto kArray = [] {\n std::array array;\n absl::c_iota(array, 1);\n return array;\n }();\n static_assert(kArray == std::array{1, 2, 3});\n}\n\nTEST(ConstexprTest, Accumulate) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_accumulate(kArray, 0) == 6);\n}\n\nTEST(ConstexprTest, AccumulateWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3};\n static_assert(absl::c_accumulate(kArray, 1, std::multiplies<>()) == 6);\n}\n\nTEST(ConstexprTest, InnerProduct) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {4, 5, 6};\n static_assert(absl::c_inner_product(kArray1, kArray2, 0) == 32);\n}\n\nTEST(ConstexprTest, InnerProductWithPredicate) {\n static constexpr std::array kArray1 = {1, 2, 3};\n static constexpr std::array kArray2 = {4, 5, 6};\n static_assert(absl::c_inner_product(kArray1, kArray2, 1, std::multiplies<>(),\n std::plus<>()) == 315);\n}\n\nTEST(ConstexprTest, AdjacentDifference) {\n static constexpr std::array kArray = {1, 2, 4};\n static constexpr auto kArrayAdjacentDifference = [] {\n std::array array;\n absl::c_adjacent_difference(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayAdjacentDifference == std::array{1, 1, 2});\n}\n\nTEST(ConstexprTest, AdjacentDifferenceWithPredicate) {\n static constexpr std::array kArray = {1, 2, 4};\n static constexpr auto kArrayAdjacentDifference = [] {\n std::array array;\n absl::c_adjacent_difference(kArray, array.begin(), std::multiplies<>());\n return array;\n }();\n static_assert(kArrayAdjacentDifference == std::array{1, 2, 8});\n}\n\nTEST(ConstexprTest, PartialSum) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayPartialSum = [] {\n std::array array;\n absl::c_partial_sum(kArray, array.begin());\n return array;\n }();\n static_assert(kArrayPartialSum == std::array{1, 3, 6});\n}\n\nTEST(ConstexprTest, PartialSumWithPredicate) {\n static constexpr std::array kArray = {1, 2, 3};\n static constexpr auto kArrayPartialSum = [] {\n std::array array;\n absl::c_partial_sum(kArray, array.begin(), std::multiplies<>());\n return array;\n }();\n static_assert(kArrayPartialSum == std::array{1, 2, 6});\n}\n\n#endif // defined(ABSL_INTERNAL_CPLUSPLUS_LANG) &&\n // ABSL_INTERNAL_CPLUSPLUS_LANG >= 202002L\n\n} // namespace\n" }, { "path": "absl/base/BUILD.bazel", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nload(\"@rules_cc//cc:cc_binary.bzl\", \"cc_binary\")\nload(\"@rules_cc//cc:cc_library.bzl\", \"cc_library\")\nload(\"@rules_cc//cc:cc_test.bzl\", \"cc_test\")\nload(\n \"//absl:copts/configure_copts.bzl\",\n \"ABSL_DEFAULT_COPTS\",\n \"ABSL_DEFAULT_LINKOPTS\",\n \"ABSL_TEST_COPTS\",\n)\n\npackage(\n default_visibility = [\"//visibility:public\"],\n features = [\n \"header_modules\",\n \"layering_check\",\n \"parse_headers\",\n ],\n)\n\nlicenses([\"notice\"])\n\ncc_library(\n name = \"atomic_hook\",\n hdrs = [\"internal/atomic_hook.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n ],\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_library(\n name = \"errno_saver\",\n hdrs = [\"internal/errno_saver.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\":config\"],\n)\n\ncc_library(\n name = \"hardening\",\n srcs = [\n \"internal/hardening.cc\",\n ],\n hdrs = [\n \"internal/hardening.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n ],\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_library(\n name = \"log_severity\",\n srcs = [\"log_severity.cc\"],\n hdrs = [\"log_severity.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_library(\n name = \"no_destructor\",\n hdrs = [\"no_destructor.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":nullability\",\n ],\n)\n\ncc_library(\n name = \"nullability\",\n hdrs = [\"nullability.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\":config\"],\n)\n\ncc_library(\n name = \"nullability_traits_internal\",\n hdrs = [\"internal/nullability_traits.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n ],\n deps = [\n \":config\",\n \":nullability\",\n ],\n)\n\ncc_library(\n name = \"raw_logging_internal\",\n srcs = [\"internal/raw_logging.cc\"],\n hdrs = [\"internal/raw_logging.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":atomic_hook\",\n \":config\",\n \":core_headers\",\n \":errno_saver\",\n \":log_severity\",\n ],\n)\n\ncc_library(\n name = \"spinlock_wait\",\n srcs = [\n \"internal/spinlock_akaros.inc\",\n \"internal/spinlock_linux.inc\",\n \"internal/spinlock_posix.inc\",\n \"internal/spinlock_wait.cc\",\n \"internal/spinlock_win32.inc\",\n ],\n hdrs = [\"internal/spinlock_wait.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:friends\",\n \"//absl/base:__pkg__\",\n ],\n deps = [\n \":base_internal\",\n \":core_headers\",\n \":errno_saver\",\n ],\n)\n\ncc_library(\n name = \"config\",\n hdrs = [\n \"config.h\",\n \"options.h\",\n \"policy_checks.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n)\n\ncc_library(\n name = \"cycleclock_internal\",\n hdrs = [\n \"internal/cycleclock_config.h\",\n \"internal/unscaledcycleclock_config.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":base_internal\",\n \":config\",\n ],\n)\n\ncc_library(\n name = \"dynamic_annotations\",\n srcs = [\n \"internal/dynamic_annotations.h\",\n ],\n hdrs = [\n \"dynamic_annotations.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_library(\n name = \"core_headers\",\n hdrs = [\n \"attributes.h\",\n \"const_init.h\",\n \"macros.h\",\n \"optimization.h\",\n \"port.h\",\n \"thread_annotations.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n ],\n)\n\ncc_library(\n name = \"malloc_internal\",\n srcs = [\n \"internal/low_level_alloc.cc\",\n ],\n hdrs = [\n \"internal/direct_mmap.h\",\n \"internal/low_level_alloc.h\",\n ],\n copts = ABSL_DEFAULT_COPTS + select({\n \"//conditions:default\": [],\n }),\n linkopts = select({\n \"@rules_cc//cc/compiler:msvc-cl\": [],\n \"@rules_cc//cc/compiler:clang-cl\": [],\n \"@rules_cc//cc/compiler:emscripten\": [],\n \"//conditions:default\": [\"-pthread\"],\n }) + ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//visibility:public\",\n ],\n deps = [\n \":base\",\n \":base_internal\",\n \":config\",\n \":core_headers\",\n \":dynamic_annotations\",\n \":raw_logging_internal\",\n ],\n)\n\ncc_library(\n name = \"base_internal\",\n hdrs = [\n \"internal/hide_ptr.h\",\n \"internal/scheduling_mode.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":config\",\n \"//absl/meta:type_traits\",\n ],\n)\n\ncc_library(\n name = \"base\",\n srcs = [\n \"casts.cc\",\n \"internal/cycleclock.cc\",\n \"internal/spinlock.cc\",\n \"internal/sysinfo.cc\",\n \"internal/thread_identity.cc\",\n \"internal/unscaledcycleclock.cc\",\n ],\n hdrs = [\n \"call_once.h\",\n \"casts.h\",\n \"internal/cycleclock.h\",\n \"internal/low_level_scheduling.h\",\n \"internal/per_thread_tls.h\",\n \"internal/spinlock.h\",\n \"internal/sysinfo.h\",\n \"internal/thread_identity.h\",\n \"internal/tsan_mutex_interface.h\",\n \"internal/unscaledcycleclock.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = select({\n \"@rules_cc//cc/compiler:msvc-cl\": [\n \"-DEFAULTLIB:advapi32.lib\",\n ],\n \"@rules_cc//cc/compiler:clang-cl\": [\n \"-DEFAULTLIB:advapi32.lib\",\n ],\n \"//absl:mingw_compiler\": [\n \"-DEFAULTLIB:advapi32.lib\",\n \"-ladvapi32\",\n ],\n \"@rules_cc//cc/compiler:emscripten\": [],\n \"//conditions:default\": [\"-pthread\"],\n }) + ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":atomic_hook\",\n \":base_internal\",\n \":config\",\n \":core_headers\",\n \":cycleclock_internal\",\n \":nullability\",\n \":raw_logging_internal\",\n \":spinlock_wait\",\n \"//absl/meta:type_traits\",\n ],\n)\n\ncc_library(\n name = \"atomic_hook_test_helper\",\n testonly = True,\n srcs = [\"internal/atomic_hook_test_helper.cc\"],\n hdrs = [\"internal/atomic_hook_test_helper.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":atomic_hook\",\n \":core_headers\",\n ],\n)\n\ncc_test(\n name = \"atomic_hook_test\",\n size = \"small\",\n srcs = [\"internal/atomic_hook_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":atomic_hook\",\n \":atomic_hook_test_helper\",\n \":core_headers\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"bit_cast_test\",\n size = \"small\",\n srcs = [\n \"bit_cast_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":base\",\n \":core_headers\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"attributes_test\",\n srcs = [\n \"attributes_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":core_headers\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"c_header_test\",\n srcs = [\"c_header_test.c\"],\n tags = [\n \"no_test_wasm\",\n ],\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_library(\n name = \"throw_delegate\",\n srcs = [\n \"throw_delegate.cc\",\n ],\n hdrs = [\n \"throw_delegate.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":raw_logging_internal\",\n ],\n)\n\ncc_test(\n name = \"throw_delegate_test\",\n srcs = [\"throw_delegate_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":throw_delegate\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"errno_saver_test\",\n size = \"small\",\n srcs = [\"internal/errno_saver_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":errno_saver\",\n \":strerror\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"exception_testing\",\n testonly = True,\n hdrs = [\"internal/exception_testing.h\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":config\",\n \"@googletest//:gtest\",\n ],\n)\n\ncc_library(\n name = \"pretty_function\",\n hdrs = [\"internal/pretty_function.h\"],\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n)\n\ncc_library(\n name = \"exception_safety_testing\",\n testonly = True,\n srcs = [\"internal/exception_safety_testing.cc\"],\n hdrs = [\"internal/exception_safety_testing.h\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":pretty_function\",\n \"//absl/memory\",\n \"//absl/meta:type_traits\",\n \"//absl/strings\",\n \"//absl/utility\",\n \"@googletest//:gtest\",\n ],\n)\n\ncc_test(\n name = \"exception_safety_testing_test\",\n srcs = [\"exception_safety_testing_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":exception_safety_testing\",\n \"//absl/memory\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\n# Common test library made available for use in non-absl code that overrides\n# AbslInternalSpinLockDelay and AbslInternalSpinLockWake.\ncc_library(\n name = \"spinlock_test_common\",\n testonly = True,\n srcs = [\"spinlock_test_common.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":base\",\n \":base_internal\",\n \":config\",\n \":core_headers\",\n \"//absl/synchronization\",\n \"@googletest//:gtest\",\n ],\n alwayslink = 1,\n)\n\ncc_test(\n name = \"spinlock_test\",\n size = \"medium\",\n srcs = [\"spinlock_test_common.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\n \"no_test_wasm\",\n ],\n deps = [\n \":base\",\n \":base_internal\",\n \":config\",\n \":core_headers\",\n \"//absl/synchronization\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"spinlock_benchmark_common\",\n testonly = True,\n srcs = [\"internal/spinlock_benchmark.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:friends\",\n \"//absl/base:__pkg__\",\n ],\n deps = [\n \":base\",\n \":base_internal\",\n \":no_destructor\",\n \":raw_logging_internal\",\n \"//absl/synchronization\",\n \"@google_benchmark//:benchmark_main\",\n ],\n alwayslink = 1,\n)\n\ncc_binary(\n name = \"spinlock_benchmark\",\n testonly = True,\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\"benchmark\"],\n visibility = [\"//visibility:private\"],\n deps = [\n \":spinlock_benchmark_common\",\n ],\n)\n\ncc_library(\n name = \"endian\",\n hdrs = [\n \"internal/endian.h\",\n \"internal/unaligned_access.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":base\",\n \":config\",\n \":core_headers\",\n \":nullability\",\n ],\n)\n\ncc_test(\n name = \"endian_test\",\n srcs = [\"internal/endian_test.cc\"],\n copts = ABSL_TEST_COPTS,\n deps = [\n \":config\",\n \":endian\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"config_test\",\n srcs = [\"config_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \"//absl/synchronization:thread_pool\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"call_once_test\",\n srcs = [\"call_once_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":base\",\n \":core_headers\",\n \"//absl/synchronization\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"casts_test\",\n size = \"small\",\n srcs = [\n \"casts_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":base\",\n \":config\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"hardening_test\",\n size = \"small\",\n srcs = [\n \"internal/hardening_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":hardening\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"no_destructor_test\",\n srcs = [\"no_destructor_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":no_destructor\",\n \":raw_logging_internal\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_binary(\n name = \"no_destructor_benchmark\",\n testonly = True,\n srcs = [\"no_destructor_benchmark.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\"benchmark\"],\n visibility = [\"//visibility:private\"],\n deps = [\n \":no_destructor\",\n \":raw_logging_internal\",\n \"@google_benchmark//:benchmark_main\",\n ],\n)\n\ncc_test(\n name = \"nullability_test\",\n srcs = [\"nullability_test.cc\"],\n deps = [\n \":nullability\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"nullability_default_nonnull_test\",\n srcs = [\"nullability_default_nonnull_test.cc\"],\n deps = [\n \":nullability\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"nullability_traits_test\",\n srcs = [\"internal/nullability_traits_test.cc\"],\n deps = [\n \":config\",\n \":nullability\",\n \":nullability_traits_internal\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"raw_logging_test\",\n srcs = [\"raw_logging_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":raw_logging_internal\",\n \"//absl/strings\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"sysinfo_test\",\n size = \"small\",\n srcs = [\"internal/sysinfo_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":base\",\n \"//absl/synchronization\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"low_level_alloc_test\",\n size = \"medium\",\n srcs = [\"internal/low_level_alloc_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\n \"no_test_ios_x86_64\",\n \"no_test_wasm\",\n ],\n deps = [\n \":malloc_internal\",\n \"//absl/container:node_hash_map\",\n ],\n)\n\ncc_test(\n name = \"thread_identity_test\",\n srcs = [\"internal/thread_identity_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\n \"no_test_wasm\",\n ],\n deps = [\n \":base\",\n \":core_headers\",\n \"//absl/synchronization\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_binary(\n name = \"thread_identity_benchmark\",\n testonly = True,\n srcs = [\"internal/thread_identity_benchmark.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\"benchmark\"],\n visibility = [\"//visibility:private\"],\n deps = [\n \":base\",\n \"//absl/synchronization\",\n \"@google_benchmark//:benchmark_main\",\n ],\n)\n\ncc_library(\n name = \"scoped_set_env\",\n testonly = True,\n srcs = [\"internal/scoped_set_env.cc\"],\n hdrs = [\"internal/scoped_set_env.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n ],\n deps = [\n \":config\",\n \":raw_logging_internal\",\n ],\n)\n\ncc_test(\n name = \"scoped_set_env_test\",\n size = \"small\",\n srcs = [\"internal/scoped_set_env_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":scoped_set_env\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"log_severity_test\",\n size = \"small\",\n srcs = [\"log_severity_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":log_severity\",\n \"//absl/flags:flag_internal\",\n \"//absl/flags:marshalling\",\n \"//absl/strings\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"strerror\",\n srcs = [\"internal/strerror.cc\"],\n hdrs = [\"internal/strerror.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":config\",\n \":core_headers\",\n \":errno_saver\",\n ],\n)\n\ncc_test(\n name = \"strerror_test\",\n size = \"small\",\n srcs = [\"internal/strerror_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":strerror\",\n \"//absl/strings\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_binary(\n name = \"strerror_benchmark\",\n testonly = True,\n srcs = [\"internal/strerror_benchmark.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n tags = [\"benchmark\"],\n visibility = [\"//visibility:private\"],\n deps = [\n \":strerror\",\n \"@google_benchmark//:benchmark_main\",\n ],\n)\n\ncc_library(\n name = \"fast_type_id\",\n hdrs = [\"fast_type_id.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n ],\n)\n\ncc_test(\n name = \"fast_type_id_test\",\n size = \"small\",\n srcs = [\"fast_type_id_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":core_headers\",\n \":fast_type_id\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"prefetch\",\n hdrs = [\n \"prefetch.h\",\n ],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":core_headers\",\n ],\n)\n\ncc_test(\n name = \"prefetch_test\",\n size = \"small\",\n srcs = [\n \"prefetch_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":prefetch\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"poison\",\n srcs = [\n \"internal/poison.cc\",\n ],\n hdrs = [\"internal/poison.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":config\",\n \":core_headers\",\n \":malloc_internal\",\n ],\n)\n\ncc_test(\n name = \"poison_test\",\n size = \"small\",\n timeout = \"short\",\n srcs = [\n \"internal/poison_test.cc\",\n ],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":poison\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"unique_small_name_test\",\n size = \"small\",\n srcs = [\"internal/unique_small_name_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n linkstatic = 1,\n deps = [\n \":core_headers\",\n \"//absl/strings\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"optimization_test\",\n size = \"small\",\n srcs = [\"optimization_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":core_headers\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"iterator_traits_internal\",\n hdrs = [\"internal/iterator_traits.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n \"//absl:friends\",\n ],\n deps = [\n \":config\",\n \"//absl/meta:type_traits\",\n ],\n)\n\ncc_test(\n name = \"iterator_traits_test\",\n srcs = [\"internal/iterator_traits_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":iterator_traits_internal\",\n \":iterator_traits_test_helper\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_library(\n name = \"tracing_internal\",\n srcs = [\"internal/tracing.cc\"],\n hdrs = [\"internal/tracing.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n visibility = [\n \"//absl:__subpackages__\",\n ],\n deps = [\n \"//absl/base:config\",\n \"//absl/base:core_headers\",\n ],\n)\n\ncc_library(\n name = \"iterator_traits_test_helper\",\n hdrs = [\"internal/iterator_traits_test_helper.h\"],\n copts = ABSL_DEFAULT_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\":config\"],\n)\n\ncc_test(\n name = \"tracing_internal_weak_test\",\n srcs = [\"internal/tracing_weak_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":tracing_internal\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n\ncc_test(\n name = \"tracing_internal_strong_test\",\n srcs = [\"internal/tracing_strong_test.cc\"],\n copts = ABSL_TEST_COPTS,\n linkopts = ABSL_DEFAULT_LINKOPTS,\n deps = [\n \":config\",\n \":core_headers\",\n \":tracing_internal\",\n \"@googletest//:gtest\",\n \"@googletest//:gtest_main\",\n ],\n)\n" }, { "path": "absl/base/CMakeLists.txt", "content": "#\n# Copyright 2017 The Abseil Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n\nfind_library(LIBRT rt)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n atomic_hook\n HDRS\n \"internal/atomic_hook.h\"\n DEPS\n absl::config\n absl::core_headers\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n errno_saver\n HDRS\n \"internal/errno_saver.h\"\n DEPS\n absl::config\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\nabsl_cc_library(\n NAME\n hardening\n HDRS\n \"internal/hardening.h\"\n SRCS\n \"internal/hardening.cc\"\n DEPS\n absl::config\n absl::core_headers\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\nabsl_cc_library(\n NAME\n log_severity\n HDRS\n \"log_severity.h\"\n SRCS\n \"log_severity.cc\"\n DEPS\n absl::config\n absl::core_headers\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\nabsl_cc_library(\n NAME\n no_destructor\n HDRS\n \"no_destructor.h\"\n DEPS\n absl::config\n absl::nullability\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\nabsl_cc_library(\n NAME\n nullability\n HDRS\n \"nullability.h\"\n DEPS\n absl::config\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\nabsl_cc_test(\n NAME\n nullability_test\n SRCS\n \"nullability_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::nullability\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n nullability_default_nonnull_test\n SRCS\n \"nullability_default_nonnull_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::nullability\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n nullability_traits_internal\n HDRS\n \"internal/nullability_traits.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n absl::nullability\n PUBLIC\n)\n\nabsl_cc_test(\n NAME\n nullability_traits_test\n SRCS\n \"internal/nullability_traits_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::nullability\n absl::nullability_traits_internal\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n raw_logging_internal\n HDRS\n \"internal/raw_logging.h\"\n SRCS\n \"internal/raw_logging.cc\"\n DEPS\n absl::atomic_hook\n absl::config\n absl::core_headers\n absl::errno_saver\n absl::log_severity\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n spinlock_wait\n HDRS\n \"internal/spinlock_wait.h\"\n SRCS\n \"internal/spinlock_akaros.inc\"\n \"internal/spinlock_linux.inc\"\n \"internal/spinlock_posix.inc\"\n \"internal/spinlock_wait.cc\"\n \"internal/spinlock_win32.inc\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::base_internal\n absl::core_headers\n absl::errno_saver\n)\n\nabsl_cc_library(\n NAME\n config\n HDRS\n \"config.h\"\n \"options.h\"\n \"policy_checks.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n PUBLIC\n)\n\nabsl_cc_library(\n NAME\n dynamic_annotations\n HDRS\n \"dynamic_annotations.h\"\n SRCS\n \"internal/dynamic_annotations.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n PUBLIC\n)\n\nabsl_cc_library(\n NAME\n core_headers\n HDRS\n \"attributes.h\"\n \"const_init.h\"\n \"macros.h\"\n \"optimization.h\"\n \"port.h\"\n \"thread_annotations.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n PUBLIC\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n malloc_internal\n HDRS\n \"internal/direct_mmap.h\"\n \"internal/low_level_alloc.h\"\n SRCS\n \"internal/low_level_alloc.cc\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::base\n absl::base_internal\n absl::config\n absl::core_headers\n absl::dynamic_annotations\n absl::raw_logging_internal\n Threads::Threads\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n base_internal\n HDRS\n \"internal/hide_ptr.h\"\n \"internal/scheduling_mode.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n absl::type_traits\n)\n\nabsl_cc_library(\n NAME\n base\n HDRS\n \"call_once.h\"\n \"casts.h\"\n \"internal/cycleclock.h\"\n \"internal/cycleclock_config.h\"\n \"internal/low_level_scheduling.h\"\n \"internal/per_thread_tls.h\"\n \"internal/spinlock.h\"\n \"internal/sysinfo.h\"\n \"internal/thread_identity.h\"\n \"internal/tsan_mutex_interface.h\"\n \"internal/unscaledcycleclock.h\"\n \"internal/unscaledcycleclock_config.h\"\n SRCS\n \"casts.cc\"\n \"internal/cycleclock.cc\"\n \"internal/spinlock.cc\"\n \"internal/sysinfo.cc\"\n \"internal/thread_identity.cc\"\n \"internal/unscaledcycleclock.cc\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n LINKOPTS\n ${ABSL_DEFAULT_LINKOPTS}\n $<$:-lrt>\n $<$:-ladvapi32>\n DEPS\n absl::atomic_hook\n absl::base_internal\n absl::config\n absl::core_headers\n absl::dynamic_annotations\n absl::log_severity\n absl::nullability\n absl::raw_logging_internal\n absl::spinlock_wait\n absl::type_traits\n Threads::Threads\n PUBLIC\n)\n\nabsl_cc_library(\n NAME\n throw_delegate\n HDRS\n \"throw_delegate.h\"\n SRCS\n \"throw_delegate.cc\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n absl::raw_logging_internal\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n exception_testing\n HDRS\n \"internal/exception_testing.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n GTest::gtest\n TESTONLY\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n pretty_function\n HDRS\n \"internal/pretty_function.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n exception_safety_testing\n HDRS\n \"internal/exception_safety_testing.h\"\n SRCS\n \"internal/exception_safety_testing.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::pretty_function\n absl::memory\n absl::meta\n absl::strings\n absl::utility\n GTest::gtest\n TESTONLY\n)\n\nabsl_cc_test(\n NAME\n absl_exception_safety_testing_test\n SRCS\n \"exception_safety_testing_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::exception_safety_testing\n absl::memory\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n atomic_hook_test_helper\n SRCS\n \"internal/atomic_hook_test_helper.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::atomic_hook\n absl::core_headers\n TESTONLY\n)\n\nabsl_cc_test(\n NAME\n atomic_hook_test\n SRCS\n \"internal/atomic_hook_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::atomic_hook_test_helper\n absl::atomic_hook\n absl::core_headers\n GTest::gmock\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n attributes_test\n SRCS\n \"attributes_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::core_headers\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n hardening_test\n SRCS\n \"internal/hardening_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::hardening\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n bit_cast_test\n SRCS\n \"bit_cast_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::core_headers\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n casts_test\n SRCS\n \"casts_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::core_headers\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n errno_saver_test\n SRCS\n \"internal/errno_saver_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::errno_saver\n absl::strerror\n GTest::gmock\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n throw_delegate_test\n SRCS\n \"throw_delegate_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::config\n absl::throw_delegate\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n spinlock_test_common\n SRCS\n \"spinlock_test_common.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::config\n absl::base_internal\n absl::core_headers\n absl::synchronization\n GTest::gtest\n TESTONLY\n)\n\n# On bazel BUILD this target use \"alwayslink = 1\" which is not implemented here\nabsl_cc_test(\n NAME\n spinlock_test\n SRCS\n \"spinlock_test_common.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::base_internal\n absl::config\n absl::core_headers\n absl::synchronization\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n endian\n HDRS\n \"internal/endian.h\"\n \"internal/unaligned_access.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::base\n absl::config\n absl::core_headers\n absl::nullability\n PUBLIC\n)\n\nabsl_cc_test(\n NAME\n endian_test\n SRCS\n \"internal/endian_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::config\n absl::endian\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n config_test\n SRCS\n \"config_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::synchronization\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n call_once_test\n SRCS\n \"call_once_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::core_headers\n absl::synchronization\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n no_destructor_test\n SRCS\n \"no_destructor_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::no_destructor\n absl::config\n absl::raw_logging_internal\n GTest::gmock\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n raw_logging_test\n SRCS\n \"raw_logging_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::raw_logging_internal\n absl::strings\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n sysinfo_test\n SRCS\n \"internal/sysinfo_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::synchronization\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n low_level_alloc_test\n SRCS\n \"internal/low_level_alloc_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::malloc_internal\n absl::node_hash_map\n Threads::Threads\n)\n\nabsl_cc_test(\n NAME\n thread_identity_test\n SRCS\n \"internal/thread_identity_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::core_headers\n absl::synchronization\n Threads::Threads\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n scoped_set_env\n SRCS\n \"internal/scoped_set_env.cc\"\n HDRS\n \"internal/scoped_set_env.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n absl::raw_logging_internal\n)\n\nabsl_cc_test(\n NAME\n scoped_set_env_test\n SRCS\n \"internal/scoped_set_env_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::scoped_set_env\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n cmake_thread_test\n SRCS\n \"internal/cmake_thread_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n)\n\nabsl_cc_test(\n NAME\n log_severity_test\n SRCS\n \"log_severity_test.cc\"\n DEPS\n absl::flags_internal\n absl::flags_marshalling\n absl::log_severity\n absl::strings\n GTest::gmock\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n strerror\n SRCS\n \"internal/strerror.cc\"\n HDRS\n \"internal/strerror.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n LINKOPTS\n ${ABSL_DEFAULT_LINKOPTS}\n DEPS\n absl::config\n absl::core_headers\n absl::errno_saver\n)\n\nabsl_cc_test(\n NAME\n strerror_test\n SRCS\n \"internal/strerror_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::strerror\n absl::strings\n GTest::gmock\n GTest::gtest_main\n)\n\nabsl_cc_library(\n NAME\n fast_type_id\n HDRS\n \"fast_type_id.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n LINKOPTS\n ${ABSL_DEFAULT_LINKOPTS}\n DEPS\n absl::config\n)\n\nabsl_cc_test(\n NAME\n fast_type_id_test\n SRCS\n \"fast_type_id_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::core_headers\n absl::fast_type_id\n GTest::gtest_main\n)\n\nabsl_cc_library(\n NAME\n prefetch\n HDRS\n \"prefetch.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n LINKOPTS\n ${ABSL_DEFAULT_LINKOPTS}\n DEPS\n absl::config\n absl::core_headers\n)\n\nabsl_cc_test(\n NAME\n prefetch_test\n SRCS\n \"prefetch_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::prefetch\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n optimization_test\n SRCS\n \"optimization_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::core_headers\n GTest::gtest_main\n)\n\nabsl_cc_library(\n NAME\n poison\n SRCS\n \"internal/poison.cc\"\n HDRS\n \"internal/poison.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n LINKOPTS\n ${ABSL_DEFAULT_LINKOPTS}\n DEPS\n absl::config\n absl::core_headers\n absl::malloc_internal\n)\n\nabsl_cc_test(\n NAME\n poison_test\n SRCS\n \"internal/poison_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::poison\n GTest::gtest_main\n)\n\nabsl_cc_library(\n NAME\n tracing_internal\n HDRS\n \"internal/tracing.h\"\n SRCS\n \"internal/tracing.cc\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::base\n)\n\nabsl_cc_test(\n NAME\n tracing_internal_weak_test\n SRCS\n \"internal/tracing_weak_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::tracing_internal\n GTest::gtest_main\n)\n\nabsl_cc_test(\n NAME\n tracing_internal_strong_test\n SRCS\n \"internal/tracing_strong_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::base\n absl::tracing_internal\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n iterator_traits_internal\n HDRS\n \"internal/iterator_traits.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n absl::type_traits\n PUBLIC\n)\n\nabsl_cc_test(\n NAME\n iterator_traits_test\n SRCS\n \"internal/iterator_traits_test.cc\"\n COPTS\n ${ABSL_TEST_COPTS}\n DEPS\n absl::config\n absl::iterator_traits_internal\n absl::iterator_traits_test_helper_internal\n GTest::gtest_main\n)\n\n# Internal-only target, do not depend on directly.\nabsl_cc_library(\n NAME\n iterator_traits_test_helper_internal\n HDRS\n \"internal/iterator_traits_test_helper.h\"\n COPTS\n ${ABSL_DEFAULT_COPTS}\n DEPS\n absl::config\n PUBLIC\n)\n" }, { "path": "absl/base/attributes.h", "content": "// Copyright 2017 The Abseil Authors.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// https://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// This header file defines macros for declaring attributes for functions,\n// types, and variables.\n//\n// These macros are used within Abseil and allow the compiler to optimize, where\n// applicable, certain function calls.\n//\n// Most macros here are exposing GCC or Clang features, and are stubbed out for\n// other compilers.\n//\n// GCC attributes documentation:\n// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html\n// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Variable-Attributes.html\n// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Type-Attributes.html\n//\n// Most attributes in this file are already supported by GCC 4.7. However, some\n// of them are not supported in older version of Clang. Thus, we check\n// `__has_attribute()` first. If the check fails, we check if we are on GCC and\n// assume the attribute exists on GCC (which is verified on GCC 4.7).\n\n// SKIP_ABSL_INLINE_NAMESPACE_CHECK\n\n#ifndef ABSL_BASE_ATTRIBUTES_H_\n#define ABSL_BASE_ATTRIBUTES_H_\n\n#include \"absl/base/config.h\"\n\n// ABSL_HAVE_ATTRIBUTE\n//\n// A function-like feature checking macro that is a wrapper around\n// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a\n// nonzero constant integer if the attribute is supported or 0 if not.\n//\n// It evaluates to zero if `__has_attribute` is not defined by the compiler.\n//\n// GCC: https://gcc.gnu.org/gcc-5/changes.html\n// Clang: https://clang.llvm.org/docs/LanguageExtensions.html\n#ifdef __has_attribute\n#define ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)\n#else\n#define ABSL_HAVE_ATTRIBUTE(x) 0\n#endif\n\n// ABSL_HAVE_CPP_ATTRIBUTE\n//\n// A function-like feature checking macro that accepts C++11 style attributes.\n// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6\n// (https://en.cppreference.com/w/cpp/experimental/feature_test). If we don't\n// find `__has_cpp_attribute`, will evaluate to 0.\n#if defined(__cplusplus) && defined(__has_cpp_attribute)\n// NOTE: requiring __cplusplus above should not be necessary, but\n// works around https://bugs.llvm.org/show_bug.cgi?id=23435.\n#define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n#define ABSL_HAVE_CPP_ATTRIBUTE(x) 0\n#endif\n\n// -----------------------------------------------------------------------------\n// Function Attributes\n// -----------------------------------------------------------------------------\n//\n// GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html\n// Clang: https://clang.llvm.org/docs/AttributeReference.html\n\n// ABSL_PRINTF_ATTRIBUTE\n// ABSL_SCANF_ATTRIBUTE\n//\n// Tells the compiler to perform `printf` format string checking if the\n// compiler supports it; see the 'format' attribute in\n// .\n//\n// Note: As the GCC manual states, \"[s]ince non-static C++ methods\n// have an implicit 'this' argument, the arguments of such methods\n// should be counted from two, not one.\"\n#if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \\\n __attribute__((__format__(__printf__, string_index, first_to_check)))\n#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \\\n __attribute__((__format__(__scanf__, string_index, first_to_check)))\n#else\n#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)\n#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)\n#endif\n\n// ABSL_ATTRIBUTE_ALWAYS_INLINE\n// ABSL_ATTRIBUTE_NOINLINE\n//\n// Forces functions to either inline or not inline. Introduced in gcc 3.1.\n#if ABSL_HAVE_ATTRIBUTE(always_inline) || \\\n (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))\n#define ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1\n#else\n#define ABSL_ATTRIBUTE_ALWAYS_INLINE\n#endif\n\n#if ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))\n#define ABSL_HAVE_ATTRIBUTE_NOINLINE 1\n#else\n#define ABSL_ATTRIBUTE_NOINLINE\n#endif\n\n// ABSL_ATTRIBUTE_NO_TAIL_CALL\n//\n// Prevents the compiler from optimizing away stack frames for functions which\n// end in a call to another function.\n#if ABSL_HAVE_ATTRIBUTE(disable_tail_calls)\n#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1\n#define ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))\n#elif defined(__GNUC__) && !defined(__clang__) && !defined(__e2k__)\n#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1\n#define ABSL_ATTRIBUTE_NO_TAIL_CALL \\\n __attribute__((optimize(\"no-optimize-sibling-calls\")))\n#else\n#define ABSL_ATTRIBUTE_NO_TAIL_CALL\n#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0\n#endif\n\n// ABSL_ATTRIBUTE_WEAK\n//\n// Tags a function as weak for the purposes of compilation and linking.\n// Weak attributes did not work properly in LLVM's Windows backend before\n// 9.0.0, so disable them there. See https://bugs.llvm.org/show_bug.cgi?id=37598\n// for further information. Weak attributes do not work across DLL boundary.\n// The MinGW compiler doesn't complain about the weak attribute until the link\n// step, presumably because Windows doesn't use ELF binaries.\n#if (ABSL_HAVE_ATTRIBUTE(weak) || \\\n (defined(__GNUC__) && !defined(__clang__))) && \\\n (!defined(_WIN32) || \\\n (defined(__clang__) && __clang_major__ >= 9 && \\\n !defined(ABSL_BUILD_DLL) && !defined(ABSL_CONSUME_DLL))) && \\\n !defined(__MINGW32__)\n#undef ABSL_ATTRIBUTE_WEAK\n#define ABSL_ATTRIBUTE_WEAK __attribute__((weak))\n#define ABSL_HAVE_ATTRIBUTE_WEAK 1\n#else\n#define ABSL_ATTRIBUTE_WEAK\n#define ABSL_HAVE_ATTRIBUTE_WEAK 0\n#endif\n\n// ABSL_ATTRIBUTE_NONNULL\n//\n// Tells the compiler either (a) that a particular function parameter\n// should be a non-null pointer, or (b) that all pointer arguments should\n// be non-null.\n//\n// Note: As the GCC manual states, \"[s]ince non-static C++ methods\n// have an implicit 'this' argument, the arguments of such methods\n// should be counted from two, not one.\"\n//\n// Args are indexed starting at 1.\n//\n// For non-static class member functions, the implicit `this` argument\n// is arg 1, and the first explicit argument is arg 2. For static class member\n// functions, there is no implicit `this`, and the first explicit argument is\n// arg 1.\n//\n// Example:\n//\n// /* arg_a cannot be null, but arg_b can */\n// void Function(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(1);\n//\n// class C {\n// /* arg_a cannot be null, but arg_b can */\n// void Method(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(2);\n//\n// /* arg_a cannot be null, but arg_b can */\n// static void StaticMethod(void* arg_a, void* arg_b)\n// ABSL_ATTRIBUTE_NONNULL(1);\n// };\n//\n// If no arguments are provided, then all pointer arguments should be non-null.\n//\n// /* No pointer arguments may be null. */\n// void Function(void* arg_a, void* arg_b, int arg_c) ABSL_ATTRIBUTE_NONNULL();\n//\n// NOTE: The GCC nonnull attribute actually accepts a list of arguments, but\n// ABSL_ATTRIBUTE_NONNULL does not.\n#if ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))\n#else\n#define ABSL_ATTRIBUTE_NONNULL(...)\n#endif\n\n// ABSL_ATTRIBUTE_NORETURN\n//\n// Tells the compiler that a given function never returns.\n//\n// Deprecated: Prefer the `[[noreturn]]` attribute standardized by C++11 over\n// this macro.\n#if ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))\n#elif defined(_MSC_VER)\n#define ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)\n#else\n#define ABSL_ATTRIBUTE_NORETURN\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS\n//\n// Tells the AddressSanitizer (or other memory testing tools) to ignore a given\n// function. Useful for cases when a function reads random locations on stack,\n// calls _exit from a cloned subprocess, deliberately accesses buffer\n// out of bounds or does other scary things with memory.\n// NOTE: GCC supports AddressSanitizer(asan) since 4.8.\n// https://gcc.gnu.org/gcc-4.8/changes.html\n#if defined(ABSL_HAVE_ADDRESS_SANITIZER) && \\\n ABSL_HAVE_ATTRIBUTE(no_sanitize_address)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))\n#elif defined(ABSL_HAVE_ADDRESS_SANITIZER) && defined(_MSC_VER) && \\\n _MSC_VER >= 1928\n// https://docs.microsoft.com/en-us/cpp/cpp/no-sanitize-address\n#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __declspec(no_sanitize_address)\n#elif defined(ABSL_HAVE_HWADDRESS_SANITIZER) && ABSL_HAVE_ATTRIBUTE(no_sanitize)\n// HWAddressSanitizer is a sanitizer similar to AddressSanitizer, which uses CPU\n// features to detect similar bugs with less CPU and memory overhead.\n// NOTE: GCC supports HWAddressSanitizer(hwasan) since 11.\n// https://gcc.gnu.org/gcc-11/changes.html\n#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS \\\n __attribute__((no_sanitize(\"hwaddress\")))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY\n//\n// Tells the MemorySanitizer to relax the handling of a given function. All \"Use\n// of uninitialized value\" warnings from such functions will be suppressed, and\n// all values loaded from memory will be considered fully initialized. This\n// attribute is similar to the ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS attribute\n// above, but deals with initialized-ness rather than addressability issues.\n// NOTE: MemorySanitizer(msan) is supported by Clang but not GCC.\n#if ABSL_HAVE_ATTRIBUTE(no_sanitize_memory)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_THREAD\n//\n// Tells the ThreadSanitizer to not instrument a given function.\n// NOTE: GCC supports ThreadSanitizer(tsan) since 4.8.\n// https://gcc.gnu.org/gcc-4.8/changes.html\n#if ABSL_HAVE_ATTRIBUTE(no_sanitize_thread)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED\n//\n// Tells the UndefinedSanitizer to ignore a given function. Useful for cases\n// where certain behavior (eg. division by zero) is being used intentionally.\n// NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.\n// https://gcc.gnu.org/gcc-4.9/changes.html\n#if ABSL_HAVE_ATTRIBUTE(no_sanitize_undefined)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \\\n __attribute__((no_sanitize_undefined))\n#elif ABSL_HAVE_ATTRIBUTE(no_sanitize)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \\\n __attribute__((no_sanitize(\"undefined\")))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_CFI\n//\n// Tells the ControlFlowIntegrity sanitizer to not instrument a given function.\n// See https://clang.llvm.org/docs/ControlFlowIntegrity.html for details.\n#if ABSL_HAVE_ATTRIBUTE(no_sanitize) && defined(__llvm__)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize(\"cfi\")))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI\n#endif\n\n// ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK\n//\n// Tells the SafeStack to not instrument a given function.\n// See https://clang.llvm.org/docs/SafeStack.html for details.\n#if ABSL_HAVE_ATTRIBUTE(no_sanitize)\n#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK \\\n __attribute__((no_sanitize(\"safe-stack\")))\n#else\n#define ABSL_ATTRIBUTE_NO_SANITIZE_SAFESTACK\n#endif\n\n// ABSL_ATTRIBUTE_RETURNS_NONNULL\n//\n// Tells the compiler that a particular function never returns a null pointer.\n#if ABSL_HAVE_ATTRIBUTE(returns_nonnull)\n#define ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))\n#else\n#define ABSL_ATTRIBUTE_RETURNS_NONNULL\n#endif\n\n// ABSL_HAVE_ATTRIBUTE_SECTION\n//\n// Indicates whether labeled sections are supported. Weak symbol support is\n// a prerequisite. Labeled sections are not supported on Darwin/iOS.\n#ifdef ABSL_HAVE_ATTRIBUTE_SECTION\n#error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set\n#elif (ABSL_HAVE_ATTRIBUTE(section) || \\\n (defined(__GNUC__) && !defined(__clang__))) && \\\n !defined(__APPLE__) && ABSL_HAVE_ATTRIBUTE_WEAK\n#define ABSL_HAVE_ATTRIBUTE_SECTION 1\n\n// ABSL_ATTRIBUTE_SECTION\n//\n// Tells the compiler/linker to put a given function into a section and define\n// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.\n// This functionality is supported by GNU linker. Any function annotated with\n// `ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into\n// whatever section its caller is placed into.\n//\n#ifndef ABSL_ATTRIBUTE_SECTION\n#define ABSL_ATTRIBUTE_SECTION(name) \\\n __attribute__((section(#name))) __attribute__((noinline))\n#endif\n\n// ABSL_ATTRIBUTE_SECTION_VARIABLE\n//\n// Tells the compiler/linker to put a given variable into a section and define\n// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.\n// This functionality is supported by GNU linker.\n#ifndef ABSL_ATTRIBUTE_SECTION_VARIABLE\n#ifdef _AIX\n// __attribute__((section(#name))) on AIX is achieved by using the `.csect`\n// pseudo op which includes an additional integer as part of its syntax\n// indicating alignment. If data fall under different alignments then you might\n// get a compilation error indicating a `Section type conflict`.\n#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)\n#else\n#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))\n#endif\n#endif\n\n// ABSL_DECLARE_ATTRIBUTE_SECTION_VARS\n//\n// A weak section declaration to be used as a global declaration\n// for ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link\n// even without functions with ABSL_ATTRIBUTE_SECTION(name).\n// ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's\n// a no-op on ELF but not on Mach-O.\n//\n#ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS\n#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) \\\n extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \\\n extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK\n#endif\n#ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS\n#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)\n#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)\n#endif\n\n// ABSL_ATTRIBUTE_SECTION_START\n//\n// Returns `void*` pointers to start/end of a section of code with\n// functions having ABSL_ATTRIBUTE_SECTION(name).\n// Returns 0 if no such functions exist.\n// One must ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and\n// link.\n//\n#define ABSL_ATTRIBUTE_SECTION_START(name) \\\n (reinterpret_cast(__start_##name))\n#define ABSL_ATTRIBUTE_SECTION_STOP(name) \\\n (reinterpret_cast(__stop_##name))\n\n#else // !ABSL_HAVE_ATTRIBUTE_SECTION\n\n#define ABSL_HAVE_ATTRIBUTE_SECTION 0\n\n// provide dummy definitions\n#define ABSL_ATTRIBUTE_SECTION(name)\n#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)\n#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)\n#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)\n#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)\n#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast(0))\n#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast(0))\n\n#endif // ABSL_ATTRIBUTE_SECTION\n\n// ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC\n//\n// Support for aligning the stack on 32-bit x86.\n#if ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) || \\\n (defined(__GNUC__) && !defined(__clang__))\n#if defined(__i386__)\n#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \\\n __attribute__((force_align_arg_pointer))\n#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)\n#elif defined(__x86_64__)\n#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)\n#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC\n#else // !__i386__ && !__x86_64\n#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)\n#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC\n#endif // __i386__\n#else\n#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC\n#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)\n#endif\n\n// ABSL_MUST_USE_RESULT\n//\n// Tells the compiler to warn about unused results.\n//\n// For code or headers that are assured to only build with C++17 and up, prefer\n// just using the standard `[[nodiscard]]` directly over this macro.\n//\n// When annotating a function, it must appear as the first part of the\n// declaration or definition. The compiler will warn if the return value from\n// such a function is unused:\n//\n// ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();\n// AllocateSprocket(); // Triggers a warning.\n//\n// When annotating a class, it is equivalent to annotating every function which\n// returns an instance.\n//\n// class ABSL_MUST_USE_RESULT Sprocket {};\n// Sprocket(); // Triggers a warning.\n//\n// Sprocket MakeSprocket();\n// MakeSprocket(); // Triggers a warning.\n//\n// Note that references and pointers are not instances:\n//\n// Sprocket* SprocketPointer();\n// SprocketPointer(); // Does *not* trigger a warning.\n//\n// ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result\n// warning. For that, warn_unused_result is used only for clang but not for gcc.\n// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425\n//\n// Note: past advice was to place the macro after the argument list.\n//\n// TODO(b/176172494): Use ABSL_HAVE_CPP_ATTRIBUTE(nodiscard) when all code is\n// compliant with the stricter [[nodiscard]].\n#if defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)\n#define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))\n#else\n#define ABSL_MUST_USE_RESULT\n#endif\n\n// ABSL_ATTRIBUTE_HOT, ABSL_ATTRIBUTE_COLD\n//\n// Tells GCC that a function is hot or cold. GCC can use this information to\n// improve static analysis, i.e. a conditional branch to a cold function\n// is likely to be not-taken.\n// This annotation is used for function declarations.\n//\n// Example:\n//\n// int foo() ABSL_ATTRIBUTE_HOT;\n#if ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_HOT __attribute__((hot))\n#else\n#define ABSL_ATTRIBUTE_HOT\n#endif\n\n#if ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_COLD __attribute__((cold))\n#else\n#define ABSL_ATTRIBUTE_COLD\n#endif\n\n// ABSL_XRAY_ALWAYS_INSTRUMENT, ABSL_XRAY_NEVER_INSTRUMENT, ABSL_XRAY_LOG_ARGS\n//\n// We define the ABSL_XRAY_ALWAYS_INSTRUMENT and ABSL_XRAY_NEVER_INSTRUMENT\n// macro used as an attribute to mark functions that must always or never be\n// instrumented by XRay. Currently, this is only supported in Clang/LLVM.\n//\n// For reference on the LLVM XRay instrumentation, see\n// http://llvm.org/docs/XRay.html.\n//\n// A function with the XRAY_ALWAYS_INSTRUMENT macro attribute in its declaration\n// will always get the XRay instrumentation sleds. These sleds may introduce\n// some binary size and runtime overhead and must be used sparingly.\n//\n// These attributes only take effect when the following conditions are met:\n//\n// * The file/target is built in at least C++11 mode, with a Clang compiler\n// that supports XRay attributes.\n// * The file/target is built with the -fxray-instrument flag set for the\n// Clang/LLVM compiler.\n// * The function is defined in the translation unit (the compiler honors the\n// attribute in either the definition or the declaration, and must match).\n//\n// There are cases when, even when building with XRay instrumentation, users\n// might want to control specifically which functions are instrumented for a\n// particular build using special-case lists provided to the compiler. These\n// special case lists are provided to Clang via the\n// -fxray-always-instrument=... and -fxray-never-instrument=... flags. The\n// attributes in source take precedence over these special-case lists.\n//\n// To disable the XRay attributes at build-time, users may define\n// ABSL_NO_XRAY_ATTRIBUTES. Do NOT define ABSL_NO_XRAY_ATTRIBUTES on specific\n// packages/targets, as this may lead to conflicting definitions of functions at\n// link-time.\n//\n// XRay isn't currently supported on Android:\n// https://github.com/android/ndk/issues/368\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \\\n !defined(ABSL_NO_XRAY_ATTRIBUTES) && !defined(__ANDROID__)\n#define ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]\n#define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)\n#define ABSL_XRAY_LOG_ARGS(N) \\\n [[clang::xray_always_instrument, clang::xray_log_args(N)]]\n#else\n#define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]\n#endif\n#else\n#define ABSL_XRAY_ALWAYS_INSTRUMENT\n#define ABSL_XRAY_NEVER_INSTRUMENT\n#define ABSL_XRAY_LOG_ARGS(N)\n#endif\n\n// ABSL_ATTRIBUTE_REINITIALIZES\n//\n// Indicates that a member function reinitializes the entire object to a known\n// state, independent of the previous state of the object.\n//\n// The clang-tidy check bugprone-use-after-move allows member functions marked\n// with this attribute to be called on objects that have been moved from;\n// without the attribute, this would result in a use-after-move warning.\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::reinitializes)\n#define ABSL_ATTRIBUTE_REINITIALIZES [[clang::reinitializes]]\n#else\n#define ABSL_ATTRIBUTE_REINITIALIZES\n#endif\n\n// -----------------------------------------------------------------------------\n// Variable Attributes\n// -----------------------------------------------------------------------------\n\n// ABSL_ATTRIBUTE_UNUSED\n//\n// Prevents the compiler from complaining about variables that appear unused.\n//\n// Deprecated: Use the standard C++17 `[[maybe_unused]]` instead.\n//\n// Due to differences in positioning requirements between the old, compiler\n// specific __attribute__ syntax and the now standard `[[maybe_unused]]`, this\n// macro does not attempt to take advantage of `[[maybe_unused]]`.\n#if ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))\n#undef ABSL_ATTRIBUTE_UNUSED\n#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))\n#else\n#define ABSL_ATTRIBUTE_UNUSED\n#endif\n\n// ABSL_ATTRIBUTE_INITIAL_EXEC\n//\n// Tells the compiler to use \"initial-exec\" mode for a thread-local variable.\n// See http://people.redhat.com/drepper/tls.pdf for the gory details.\n#if ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model(\"initial-exec\")))\n#else\n#define ABSL_ATTRIBUTE_INITIAL_EXEC\n#endif\n\n// ABSL_ATTRIBUTE_PACKED\n//\n// Instructs the compiler not to use natural alignment for a tagged data\n// structure, but instead to reduce its alignment to 1.\n//\n// Use of this attribute is HIGHLY DISCOURAGED. Taking the address of or\n// binding a reference to any unaligned member is UB, and it is very easy to\n// do so unintentionally when passing such members as function arguments.\n//\n// DO NOT APPLY THIS ATTRIBUTE TO STRUCTS CONTAINING ATOMICS. Doing\n// so can cause atomic variables to be mis-aligned and silently violate\n// atomicity on x86.\n//\n// This attribute can either be applied to members of a structure or to a\n// structure in its entirety. Applying this attribute (judiciously) to a\n// structure in its entirety to optimize the memory footprint of very\n// commonly-used structs is fine. Do not apply this attribute to a structure in\n// its entirety if the purpose is to control the offsets of the members in the\n// structure. Instead, apply this attribute only to structure members that need\n// it.\n//\n// When applying ABSL_ATTRIBUTE_PACKED only to specific structure members the\n// natural alignment of structure members not annotated is preserved. Aligned\n// member accesses are faster than non-aligned member accesses even if the\n// targeted microprocessor supports non-aligned accesses.\n#if ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))\n#else\n#define ABSL_ATTRIBUTE_PACKED\n#endif\n\n// ABSL_ATTRIBUTE_FUNC_ALIGN\n//\n// Tells the compiler to align the function start at least to certain\n// alignment boundary\n#if ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))\n#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))\n#else\n#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)\n#endif\n\n// ABSL_FALLTHROUGH_INTENDED\n//\n// Annotates implicit fall-through between switch labels, allowing a case to\n// indicate intentional fallthrough and turn off warnings about any lack of a\n// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by\n// a semicolon and can be used in most places where `break` can, provided that\n// no statements exist between it and the next switch label.\n//\n// Example:\n//\n// switch (x) {\n// case 40:\n// case 41:\n// if (truth_is_out_there) {\n// ++x;\n// ABSL_FALLTHROUGH_INTENDED; // Use instead of/along with annotations\n// // in comments\n// } else {\n// return x;\n// }\n// case 42:\n// ...\n//\n// Notes: When supported, GCC and Clang can issue a warning on switch labels\n// with unannotated fallthrough using the warning `-Wimplicit-fallthrough`. See\n// clang documentation on language extensions for details:\n// https://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough\n//\n// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro has\n// no effect on diagnostics. In any case this macro has no effect on runtime\n// behavior and performance of code.\n\n#ifdef ABSL_FALLTHROUGH_INTENDED\n#error \"ABSL_FALLTHROUGH_INTENDED should not be defined.\"\n#elif ABSL_HAVE_CPP_ATTRIBUTE(fallthrough)\n#define ABSL_FALLTHROUGH_INTENDED [[fallthrough]]\n#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::fallthrough)\n#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]\n#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::fallthrough)\n#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]\n#else\n#define ABSL_FALLTHROUGH_INTENDED \\\n do { \\\n } while (0)\n#endif\n\n// ABSL_DEPRECATED()\n//\n// Marks a deprecated class, struct, enum, function, method and variable\n// declarations. The macro argument is used as a custom diagnostic message (e.g.\n// suggestion of a better alternative).\n//\n// For code or headers that are assured to only build with C++14 and up, prefer\n// just using the standard `[[deprecated(\"message\")]]` directly over this macro.\n//\n// Examples:\n//\n// class ABSL_DEPRECATED(\"Use Bar instead\") Foo {...};\n//\n// ABSL_DEPRECATED(\"Use Baz() instead\") void Bar() {...}\n//\n// template \n// ABSL_DEPRECATED(\"Use DoThat() instead\")\n// void DoThis();\n//\n// enum FooEnum {\n// kBar ABSL_DEPRECATED(\"Use kBaz instead\"),\n// };\n//\n// Every usage of a deprecated entity will trigger a warning when compiled with\n// GCC/Clang's `-Wdeprecated-declarations` option. Google's production toolchain\n// turns this warning off by default, instead relying on clang-tidy to report\n// new uses of deprecated code.\n#if ABSL_HAVE_ATTRIBUTE(deprecated)\n#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))\n#else\n#define ABSL_DEPRECATED(message)\n#endif\n\n// When deprecating Abseil code, it is sometimes necessary to turn off the\n// warning within Abseil, until the deprecated code is actually removed. The\n// deprecated code can be surrounded with these directives to achieve that\n// result.\n//\n// class ABSL_DEPRECATED(\"Use Bar instead\") Foo;\n//\n// ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING\n// Baz ComputeBazFromFoo(Foo f);\n// ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING\n#if defined(__GNUC__) || defined(__clang__)\n// Clang also supports these GCC pragmas.\n#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING \\\n _Pragma(\"GCC diagnostic push\") \\\n _Pragma(\"GCC diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING \\\n _Pragma(\"GCC diagnostic pop\")\n#elif defined(_MSC_VER)\n#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING \\\n _Pragma(\"warning(push)\") _Pragma(\"warning(disable: 4996)\")\n#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING \\\n _Pragma(\"warning(pop)\")\n#else\n#define ABSL_INTERNAL_DISABLE_DEPRECATED_DECLARATION_WARNING\n#define ABSL_INTERNAL_RESTORE_DEPRECATED_DECLARATION_WARNING\n#endif // defined(__GNUC__) || defined(__clang__)\n\n// ABSL_REQUIRE_EXPLICIT_INIT\n//\n// ABSL_REQUIRE_EXPLICIT_INIT is placed *after* the data members of an aggregate\n// type to indicate that the annotated member must be explicitly initialized by\n// the user whenever the aggregate is constructed. For example:\n//\n// struct Coord {\n// int x ABSL_REQUIRE_EXPLICIT_INIT;\n// int y ABSL_REQUIRE_EXPLICIT_INIT;\n// };\n// Coord coord = {1}; // warning: field 'y' is not explicitly initialized\n//\n// Note that usage on C arrays is not supported in C++.\n// Use a struct (such as std::array) to wrap the array member instead.\n//\n// Avoid applying this attribute to the members of non-aggregate types.\n// The behavior within non-aggregates is unspecified and subject to change.\n//\n// Do NOT attempt to suppress or demote the error generated by this attribute.\n// Just like with a missing function argument, it is a hard error by design.\n//\n// See the upstream documentation for more details:\n// https://clang.llvm.org/docs/AttributeReference.html#require-explicit-initialization\n#ifdef __cplusplus\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::require_explicit_initialization)\n// clang-format off\n#define ABSL_REQUIRE_EXPLICIT_INIT \\\n [[clang::require_explicit_initialization]] = \\\n AbslInternal_YouForgotToExplicitlyInitializeAField::v\n#else\n#define ABSL_REQUIRE_EXPLICIT_INIT \\\n = AbslInternal_YouForgotToExplicitlyInitializeAField::v\n#endif\n// clang-format on\n#else\n// clang-format off\n#if ABSL_HAVE_ATTRIBUTE(require_explicit_initialization)\n#define ABSL_REQUIRE_EXPLICIT_INIT \\\n __attribute__((require_explicit_initialization))\n#else\n#define ABSL_REQUIRE_EXPLICIT_INIT \\\n /* No portable fallback for C is available */\n#endif\n// clang-format on\n#endif\n\n#ifdef __cplusplus\nstruct AbslInternal_YouForgotToExplicitlyInitializeAField {\n // A portable version of [[clang::require_explicit_initialization]] that\n // never builds, as a last resort for all toolchains.\n // The error messages are poor, so we don't rely on this unless we have to.\n template \n#if !defined(SWIG)\n constexpr\n#endif\n operator T() const /* NOLINT */ {\n const void *volatile deliberately_volatile_ptr = nullptr;\n // Infinite loop to prevent constexpr compilation\n for (;;) {\n // This assignment ensures the 'this' pointer is not optimized away, so\n // that linking always fails.\n deliberately_volatile_ptr = this; // Deliberately not constexpr\n (void)deliberately_volatile_ptr;\n }\n }\n // This is deliberately left undefined to prevent linking\n static AbslInternal_YouForgotToExplicitlyInitializeAField v;\n};\n#endif\n\n// ABSL_CONST_INIT\n//\n// A variable declaration annotated with the `ABSL_CONST_INIT` attribute will\n// not compile (on supported platforms) unless the variable has a constant\n// initializer. This is useful for variables with static and thread storage\n// duration, because it guarantees that they will not suffer from the so-called\n// \"static init order fiasco\".\n//\n// This attribute must be placed on the initializing declaration of the\n// variable. Some compilers will give a -Wmissing-constinit warning when this\n// attribute is placed on some other declaration but missing from the\n// initializing declaration.\n//\n// In some cases (notably with thread_local variables), `ABSL_CONST_INIT` can\n// also be used in a non-initializing declaration to tell the compiler that a\n// variable is already initialized, reducing overhead that would otherwise be\n// incurred by a hidden guard variable. Thus annotating all declarations with\n// this attribute is recommended to potentially enhance optimization.\n//\n// Example:\n//\n// class MyClass {\n// public:\n// ABSL_CONST_INIT static MyType my_var;\n// };\n//\n// ABSL_CONST_INIT MyType MyClass::my_var = MakeMyType(...);\n//\n// For code or headers that are assured to only build with C++20 and up, prefer\n// just using the standard `constinit` keyword directly over this macro.\n//\n// Note that this attribute is redundant if the variable is declared constexpr.\n#if defined(__cpp_constinit) && __cpp_constinit >= 201907L\n#define ABSL_CONST_INIT constinit\n#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)\n#define ABSL_CONST_INIT [[clang::require_constant_initialization]]\n#else\n#define ABSL_CONST_INIT\n#endif\n\n// ABSL_ATTRIBUTE_PURE_FUNCTION\n//\n// ABSL_ATTRIBUTE_PURE_FUNCTION is used to annotate declarations of \"pure\"\n// functions. A function is pure if its return value is only a function of its\n// arguments. The pure attribute prohibits a function from modifying the state\n// of the program that is observable by means other than inspecting the\n// function's return value. Declaring such functions with the pure attribute\n// allows the compiler to avoid emitting some calls in repeated invocations of\n// the function with the same argument values.\n//\n// Example:\n//\n// ABSL_ATTRIBUTE_PURE_FUNCTION std::string FormatTime(Time t);\n#if ABSL_HAVE_CPP_ATTRIBUTE(gnu::pure)\n#define ABSL_ATTRIBUTE_PURE_FUNCTION [[gnu::pure]]\n#elif ABSL_HAVE_ATTRIBUTE(pure)\n#define ABSL_ATTRIBUTE_PURE_FUNCTION __attribute__((pure))\n#else\n// If the attribute isn't defined, we'll fallback to ABSL_MUST_USE_RESULT since\n// pure functions are useless if its return is ignored.\n#define ABSL_ATTRIBUTE_PURE_FUNCTION ABSL_MUST_USE_RESULT\n#endif\n\n// ABSL_ATTRIBUTE_CONST_FUNCTION\n//\n// ABSL_ATTRIBUTE_CONST_FUNCTION is used to annotate declarations of \"const\"\n// functions. A const function is similar to a pure function, with one\n// exception: Pure functions may return value that depend on a non-volatile\n// object that isn't provided as a function argument, while the const function\n// is guaranteed to return the same result given the same arguments.\n//\n// Example:\n//\n// ABSL_ATTRIBUTE_CONST_FUNCTION int64_t ToInt64Milliseconds(Duration d);\n#if defined(_MSC_VER) && !defined(__clang__)\n// Put the MSVC case first since MSVC seems to parse const as a C++ keyword.\n#define ABSL_ATTRIBUTE_CONST_FUNCTION ABSL_ATTRIBUTE_PURE_FUNCTION\n#elif ABSL_HAVE_CPP_ATTRIBUTE(gnu::const)\n#define ABSL_ATTRIBUTE_CONST_FUNCTION [[gnu::const]]\n#elif ABSL_HAVE_ATTRIBUTE(const)\n#define ABSL_ATTRIBUTE_CONST_FUNCTION __attribute__((const))\n#else\n// Since const functions are more restrictive pure function, we'll fallback to a\n// pure function if the const attribute is not handled.\n#define ABSL_ATTRIBUTE_CONST_FUNCTION ABSL_ATTRIBUTE_PURE_FUNCTION\n#endif\n\n// ABSL_ATTRIBUTE_LIFETIME_BOUND indicates that a resource owned by a function\n// parameter or implicit object parameter is retained by the return value of the\n// annotated function (or, for a parameter of a constructor, in the value of the\n// constructed object). This attribute causes warnings to be produced if a\n// temporary object does not live long enough.\n//\n// When applied to a reference parameter, the referenced object is assumed to be\n// retained by the return value of the function. When applied to a non-reference\n// parameter (for example, a pointer or a class type), all temporaries\n// referenced by the parameter are assumed to be retained by the return value of\n// the function.\n//\n// See also the upstream documentation:\n// https://clang.llvm.org/docs/AttributeReference.html#lifetimebound\n// https://learn.microsoft.com/en-us/cpp/code-quality/c26816?view=msvc-170\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetimebound)\n#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[clang::lifetimebound]]\n#elif ABSL_HAVE_CPP_ATTRIBUTE(msvc::lifetimebound)\n#define ABSL_ATTRIBUTE_LIFETIME_BOUND [[msvc::lifetimebound]]\n#elif ABSL_HAVE_ATTRIBUTE(lifetimebound)\n#define ABSL_ATTRIBUTE_LIFETIME_BOUND __attribute__((lifetimebound))\n#else\n#define ABSL_ATTRIBUTE_LIFETIME_BOUND\n#endif\n\n// Internal attribute; name and documentation TBD.\n//\n// See the upstream documentation:\n// https://clang.llvm.org/docs/AttributeReference.html#lifetime_capture_by\n#if ABSL_HAVE_CPP_ATTRIBUTE(clang::lifetime_capture_by)\n#define ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(Owner) \\\n [[clang::lifetime_capture_by(Owner)]]\n#else\n#define ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(Owner)\n#endif\n\n// ABSL_ATTRIBUTE_VIEW indicates that a type is solely a \"view\" of data that it\n// points to, similarly to a span, string_view, or other non-owning reference\n// type.\n// This enables diagnosing certain lifetime issues similar to those enabled by\n// ABSL_ATTRIBUTE_LIFETIME_BOUND, such as:\n//\n// struct ABSL_ATTRIBUTE_VIEW StringView {\n// template\n// StringView(const R&);\n// };\n//\n// StringView f(std::string s) {\n// return s; // warning: address of stack memory returned\n// }\n//\n// We disable this on Clang versions < 13 because of the following\n// false-positive:\n//\n// absl::string_view f(std::optional sv) { return *sv; }\n//\n// See the following links for details:\n// https://reviews.llvm.org/D64448\n// https://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html\n#if ABSL_HAVE_CPP_ATTRIBUTE(gsl::Pointer) && \\\n (!defined(__clang_major__) || __clang_major__ >= 13)\n#define ABSL_ATTRIBUTE_VIEW [[gsl::Pointer]]\n#else\n#define ABSL_ATTRIBUTE_VIEW\n#endif\n\n// ABSL_ATTRIBUTE_OWNER indicates that a type is a container, smart pointer, or\n// similar class that owns all the data that it points to.\n// This enables diagnosing certain lifetime issues similar to those enabled by\n// ABSL_ATTRIBUTE_LIFETIME_BOUND, such as:\n//\n// struct ABSL_ATTRIBUTE_VIEW StringView {\n// template\n// StringView(const R&);\n// };\n//\n// struct ABSL_ATTRIBUTE_OWNER String {};\n//\n// StringView f(String s) {\n// return s; // warning: address of stack memory returned\n// }\n//\n// We disable this on Clang versions < 13 because of the following\n// false-positive:\n//\n// absl::string_view f(std::optional sv) { return *sv; }\n//\n// See the following links for details:\n// https://reviews.llvm.org/D64448\n// https://lists.llvm.org/pipermail/cfe-dev/2018-November/060355.html\n#if ABSL_HAVE_CPP_ATTRIBUTE(gsl::Owner) && \\\n (!defined(__clang_major__) || __clang_major__ >= 13)\n#define ABSL_ATTRIBUTE_OWNER [[gsl::Owner]]\n#else\n#define ABSL_ATTRIBUTE_OWNER\n#endif\n\n// ABSL_ATTRIBUTE_TRIVIAL_ABI\n// Indicates that a type is \"trivially relocatable\" -- meaning it can be\n// relocated without invoking the constructor/destructor, using a form of move\n// elision.\n//\n// From a memory safety point of view, putting aside destructor ordering, it's\n// safe to apply ABSL_ATTRIBUTE_TRIVIAL_ABI if an object's location\n// can change over the course of its lifetime: if a constructor can be run one\n// place, and then the object magically teleports to another place where some\n// methods are run, and then the object teleports to yet another place where it\n// is destroyed. This is notably not true for self-referential types, where the\n// move-constructor must keep the self-reference up to date. If the type changed\n// location without invoking the move constructor, it would have a dangling\n// self-reference.\n//\n// The use of this teleporting machinery means that the number of paired\n// move/destroy operations can change, and so it is a bad idea to apply this to\n// a type meant to count the number of moves.\n//\n// Warning: applying this can, rarely, break callers. Objects passed by value\n// will be destroyed at the end of the call, instead of the end of the\n// full-expression containing the call. In addition, it changes the ABI\n// of functions accepting this type by value (e.g. to pass in registers).\n//\n// See also the upstream documentation:\n// https://clang.llvm.org/docs/AttributeReference.html#trivial-abi\n//\n// b/321691395 - This is currently disabled in open-source builds since\n// compiler support differs. If system libraries compiled with GCC are mixed\n// with libraries compiled with Clang, types will have different ideas about\n// their ABI, leading to hard to debug crashes.\n#define ABSL_ATTRIBUTE_TRIVIAL_ABI\n\n// ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS\n//\n// Indicates a data member can be optimized to occupy no space (if it is empty)\n// and/or its tail padding can be used for other members.\n//\n// For code that is assured to only build with C++20 or later, prefer using\n// the standard attribute `[[no_unique_address]]` directly instead of this\n// macro.\n//\n// https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/#c20-no_unique_address\n// Current versions of MSVC have disabled `[[no_unique_address]]` since it\n// breaks ABI compatibility, but offers `[[msvc::no_unique_address]]` for\n// situations when it can be assured that it is desired. Since Abseil does not\n// claim ABI compatibility in mixed builds, we can offer it unconditionally.\n#if defined(_MSC_VER) && _MSC_VER >= 1929\n#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]\n#elif ABSL_HAVE_CPP_ATTRIBUTE(no_unique_address)\n#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]\n#else\n#define ABSL_ATTRIBUTE_NO_UNIQUE_ADDRESS\n#endif\n\n// ABSL_ATTRIBUTE_UNINITIALIZED\n//\n// GCC and Clang support a flag `-ftrivial-auto-var-init=