CreateAlgorithm.hpp

Go to the documentation of this file.

#pragma once

#include <tudocomp/Env.hpp>
#include <tudocomp/Registry.hpp>
#include <tudocomp/Algorithm.hpp>
#include <tudocomp/Compressor.hpp>

namespace tdc {

template<typename T, typename registry_root_t = T>
class Builder {
    Registry<registry_root_t> m_registry;
    std::string m_options;
public:
    inline Builder() {}

    inline Builder& options(const std::string& options) {
        m_options = options;
        return *this;
    }


    inline Builder& registry(const Registry<registry_root_t>& reg) {
        m_registry = reg;
        return *this;
    }

    inline Env env() {
        Meta meta = T::meta();
        auto fixed_static_args = std::move(meta).build_static_args_ast_value();

        auto padded_options = meta.name() + "(" + m_options + ")";
        auto meta_type = meta.type();

        eval::AlgorithmTypes types = m_registry.algorithm_map();
        gather_types(types, {
            std::move(meta)
        });

        ast::Parser p { padded_options };

        auto evald_algo = eval::cl_eval(
            p.parse_value(),
            meta_type,
            types,
            std::move(fixed_static_args)
        );

        auto evaluated_options = evald_algo.as_algorithm();

        auto env_root = std::make_shared<EnvRoot>(std::move(evaluated_options));
        Env env(env_root, env_root->algo_value());

        return env;
    }

    template<typename... Args>
    inline T instance(Args&&... args) {
        return T(env(), std::forward<Args>(args)...);
    }
};

template<typename T, typename registry_root_t = T>
Builder<T, registry_root_t> builder() {
    return Builder<T, registry_root_t>();
}


inline std::unique_ptr<Compressor> create_algo_with_registry_dynamic(
        const Registry<Compressor>& registry,
        const AlgorithmValue& algorithm_value) {
    return registry.select_algorithm(algorithm_value);
}

template<typename T, typename registry_root_t, typename... Args>
T create_algo_with_registry(const std::string& options,
                            const Registry<registry_root_t>& registry,
                            Args&&... args) {
    return builder<T, registry_root_t>()
        .registry(registry)
        .options(options)
        .instance(std::forward<Args>(args)...);
}

template<class T, class... Args>
T create_algo(const std::string& options, Args&&... args) {
    return create_algo_with_registry<T>(options, Registry<T>(), std::forward<Args>(args)...);
}

template<class T>
T create_algo() {
    return create_algo<T>("");
}

inline Env create_env(Meta&& meta, const std::string& options = "") {
    auto fixed_static_args = std::move(meta).build_static_args_ast_value();

    auto padded_options = meta.name() + "(" + options + ")";
    auto meta_type = meta.type();

    eval::AlgorithmTypes types;
    gather_types(types, {
        std::move(meta)
    });

    ast::Parser p { padded_options };

    auto evald_algo = eval::cl_eval(
        p.parse_value(),
        meta_type,
        types,
        std::move(fixed_static_args)
    );

    auto evaluated_options = evald_algo.as_algorithm();
    auto env_root = std::make_shared<EnvRoot>(std::move(evaluated_options));
    Env env(env_root, env_root->algo_value());

    return env;
}

}