similarity_table.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <fstream>
#include <map>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include <arkanjo/base/function.hpp>
#include <arkanjo/base/path.hpp>
#include <arkanjo/utils/utils.hpp>
#include <arkanjo/base/config.hpp>
 
struct PathId {
  int value;
 
  explicit PathId(int v = -1) : value(v) {}
 
  bool operator==(const PathId& other) const {
    return value == other.value;
  }
 
  bool operator!=(const PathId& other) const {
    return value != other.value;
  }
 
  bool operator<(const PathId& other) const {
    return value < other.value;
  }
 
  operator int() const { return value; }
};
 
template<typename Key, typename Weight>
using AdjacencyList = std::vector<std::vector<std::pair<Key, Weight>>>;
 
struct Cluster {
    std::vector<int> members; 
};
 
struct ClusterInfo {
    std::vector<Path> paths;
    int total_lines = 0;
    int total_pairs = 0;
 
    double score() const {
        double w_files = 0.3;
        double w_lines = 0.4;
        double w_density = 0.3;
        double d = total_pairs > 0 ? (double)total_lines / total_pairs : 0;
        return w_files * paths.size() + w_lines * total_lines + w_density * d;
    }
};
 
class Similarity_Table {
  private:
    static constexpr const char* SIMILARITY_TABLE_FILE_NAME = "output_parsed.txt"; 
    static constexpr const double DEFAULT_SIMILARITY = 100.00; 
    static constexpr const double EPS_ERROR_MARGIN = 1e-6;     
    static constexpr const double MAXIMUM_SIMILARITY = 100.00; 
    static constexpr const double MINIMUM_SIMILARITY = 0.00;   
 
    double similarity_threshold;    
    std::vector<Path> paths;        
    std::map<Path, PathId> path_id; 
 
    AdjacencyList<PathId, double> similarity_graph;
    std::map<std::pair<PathId, PathId>, double> similarity_table; 
 
    PathId find_id_path(const Path& path);
 
    void read_comparation(std::ifstream& table_file);
 
    void read_file_table(std::ifstream& table_file);
 
    void init_similarity_table();
 
    bool is_above_threshold(double similarity) const;
 
    std::vector<std::tuple<int, Path, Path>> sort_pairs_by_line_number(const std::vector<std::pair<Path, Path>>& similar_path_pairs) const;
 
  public:
    explicit Similarity_Table(double _similarity_threshold);
 
    explicit Similarity_Table();
 
    void load();
 
    void update_similarity(double new_similarity_threshold);
 
    double get_similarity(const Path& path1, const Path& path2);
 
    bool is_similar(const Path& path1, const Path& path2);
 
    const std::vector<Path>& get_path_list() const;
 
    int get_number_lines_in_pair(const Path& path1, const Path& path2);
 
    std::vector<Path> get_similar_path_to_the_reference(const Path& reference);
 
    std::vector<std::tuple<double, Path, Path>> get_all_path_pairs_and_similarity_sorted_by_similarity();
 
    std::vector<std::pair<Path, Path>> get_all_similar_path_pairs_sorted_by_similarity();
 
    std::vector<std::pair<Path, Path>> get_all_similar_path_pairs_sorted_by_line_number();
 
    std::vector<Cluster> get_clusters();
 
    std::vector<ClusterInfo> get_clusters_info(bool sorted);
};