JsonUtility.hpp

[詳解]

#pragma once
 
/**
 * @file JsonUtility.hpp
 * @brief Json形式のデータをシリアライズ/デシリアライズ可能なデータ型を提供します
 * @author 樺澤陽向
 * @date 2025/05/08
 * @since ver1.0.0 コメント追加
 */
 
#include <string>
#include <vector>
#include "Json.hpp"
#include <type_traits>
#include <initializer_list>
#include <filesystem>
 
 
namespace Kisaragi_Lib
{
    class SerializableObject;
 
    /// <summary>
    /// SerializableObject内に格納されるインナークラス。
    /// 使用者側で直接いじることはないと思いますので、
    /// 興味がある場合は見るくらいでいいと思います。
    /// </summary>
    /// @since ver1.0.0 コメント追加
    struct SerializableStruct
    {
        enum class ValueType
        {
            NULLPTR_T,
            BOOL,
            INT,
            FLOAT,
            STRING,
            SERIALIZABLE_OBJECT,
 
            //VECTOR,
        };
 
        /// <summary>
        /// 値を管理する共用体
        /// </summary>
        using Value = std::variant
            <
            std::reference_wrapper<std::nullptr_t>,
            std::reference_wrapper<bool>,
            std::reference_wrapper<int>,
            std::reference_wrapper<float>,
            std::reference_wrapper<std::string>,
 
            std::reference_wrapper<SerializableObject>  //mapの場合はこっち使ってね.
 
            //std::reference_wrapper<std::vector<SerializableStruct>>   //配列の場合はこっち
            >;
 
        Value value;
        std::string name;
        ValueType type;
 
 
        SerializableStruct() = delete;
 
        SerializableStruct(std::string& _str, std::string _name) : value{ std::ref(_str) }, name{ _name }, type{ ValueType::STRING }
        {
 
        }
 
        explicit SerializableStruct(bool& _bool, std::string _name) : value{ std::ref(_bool) }, name{ _name }, type{ ValueType::BOOL }
        {
 
        }
 
        explicit SerializableStruct(float& _float, std::string _name) : value{ std::ref(_float) }, name{ _name }, type{ ValueType::FLOAT }
        {
 
        }
 
        explicit SerializableStruct(int& _int, std::string _name) : value{ std::ref(_int) }, name{ _name } , type{ ValueType::INT }
        {
 
        }
 
        //暗黙的な"基底クラス"への変換はできるらしい
        explicit SerializableStruct(SerializableObject& _serializableClass, std::string _name) : value{ std::ref(_serializableClass) }, name{ _name } , type{ ValueType::SERIALIZABLE_OBJECT }
        {
 
        }
 
        //explicit SerializableStruct(std::vector<SerializableStruct>& _vec, std::string _name) : value{ _vec }, name{ _name }, type{ ValueType::VECTOR }
        //{
 
        //}
 
 
        //自分が所属する階層のjsonを受け取る
        void FormJson(Json _json);
 
        void ToJson(std::ostream& os, int indentLevel) const;
        
    };
 
    /// <summary>
    /// SerializableObjectに変数を登録する際に扱うマクロ
    /// </summary>
    /// @since ver1.0.0 コメント追加
#define SERIALIZABLE(_in) ( SerializableStruct(std::ref(_in) , #_in ) )
 
 
    // 出力用
    std::ostream& operator<<(std::ostream& os, const SerializableStruct& ss);
 
    /// <summary>
    /// 自身の監視対象データをJson形式にシリアライズしたり、
    /// Json形式からデシリアライズできる基底データクラス
    /// </summary>
    /// @code 監視対象にする方法
    /// class MyClass : public SerializableObject
    /// {
    /// public:
    ///     int a;
    ///     int b;
    ///     bool c;
    /// 
    ///     /// <summary>
    ///     /// コンストラクタでJson化する変数を登録,
    ///     /// int,
    ///     /// bool,
    ///     /// float,
    ///     /// string,
    ///     /// SerializableStructのみ
    ///     /// </summary>
    ///     MyClass() :SerializableObject({
    ///         SERIALIZABLE(a),
    ///         SERIALIZABLE(b),
    ///         SERIALIZABLE(c)
    ///         })
    ///     {
    ///     }
    /// };
    /// 
    /// class MyClass2 : public SerializableObject
    /// {
    /// public:
    ///     int a;
    ///     int b;
    ///     bool c;
    ///     MyClass aaa;
    /// 
    ///     /// <summary>
    ///     /// コンストラクタでJson化する変数を登録,
    ///     /// </summary>
    ///     MyClass2() :SerializableObject({
    ///         SERIALIZABLE(a),
    ///         SERIALIZABLE(b),
    ///         SERIALIZABLE(c),
    ///         SERIALIZABLE(aaa),
    ///         })
    ///     {
    ///     }
    /// 
    /// };
    /// @endcode
    /// @since ver1.0.0 コメント追加
    class SerializableObject
    {
    private:
        std::vector<SerializableStruct> vec;
 
    public:
 
        //入れ子構造の時の記述用
        std::ostream& ToJson(std::ostream& _file ,unsigned int _depth)
        {
            std::string indent(_depth, '\t');
            _file << "{" << std::endl;
 
            for (size_t i = 0; i < vec.size(); ++i)
            {
                _file << indent << "  " << vec[i];
                
                if (i < vec.size() - 1)
                {
                    _file << ",";
                }
 
                _file << std::endl;
            }
 
            _file << indent << "}";
 
            return _file;
        }
 
 
        SerializableObject(std::initializer_list<SerializableStruct> _in) : vec{ _in }
        {
 
        }
 
        void ToJson(const fs::path& _fileName, const fs::path& _directry = "./jsonFiles")
        {
            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;
            }
 
 
            file << "{" <<std::endl;
 
            for (size_t i = 0; i < vec.size(); ++i)
            {
                file << "  " << vec[i];
 
                if (i < vec.size() - 1)
                {
                    file << ",";
                }
 
                file << std::endl;
            }
 
            file << "}";
 
            file.close();
        }
 
        void FormJson(std::string _json)
        {
            Json json = JsonParser{ _json }.Parse();
 
            for (auto& value : vec)
            {
                value.FormJson(json);
            }
        }
 
        void FormJson(Json _json)
        {
            for (auto& value : vec)
            {
                value.FormJson(_json);
            }
        }
    };
}