load_prebuilt.hpp

Go to the documentation of this file.

#ifndef KNNCOLLE_LOAD_PREBUILT_HPP
#define KNNCOLLE_LOAD_PREBUILT_HPP
 
#include <string>
#include <unordered_map>
#include <functional>
#include <fstream>
#include <memory>
 
#include "Prebuilt.hpp"
#include "Bruteforce.hpp"
#include "Vptree.hpp"
#include "L2Normalized.hpp"
 
namespace knncolle {
 
template<typename Index_, typename Data_, typename Distance_>
using LoadPrebuiltFunction = std::function<Prebuilt<Index_, Data_, Distance_>* (const std::filesystem::path&)>;
 
template<typename Index_, typename Data_, typename Distance_>
inline std::unordered_map<std::string, LoadPrebuiltFunction<Index_, Data_, Distance_> >& load_prebuilt_registry() {
    static std::unordered_map<std::string, LoadPrebuiltFunction<Index_, Data_, Distance_> > registry;
    return registry;
}
 
class LoadPrebuiltNotFoundError final : public std::runtime_error {
public:
    LoadPrebuiltNotFoundError(std::string algorithm, std::filesystem::path path) : 
        std::runtime_error("cannot find a load_prebuilt_registry() function for '" + algorithm + "' at '" + path.string() + "'"),
        my_algorithm(std::move(algorithm)),
        my_path(std::move(path))
    {}
private:
    std::string my_algorithm;
    std::filesystem::path my_path;
 
public:
    const std::string& get_algorithm() const {
        return my_algorithm;
    }
 
    const std::filesystem::path& get_path() const {
        return my_path;
    }
};
 
template<typename Index_, typename Data_, typename Distance_>
Prebuilt<Index_, Data_, Distance_>* load_prebuilt_raw(const std::filesystem::path& dir) {
    const auto alg_path = dir / "ALGORITHM";
    const auto algorithm = quick_load_as_string(alg_path);
 
    const auto& reg = load_prebuilt_registry<Index_, Data_, Distance_>(); 
    auto it = reg.find(algorithm);
    if (it == reg.end()) {
        throw LoadPrebuiltNotFoundError(algorithm, alg_path);
    }
 
    return (it->second)(dir);
}
 
template<typename Index_, typename Data_, typename Distance_>
std::unique_ptr<Prebuilt<Index_, Data_, Distance_> > load_prebuilt_unique(const std::filesystem::path& dir) {
    return std::unique_ptr<Prebuilt<Index_, Data_, Distance_> >(load_prebuilt_raw<Index_, Data_, Distance_>(dir));
}
 
template<typename Index_, typename Data_, typename Distance_>
std::shared_ptr<Prebuilt<Index_, Data_, Distance_> > load_prebuilt_shared(const std::filesystem::path& dir) {
    return std::shared_ptr<Prebuilt<Index_, Data_, Distance_> >(load_prebuilt_raw<Index_, Data_, Distance_>(dir));
}
 
struct L2NormalizedPrebuiltTypes {
    NumericType normalized;
};
 
inline L2NormalizedPrebuiltTypes load_l2normalized_prebuilt_types(const std::filesystem::path& dir) {
    L2NormalizedPrebuiltTypes config;
    quick_load(dir / "NORMALIZED", &(config.normalized), 1);
    return config;
}
 
template<typename Index_, typename Data_, typename Distance_, typename Normalized_>
Prebuilt<Index_, Data_, Distance_>* load_l2normalized_prebuilt(const std::filesystem::path& dir) {
    return new L2NormalizedPrebuilt<Index_, Data_, Distance_, Normalized_>(dir);
}
 
template<typename Index_, typename Data_, typename Distance_, class DistanceMetric_ = DistanceMetric<Data_, Distance_> >
Prebuilt<Index_, Data_, Distance_>* load_bruteforce_prebuilt(const std::filesystem::path& dir) {
    return new BruteforcePrebuilt<Index_, Data_, Distance_, DistanceMetric_>(dir);
}
 
template<typename Index_, typename Data_, typename Distance_, class DistanceMetric_ = DistanceMetric<Data_, Distance_> >
Prebuilt<Index_, Data_, Distance_>* load_vptree_prebuilt(const std::filesystem::path& dir) {
    return new VptreePrebuilt<Index_, Data_, Distance_, DistanceMetric_>(dir);
}
 
}
 
#endif