Constain bounding_aabb_of with static sizing concept

Author: adamkewley

liboscar/Concepts/AssociativeContainerKey.h renamed to liboscar/Concepts/AssociativeContainerKeyFor.h

@@ -10,7 +10,7 @@ namespace osc
     // Satisfied if `Key` is a valid key for the given associative
     // container `Container`.
     template<typename Key, typename Container>
-    concept AssociativeContainerKey = requires(Container& c, Key key) {
+    concept AssociativeContainerKeyFor = requires(Container& c, Key key) {
         requires AssociativeContainer<Container>;
         { c.find(key) } -> std::same_as<std::ranges::iterator_t<Container>>;
     };

liboscar/Concepts/InputRangeWithSizeGreaterThan.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <liboscar/Concepts/RangeWithSizeGreaterThan.h>
+
+#include <ranges>
+
+namespace osc
+{
+    // Satisfied if `T` is a `std::ranges::input_range<T>` AND has a size that's
+    // known at compile-time to be non-zero.
+    template<typename T, size_t N>
+    concept InputRangeWithSizeGreaterThan = std::ranges::input_range<T> and RangeWithSizeGreaterThan<T, N>;
+}

liboscar/Concepts/InputRangeWithSizeGreaterThan.tests.cpp

@@ -0,0 +1,21 @@
+#include "InputRangeWithSizeGreaterThan.h"
+
+#include <gtest/gtest.h>
+
+#include <liboscar/Maths/Triangle.h>
+#include <liboscar/Maths/Vector3.h>
+
+#include <array>
+#include <span>
+
+using namespace osc;
+
+TEST(InputRangeWithSizeGreaterThan, returns_false_for_dynamically_sized_std_span)
+{
+    static_assert(InputRangeWithSizeGreaterThan<Vector3, 2>);
+    static_assert(InputRangeWithSizeGreaterThan<Triangle, 2>);
+    static_assert(InputRangeWithSizeGreaterThan<const Triangle&, 2>);
+    static_assert(not InputRangeWithSizeGreaterThan<Triangle, 3>);
+    static_assert(InputRangeWithSizeGreaterThan<std::span<int, 5>, 4>);
+    static_assert(InputRangeWithSizeGreaterThan<std::array<int, 5>, 4>);
+}

liboscar/Concepts/RangeWithSizeGreaterThan.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <concepts>
+#include <cstddef>
+#include <ranges>
+#include <tuple>
+
+namespace osc
+{
+    namespace detail
+    {
+        template<typename T> concept HasTupleSize = requires { std::tuple_size<std::remove_cvref_t<T>>{}; };
+        template<typename T> concept HasExtent = requires { { std::remove_cvref_t<T>::extent } -> std::convertible_to<size_t>; };
+
+        template<typename T, typename = void>
+        struct SizeHelper { static constexpr size_t size = std::dynamic_extent; };
+
+        template<HasTupleSize T>
+        requires (not HasExtent<T>)
+        struct SizeHelper<T> { static constexpr size_t size = std::tuple_size_v<std::remove_cvref_t<T>>; };
+
+        template<HasExtent T>
+        struct SizeHelper<T> { static constexpr size_t size = std::remove_cvref_t<T>::extent; };
+    }
+
+    // Satisfied if `T` has a compile-time-known size greater than `N`
+    template<typename T, size_t N>
+    concept RangeWithSizeGreaterThan = std::ranges::range<T> and (detail::SizeHelper<T>::size != std::dynamic_extent and detail::SizeHelper<T>::size > N);
+}

liboscar/Concepts/StaticallySizedNonEmptyInputRange.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <liboscar/Concepts/StaticallySizedNonEmptyInputRange.h>
+#include <liboscar/Concepts/InputRangeWithSizeGreaterThan.h>
 #include <liboscar/Maths/AABB.h>
 #include <liboscar/Maths/CommonFunctions.h>
 #include <liboscar/Maths/Matrix4x4.h>
@@ -136,7 +136,7 @@ namespace osc
     }
 
     // returns an `AABB` that tightly bounds the `Vector3`s projected from `r` (specialized for compile-time-non-empty ranges)
-    template<StaticallySizedNonEmptyInputRange R, class Proj = std::identity>
+    template<InputRangeWithSizeGreaterThan<0> R, class Proj = std::identity>
     requires std::convertible_to<typename std::projected<std::ranges::iterator_t<R>, Proj>::value_type, const Vector3&>
     constexpr AABB bounding_aabb_of(R&& r, Proj proj = {})
     {

liboscar/Maths/AABBFunctions.h

@@ -17,8 +17,9 @@ namespace osc
         using const_pointer = const value_type*;
         using iterator = value_type*;
         using const_iterator = const value_type*;
+        static constexpr size_t extent = 3;
 
-        constexpr size_type size() const { return 3; }
+        constexpr size_type size() const { return extent; }
         constexpr pointer data() { return &p0; }
         constexpr const_pointer data() const { return &p0; }
         constexpr iterator begin() { return data(); }

liboscar/Maths/Triangle.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <liboscar/Concepts/AssociativeContainer.h>
-#include <liboscar/Concepts/AssociativeContainerKey.h>
+#include <liboscar/Concepts/AssociativeContainerKeyFor.h>
 
 #include <algorithm>
 #include <concepts>
@@ -89,7 +89,7 @@ namespace osc
     }
 
     // returns a copy of the element with key equivalent to `key`, or `std::nullopt` if no such element exists in `container`
-    template<AssociativeContainer Lookup, AssociativeContainerKey<Lookup> Key>
+    template<AssociativeContainer Lookup, AssociativeContainerKeyFor<Lookup> Key>
     std::optional<typename Lookup::mapped_type> lookup_or_nullopt(const Lookup& lookup, const Key& key)
     {
         if (const auto it = lookup.find(key); it != lookup.end()) {
@@ -112,7 +112,7 @@ namespace osc
     }
 
     // returns a pointer to the element with key equivalent to `key`, or `nullptr` if no such element exists in `container`
-    template<AssociativeContainer T, AssociativeContainerKey<T> Key>
+    template<AssociativeContainer T, AssociativeContainerKeyFor<T> Key>
     auto* lookup_or_nullptr(const T& container, const Key& key)
     {
         using return_type = decltype(std::addressof(std::ranges::begin(container)->second));
@@ -124,7 +124,7 @@ namespace osc
     }
 
     // returns a mutable pointer to the element with key equivalent to `key`, or `nullptr` if no such element exists in `container`
-    template<AssociativeContainer T, AssociativeContainerKey<T> Key>
+    template<AssociativeContainer T, AssociativeContainerKeyFor<T> Key>
     auto* lookup_or_nullptr(T& container, const Key& key)
     {
         using return_type = decltype(std::addressof(std::ranges::begin(container)->second));

liboscar/Utils/Algorithms.h

@@ -6,12 +6,14 @@
 // ready for production, each translation unit should only `#include` it uses.
 
 #include <liboscar/Concepts/AssociativeContainer.h>
-#include <liboscar/Concepts/AssociativeContainerKey.h>
+#include <liboscar/Concepts/AssociativeContainerKeyFor.h>
 #include <liboscar/Concepts/BitCastable.h>
 #include <liboscar/Concepts/ConvertibleToAnyOf.h>
 #include <liboscar/Concepts/DereferencesTo.h>
+#include <liboscar/Concepts/InputRangeWithSizeGreaterThan.h>
 #include <liboscar/Concepts/NamedInputStream.h>
 #include <liboscar/Concepts/ObjectRepresentationByte.h>
+#include <liboscar/Concepts/RangeWithSizeGreaterThan.h>
 #include <liboscar/Concepts/SameAsAnyOf.h>
 #include <liboscar/DOM/Class.h>
 #include <liboscar/DOM/Node.h>