Split up the customized saves into three separate functions.

One per type, so users don't have to define all possible combinations if
they're just interested in customizing the save for one of the types.

Author: LTLA

include/knncolle_annoy/Annoy.hpp

@@ -336,9 +336,20 @@ class AnnoyPrebuilt final : public knncolle::Prebuilt<Index_, Data_, Distance_>
         const auto dname = get_distance_name<AnnoyDistance_>();
         knncolle::quick_save(prefix + "distance", dname, std::strlen(dname));
 
-        auto& cust = customize_save_for_annoy_types<AnnoyDistance_, AnnoyIndex_, AnnoyData_>();
-        if (cust) {
-            cust(prefix);
+        // Handling custom Annoy types. 
+        auto& icust = custom_save_for_annoy_index<AnnoyIndex_>(); 
+        if (icust) {
+            icust(prefix);
+        }
+
+        auto& dcust = custom_save_for_annoy_data<AnnoyData_>();
+        if (dcust) {
+            dcust(prefix);
+        }
+
+        auto& dscust = custom_save_for_annoy_distance<AnnoyDistance_>();
+        if (dscust) {
+            dscust(prefix);
         }
 
         // Not bothering to save anything else; the RNG and thread policy

include/knncolle_annoy/load_annoy_prebuilt.hpp

@@ -62,15 +62,17 @@ inline AnnoyPrebuiltTypes load_annoy_prebuilt_types(const std::string& prefix) {
  * Helper function to define a `knncolle::LoadPrebuiltFunction` for Annoy in `knncolle::load_prebuilt()`.
  *
  * 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_`.
+ * In this function, users should 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 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.
+ * This avoids binary bloat from repeated instantiations of the Annoy template classes, if the user's application only deals with a certain subset of combinations. 
+ *
+ * For unknown types or distances, users can set `custom_save_for_annoy_index()`, `custom_save_for_annoy_data()` and/or `custom_save_for_annoy_distance()`.
+ * Each custom function saves additional information about its type to disk during a `knncolle::Prebuilt::save()` call.
+ * That information can then be parsed in the user-defined `knncolle::LoadPrebuiltFunction` to recover an Annoy index with the appropriate template types.
  * 
  * @tparam Index_ Integer type for the observation indices.
  * @tparam Data_ Numeric type for the input and query data.

include/knncolle_annoy/utils.hpp

@@ -60,19 +60,52 @@ const char* get_distance_name() {
 }
 
 /**
- * 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 `knncolle::get_numeric_type()` or `get_distance_name()`.
+ * Define a customized saving function to preserve `AnnoyIndex_` type information when saving a prebuilt Annoy index in `knncolle::Prebuilt::save()`.
+ * Users can provide their own function here to handle an `AnnoyIndex_` type that is unknown to `knncolle::get_numeric_type()`. 
  * 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. 
  * @tparam AnnoyIndex_ Integer type for the observation indices in the Annoy index.
+ *
+ * @return A global function for saving information about `AnnoyIndex_`. 
+ * By default, no function is provided.
+ * If set, the function will be called by the `knncolle::Prebuilt::save()` method for the Annoy `Prebuilt` subclass.
+ */
+template<class AnnoyIndex_>
+std::function<void(const std::string&)>& custom_save_for_annoy_index() {
+    static std::function<void(const std::string&)> fun;
+    return fun;
+}
+
+/**
+ * Define a customd saving function to preserve `AnnoyData_` type information when saving a prebuilt Annoy index in `knncolle::Prebuilt::save()`.
+ * Users can provide their own function here to handle an `AnnoyData_` type that is unknown to `knncolle::get_numeric_type()`. 
+ * Any modifications to this function are not thread-safe and should be done in a serial section. 
+ *
  * @tparam AnnoyData_ Floating-point type for data in the Annoy index.
  *
- * @return A global function for saving information about `AnnoyDistance_`, `AnnoyIndex_` and `AnnoyData_`.
- * If set, this will be called by the `knncolle::Prebuilt::save()` method for the Annoy `Prebuilt` subclass.
+ * @return A global function for saving information about `AnnoyData_`. 
+ * By default, no function is provided.
+ * If set, the function will be called by the `knncolle::Prebuilt::save()` method for the Annoy `Prebuilt` subclass.
+ */
+template<class AnnoyData_>
+std::function<void(const std::string&)>& custom_save_for_annoy_data() {
+    static std::function<void(const std::string&)> fun;
+    return fun;
+}
+
+/**
+ * Define a customd saving function to preserve `AnnoyDistance_` type information when saving a prebuilt Annoy index in `knncolle::Prebuilt::save()`.
+ * Users can provide their own function here to handle an `AnnoyDistance_` type that is unknown to `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.
+ *
+ * @return A global function for saving information about `AnnoyDistance_`. 
+ * By default, no function is provided.
+ * If set, the function will be called by the `knncolle::Prebuilt::save()` method for the Annoy `Prebuilt` subclass.
  */
-template<class AnnoyDistance_, typename AnnoyIndex_, typename AnnoyData_>
-std::function<void(const std::string&)>& customize_save_for_annoy_types() {
+template<class AnnoyDistance_>
+std::function<void(const std::string&)>& custom_save_for_annoy_distance() {
     static std::function<void(const std::string&)> fun;
     return fun;
 }

tests/src/load_annoy_prebuilt.cpp

@@ -75,10 +75,15 @@ TEST_F(AnnoyLoadPrebuiltTest, Manhattan) {
 }
 
 TEST_F(AnnoyLoadPrebuiltTest, Custom) {
-    auto& cust = knncolle_annoy::customize_save_for_annoy_types<Annoy::Euclidean, int, float>();
-    cust = [](const std::string& prefix) -> void {
+    knncolle_annoy::custom_save_for_annoy_index<int>() = [](const std::string& prefix) -> void {
         knncolle::quick_save(prefix + "FOO", "bar", 3);
     };
+    knncolle_annoy::custom_save_for_annoy_data<float>() = [](const std::string& prefix) -> void {
+        knncolle::quick_save(prefix + "WHEE", "stuff", 5);
+    };
+    knncolle_annoy::custom_save_for_annoy_distance<Annoy::Euclidean>() = [](const std::string& prefix) -> void {
+        knncolle::quick_save(prefix + "YAY", "blah", 4);
+    };
 
     knncolle_annoy::AnnoyBuilder<int, double, double, Annoy::Euclidean> ab;
     auto aptr = ab.build_unique(knncolle::SimpleMatrix<int, double>(ndim, nobs, data.data()));
@@ -88,7 +93,12 @@ TEST_F(AnnoyLoadPrebuiltTest, Custom) {
 
     // Custom function is respected.
     EXPECT_EQ(knncolle::quick_load_as_string(prefix + "FOO"), "bar");
-    cust = nullptr;
+    EXPECT_EQ(knncolle::quick_load_as_string(prefix + "WHEE"), "stuff");
+    EXPECT_EQ(knncolle::quick_load_as_string(prefix + "YAY"), "blah");
+
+    knncolle_annoy::custom_save_for_annoy_index<int>() = nullptr;
+    knncolle_annoy::custom_save_for_annoy_data<float>() = nullptr;
+    knncolle_annoy::custom_save_for_annoy_distance<Annoy::Euclidean>() = nullptr;
 
     // Everything else is still fine.
     auto reloaded = knncolle::load_prebuilt_shared<int, double, double>(prefix);