BUILD.bazel

load("//:build_helpers.bzl", "includes_config", "strip_include_prefix_config")

licenses(["notice"])

exports_files(["LICENSE"])

package(default_visibility = ["//visibility:public"])

# Use `includes` for public usage so diagnostics are not emitted to users for issues in our headers.
# This is because this option uses -isystem for includes.
# More info: https://bazel.build/reference/be/c-cpp#cc_library.includes
#
# Use `strip_include_prefix` during testing so diagnostics apply.
# This is because this option uses -I for includes.
# More info: https://bazel.build/reference/be/c-cpp#cc_library.strip_include_prefix
config_setting(
    name = "strip_include_prefix_instead_of_includes",
    define_values = {"enable_strip_include_prefix_instead_of_includes": "true"},
)

cc_library(
    name = "algorithm",
    hdrs = ["include/fixed_containers/algorithm.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":memory",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "arrow_proxy",
    hdrs = ["include/fixed_containers/arrow_proxy.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "assert_or_abort",
    hdrs = ["include/fixed_containers/assert_or_abort.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "bidirectional_iterator",
    hdrs = ["include/fixed_containers/bidirectional_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":arrow_proxy",
        ":concepts",
        ":iterator_utils",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "circular_indexing",
    hdrs = ["include/fixed_containers/circular_indexing.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":int_math",
        ":integer_range",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "circular_integer_range_iterator",
    hdrs = ["include/fixed_containers/circular_integer_range_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":circular_indexing",
        ":int_math",
        ":integer_range",
        ":iterator_utils",
        ":random_access_iterator",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "comparison_chain",
    hdrs = ["include/fixed_containers/comparison_chain.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    # copts = ["-std=c++20"], # Not needed
)

cc_library(
    name = "concepts",
    hdrs = ["include/fixed_containers/concepts.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "consteval_compare",
    hdrs = ["include/fixed_containers/consteval_compare.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "emplace",
    hdrs = ["include/fixed_containers/emplace.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "enum_array",
    hdrs = ["include/fixed_containers/enum_array.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":enum_utils",
        ":ranges",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "enum_map",
    hdrs = ["include/fixed_containers/enum_map.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":concepts",
        ":emplace",
        ":enum_utils",
        ":erase_if",
        ":filtered_integer_range_iterator",
        ":fixed_vector",
        ":memory",
        ":optional_storage",
        ":pair",
        ":preconditions",
        ":source_location",
        ":type_name",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "enum_set",
    hdrs = ["include/fixed_containers/enum_set.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":concepts",
        ":enum_utils",
        ":erase_if",
        ":filtered_integer_range_iterator",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "enum_utils",
    hdrs = ["include/fixed_containers/enum_utils.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":concepts",
        "@com_github_neargye_magic_enum//:magic_enum",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "erase_if",
    hdrs = ["include/fixed_containers/erase_if.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "filtered_integer_range_iterator",
    hdrs = ["include/fixed_containers/filtered_integer_range_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":integer_range",
        ":iterator_utils",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_circular_deque",
    hdrs = ["include/fixed_containers/fixed_circular_deque.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":fixed_deque",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_circular_queue",
    hdrs = ["include/fixed_containers/fixed_circular_queue.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":fixed_circular_deque",
        ":queue_adapter",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_deque",
    hdrs = ["include/fixed_containers/fixed_deque.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":algorithm",
        ":assert_or_abort",
        ":circular_indexing",
        ":concepts",
        ":integer_range",
        ":iterator_utils",
        ":memory",
        ":optional_storage",
        ":preconditions",
        ":random_access_iterator",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_doubly_linked_list",
    hdrs = ["include/fixed_containers/fixed_doubly_linked_list.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":fixed_index_based_storage",
        ":concepts",
    ]
)

cc_library(
    name = "fixed_doubly_linked_list_raw_view",
    hdrs = ["include/fixed_containers/fixed_doubly_linked_list_raw_view.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":fixed_doubly_linked_list",
        ":forward_iterator",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_index_based_storage",
    hdrs = ["include/fixed_containers/fixed_index_based_storage.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":fixed_vector",
        ":index_or_value_storage",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_list",
    hdrs = ["include/fixed_containers/fixed_list.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":concepts",
        ":fixed_doubly_linked_list",
        ":iterator_utils",
        ":preconditions",
        ":sequence_container_checking",
        ":source_location",
    ]
)

cc_library(
    name = "fixed_map",
    hdrs = ["include/fixed_containers/fixed_map.hpp",],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":concepts",
        ":emplace",
        ":erase_if",
        ":fixed_red_black_tree",
        ":map_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "wyhash",
    hdrs = ["include/fixed_containers/wyhash.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_robinhood_hashtable",
    hdrs = ["include/fixed_containers/fixed_robinhood_hashtable.hpp",],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":map_entry",
        ":fixed_doubly_linked_list",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_map_adapter",
    hdrs = ["include/fixed_containers/fixed_map_adapter.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":erase_if",
        ":forward_iterator",
        ":source_location",
        ":preconditions",
        ":assert_or_abort",
        ":emplace",
    ],
)

cc_library(
    name = "fixed_set_adapter",
    hdrs = ["include/fixed_containers/fixed_set_adapter.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":erase_if",
        ":forward_iterator",
        ":source_location",
        ":preconditions",
        ":assert_or_abort",
    ],
)

cc_library(
    name = "fixed_unordered_map",
    hdrs = ["include/fixed_containers/fixed_unordered_map.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":wyhash",
        ":fixed_robinhood_hashtable",
        ":fixed_map_adapter",
        ":map_checking",
    ]
)

cc_library(
    name = "fixed_unordered_map_raw_view",
    hdrs = ["include/fixed_containers/fixed_unordered_map_raw_view.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":fixed_doubly_linked_list_raw_view",
        ":forward_iterator",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_unordered_set",
    hdrs = ["include/fixed_containers/fixed_unordered_set.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":wyhash",
        ":fixed_robinhood_hashtable",
        ":fixed_set_adapter",
        ":set_checking",
    ]
)

cc_library(
    name = "fixed_unordered_set_raw_view",
    hdrs = ["include/fixed_containers/fixed_unordered_set_raw_view.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":fixed_doubly_linked_list_raw_view",
        ":map_entry",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_queue",
    hdrs = ["include/fixed_containers/fixed_queue.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":fixed_deque",
        ":queue_adapter",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_red_black_tree",
    hdrs = [
        "include/fixed_containers/fixed_red_black_tree.hpp",
        "include/fixed_containers/fixed_red_black_tree_nodes.hpp",
        "include/fixed_containers/fixed_red_black_tree_ops.hpp",
        "include/fixed_containers/fixed_red_black_tree_storage.hpp",
        "include/fixed_containers/fixed_red_black_tree_types.hpp",
    ],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_index_based_storage",
        ":value_or_reference_storage",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_red_black_tree_view",
    hdrs = ["include/fixed_containers/fixed_red_black_tree_view.hpp"],
    deps = [
        ":assert_or_abort",
        ":fixed_red_black_tree",
    ],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_set",
    hdrs = ["include/fixed_containers/fixed_set.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":bidirectional_iterator",
        ":concepts",
        ":erase_if",
        ":fixed_red_black_tree",
        ":set_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_stack",
    hdrs = ["include/fixed_containers/fixed_stack.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":fixed_vector",
        ":sequence_container_checking",
        ":source_location",
        ":stack_adapter",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_string",
    hdrs = ["include/fixed_containers/fixed_string.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_vector",
        ":preconditions",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_vector",
    hdrs = ["include/fixed_containers/fixed_vector.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":algorithm",
        ":concepts",
        ":iterator_utils",
        ":memory",
        ":optional_storage",
        ":preconditions",
        ":random_access_iterator_transformer",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "forward_iterator",
    hdrs = ["include/fixed_containers/forward_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":arrow_proxy",
        ":concepts",
        ":iterator_utils",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "in_out",
    hdrs = ["include/fixed_containers/in_out.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "index_or_value_storage",
    hdrs = ["include/fixed_containers/index_or_value_storage.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts"
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "int_math",
    hdrs = ["include/fixed_containers/int_math.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "integer_range",
    hdrs = ["include/fixed_containers/integer_range.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "integer_range_iterator",
    hdrs = ["include/fixed_containers/integer_range_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":int_math",
        ":integer_range",
        ":iterator_utils",
        ":random_access_iterator",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "iterator_utils",
    hdrs = ["include/fixed_containers/iterator_utils.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "map_checking",
    hdrs = ["include/fixed_containers/map_checking.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":source_location",
        ":type_name",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "optional_storage",
    hdrs = ["include/fixed_containers/optional_storage.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":reference_storage",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "optional_reference",
    hdrs = ["include/fixed_containers/optional_reference.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":optional_reference_checking",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "optional_reference_checking",
    hdrs = ["include/fixed_containers/optional_reference_checking.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "max_size",
    hdrs = ["include/fixed_containers/max_size.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "memory",
    hdrs = ["include/fixed_containers/memory.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "out",
    hdrs = ["include/fixed_containers/out.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "pair",
    hdrs = ["include/fixed_containers/pair.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "pair_view",
    hdrs = ["include/fixed_containers/pair_view.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "map_entry",
    hdrs = ["include/fixed_containers/map_entry.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":value_or_reference_storage",
        ":concepts",
        ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "preconditions",
    hdrs = ["include/fixed_containers/preconditions.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "queue_adapter",
    hdrs = ["include/fixed_containers/queue_adapter.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "random_access_iterator",
    hdrs = ["include/fixed_containers/random_access_iterator.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":arrow_proxy",
        ":iterator_utils",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "random_access_iterator_transformer",
    hdrs = ["include/fixed_containers/random_access_iterator_transformer.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":iterator_utils"
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "ranges",
    hdrs = ["include/fixed_containers/ranges.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [":concepts"],
    copts = ["-std=c++20"],
)

cc_library(
    name = "recursive_reflection_fwd",
    hdrs = ["include/fixed_containers/recursive_reflection_fwd.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":in_out",
        ":reflection",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "recursive_reflection",
    hdrs = ["include/fixed_containers/recursive_reflection.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":in_out",
        ":out",
        ":reflection",
        ":recursive_reflection_fwd",
        ":type_name",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "reference_storage",
    hdrs = ["include/fixed_containers/reference_storage.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [":concepts"],
    copts = ["-std=c++20"],
)

cc_library(
    name = "reflection",
    hdrs = ["include/fixed_containers/reflection.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_stack",
        ":fixed_vector",
        ":in_out",
        ":tuples",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "sequence_container_checking",
    hdrs = ["include/fixed_containers/sequence_container_checking.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":source_location",
        ":string_literal",
        ":type_name",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "set_checking",
    hdrs = ["include/fixed_containers/set_checking.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":source_location",
        ":type_name",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "source_location",
    hdrs = ["include/fixed_containers/source_location.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "stack_adapter",
    hdrs = ["include/fixed_containers/stack_adapter.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "string_literal",
    hdrs = ["include/fixed_containers/string_literal.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "struct_view",
    hdrs = ["include/fixed_containers/struct_view.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":assert_or_abort",
        ":fixed_vector",
        ":fixed_map",
        ":fixed_set",
        ":iterator_utils",
        ":memory",
        ":in_out",
        ":out",
        ":random_access_iterator",
        ":reflection",
        ":recursive_reflection_fwd",
        ":recursive_reflection",
        ":type_name",
        ":preconditions", 
        ":sequence_container_checking",
        ":concepts",
        "@com_github_neargye_magic_enum//:magic_enum",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "tuples",
    hdrs = [
        "include/fixed_containers/tuples.hpp",
        "include/fixed_containers/tuples_as_tuple_view.hpp"
    ],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "type_name",
    hdrs = ["include/fixed_containers/type_name.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    copts = ["-std=c++20"],
)

cc_library(
    name = "value_or_reference_storage",
    hdrs = ["include/fixed_containers/value_or_reference_storage.hpp"],
    includes = includes_config(),
    strip_include_prefix = strip_include_prefix_config(),
    deps = [
        ":concepts",
        ":reference_storage",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "enums_test_common",
    hdrs = ["test/enums_test_common.hpp"],
    deps = [
        ":enum_map",
        ":enum_utils",
        "@com_github_neargye_magic_enum//:magic_enum",
    ],
    copts = ["-std=c++20"],
    strip_include_prefix = "/test",
    visibility = ["//visibility:private"],
)

cc_library(
    name = "instance_counter",
    hdrs = ["test/instance_counter.hpp"],
    strip_include_prefix = "/test",
    copts = ["-std=c++20"],
    visibility = ["//visibility:private"],
)

cc_test(
    name = "instance_counter_test",
    srcs = ["test/instance_counter_test.cpp"],
    deps = [
		":concepts",
        ":instance_counter",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_library(
    name = "mock_testing_types",
    hdrs = ["test/mock_testing_types.hpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
    ],
    strip_include_prefix = "/test",
    copts = ["-std=c++20"],
    visibility = ["//visibility:private"],
)

cc_library(
    name = "test_utilities_common",
    hdrs = ["test/test_utilities_common.hpp"],
    deps = [
        ":concepts",
        "@com_google_googletest//:gtest",
    ],
    copts = ["-std=c++20"],
    strip_include_prefix = "/test",
    visibility = ["//visibility:private"],
)

cc_test(
    name = "circular_indexing_test",
    srcs = ["test/circular_indexing_test.cpp"],
    deps = [
        ":circular_indexing",
        ":integer_range",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "circular_integer_range_iterator_test",
    srcs = ["test/circular_integer_range_iterator_test.cpp"],
    deps = [
        ":concepts",
        ":circular_integer_range_iterator",
        ":integer_range",
        ":iterator_utils",
        ":random_access_iterator",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "comparison_chain_test",
    srcs = ["test/comparison_chain_test.cpp"],
    deps = [
        ":comparison_chain",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "concepts_test",
    srcs = ["test/concepts_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "enum_array_test",
    srcs = ["test/enum_array_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":enum_array",
        ":enums_test_common",
        ":mock_testing_types",
        ":ranges",
        "@com_github_neargye_magic_enum//:magic_enum",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "enum_map_test",
    srcs = ["test/enum_map_test.cpp"],
    deps = [
        ":arrow_proxy",
        ":assert_or_abort",
        ":concepts",
        ":consteval_compare",
        ":enum_map",
        ":enums_test_common",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "enum_set_test",
    srcs = ["test/enum_set_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":consteval_compare",
        ":enum_set",
        ":enums_test_common",
        ":max_size",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "enum_utils_test",
    srcs = ["test/enum_utils_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":enum_utils",
        ":enums_test_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "filtered_integer_range_iterator_test",
    srcs = ["test/filtered_integer_range_iterator_test.cpp"],
    deps = [
        ":bidirectional_iterator",
        ":concepts",
        ":integer_range",
        ":iterator_utils",
        ":filtered_integer_range_iterator",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_circular_deque_test",
    srcs = ["test/fixed_circular_deque_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_circular_deque",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_circular_queue_test",
    srcs = ["test/fixed_circular_queue_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_circular_queue",
        ":fixed_vector",
        ":max_size",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_deque_test",
    srcs = ["test/fixed_deque_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_deque",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_doubly_linked_list_test",
    srcs = ["test/fixed_doubly_linked_list_test.cpp"],
    deps = [
        ":fixed_doubly_linked_list",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_doubly_linked_list_raw_view_test",
    srcs = ["test/fixed_doubly_linked_list_raw_view_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_list",
        ":fixed_doubly_linked_list",
        ":fixed_doubly_linked_list_raw_view",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_map_perf_test",
    srcs = ["test/fixed_map_perf_test.cpp"],
    deps = [
        ":consteval_compare",
        ":fixed_index_based_storage",
        ":fixed_map",
        ":fixed_red_black_tree",
        "@com_google_googletest//:gtest_main",
        "@com_google_benchmark//:benchmark_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_list_test",
    srcs = ["test/fixed_list_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":fixed_list",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_map_test",
    srcs = ["test/fixed_map_test.cpp"],
    deps = [
        ":arrow_proxy",
        ":assert_or_abort",
        ":concepts",
        ":consteval_compare",
        ":fixed_map",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_unordered_map_test",
    srcs = ["test/fixed_unordered_map_test.cpp"],
    deps = [
        ":arrow_proxy",
        ":concepts",
        ":consteval_compare",
        ":fixed_map_adapter",
        ":fixed_unordered_map",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_unordered_map_raw_view_test",
    srcs = ["test/fixed_unordered_map_raw_view_test.cpp"],
    deps = [
		":map_entry",
        ":fixed_unordered_map",
        ":fixed_unordered_map_raw_view",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_unordered_set_test",
    srcs = ["test/fixed_unordered_set_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":fixed_set_adapter",
        ":fixed_unordered_set",
        ":instance_counter",
        ":max_size",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_unordered_set_raw_view_test",
    srcs = ["test/fixed_unordered_set_raw_view_test.cpp"],
    deps = [
        ":concepts",
        ":map_entry",
        ":fixed_unordered_set",
        ":fixed_unordered_set_raw_view",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_red_black_tree_test",
    srcs = ["test/fixed_red_black_tree_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":fixed_index_based_storage",
        ":fixed_red_black_tree",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_red_black_tree_view_test",
    srcs = ["test/fixed_red_black_tree_view_test.cpp"],
    deps = [
        ":fixed_red_black_tree_view",
        ":fixed_red_black_tree",
        ":fixed_set",
        ":fixed_vector",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_set_test",
    srcs = ["test/fixed_set_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":concepts",
        ":consteval_compare",
        ":fixed_set",
        ":max_size",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_robinhood_hashtable_test",
    srcs = ["test/fixed_robinhood_hashtable_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_robinhood_hashtable",
        ":instance_counter",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20",],
)

cc_test(
    name = "fixed_stack_test",
    srcs = ["test/fixed_stack_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_stack",
        ":fixed_vector",
        ":max_size",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_queue_test",
    srcs = ["test/fixed_queue_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_queue",
        ":fixed_vector",
        ":max_size",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_string_test",
    srcs = ["test/fixed_string_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":fixed_string",
        ":max_size",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_vector_test",
    srcs = ["test/fixed_vector_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":fixed_vector",
        ":instance_counter",
        ":max_size",
        ":memory",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "in_out_test",
    srcs = ["test/in_out_test.cpp"],
    deps = [
        ":in_out",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "int_math_test",
    srcs = ["test/int_math_test.cpp"],
    deps = [
        ":int_math",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "integer_range_iterator_test",
    srcs = ["test/integer_range_iterator_test.cpp"],
    deps = [
        ":concepts",
        ":integer_range_iterator",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "integer_range_test",
    srcs = ["test/integer_range_test.cpp"],
    deps = [
        ":concepts",
        ":integer_range",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "macro_countermeasures_test",
    srcs = ["test/macro_countermeasures_test.cpp"],
    deps = [
        ":enum_array",
        ":enum_map",
        ":enum_set",
        ":enum_utils",
        ":fixed_circular_deque",
        ":fixed_circular_queue",
        ":fixed_deque",
        ":fixed_map",
        ":fixed_set",
        ":fixed_stack",
        ":fixed_string",
        ":fixed_unordered_map",
        ":fixed_unordered_set",
        ":fixed_vector",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "memory_test",
    srcs = ["test/memory_test.cpp"],
    deps = [
        ":memory",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "optional_storage_test",
    srcs = ["test/optional_storage_test.cpp"],
    deps = [
        ":optional_storage",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "out_test",
    srcs = ["test/out_test.cpp"],
    deps = [
        ":mock_testing_types",
        ":out",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "pair_test",
    srcs = ["test/pair_test.cpp"],
    deps = [
        ":concepts",
        ":pair",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "pair_view_test",
    srcs = ["test/pair_view_test.cpp"],
    deps = [
        ":concepts",
        ":mock_testing_types",
        ":pair_view",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "queue_adapter_test",
    srcs = ["test/queue_adapter_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_deque",
        ":queue_adapter",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "optional_reference_test",
    srcs = ["test/optional_reference_test.cpp"],
    deps = [
        ":concepts",
        ":optional_reference",
        ":mock_testing_types",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "recursive_reflection_test",
    srcs = ["test/recursive_reflection_test.cpp"],
    deps = [
        ":concepts",
        ":struct_view",
        ":reflection",
        ":recursive_reflection",
        ":recursive_reflection_fwd",
        ":fixed_vector",
        ":fixed_set",
        ":in_out",
        ":out",
        "@com_github_neargye_magic_enum//:magic_enum",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "reflection_test",
    srcs = ["test/reflection_test.cpp"],
    deps = [
        ":consteval_compare",
        ":fixed_vector",
        ":mock_testing_types",
        ":reflection",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "stack_adapter_test",
    srcs = ["test/stack_adapter_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_stack",
        ":stack_adapter",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "string_literal_test",
    srcs = ["test/string_literal_test.cpp"],
    deps = [
        ":string_literal",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "struct_view_test",
    srcs = ["test/struct_view_test.cpp"],
    deps = [
        ":concepts",
        ":struct_view",
        ":reflection",
        ":recursive_reflection",
        ":recursive_reflection_fwd",
        ":fixed_vector",
        ":in_out",
        ":out",
        "@com_github_neargye_magic_enum//:magic_enum",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "tuples_test",
    srcs = ["test/tuples_test.cpp"],
    deps = [
        ":int_math",
        ":tuples",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "type_name_test",
    srcs = ["test/type_name_test.cpp"],
    deps = [
        ":assert_or_abort",
        ":type_name",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

test_suite(
    name = "all_tests",
)