Database.hpp

Go to the documentation of this file.

#pragma once
 
#include <Core/Core.hpp>
#include <Logger/Logger.hpp>
#include <Utility/FileUtils.hpp>
#include <Utility/SizeUtils.hpp>
#include <Utility/StringUtils.hpp>
 
#include <SQLiteCpp/SQLiteCpp.h>
//#include <Utility/GZip.hpp>
#include "Models/Encryption.hpp"
#include <memory>
#include <vector>
 
 
NS_ENIGMA_BEGIN
 
class Database final {
    ENIGMA_STATIC_CLASS(Database);
 
  public:
#pragma region enums
    enum class OrderBy : byte {
      ID,
      Title,
      DateTime,
      Size,
 
      ENIGMA_ENUM_DECLARE_BEGIN_END(ID)
    };
    friend const char *operator*(OrderBy order_by) {
#define CASE_STR(e) \
  case OrderBy::e:  \
    return #e
      switch (order_by) {
        CASE_STR(ID);
        CASE_STR(Title);
        CASE_STR(DateTime);
        CASE_STR(Size);
        default:
          return "<unknown OrderBy>";
      }
#undef CASE_STR
    }
    friend std::ostream& operator<<(std::ostream& os, const OrderBy order_by) noexcept // for constructing sql
    {
      switch (order_by) {
        case OrderBy::ID:
          os << "ide";
          break;
        case OrderBy::Title:
          os << "title";
          break;
        case OrderBy::DateTime:
          os << "date_time";
          break;
        case OrderBy::Size:
          os << "size";
          break;
        default:
          break;
      }
      return os;
    }
    enum class Order : byte {
      Ascending,
      Descending,
 
      ENIGMA_ENUM_DECLARE_BEGIN_END(Ascending)
    };
    friend const char *operator*(Order order) {
#define CASE_STR(e) \
  case Order::e:    \
    return #e
      switch (order) {
        CASE_STR(Ascending);
        CASE_STR(Descending);
        default:
          return "<unknown Order>";
      }
#undef CASE_STR
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Order order) noexcept // for constructing sql
    {
      return os << (order == Order::Ascending ? "ASC" : "DESC");
    }
#pragma endregion enums
 
  public:
    static void initialize();
    static void shutdown();
 
  public:
    static std::int64_t addEncryption(const std::unique_ptr<Encryption>& e);
 
    static std::int64_t addCipherChunk(const std::unique_ptr<CipherChunk>& cc);
 
    static std::unique_ptr<Encryption> getEncryption(const std::int64_t ide);
 
    static std::unique_ptr<CipherChunk> getCipherChunk(const std::int64_t ide);
 
    static void getCipherChunks(const std::int64_t ide, const std::function<bool(std::unique_ptr<CipherChunk>&& cc)>& callback);
 
    static std::vector<std::unique_ptr<Encryption>> getAllEncryptions(const OrderBy order_by = OrderBy::ID, const Order order = Order::Descending);
 
    static bool deleteEncryption(const std::int64_t ide);
 
    static bool deleteAllEncryptions();
 
    static std::vector<std::unique_ptr<Encryption>> searchEncryptionsByTitle(const std::string& qtitle, OrderBy order_by = OrderBy::ID, Order order = Order::Descending);
 
  public: // Accessors
    static const std::unique_ptr<SQLite::Database>& getStorage() noexcept { return m_database; }
 
  public: // Modifiers
    static void Vacuum() noexcept;
 
    static void Export(const fs::path& filename);
    static void Import(const fs::path& filename);
 
  private:
    inline static std::unique_ptr<SQLite::Database> m_database{nullptr}; 
};
 
NS_ENIGMA_END