Merge pull request #16903 from vespa-engine/havardpe/avoid-cell-type-switches

avoid cell type switch

3 files changed, 49 insertions, 28 deletions

diff --git a/eval/src/tests/eval/value_type/value_type_test.cpp b/eval/src/tests/eval/value_type/value_type_test.cpp
index e0c90166fa2..120ab2d93e9 100644
--- a/eval/src/tests/eval/value_type/value_type_test.cpp
+++ b/eval/src/tests/eval/value_type/value_type_test.cpp
@@ -561,4 +561,23 @@ TEST("require that peek type inference works as expected") {
     EXPECT_EQUAL(input2.peek({"a", "b", "c", "d", "e"}), type("double"));
 }
 
+TEST("require that cell alignment can be obtained") {
+    EXPECT_EQUAL(CellTypeUtils::alignment(CellType::DOUBLE), alignof(double));
+    EXPECT_EQUAL(CellTypeUtils::alignment(CellType::FLOAT), alignof(float));
+}
+
+TEST("require that cell array size can be calculated") {
+    EXPECT_EQUAL(CellTypeUtils::mem_size(CellType::DOUBLE, 37), 37 * sizeof(double));
+    EXPECT_EQUAL(CellTypeUtils::mem_size(CellType::FLOAT, 37), 37 * sizeof(float));
+}
+
+TEST("require that all cell types can be listed") {
+    std::vector<CellType> expect = {CellType::FLOAT, CellType::DOUBLE};
+    auto list = CellTypeUtils::list_types();
+    ASSERT_EQUAL(list.size(), expect.size());
+    for (size_t i = 0; i < list.size(); ++i) {
+        EXPECT_TRUE(list[i] == expect[i]);
+    }
+}
+
 TEST_MAIN() { TEST_RUN_ALL(); }
diff --git a/eval/src/vespa/eval/eval/cell_type.cpp b/eval/src/vespa/eval/eval/cell_type.cpp
index 365a3f59a56..ff720863cd5 100644
--- a/eval/src/vespa/eval/eval/cell_type.cpp
+++ b/eval/src/vespa/eval/eval/cell_type.cpp
@@ -10,10 +10,30 @@ using vespalib::make_string_short::fmt;
 
 namespace vespalib::eval {
 
-void
-CellTypeUtils::bad_argument(uint32_t id)
+uint32_t
+CellTypeUtils::alignment(CellType cell_type)
 {
-    throw IllegalArgumentException(fmt("Unknown CellType id=%u", id));
+    return TypifyCellType::resolve(cell_type, [](auto t)->uint32_t
+                                   {
+                                       using T = decltype(t)::type;
+                                       return alignof(T);
+                                   });
+}
+
+size_t
+CellTypeUtils::mem_size(CellType cell_type, size_t sz)
+{
+    return TypifyCellType::resolve(cell_type, [sz](auto t)->size_t
+                                   {
+                                       using T = decltype(t)::type;
+                                       return (sz * sizeof(T));
+                                   });
+}
+
+std::vector<CellType>
+CellTypeUtils::list_types()
+{
+    return {CellType::FLOAT, CellType::DOUBLE};
 }
 
 }
diff --git a/eval/src/vespa/eval/eval/cell_type.h b/eval/src/vespa/eval/eval/cell_type.h
index 6bb9756421f..5fcaa57dc43 100644
--- a/eval/src/vespa/eval/eval/cell_type.h
+++ b/eval/src/vespa/eval/eval/cell_type.h
@@ -139,30 +139,6 @@ template <typename A, typename B> constexpr auto unify_cell_types() {
     return get_cell_value<CellMeta::unify(a, b).cell_type>();
 }
 
-struct CellTypeUtils {
-    static void bad_argument [[ noreturn ]] (uint32_t id);
-
-    static constexpr uint32_t alignment(CellType cell_type) {
-        switch (cell_type) {
-        case CellType::DOUBLE: return alignof(double);
-        case CellType::FLOAT: return alignof(float);
-        default: bad_argument((uint32_t)cell_type);
-        }
-    }
-
-    static constexpr size_t mem_size(CellType cell_type, size_t sz) {
-        switch (cell_type) {
-        case CellType::DOUBLE: return sz * sizeof(double);
-        case CellType::FLOAT:  return sz * sizeof(float);
-        default: bad_argument((uint32_t)cell_type);
-        }
-    }
-
-    static std::vector<CellType> list_types() {
-        return {CellType::FLOAT, CellType::DOUBLE};
-    }
-};
-
 struct TypifyCellType {
     template <typename T> using Result = TypifyResultType<T>;
     template <typename F> static decltype(auto) resolve(CellType value, F &&f) {
@@ -170,7 +146,7 @@ struct TypifyCellType {
         case CellType::DOUBLE: return f(Result<double>());
         case CellType::FLOAT:  return f(Result<float>());
         }
-        CellTypeUtils::bad_argument((uint32_t)value);
+        abort();
     }
 };
 
@@ -222,4 +198,10 @@ struct TypifyCellMeta {
     }
 };
 
+struct CellTypeUtils {
+    static uint32_t alignment(CellType cell_type);
+    static size_t mem_size(CellType cell_type, size_t sz);
+    static std::vector<CellType> list_types();
+};
+
 } // namespace