Kisaragi_Lib::Json クラス

Jsonデータを取り扱うクラス [詳解]

#include <Json.hpp>

公開メンバ関数
	Json ()
	Json (std::string _str)
	Json (bool _bool)
	Json (float _float)
	Json (int _int)
	Json (const Json &other)=default
	Json (Json &&other) noexcept=default
Json &	operator= (Json &&other) noexcept=default
Json &	operator= (const Json &other)
template<class T>
const T &	Get () const
template<class T>
T &	Get ()
template<class T>
const bool	IsType ()
template<class T>
Json &	operator= (const T _in)
template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>
Json &	operator[] (const T _index)
Json &	operator[] (const std::string &_key)
void	Write (const fs::path &_fileName, const fs::path &_directry="./jsonFiles")
	自身をJsonファイルとして書き込みます

非公開型
using	Value
	値を管理する共用体

非公開メンバ関数
void	Write (std::ofstream &_file, unsigned int _depth=0)
void	WriteNotText (std::ofstream &_file, unsigned int _depth=0)
void	WriteText (std::ofstream &_file, unsigned int _depth=0)
void	WriteObject (std::ofstream &_file, unsigned int _depth=0)
void	WriteArray (std::ofstream &_file, unsigned int _depth=0)
void	WriteJsonDepth (std::ofstream &_file, unsigned int _depth=0)

非公開変数類
const int	TEXT_INDEX = 4
Value	value

詳解

Jsonデータを取り扱うクラス

から

ver1.0.0 コメント追加

型定義メンバ詳解

Value

using Kisaragi_Lib::Json::Value

private

初期値:

 std::variant
            <
            std::nullptr_t,
            bool,
            int,
            float,
            std::string,
            std::unordered_map<std::string, Json>,
            std::vector<Json>
            >

値を管理する共用体

構築子と解体子

Json() [1/7]

Kisaragi_Lib::Json::Json ( )

inline

               : value{nullptr}
        {
            
        }

参照元 Json(), Json(), operator=(), operator=(), operator=(), operator[](), operator[]().

Json() [2/7]

Kisaragi_Lib::Json::Json ( std::string _str )

inline

                             : value{ _str }
        {
 
        }

Json() [3/7]

Kisaragi_Lib::Json::Json ( bool _bool )

inlineexplicit

                                  : value{ _bool }
        {
 
        }

Json() [4/7]

Kisaragi_Lib::Json::Json ( float _float )

inlineexplicit

                                    : value{ _float }
        {
 
        }

Json() [5/7]

Kisaragi_Lib::Json::Json ( int _int )

inlineexplicit

                                : value{ _int }
        {
 
        }

Json() [6/7]

Kisaragi_Lib::Json::Json ( const Json & other )

default

Json() [7/7]

Kisaragi_Lib::Json::Json ( Json && other )

defaultnoexcept

関数詳解

operator=() [1/3]

Json & Kisaragi_Lib::Json::operator= ( Json && other )

defaultnoexcept

operator=() [2/3]

Json & Kisaragi_Lib::Json::operator= ( const Json & other )

inline

        {
            if (this != &other)
            {
                value = other.value;
            }
            return *this;
        }

Get() [1/2]

template<class T>

const T & Kisaragi_Lib::Json::Get ( ) const

inline

        {
            if (std::holds_alternative<T>(value))
            {
                return std::get<T>(value);
            }
 
            Debug::PrintAssertStatic("その型を保有していません");
        }

参照元 Kisaragi_Lib::SerializableStruct::FormJson().

Get() [2/2]

template<class T>

T & Kisaragi_Lib::Json::Get ( )

inline

        {
            if (std::holds_alternative<T>(value))
            {
                return std::get<T>(value);
            }
 
            Debug::PrintAssertStatic("その型を保有していません");
        }

IsType()

template<class T>

const bool Kisaragi_Lib::Json::IsType ( )

inline

        {
            if (std::holds_alternative<T>(value))
            {
                return true;
            }
 
            return false;
        }

operator=() [3/3]

template<class T>

Json & Kisaragi_Lib::Json::operator= ( const T _in )

inline

        {
            value = _in;
 
            return *this;
        }

operator[]() [1/2]

template<typename T, typename = std::enable_if_t<std::is_integral_v<T>>>

Json & Kisaragi_Lib::Json::operator[] ( const T _index )

inline

        {
            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];
        }

operator[]() [2/2]

Json & Kisaragi_Lib::Json::operator[] ( const std::string & _key )

inline

        {
            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];
        }

Write() [1/2]

void Kisaragi_Lib::Json::Write ( const fs::path & _fileName, const fs::path & _directry = "./jsonFiles" )

inline

自身をJsonファイルとして書き込みます

引数

_fileName	保存ファイル名(拡張子の省略可能)
_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;
        }

参照元 Write().

Write() [2/2]

void Kisaragi_Lib::Json::Write ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            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);
            }
        }

WriteNotText()

void Kisaragi_Lib::Json::WriteNotText ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            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);
        }

参照元 Write().

WriteText()

void Kisaragi_Lib::Json::WriteText ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            if (!_file) {
                Debug::PrintAssertStatic("エラー: 有効なファイルではありません");
                return;
            }
 
            _file << "\"" + std::get<std::string>(value) + "\"";
 
            return;
        }

参照元 Write().

WriteObject()

void Kisaragi_Lib::Json::WriteObject ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            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 << "}";
        }

参照元 Write().

WriteArray()

void Kisaragi_Lib::Json::WriteArray ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            _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 << "]";
        }

参照元 Write().

WriteJsonDepth()

void Kisaragi_Lib::Json::WriteJsonDepth ( std::ofstream & _file, unsigned int _depth = 0 )

inlineprivate

        {
            if (!_file)
            {
                Debug::PrintAssertStatic("エラー: 有効なファイルではありません");
                return;
            }
 
            _file << std::string(_depth, '\t');
        }

参照元 WriteArray(), WriteObject().

メンバ詳解

TEXT_INDEX

const int Kisaragi_Lib::Json::TEXT_INDEX = 4

private

参照元 Write().

value

Value Kisaragi_Lib::Json::value

private

参照元 Get(), Get(), IsType(), Json(), Json(), Json(), Json(), Json(), operator=(), operator=(), operator[](), operator[](), Write(), Write(), WriteArray(), WriteNotText(), WriteObject(), WriteText() (計18項目).

---

このクラス詳解は次のファイルから抽出されました:

• Json.hpp