Moved NumericType and get_numeric_type to knncolle for general use.

Author: LTLA

include/knncolle_annoy/Annoy.hpp

@@ -328,9 +328,9 @@ class AnnoyPrebuilt final : public knncolle::Prebuilt<Index_, Data_, Distance_>
         knncolle::quick_save(prefix + "num_dim", &my_dim, 1);
         knncolle::quick_save(prefix + "search_mult", &my_search_mult, 1);
 
-        NumericType types[2];
-        types[0] = get_numeric_type<AnnoyIndex_>();
-        types[1] = get_numeric_type<AnnoyData_>();
+        knncolle::NumericType types[2];
+        types[0] = knncolle::get_numeric_type<AnnoyIndex_>();
+        types[1] = knncolle::get_numeric_type<AnnoyData_>();
         knncolle::quick_save(prefix + "types", types, 2);
 
         const auto dname = get_distance_name<AnnoyDistance_>();

include/knncolle_annoy/load_annoy_prebuilt.hpp

@@ -26,12 +26,12 @@ struct AnnoyPrebuiltTypes {
     /**
      * Type of the index, i.e., `AnnoyIndex_` in `AnnoyBuilder()`.
      */
-    NumericType index;
+    knncolle::NumericType index;
 
     /**
      * Type of the data, i.e., `AnnoyData_` in `AnnoyBuilder()`.
      */
-    NumericType data;
+    knncolle::NumericType data;
 
     /**
      * Name of the distance metric, i.e., `AnnoyDistance_` in `AnnoyBuilder()`.
@@ -47,7 +47,7 @@ struct AnnoyPrebuiltTypes {
  * This is typically used to choose template parameters for `load_annoy_prebuilt()`.
  */
 inline AnnoyPrebuiltTypes load_annoy_prebuilt_types(const std::string& prefix) {
-    NumericType types[2];
+    knncolle::NumericType types[2];
     knncolle::quick_load(prefix + "types", types, 2);
 
     AnnoyPrebuiltTypes config;
@@ -61,15 +61,16 @@ inline AnnoyPrebuiltTypes load_annoy_prebuilt_types(const std::string& prefix) {
 /**
  * Helper function to define a `knncolle::LoadPrebuiltFunction` for Annoy in `knncolle::load_prebuilt()`.
  *
- * In an Annoy-specific `knncolle::LoadPrebuiltFunction`,
- * users should first call `load_annoy_prebuilt_types()` to figure out the saved index's `AnnoyDistance_`, `AnnoyIndex` and `AnnoyData_`.
- * Then, they can call `load_annoy_prebuilt()` with the specified types to return a pointer to a `knncolle::Prebuilt` object.
- * This can be registered in `load_prebuilt_registry()` with the key in `knncolle_annoy::save_name`.
+ * To load an Annoy index from disk, users are expected to define and register an Annoy-specific `knncolle::LoadPrebuiltFunction`.
+ * In this function, users should first call `load_annoy_prebuilt_types()` to figure out the saved index's `AnnoyDistance_`, `AnnoyIndex` and `AnnoyData_`.
+ * Then, they should call `load_annoy_prebuilt()` with the appropriate types to return a pointer to a `knncolle::Prebuilt` object.
+ * This user-defined function should be registered in `load_prebuilt_registry()` with the key in `knncolle_annoy::save_name`.
  * 
- * We do not automatically register a function as the user is responsible for deciding what types should be handled.
- * This avoids binary bloat from repeated instantiations of the Annoy template classes for every possible combination of types.
- * Instead, the user chooses which combinations of types can be loaded, e.g., if their application only deals with those combinations. 
- * Users may also have more information to handle unknown types from `get_numeric_type()` or unknown distances from `get_distance_name()`.
+ * We do not define a default function for loading Annoy indices as there are too many possible combinations of types.
+ * Instead, the user is responsible for deciding which combinations of types should be handled.
+ * This avoids binary bloat from repeated instantiations of the Annoy template classes, if an application only deals with a certain subset of combinations. 
+ * For types or distances that are unknown to `knncolle::get_numeric_type()` or `get_distance_name()`, respectively,
+ * users can store additional information on disk via `customize_save_for_annoy_types()` for use in loading.
  * 
  * @tparam Index_ Integer type for the observation indices.
  * @tparam Data_ Numeric type for the input and query data.

include/knncolle_annoy/utils.hpp

@@ -3,7 +3,6 @@
 
 #include <fstream>
 #include <string>
-#include <cstdint>
 #include <cstddef>
 #include <stdexcept>
 #include <type_traits>
@@ -60,135 +59,9 @@ const char* get_distance_name() {
     }
 }
 
-/**
- * Numeric types for `AnnoyIndex_` and `AnnoyData_` template parameters of `AnnoyBuilder`.
- * These are typically set by `get_numeric_type()`.
- */
-enum class NumericType : char {
-    UINT8_T, INT8_T,
-    UINT16_T, INT16_T,
-    UINT32_T, INT32_T,
-    UINT64_T, INT64_T,
-    UNSIGNED_CHAR, SIGNED_CHAR, CHAR,
-    UNSIGNED_SHORT, SHORT,
-    UNSIGNED_INT, INT,
-    UNSIGNED_LONG, LONG,
-    UNSIGNED_LONG_LONG, LONG_LONG,
-    SIZE_T, PTRDIFF_T,
-    FLOAT, DOUBLE,
-    UNKNOWN
-};
-
-/**
- * @tparam Type_ Some integer or floating-point type, typically used as `AnnoyIndex_` or `AnnoyData_` in `AnnoyBuilder()`.
- * @return Identity of the numeric type.
- *
- * For unknown types, consider using `customize_save_for_annoy_types()` to add more information to the on-disk representation during a `knncolle::Prebuilt::save()` call.
- */
-template<typename Type_>
-NumericType get_numeric_type() {
-#ifdef UINT8_MAX
-    if constexpr(std::is_same<Type_, std::uint8_t>::value) {
-        return NumericType::UINT8_T;
-    }
-#endif
-#ifdef INT8_MAX
-    if constexpr(std::is_same<Type_, std::int8_t>::value) {
-        return NumericType::INT8_T;
-    }
-#endif
-
-#ifdef UINT16_MAX
-    if constexpr(std::is_same<Type_, std::uint16_t>::value) {
-        return NumericType::UINT16_T;
-    }
-#endif
-#ifdef INT16_MAX
-    if constexpr(std::is_same<Type_, std::int16_t>::value) {
-        return NumericType::INT16_T;
-    }
-#endif
-
-#ifdef UINT32_MAX
-    if constexpr(std::is_same<Type_, std::uint32_t>::value) {
-        return NumericType::UINT32_T;
-    }
-#endif
-#ifdef INT32_MAX
-    if constexpr(std::is_same<Type_, std::int32_t>::value) {
-        return NumericType::INT32_T;
-    }
-#endif
-
-#ifdef UINT64_MAX
-    if constexpr(std::is_same<Type_, std::uint64_t>::value) {
-        return NumericType::UINT64_T;
-    }
-#endif
-#ifdef INT64_MAX
-    if constexpr(std::is_same<Type_, std::int64_t>::value) {
-        return NumericType::INT64_T;
-    }
-#endif
-
-    if constexpr(std::is_same<Type_, unsigned char>::value) {
-        return NumericType::UNSIGNED_CHAR;
-    }
-    if constexpr(std::is_same<Type_, signed char>::value) {
-        return NumericType::SIGNED_CHAR;
-    }
-    if constexpr(std::is_same<Type_, char>::value) {
-        return NumericType::CHAR;
-    }
-
-    if constexpr(std::is_same<Type_, unsigned short>::value) {
-        return NumericType::UNSIGNED_SHORT;
-    }
-    if constexpr(std::is_same<Type_, short>::value) {
-        return NumericType::SHORT;
-    }
-
-    if constexpr(std::is_same<Type_, unsigned int>::value) {
-        return NumericType::UNSIGNED_INT;
-    }
-    if constexpr(std::is_same<Type_, int>::value) {
-        return NumericType::INT;
-    }
-
-    if constexpr(std::is_same<Type_, unsigned long>::value) {
-        return NumericType::UNSIGNED_LONG;
-    }
-    if constexpr(std::is_same<Type_, long>::value) {
-        return NumericType::LONG;
-    }
-
-    if constexpr(std::is_same<Type_, unsigned long long>::value) {
-        return NumericType::UNSIGNED_LONG_LONG;
-    }
-    if constexpr(std::is_same<Type_, long long>::value) {
-        return NumericType::LONG_LONG;
-    }
-
-    if constexpr(std::is_same<Type_, std::size_t>::value) {
-        return NumericType::SIZE_T;
-    }
-    if constexpr(std::is_same<Type_, std::ptrdiff_t>::value) {
-        return NumericType::PTRDIFF_T;
-    }
-
-    if constexpr(std::is_same<Type_, float>::value) {
-        return NumericType::FLOAT;
-    }
-    if constexpr(std::is_same<Type_, double>::value) {
-        return NumericType::DOUBLE;
-    }
-
-    return NumericType::UNKNOWN;
-}
-
 /**
  * Define a customized saving function to preserve type information from the Annoy index in `knncolle::Prebuilt::save()`.
- * Users can provide their own function here, to handle types that are unknown to `get_numeric_type()` or `get_distance_name()`.
+ * Users can provide their own function here, to handle types that are unknown to `knncolle::get_numeric_type()` or `get_distance_name()`.
  * Any modifications to this function are not thread-safe and should be done in a serial section. 
  *
  * @tparam AnnoyDistance_ An **Annoy**-compatible class to compute the distance between vectors. 

tests/src/utils.cpp

@@ -3,48 +3,7 @@
 #include "knncolle_annoy/utils.hpp"
 #include "annoy/annoylib.h"
 
-#include <cstdint>
-#include <cstddef>
-
-TEST(GetNumericType, Basic) {
-    // Don't do more specific tests because some compilers might have aliases
-    // e.g., size_t might be a uint64_t and get reported as a UINT64_T.
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::uint8_t>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::int8_t>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::uint16_t>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::int16_t>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::uint32_t>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::int32_t>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::uint64_t>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::int64_t>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<char>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<signed char>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<unsigned char>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<short>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<unsigned short>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<int>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<unsigned int>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<long>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<unsigned long>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<long long>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<unsigned long long>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::size_t>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<std::ptrdiff_t>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_NE(knncolle_annoy::get_numeric_type<float>(), knncolle_annoy::NumericType::UNKNOWN);
-    EXPECT_NE(knncolle_annoy::get_numeric_type<double>(), knncolle_annoy::NumericType::UNKNOWN);
-
-    EXPECT_EQ(knncolle_annoy::get_numeric_type<bool>(), knncolle_annoy::NumericType::UNKNOWN);
-}
+#include <string>
 
 TEST(GetDistanceName, Basic) {
     EXPECT_EQ(std::string(knncolle_annoy::get_distance_name<Annoy::Euclidean>()), "euclidean");