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/path.hpp>
#include <arkanjo/base/config/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; }
};
 
struct SimilarPair {
  double similarity;
  uint32_t number_lines = 0;
  PathId id1;
  PathId id2;
};
 
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 {
 
  public:
    enum class Cache_Compatibility {
        Success,
        Fail
    };
 
  private:
    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);
 
    Cache_Compatibility init_similarity_table();
 
    bool is_above_threshold(double similarity) const;
 
  public:
    explicit Similarity_Table(double _similarity_threshold);
 
    explicit Similarity_Table();
 
    Cache_Compatibility load();
 
    void update_similarity(double new_similarity_threshold);
 
    double get_similarity(const Path& path1, const Path& path2);
 
    double get_threshold_similarity() const;
 
    const Path& get_path(PathId id) const;
 
    bool is_similar(const Path& path1, const Path& path2);
 
    void normalize_pair(PathId& id1, PathId& id2) const;
 
    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<SimilarPair> get_all_similar_pairs();
 
    bool compare_paths(const SimilarPair& a, const SimilarPair& b) const;
 
    void sort_pairs_by_line_number(std::vector<SimilarPair>& similar_pairs) const;
 
    void sort_pairs_by_similarity(std::vector<SimilarPair>& similar_pairs) const;
 
    std::vector<Cluster> get_clusters();
 
    std::vector<ClusterInfo> get_clusters_info(bool sorted);
};