Json.hpp

[詳解]

#pragma once
 
/**
 * @file Json.hpp
 * @brief Json形式のデータを取り扱うためのヘッダ
 * @author 樺澤陽向
 * @date 2025/05/08
 * @since ver1.0.0 コメント追加
 */
 
#include "../ConsoleDebug/Debug.hpp"
#include <string>
#include <vector>
#include <variant>
#include <unordered_map>
#include <filesystem>
#include <fstream>
 
#include <memory>
 
 
 
namespace Kisaragi_Lib
{
 
    namespace fs = std::filesystem;
 
    //TODO これJsonの入れ子手動で出来なくない?
 
    /// <summary>
    /// Jsonデータを取り扱うクラス
    /// </summary>
    /// @since ver1.0.0 コメント追加
    class Json
    {
    public:
 
        Json() : value{nullptr}
        {
            
        }
 
        Json(std::string _str) : value{ _str }
        {
 
        }
 
        explicit Json(bool _bool) : value{ _bool }
        {
 
        }
 
        explicit Json(float _float) : value{ _float }
        {
 
        }
 
        explicit Json(int _int) : value{ _int }
        {
 
        }
 
        // コピーコンストラクタとムーブコンストラクタ
        Json(const Json& other) = default;
        Json(Json&& other) noexcept = default;
        Json& operator=(Json&& other) noexcept = default;
 
        Json& operator=(const Json& other)
        {
            if (this != &other)
            {
                value = other.value;
            }
            return *this;
        }
 
        template<class T>
        const T& Get() const
        {
            if (std::holds_alternative<T>(value))
            {
                return std::get<T>(value);
            }
 
            Debug::PrintAssertStatic("その型を保有していません");
        }
 
        template<class T>
        T& Get()
        {
            if (std::holds_alternative<T>(value))
            {
                return std::get<T>(value);
            }
 
            Debug::PrintAssertStatic("その型を保有していません");
        }
 
        //TODO Debug
        template<class T>
        const bool IsType()
        {
            if (std::holds_alternative<T>(value))
            {
                return true;
            }
 
            return false;
        }
 
        template<class T>
        Json& operator=(const T _in)
        {
            value = _in;
 
            return *this;
        }
 
        // 数値型（int, short, longなど）に限定したコンストラクタ
        template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
        Json& operator[](const T _index)
        {
            int index{ _index };
 
            if (!std::holds_alternative<std::vector<Json>>(value))
            {
                value = std::vector<Json>{};
            }
 
            // 配列が小さすぎる場合にresizeする
            auto& vec = std::get<std::vector<Json>>(value);
            if (index >= static_cast<int>(vec.size()))
            {
                vec.resize(index + 1);
            }
 
            return vec[index];
        }
 
        Json& operator[](const std::string& _key)
        {
            if (!std::holds_alternative<std::unordered_map<std::string, Json>>(value))
            {
                value = std::unordered_map<std::string, Json>{};
            }
 
            return std::get<std::unordered_map<std::string,Json>>(value)[_key];
        }
 
 
        /// <summary>
        /// 自身をJsonファイルとして書き込みます
        /// </summary>
        /// <param name="_fileName">保存ファイル名(拡張子の省略可能)</param>
        /// <param name="_directry">
        /// 保存先ディレクトリのパス
        /// デフォルト値は"./jsonFiles"
        /// </param>
        void Write(const fs::path& _fileName, const fs::path& _directry = "./jsonFiles")
        {
            if (value.index() < 5)
            {
                Debug::PrintAssertStatic("エラー : 最上位におけるのは配列か連想配列のみです");
                return;
            }
 
            if (!fs::exists(_directry))
            {
                try
                {
                    fs::create_directories(_directry);
                }
                catch (const fs::filesystem_error& e)
                {
                    Debug::PrintAssertStatic("エラー : ファイルシステムでエラーが発生しました");
                    return;
                }
            }
 
            // フォルダ位置
            fs::path filePass = _directry;
            // /= /を追加(ない場合のみ)
            // ディレクトリ + ファイル名
            filePass /= _fileName;
            // 拡張子がない場合つける
            filePass.replace_extension(".json");
 
            std::ofstream file(filePass, std::ios::out | std::ios::trunc); // ファイルを開く（新規作成・上書き）
 
            if (!file)
            {
                Debug::PrintAssertStatic("エラー: ファイルが開けませんでした");
                return;
            }
 
            this->Write(file);
 
            file.close();
            return;
        }
 
 
 
    private:
 
        void Write(std::ofstream& _file, unsigned int _depth = 0)
        {
            if (value.index() < TEXT_INDEX)
            {
                WriteNotText(_file,_depth);
            }
            else if (value.index() == TEXT_INDEX)
            {
                WriteText(_file, _depth);
            }
            else if(value.index() == TEXT_INDEX + 1)
            {
                WriteObject(_file, _depth);
            }
            else
            {
                WriteArray(_file, _depth);
            }
        }
 
        void WriteNotText(std::ofstream& _file, unsigned int _depth = 0)
        {
            std::visit([&](auto&& arg)
                {
                    using T = std::decay_t<decltype(arg)>;
 
                    if constexpr (std::is_same_v<T, std::nullptr_t>)
                    {
                        _file << "null";
                    }
                    else if constexpr (std::is_same_v<T, bool>)
                    {
                        _file << (arg ? "true" : "false");
                    }
                    else if constexpr (std::is_same_v<T, int> || std::is_same_v<T, float>)
                    {
                        _file << std::to_string(arg);
                    }
 
                }, value);
        }
 
        void WriteText(std::ofstream& _file, unsigned int _depth = 0)
        {
            if (!_file) {
                Debug::PrintAssertStatic("エラー: 有効なファイルではありません");
                return;
            }
 
            _file << "\"" + std::get<std::string>(value) + "\"";
 
            return;
        }
 
        void WriteObject(std::ofstream& _file, unsigned int _depth = 0)
        {
            if (!_file)
            {
                Debug::PrintAssertStatic("エラー: 有効なファイルではありません");
                return;
            }
 
 
            _depth++;
 
            _file << "{\n";
 
            bool isFirst = true;
 
 
            for (auto& element : std::get<std::unordered_map<std::string, Json>>(value))
            {
                if (isFirst)
                {
                    isFirst = false;
                }
                else
                {
                    _file << ",\n";
                }
 
                //改行を出力
                WriteJsonDepth(_file, _depth);
                //keyを出力
                _file << "\"" + element.first + "\"" + " : ";
                //値を出力
                element.second.Write(_file, _depth);
 
            }
 
            _file << "\n";
            //改行を出力
            WriteJsonDepth(_file, _depth - 1);
            _file << "}";
        }
 
        void WriteArray(std::ofstream& _file, unsigned int _depth = 0)
        {
            _depth++;
 
            _file << "[\n";
 
            bool isFirst = true;
 
            for (auto& element : std::get<std::vector<Json>>(value))
            {
                if (isFirst)
                {
                    isFirst = false;
                }
                else
                {
                    _file << ",\n";
                }
 
                //改行を出力
                WriteJsonDepth(_file, _depth);
                //値を出力
                element.Write(_file, _depth);
 
            }
 
            _file << "\n";
            //改行を出力
            WriteJsonDepth(_file, _depth - 1);
            _file << "]";
        }
 
        void WriteJsonDepth(std::ofstream& _file, unsigned int _depth = 0)
        {
            if (!_file)
            {
                Debug::PrintAssertStatic("エラー: 有効なファイルではありません");
                return;
            }
 
            _file << std::string(_depth, '\t');
        }
 
 
        /// <summary>
        /// 値を管理する共用体
        /// </summary>
        using Value = std::variant
            <
            std::nullptr_t,
            bool,
            int,
            float,
            std::string,
            std::unordered_map<std::string, Json>,
            std::vector<Json>
            >;
 
        const int TEXT_INDEX = 4;
 
        Value value;
    };
 
 
    /// <summary>
    /// Json読み込みクラス
    /// </summary>
    class JsonParser
    {
    private:
        std::string jsonFile;
        size_t pos;
 
    public:
        /// <summary>
        /// 自身が取り扱うJsonファイルを読み込みます
        /// </summary>
        /// <param name="_jsonFile">変換するJsonファイルのパス</param>
        /// @since ver1.0.0 コメント追加
        JsonParser(fs::path _jsonFile) : pos(0)
        {
            //拡張子がなければ付ける
            _jsonFile.replace_extension(".json");
 
            if (!fs::exists(_jsonFile))
            {
                Debug::PrintAssertStatic(" JsonContainer.Load() : ファイルが存在しません");
                return;
            }
 
            std::ifstream file(_jsonFile); // ファイルを開く
 
            if (!file) {
                Debug::PrintAssertStatic("ファイルを開けませんでした。");
                return;
            }
 
            jsonFile = std::string(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
            file.close();
 
            //制御文字を削除
            RemoveControlChars(jsonFile);
 
        }
 
        /// <summary>
        /// 読み込んだJsonファイルを変換し、Jsonクラスとして返します
        /// </summary>
        /// <returns>変換されたJsonクラス</returns>
        Json Parse()
        {
            SpaceSkip();
            if (jsonFile[pos] == '{')
            {
                return ParseObject();
            }
            else if (jsonFile[pos] == '[')
            {
                return ParseArray();
            }
 
            return Json{};
        }
 
    private:
 
        /// <summary>
        /// ASCII code 32以下の制御文字を削除する
        /// </summary>
        /// <param name="str"></param>
        void RemoveControlChars(std::string& str)
        {
            str.erase(std::remove_if(str.begin(), str.end(),
                [](char c) { return (c < 32); }), str.end());
        }
 
        Json ParseObject()
        {
            pos++; // '{' をスキップ
            SpaceSkip();
 
            Json json = Json();
 
            while (jsonFile[pos] != '}')
            {
                std::string key;
 
                key = ParseString();
                SpaceSkip();
 
                if (jsonFile[pos] != ':')
                {
                    return json;
                    //throw std::runtime_error("Expected ':'");
                }
 
                pos++; //:をスキップ
                SpaceSkip();
 
                json[key] = ParseImpl();
 
                SpaceSkip();
 
                CommaSkip();
 
                SpaceSkip();
 
            }
 
            if (jsonFile[pos] == '}')
            {
                pos++;
            }
 
            return json;
        }
 
        Json ParseArray()
        {
            pos++; // '{' をスキップ
 
            Json json = Json{};
 
            int i = 0;
            while (jsonFile[pos] != ']')
            {
                SpaceSkip();
 
                json[i] = ParseImpl();
 
                SpaceSkip();
 
                CommaSkip();
 
                SpaceSkip();
 
                i++;
            }
 
            if (jsonFile[pos] == ']')
            {
                pos++;
            }
 
            return json;
        }
 
        std::string ParseString()
        {
            std::string result;
            pos++; // '"' をスキップ
 
            while (pos < jsonFile.size() && jsonFile[pos] != '"') {
                result += jsonFile[pos++];
            }
 
            pos++; // '"' をスキップ
            return result;
        }
 
        std::string ParseNotString()
        {
            std::string result;
 
            while (pos < jsonFile.size() && jsonFile[pos] != ',' && jsonFile[pos] != ']' && jsonFile[pos] != '}') {
                result += jsonFile[pos++];
            }
 
            return Trim(result);
        }
 
        bool isNumber(const std::string& str)
        {
            try {
                std::stod(str);  // ストリングを数値に変換できるか試す
                return true;
            }
            catch (...) {
                return false;
            }
        }
 
        Json ParseImpl()
        {
            SpaceSkip();
            if (jsonFile[pos] == '{')
            {
                return ParseObject();
            }
            else if (jsonFile[pos] == '[')
            {
                return ParseArray();
            }
            else if (jsonFile[pos] == '\"')
            {
                return Json(ParseString());
            }
            else if (jsonFile[pos] != ',')
            {
                std::string str = ParseNotString();
 
                if (str == "true")
                {
                    return Json(true);
                }
                else if (str == "false")
                {
                    return Json(false);
                }
                else if (str.find(".") != std::string::npos || !str.empty() && str.back() == 'f')
                {
                    if (!str.empty() && str.back() == 'f') {
                        str.pop_back(); // 末尾の 'f' を削除
                    }
 
                    return Json(std::stof(str));
                }
                else if (isNumber(str))
                {
                    return Json(std::stoi(str));
                }
 
                return Json{};
            }
            else
            {
                //何も入力されていないためnull
                return Json{};
            }
        }
 
        std::string Trim(const std::string& str)
        {
            size_t first = str.find_first_not_of(" \t\n\r");
            if (first == std::string::npos)
                return "";
 
            size_t last = str.find_last_not_of(" \t\n\r");
            return str.substr(first, (last - first + 1));
        }
 
        void SpaceSkip()
        {
            while (pos < jsonFile.size() && std::isspace(jsonFile[pos]))
            {
                pos++;
            }
        }
 
        void CommaSkip()
        {
            if (pos < jsonFile.size() && jsonFile[pos] == ',')
            {
                pos++;  //, をスキップ
            }
        }
    };
}