cachier.h

#ifndef CACHIER_H
#define CACHIER_H
 
#include <algorithm>
#include <dirent.h>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <sys/stat.h>
#include <unistd.h>
#include <vector>
 
class Cachier {
public:
  enum CacheOverwriteOption { OVERWRITE_CACHE, DONT_OVERWRITE_CACHE };
 
  struct HashResult {
    std::size_t key;
    std::string error;
  };
 
  Cachier(const std::string &cache_store_path,
          bool ensure_cache_store_path = true)
      : cache_store_path(cache_store_path) {
 
    // Create cache_store_path if asked
    if (ensure_cache_store_path) {
      createDir(cache_store_path);
    }
 
    // Check if the cache_store_path is valid and writable
    struct stat dir_stat;
    if (!(stat(cache_store_path.c_str(), &dir_stat) == 0 &&
          S_ISDIR(dir_stat.st_mode) &&
          access(cache_store_path.c_str(), W_OK) == 0)) {
      std::cerr
          << "Warning: Cache store path is not valid or not writeable, caching "
             "feature will not work."
          << std::endl;
    } else {
      initialized = true;
    }
  }
 
  HashResult addCache(const std::string &filename,
                      const std::string &content = "",
                      const CacheOverwriteOption &cache_overwrite_option =
                          DONT_OVERWRITE_CACHE) {
 
    initCheck();
 
    // Compute hash
    HashResult hash_result = computeHash(filename);
 
    if (hash_result.error != "") {
      return {0, hash_result.error};
    }
 
    // Prevent overwrite if cache exists and was asked not to overwrite it
    if (cache_overwrite_option == DONT_OVERWRITE_CACHE &&
        cacheExists(hash_result.key)) {
      auto error = "Error: cache exists, not over-writing it.";
      return {0, error};
    }
 
    // Add file to cache_store_path
    bool cache_created =
        createCacheFile(std::to_string(hash_result.key), content);
 
    HashResult error = {0, "Error: unable to create cache file."};
    return cache_created ? hash_result : error;
  }
 
  bool cacheExists(const std::size_t &key) {
    // Check if file is in cache_store_path
    return fileExists(cache_store_path +
                      std::filesystem::path::preferred_separator +
                      std::to_string(key));
  }
 
  bool cacheExists(const std::string &filename) {
 
    initCheck();
 
    // Compute hash
    auto hash_result = computeHash(filename);
 
    // Check if file is in cache_store_path
    return fileExists(cache_store_path +
                      std::filesystem::path::preferred_separator +
                      std::to_string(hash_result.key));
  }
 
  bool isInitialized() {
    initialization_checked = true;
    return initialized;
  }
 
  HashResult computeHash(const std::string &filename) {
 
    struct stat fileStat;
 
    if (stat(filename.c_str(), &fileStat) != 0 &&
        !std::filesystem::is_regular_file(filename)) {
      auto error = "Error: " + filename + " is not a valid file.";
      return {0, error};
    }
 
    // Get file size and modification time
    size_t fileSize = fileStat.st_size;
    time_t fileTime = fileStat.st_mtime;
 
    // Read first 8 bytes of file
    std::ifstream file(filename, std::ios::binary);
    std::vector<char> buffer(8);
    file.read(buffer.data(), 8);
 
    // Hash file name, size, time, and header info
    std::string fileHeader(buffer.begin(), buffer.end());
    std::stringstream ss;
    ss << fileSize << fileTime << fileHeader;
    std::string fileString = filename + ss.str();
    std::size_t fileHash = std::hash<std::string>{}(fileString);
 
    return {fileHash, ""};
  }
 
  std::string getContent(const std::string &key) {
    auto target_cache_file_path =
        cache_store_path + std::filesystem::path::preferred_separator + key;
    return read_file_content(target_cache_file_path);
  }
 
private:
  std::string cache_store_path;
 
  bool initialized = false;
 
  bool initialization_checked = false;
 
  std::size_t stringToSize_t(std::string str) {
    std::stringstream sstream(str);
    size_t result;
    sstream >> result;
    return result;
  }
 
  bool createCacheFile(const std::string &filename,
                       const std::string &content = "") {
    std::string file_path = cache_store_path +
                            std::filesystem::path::preferred_separator +
                            filename;
 
    std::ofstream file(file_path);
    file << content;
    file.close();
 
    return file.good();
  }
 
  bool fileExists(const std::string &path) {
    return std::filesystem::exists(path);
  }
 
  bool createDir(const std::string &path) {
    if (!std::filesystem::exists(path))
      return std::filesystem::create_directories(path);
    else
      return false;
  }
 
  std::string read_file_content(const std::string &filename) {
    std::ifstream file(filename);
    if (!file.is_open()) {
      // handle error
      return "";
    }
    std::string content((std::istreambuf_iterator<char>(file)),
                        (std::istreambuf_iterator<char>()));
    return content;
  }
 
  void initCheck() {
    if (initialization_checked == false) {
      throw std::runtime_error("Initialization checks were not performed, did "
                               "you forgot calling Cachier::isInitialized "
                               "before using the library?");
    }
  }
};
 
#endif // CACHIER_H