Json.h

Go to the documentation of this file.

// File: Json.h
// Description: JSON file parser and handler with all declarations, methods, variables, and templates
// Author(s): Marcelo Escamilla (marcelo.escamilla@digipen.edu)
// 2025 / 09 / 19
// (C) Digipen 2025
//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
#pragma once
#include <string_view>
#include "Logging.h"
//#include <nlohmann/json_fwd.hpp>
#include <nlohmann/json.hpp>
#include <string.h>
 
 
using json = nlohmann::json;

//using value_type = nlohmann::basic_json;

//using reference = value_type&;
 
namespace sys
{
class Json
{
 
public:
    Json(std::string filePath);
    Json()            = default;
    Json(const Json&) = default;
    Json(Json&&)      = default;
    ~Json()           = default;
 
    // dont use for now
    auto data() -> json&;
 
    static auto test() -> void;       // for testing the read function
    static auto savingTest() -> void; // for testing the save function
 
    // Dump the JSON to the console
    // pretty = sets the indentation level for pretty printing (usually 4)
    auto jsonDump(int pretty) -> void;
 
    // Read a value from the JSON using a dot-separated key path
    // Example: "tester.value"
    // tester is the root/the json object name, value is the object inside tester that you want to go into
    // continuing adding "." will go deeper into the json structure
    // value is the variable you want to store the result in
    template <typename T>
    auto read(const std::string& keyPath, T& value) const -> bool
    {
        assert(isValid && "Stream is not valid. Ensure the file was opened successfully.");
 
        try
        {
            auto current = &j;
            size_t start = 0, end;
 
            while ((end = keyPath.find('.', start)) != std::string::npos)
            {
                auto key = keyPath.substr(start, end - start);
                current  = &current->at(key);
                start    = end + 1;
            }
 
            auto lastKey = keyPath.substr(start);
            value        = current->at(lastKey).get<T>();
        }
        catch (const json::exception& exception)
        {
            hlg::Error("Stream: JSON key error: {}", exception.what());
            return false;
        }
 
        return true;
    }

    auto clear() -> void;

    auto save() -> void;

    auto saveAs(const std::string& newFilePath) -> void;
 
    // Overload the subscript operator to access JSON elements directly
    template <typename T>
    auto operator[](T* key)
    {
        return j[key];
    }
 
 
    // private
private:
    bool isValid{false};
    json j;
    std::string filePath;

    auto open(std::string filePath) -> bool;
 
};
 
} // namespace th