Reviewed logic, added algorithms parameter, extended tests

cli/main.cpp

@@ -2,31 +2,35 @@
 
 #include <CLI/CLI.hpp>
 
-#include "core/DirectoryScan.h"
-#include "core/DirectoryGroupScan.h"
+#include "core/facade/FileGroupsScan.h"
 
-void duplicatesSearch(const std::string & directoryPath) {
+namespace {
+    const std::vector<std::string> standardAlgorithms = {"name", "size", "head", "hash"};
+}
+
+void duplicatesSearch(const std::string & directoryPath, const std::vector<std::string> & algorithms) {
     std::cout << "Search duplicates in " << directoryPath << std::endl;
 
-    core::DirectoryScan directoryScan(std::cout);
-    auto duplicates = directoryScan.scan(directoryPath);
+    core::FileGroupsScan fileGroupsScan(std::cout, algorithms);
+    auto duplicates = fileGroupsScan.scan(directoryPath);
 
-    core::DirectoryGroupScan directoryGroupScan;
     for (const auto & group : duplicates) {
-        directoryGroupScan.scan(group);
-    }
-
-    for (auto & group : directoryGroupScan.groups()) {
-        std::cout << group;
+        for (const auto & file : group) {
+            std::cout << file << "\n";
+        }
+        std::cout << "\n";
     }
 }
 
 int main(int argc, char **argv) {
     CLI::App app{"dsearch"};
 
     std::string directory = std::filesystem::current_path().string();
-    auto duplicates = app.add_option("-d,--directory", directory);
+    std::vector<std::string> algorithms = standardAlgorithms;
+    app.add_option("-d,--directory", directory);
+    app.add_option("-als,--algorithms", algorithms);
+
     CLI11_PARSE(app, argc, argv);
 
-    duplicatesSearch(directory);
+    duplicatesSearch(directory, algorithms);
 }

core/CMakeLists.txt

@@ -1,9 +1,8 @@
 cmake_minimum_required(VERSION 3.22.1 FATAL_ERROR)
 
 add_library(core
-    DirectoryScan.cpp
-    DirectoryGroupScan.cpp
-
+    src/duplicate_search/Factory.cpp
+    src/facade/FileGroupsScan.cpp
 )
 
 target_include_directories(core 

core/include/core/duplicate_search/Factory.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <memory>
+
+#include "core/duplicate_search/DuplicateSearch.h"
+
+namespace core {
+    std::unique_ptr<DuplicateSearch> createDuplicateSearch(const std::string & algorithm);
+}

core/include/core/duplicate_search/HashSearch.h

@@ -3,7 +3,7 @@
 #include <fstream>
 #include <string>
 
-#include "core/HashXxh3.h"
+#include "core/hash/HashXxh3.h"
 #include "core/file_api/FileApi.h"
 #include "core/duplicate_search/IndexedSearch.h"
 
@@ -12,19 +12,13 @@ namespace core
 
 class HashSearch : public IndexedSearch<int64_t> {
 public:
-    HashSearch(uint64_t blockSize, uint64_t ignoreSize, std::unique_ptr<FileApi> && fileApi)
+    HashSearch(uint64_t blockSize, std::unique_ptr<FileApi> && fileApi)
     : _blockSize(blockSize)
-    , _ignoreSize(ignoreSize)
     , _fileApi(std::move(fileApi))
     {
     }
 
     void process(const std::filesystem::path & filePath) override {
-        if (std::filesystem::file_size(filePath) <= _ignoreSize) {
-            _ignored.push_back(filePath);
-            return;
-        }
-
         HashXxh3 hash;
 
         _fileApi->open(filePath);
@@ -37,22 +31,9 @@ class HashSearch : public IndexedSearch<int64_t> {
         this->add(hash.digest(), filePath);
     }
 
-    Groups duplicates() const override {
-        auto duplicates = IndexedSearch<int64_t>::duplicates();
-        duplicates.push_back(_ignored);
-        return duplicates;
-    }
-
-    void reset() override {
-        IndexedSearch<int64_t>::reset();
-        _ignored.clear();
-    }
-
 protected:
     uint64_t _blockSize = 0;
-    uint64_t _ignoreSize = 0;
     std::unique_ptr<FileApi> _fileApi;
-    std::vector<std::filesystem::path> _ignored;
 };
 
 }

core/include/core/duplicate_search/IndexedSearch.h

@@ -12,11 +12,10 @@ class IndexedSearch : public DuplicateSearch {
 public:
     Groups duplicates() const override {
         Groups result;
-        std::for_each(std::begin(_duplicatesIndex), std::end(_duplicatesIndex), [&](const auto & pair) {
-            // result.emplace_back(std::move(pair.second));
+
+        for (const auto & pair : _duplicatesIndex) {
             result.push_back(pair.second);
-
-        });
+        }
 
         return result;
     }
@@ -31,7 +30,6 @@ class IndexedSearch : public DuplicateSearch {
         auto uniqueIt = _uniquesIndex.find(key);
 
         if (std::end(_uniquesIndex) != uniqueIt) {
-            //use move?
             _duplicatesIndex[key].push_back(uniqueIt->second);
             _duplicatesIndex[key].push_back(filePath);
 

core/include/core/DirectoryScan.h → core/include/core/facade/FileGroupsScan.h

@@ -2,16 +2,16 @@
 
 #include <memory>
 #include <ostream>
+#include <string>
 #include <vector>
 
-#include "core/DirectoryGroupScan.h"
 #include "core/duplicate_search/DuplicateSearch.h"
 
 namespace core {
 
-class DirectoryScan {
+class FileGroupsScan {
 public:
-    DirectoryScan(std::ostream & logStream);
+    FileGroupsScan(std::ostream & logStream, const std::vector<std::string> & algorithms);
 
     DuplicateSearch::Groups scan(const std::filesystem::path & deirectoryPath);
 

core/include/core/file_api/FileStream.h

@@ -11,7 +11,7 @@ namespace core {
 class FileStream : public FileApi {
 public:
     void open(const std::filesystem::path & filePath) override {
-        _stream = std::move(std::ifstream(filePath.c_str(), std::ios::binary)); 
+        _stream = std::ifstream(filePath.c_str(), std::ios::binary); 
 
         if (!_stream.good()) {
             throw std::runtime_error("can't open " + filePath.string());

core/include/core/HashXxh3.h → core/include/core/hash/HashXxh3.h

@@ -1,7 +1,6 @@
 #include <memory>
 #include <stdexcept>
 
-// #include <xxh3.h>
 #include <xxhash.h>
 
 namespace core {
@@ -32,13 +31,13 @@ class HashXxh3 {
         }
 
         if (XXH3_64bits_update(_state.get(), data.data(), data.size()) == XXH_ERROR) {
-            throw std::runtime_error("xx3 update error");
+            throw std::runtime_error("xx3 vector update error");
         }
     }
 
     void update(const std::string & data) {
         if (XXH3_64bits_update(_state.get(), data.data(), data.size()) == XXH_ERROR) {
-            throw std::runtime_error("xx3 update error");
+            throw std::runtime_error("xx3 string update error");
         }
     }