db.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <filesystem>
#include <fstream>
#include <nlohmann/json.hpp>
#include <variant>
 
#include "../std/expected.hpp"
#include "../std/concept.hpp"
#include "../macro.hpp"

namespace ns_db
{
 
using object_t = nlohmann::basic_json<>::object_t;
class Db;
 
namespace
{
 
namespace fs = std::filesystem;
 
 
using json_t = nlohmann::json;
 
template<typename T>
concept IsString =
     std::convertible_to<std::decay_t<T>, std::string>
  or std::constructible_from<std::string, std::decay_t<T>>;
 
} // anonymous namespace
 
using KeyType = json_t::value_t;

class Db
{
  private:
    std::variant<json_t, std::reference_wrapper<json_t>> m_json;
  public:
    // Constructors
    Db() noexcept;
    template<typename T> requires std::same_as<std::remove_cvref_t<T>, json_t>
    explicit Db(T&& json) noexcept;
    template<typename T> requires std::same_as<std::remove_cvref_t<T>, json_t>
    explicit Db(std::reference_wrapper<T> const& json) noexcept;
    // Element access
    [[maybe_unused]] [[nodiscard]] std::vector<std::string> keys() const noexcept;
    [[maybe_unused]] [[nodiscard]] std::vector<std::pair<std::string, Db>> items() const noexcept;
    template<typename V = Db>
    [[maybe_unused]] [[nodiscard]] Value<V> value() noexcept;
    template<typename F, IsString Ks>
    [[maybe_unused]] [[nodiscard]] decltype(auto) apply(F&& f, Ks&& ks);
    [[maybe_unused]] [[nodiscard]] Value<std::string> dump();
    // Capacity
    [[maybe_unused]] [[nodiscard]] bool empty() const noexcept;
    // Lookup
    template<IsString T>
    [[maybe_unused]] [[nodiscard]] bool contains(T&& t) const noexcept;
    [[maybe_unused]] [[nodiscard]] KeyType type() const noexcept;
    // Modifiers
    template<IsString T>
    [[maybe_unused]] [[nodiscard]] bool erase(T&& t);
    [[maybe_unused]] void clear();
    json_t& data();
    json_t const& data() const;
    // Operators
    template<typename T>
    Db& operator=(T&& t);
    [[maybe_unused]] [[nodiscard]] Db operator()(std::string const& t);
    // Friends
    friend std::ostream& operator<<(std::ostream& os, Db const& db);
};

inline Db::Db() noexcept : m_json(json_t::object())
{
}

template<typename T> requires std::same_as<std::remove_cvref_t<T>, json_t>
inline Db::Db(std::reference_wrapper<T> const& json) noexcept : m_json(json)
{
}

template<typename T> requires std::same_as<std::remove_cvref_t<T>, json_t>
inline Db::Db(T&& json) noexcept : m_json(json)
{
}

inline json_t& Db::data()
{
  if (std::holds_alternative<std::reference_wrapper<json_t>>(m_json))
  {
    return std::get<std::reference_wrapper<json_t>>(m_json).get();
  }
 
  return std::get<json_t>(m_json);
}

inline json_t const& Db::data() const
{
  return const_cast<Db*>(this)->data();
}

inline std::vector<std::string> Db::keys() const noexcept
{
  json_t const& json = data();
  return_if(not json.is_structured(), {}, "E::Invalid non-structured json access");
  return json.items()
    | std::views::transform([&](auto&& e) { return e.key(); })
    | std::ranges::to<std::vector<std::string>>();
}

inline std::vector<std::pair<std::string,Db>> Db::items() const noexcept
{
  json_t const& json = data();
  return_if(not json.is_structured(), {}, "E::Invalid non-structured json access");
  return json.items()
    | std::views::transform([](auto&& e){ return std::make_pair(e.key(), Db{e.value()}); })
    | std::ranges::to<std::vector<std::pair<std::string,Db>>>();
}

template<typename V>
Value<V> Db::value() noexcept
{
  json_t& json = data();
  if constexpr ( std::same_as<V,Db> )
  {
    return Db{json};
  }
  else if constexpr ( ns_concept::IsVector<V> and ns_concept::Uniform<typename V::value_type, std::string>)
  {
    return_if(not json.is_array(), Error("D::Tried to create array with non-array entry"));
    return_if(std::any_of(json.begin(), json.end(), [](auto&& e){ return not e.is_string(); })
      , Error("D::Invalid key type for string array")
    );
    return std::ranges::subrange(json.begin(), json.end())
      | std::views::transform([](auto&& e){ return typename std::remove_cvref_t<V>::value_type(e); })
      | std::ranges::to<V>();
  }
  else if constexpr (ns_concept::StringConstructible<V>)
  {
    return ( json.is_string() )?
        Value<V>(std::string{json})
      : Error("D::Json element is not a string");
  }
  else
  {
    static_assert(std::is_same_v<V, V> == false, "Unsupported type V for value()");
    return Error("D::No viable type conversion");
  }
}

inline Value<std::string> Db::dump()
{
  return Try(data().dump(2));
}

inline bool Db::empty() const noexcept
{
  return data().empty();
}

template<IsString T>
bool Db::contains(T&& key) const noexcept
{
  json_t const& json = data();
  return (json.is_object() || json.is_array()) && json.contains(key);
}

inline KeyType Db::type() const noexcept
{
  return data().type();
}

template<IsString T>
bool Db::erase(T&& key)
{
  auto str_key = ns_string::to_string(key);
 
  json_t& json = data();
 
  if ( json.is_array() )
  {
    auto it_search = std::find(json.begin(), json.end(), str_key);
    if ( it_search == json.end() ) { return false; }
    json.erase(std::distance(json.begin(), it_search));
    return true;
  }
  else if(json.is_object())
  {
    return json.erase(str_key) > 0;
  }
 
  return false;
}

inline void Db::clear()
{
  data() = json_t::object();
}

template<typename T>
Db& Db::operator=(T&& value)
{
  data() = value;
  return *this;
}

inline Db Db::operator()(std::string const& key)
{
  json_t& json = data();
 
  if(json.is_object() or json.empty())
  {
    return Db{std::reference_wrapper<json_t>(json[key])};
  }
 
  return *this;
}

inline std::ostream& operator<<(std::ostream& os, Db const& db)
{
  os << db.data();
  return os;
}

[[nodiscard]] inline Value<Db> read_file(fs::path const& path_file_db)
{
  return_if(not Try(fs::exists(path_file_db)), Error("D::Invalid db file '{}'", path_file_db.string()));
  // Parse a file
  auto f_parse_file = [](std::ifstream const& f) -> Value<json_t>
  {
    // Read to string
    std::string contents = ns_string::to_string(f.rdbuf());
    // Validate contents and return parsed result
    return Try(json_t::parse(contents));
  };
  // Open target file as read
  std::ifstream file(path_file_db, std::ios::in);
  return_if(not file.is_open(), Error("D::Failed to open '{}'", path_file_db.string()));
  // Try to parse
  return Db(Pop(f_parse_file(file)));
}

[[nodiscard]] inline Value<void> write_file(fs::path const& path_file_db, Db& db)
{
  std::ofstream file(path_file_db, std::ios::trunc);
  return_if(not file.is_open(), Error("D::Failed to open '{}' for writing", path_file_db.string()));
  file << std::setw(2) << Pop(db.dump());
  file.close();
  return Value<void>{};
}

template<ns_concept::StringRepresentable S>
Value<Db> from_string(S&& s)
{
  std::string data = ns_string::to_string(s);
  return_if(data.empty(), Error("D::Empty json data"));
  return Try(Db{json_t::parse(data)}, "D::Could not parse json file");
}
 
} // namespace ns_db
 
/* vim: set expandtab fdm=marker ts=2 sw=2 tw=100 et :*/