BUILD.bazel

licenses(["notice"])

exports_files(["LICENSE"])

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

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

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

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

cc_library(
    name = "circular_integer_range_iterator",
    hdrs = ["include/fixed_containers/circular_integer_range_iterator.hpp"],
    includes = ["include"],
    deps = [
        ":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 = ["include"],
    # copts = ["-std=c++20"], # Not needed
)

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

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

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

cc_library(
    name = "enum_map",
    hdrs = ["include/fixed_containers/enum_map.hpp"],
    includes = ["include"],
    deps = [
        ":bidirectional_iterator",
        ":concepts",
        ":enum_utils",
        ":erase_if",
        ":filtered_integer_range_iterator",
        ":fixed_vector",
        ":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 = ["include"],
    deps = [
        ":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 = ["include"],
    deps = [
        "@com_github_neargye_magic_enum//:magic_enum",
    ],
    copts = ["-std=c++20"],
)

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

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

cc_library(
    name = "fixed_deque",
    hdrs = ["include/fixed_containers/fixed_deque.hpp"],
    includes = ["include"],
    deps = [
        ":algorithm",
        ":circular_integer_range_iterator",
        ":consteval_compare",
        ":integer_range",
        ":iterator_utils",
        ":optional_storage",
        ":preconditions",
        ":random_access_iterator",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

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

cc_library(
    name = "fixed_map",
    hdrs = ["include/fixed_containers/fixed_map.hpp",],
    includes = ["include"],
    deps = [
        ":bidirectional_iterator",
        ":erase_if",
        ":fixed_red_black_tree",
        ":map_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 = ["include"],
    deps = [
        ":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 = [
        ":fixed_red_black_tree",
    ],
    includes = ["include"],
    copts = ["-std=c++20"],
)

cc_library(
    name = "fixed_set",
    hdrs = ["include/fixed_containers/fixed_set.hpp"],
    includes = ["include"],
    deps = [
        ":bidirectional_iterator",
        ":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 = ["include"],
    deps = [
        ":fixed_vector",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

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

cc_library(
    name = "fixed_string",
    hdrs = ["include/fixed_containers/fixed_string.hpp"],
    includes = ["include"],
    deps = [
        ":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 = ["include"],
    deps = [
        ":algorithm",
        ":concepts",
        ":consteval_compare",
        ":integer_range",
        ":iterator_utils",
        ":optional_storage",
        ":preconditions",
        ":random_access_iterator_transformer",
        ":sequence_container_checking",
        ":source_location",
    ],
    copts = ["-std=c++20"],
)

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

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

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

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

cc_library(
    name = "integer_range_iterator",
    hdrs = ["include/fixed_containers/integer_range_iterator.hpp"],
    includes = ["include"],
    deps = [
        ":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 = ["include"],
    copts = ["-std=c++20"],
)

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

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

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

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

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

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

cc_library(
    name = "random_access_iterator",
    hdrs = ["include/fixed_containers/random_access_iterator.hpp"],
    includes = ["include"],
    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 = ["include"],
    deps = [
        ":iterator_utils"
    ],
    copts = ["-std=c++20"],
)

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

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

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

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

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

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

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

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

cc_library(
    name = "value_or_reference_storage",
    hdrs = ["include/fixed_containers/value_or_reference_storage.hpp"],
    includes = ["include"],
    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"],
    deps = [":concepts"],
    strip_include_prefix = "/test",
    copts = ["-std=c++20"],
    visibility = ["//visibility:private"],
)

cc_library(
    name = "mock_testing_types",
    hdrs = ["test/mock_testing_types.hpp"],
    deps = [":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_integer_range_iterator_test",
    srcs = ["test/circular_integer_range_iterator_test.cpp"],
    deps = [
        ":concepts",
        ":circular_integer_range_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 = [
        ":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 = [
        ":consteval_compare",
        ":enum_array",
        ":enums_test_common",
        ":mock_testing_types",
        "@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 = [
        ":consteval_compare",
        ":enum_map",
        ":enums_test_common",
        ":instance_counter",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
        "@com_github_ericniebler_range-v3//:range-v3",
    ],
    copts = ["-std=c++20"],
)

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

cc_test(
    name = "enum_utils_test",
    srcs = ["test/enum_utils_test.cpp"],
    deps = [
        ":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 = [
        ":concepts",
        ":filtered_integer_range_iterator",
        "@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 = [
        ":fixed_deque",
        ":instance_counter",
        ":mock_testing_types",
        ":test_utilities_common",
        "@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_map",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_map_test",
    srcs = ["test/fixed_map_test.cpp"],
    deps = [
        ":concepts",
        ":consteval_compare",
        ":fixed_map",
        ":instance_counter",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
        "@com_github_ericniebler_range-v3//:range-v3",
    ],
    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_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 = [
        ":concepts",
        ":consteval_compare",
        ":fixed_red_black_tree",
        ":fixed_red_black_tree_view",
        ":fixed_set",
        ":mock_testing_types",
        ":test_utilities_common",
        "@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 = [
        ":concepts",
        ":consteval_compare",
        ":fixed_set",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
        "@com_github_ericniebler_range-v3//:range-v3",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "fixed_stack_test",
    srcs = ["test/fixed_stack_test.cpp"],
    deps = [
        ":concepts",
        ":fixed_stack",
        ":fixed_vector",
        "@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",
        "@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",
        ":mock_testing_types",
        ":test_utilities_common",
        "@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 = [
        ":fixed_vector",
        ":instance_counter",
        ":mock_testing_types",
        ":test_utilities_common",
        "@com_github_ericniebler_range-v3//:range-v3",
        "@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",
        "@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_utils",
        ":enum_set",
        ":enum_map",
        ":fixed_deque",
        ":fixed_map",
        ":fixed_string",
        ":fixed_set",
        ":fixed_stack",
        ":fixed_vector",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "out_test",
    srcs = ["test/out_test.cpp"],
    deps = [
        ":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",
        ":pair_view",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

cc_test(
    name = "reflection_test",
    srcs = ["test/reflection_test.cpp"],
    deps = [
        ":reflection",
        "@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 = "type_name_test",
    srcs = ["test/type_name_test.cpp"],
    deps = [
        ":type_name",
        "@com_google_googletest//:gtest",
        "@com_google_googletest//:gtest_main",
    ],
    copts = ["-std=c++20"],
)

test_suite(
    name = "all_tests",
)