similar_function_finder.cpp

Go to the documentation of this file.

#include "similar_function_finder.hpp"
#include "similar_function_finder_entry.hpp"
#include <arkanjo/base/function/function_loader.hpp>
#include <arkanjo/base/function/function_printer.hpp>
#include <arkanjo/base/preprocess_state.hpp>
#include <arkanjo/formatter/format_manager.hpp>
 
using fm = FormatterManager;
 
void SimilarFunctionFinder::find_path_that_meets_pattern() {
    std::vector<Path> paths = similarity_table->get_path_list();
    FunctionLoader loader;
    for (const auto& _path : paths) {
        auto function = loader.load(_path);
 
        if (function.contains_given_pattern(function_pattern))
            path = _path;
    }
}
 
void SimilarFunctionFinder::print_empty_path_message() const {
    fm::write(TEMPLATE_EMPTY_FUNCTION, SimilarFunctionEmptyEntry{
        function_pattern
    }, Format::TEXT);
}
 
Function SimilarFunctionFinder::get_reference_function(const Path& path) const {
    FunctionLoader loader;
    return loader.load(path);
}
 
void SimilarFunctionFinder::print_reference_path() {
    fm::write(REFERENCE_PATH_MESSAGE);
    auto function = get_reference_function(path);
    FunctionPrinter::print_basic_info(function);
}
 
void SimilarFunctionFinder::print_similar_functions(const std::vector<Path>& similar_paths) {
    fm::write(TEMPLATE_COUNT, SimilarFunctionCountEntry{
        similar_paths.size()
    }, Format::TEXT);
    fm::write("");
    for (const auto& similar_path : similar_paths) {
        auto function = get_reference_function(similar_path);
        fm::write(Utils::LIMITER_PRINT);
        FunctionPrinter::print_basic_info(function);
        fm::write(Utils::LIMITER_PRINT);
        fm::write("");
    }
}
 
void SimilarFunctionFinder::print_similar_functions() {
    std::vector<Path> similar_paths = similarity_table->get_similar_path_to_the_reference(path);
 
    fm::write(Utils::LIMITER_PRINT);
    print_reference_path();
    fm::write(Utils::LIMITER_PRINT);
    if (open_folder) {
        auto params = Preprocess_State::read_current_run_params();
        fs::path full_path = params.path / fs::path{path.relative_path()};
        fs::path dir_path = full_path.parent_path();
        Utils::open_folder(dir_path);
        return;
    }
    print_similar_functions(similar_paths);
}
 
void SimilarFunctionFinder::handle_show_mode() {
    Function ref = get_reference_function(path);
    FunctionPrinter::print_basic_info(ref);
    fm::write("");
    FunctionPrinter::print_code(ref, no_numbers);
}
 
SimilarFunctionFinder::SimilarFunctionFinder(Similarity_Table* _similarity_table) {
    similarity_table = _similarity_table;
    function_pattern = "";
}
 
bool SimilarFunctionFinder::validate(const ParsedOptions& options) {
    open_folder = options.has("open");
    show_mode = options.has("show");
    no_numbers = options.has("no-numbers");
 
    if (options.extra_args.empty())
        throw CLIError("Similar Function Finder Command expect one parameter, but none was given");
 
    return true;
}
 
bool SimilarFunctionFinder::run(const ParsedOptions& options) {
    function_pattern = options.extra_args[0];
 
    find_path_that_meets_pattern();
 
    if (path.empty()) {
        print_empty_path_message();
        return true;
    }
 
    if (show_mode) {
        handle_show_mode();
        return true;
    }
 
    print_similar_functions();
 
    return true;
}