JsonTree.h

[詳解]

/// @file
/// @brief JSONツリーを作成するためのクラス JsonTree のヘッダ。
///
/// Copyright(C)SEGA

#ifndef AMDAEMON_UTIL_JSONTREE_H
#define AMDAEMON_UTIL_JSONTREE_H

#include "amdaemon/env.h"

#include <type_traits>
#include <functional>
#include <memory>
#include <string>
#include <locale>
#include <sstream>
#include <cstdint>

namespace amdaemon
{
namespace util
{
    // 前方宣言
    struct JsonValue;
    class JsonArrayAdder;
    class JsonObjectAdder;

    /// @brief JSON配列への要素追加処理を提供する抽象クラス。
    /// @ingroup g_util g_dump
    class JsonArrayAdder
    {
    public:
        /// コンストラクタ。
        JsonArrayAdder() { }

        /// デストラクタ。
        virtual ‾JsonArrayAdder() { }

        /// @brief 文字列値を追加する。
        /// @param[in] value 文字列値。
        void addValue(const wchar_t* value);

        /// @brief 文字列値を追加する。
        /// @tparam Traits 文字特性型。
        /// @tparam Alloc アロケータ型。
        /// @param[in] value 文字列値。
        template<class Traits, class Alloc>
        void addValue(const std::basic_string<wchar_t, Traits, Alloc>& value)
        {
            addValue(value.c_str());
        }

        /// @brief 文字列値を追加する。
        /// @param[in] value 文字列値。
        /// @param[in] loc ロケール。
        void addValue(const char* value, const std::locale& loc = std::locale());

        /// @brief 文字列値を追加する。
        /// @tparam Traits 文字特性型。
        /// @tparam Alloc アロケータ型。
        /// @param[in] value 文字列値。
        /// @param[in] loc ロケール。
        template<class Traits, class Alloc>
        void addValue(
            const std::basic_string<char, Traits, Alloc>& value,
            const std::locale& loc = std::locale())
        {
            addValue(value.c_str(), loc);
        }

        /// @brief 真偽値を追加する。
        /// @param[in] value 真偽値。
        void addValue(bool value);

        /// nullptr 値を追加する。
        void addValue(std::nullptr_t);

        /// @brief 整数値を追加する。
        /// @tparam T 整数型。
        /// @param[in] value 整数値。
        template<class T>
        auto addValue(const T& value)
            -> typename std::enable_if<std::is_integral<T>::value>::type
        {
            addDirectValue(std::to_wstring(value).c_str());
        }

        /// @brief float 値を追加する。
        /// @param[in] value float 値。
        ///
        /// value が非数値の場合は、その値を表す文字列値が追加される。
        void addValue(float value);

        /// @brief double 値を追加する。
        /// @param[in] value double 値。
        ///
        /// value が非数値の場合は、その値を表す文字列値が追加される。
        void addValue(double value);

        /// @brief 任意の値を文字列化して追加する。
        /// @tparam T 値型。
        /// @param[in] value 値。
        template<class T>
        auto addValue(const T& value)
            -> typename std::enable_if<!std::is_arithmetic<T>::value>::type
        {
            std::wostringstream ss;
            ss << value;
            addValue(ss.str().c_str());
        }

        /// @brief 配列値を追加する。
        /// @param[in] addFunc 配列要素の追加を行う関数。
        void addArray(std::function<void (JsonArrayAdder&)> addFunc);

        /// @brief オブジェクト値を追加する。
        /// @param[in] addFunc オブジェクト要素の追加を行う関数。
        void addObject(std::function<void (JsonObjectAdder&)> addFunc);

    protected:
        /// @brief JSON値を追加する。
        /// @param[in] value JSON値。
        virtual void addValue(JsonValue value) = 0;

    private:
        /// @brief 直値を追加する。
        /// @param[in] value 直値。
        void addDirectValue(const wchar_t* value);
    };

    /// @brief JSONオブジェクトへの要素追加処理を提供する抽象クラス。
    /// @ingroup g_util g_dump
    class JsonObjectAdder
    {
    public:
        /// コンストラクタ。
        JsonObjectAdder() { }

        /// デストラクタ。
        virtual ‾JsonObjectAdder() { }

        /// @brief 文字列値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value 文字列値。
        void addValue(const wchar_t* name, const wchar_t* value);

        /// @brief 文字列値を追加する。
        /// @tparam Traits 文字特性型。
        /// @tparam Alloc アロケータ型。
        /// @param[in] name 要素名。
        /// @param[in] value 文字列値。
        template<class Traits, class Alloc>
        void addValue(
            const wchar_t* name,
            const std::basic_string<wchar_t, Traits, Alloc>& value)
        {
            addValue(name, value.c_str());
        }

        /// @brief 文字列値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value 文字列値。
        /// @param[in] loc ロケール。
        void addValue(
            const wchar_t* name,
            const char* value,
            const std::locale& loc = std::locale());

        /// @brief 文字列値を追加する。
        /// @tparam Traits 文字特性型。
        /// @tparam Alloc アロケータ型。
        /// @param[in] name 要素名。
        /// @param[in] value 文字列値。
        /// @param[in] loc ロケール。
        template<class Traits, class Alloc>
        void addValue(
            const wchar_t* name,
            const std::basic_string<char, Traits, Alloc>& value,
            const std::locale& loc = std::locale())
        {
            addValue(name, value.c_str(), loc);
        }

        /// @brief 真偽値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value 真偽値。
        void addValue(const wchar_t* name, bool value);

        /// @brief nullptr 値を追加する。
        /// @param[in] name 要素名。
        void addValue(const wchar_t* name, std::nullptr_t);

        /// @brief 整数値を追加する。
        /// @tparam T 整数型。
        /// @param[in] name 要素名。
        /// @param[in] value 整数値。
        template<class T>
        auto addValue(const wchar_t* name, const T& value)
            -> typename std::enable_if<std::is_integral<T>::value>::type
        {
            addDirectValue(name, std::to_wstring(value).c_str());
        }

        /// @brief float 値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value float 値。
        ///
        /// value が非数値の場合は、その値を表す文字列値が追加される。
        void addValue(const wchar_t* name, float value);

        /// @brief double 値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value double 値。
        ///
        /// value が非数値の場合は、その値を表す文字列値が追加される。
        void addValue(const wchar_t* name, double value);

        /// @brief 任意の値を文字列化して追加する。
        /// @tparam T 値型。
        /// @param[in] name 要素名。
        /// @param[in] value 値。
        template<class T>
        auto addValue(const wchar_t* name, const T& value)
            -> typename std::enable_if<!std::is_arithmetic<T>::value>::type
        {
            std::wostringstream ss;
            ss << value;
            addValue(name, ss.str().c_str());
        }

        /// @brief 配列値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] addFunc 配列要素の追加を行う関数。
        void addArray(const wchar_t* name, std::function<void (JsonArrayAdder&)> addFunc);

        /// @brief オブジェクト値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] addFunc オブジェクト要素の追加を行う関数。
        void addObject(const wchar_t* name, std::function<void (JsonObjectAdder&)> addFunc);

    protected:
        /// @brief JSON値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value JSON値。
        virtual void addValue(const wchar_t* name, JsonValue value) = 0;

    private:
        /// @brief 直値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value 直値。
        void addDirectValue(const wchar_t* name, const wchar_t* value);
    };

    /// @brief JSONツリーを作成するためのクラス。
    /// @ingroup g_util g_dump
    class JsonTree : public JsonObjectAdder
    {
    public:
        /// コンストラクタ。
        JsonTree();

        /// @brief コピーコンストラクタ。
        /// @param[in] src コピー元。
        JsonTree(const JsonTree& src);

        /// @brief ムーブコンストラクタ。
        /// @param[in] src ムーブ元。
        JsonTree(JsonTree&& src);

        /// デストラクタ。
        ‾JsonTree();

        /// @brief コピー代入演算子のオーバロード。
        /// @param[in] r 右辺値。
        /// @return 自身の参照。
        JsonTree& operator=(const JsonTree& r);

        /// @brief ムーブ代入演算子のオーバロード。
        /// @param[in] r 右辺値。
        /// @return 自身の参照。
        JsonTree& operator=(JsonTree&& r);

        /// @brief 他のJSONツリーをぶら下げる。
        /// @param[in] name 要素名。
        /// @param[in] tree ぶら下げるJSONツリー。
        /// @attention
        /// あくまで現時点でのJSONツリーのコピーをぶら下げるのみであり、
        /// 第2引数に渡したJSONツリーを変更しても追加先には反映されない。
        void addTree(const wchar_t* name, const JsonTree& tree);

        /// @brief 他のJSONツリーをぶら下げる。
        /// @param[in] name 要素名。
        /// @param[in] tree ぶら下げるJSONツリー。
        /// @attention
        /// あくまで現時点でのJSONツリーのコピーをぶら下げるのみであり、
        /// 第2引数に渡したJSONツリーを変更しても追加先には反映されない。
        void addTree(const wchar_t* name, JsonTree&& tree);

        /// @brief JSON形式文字列を作成して追加する。
        /// @param[in,out] str JSON形式文字列の追加先。
        /// @param[in] indent インデントレベル。負数ならば整形しない。
        void toString(std::wstring& str, std::int32_t indent = 0) const;

        /// @brief JSON形式文字列を作成して返す。
        /// @param[in] indent インデントレベル。負数ならば整形しない。
        /// @return JSON形式文字列。
        std::wstring toString(std::int32_t indent = 0) const
        {
            std::wstring str;
            toString(str, indent);
            return str;
        }

    private:
        /// @brief JSON値を追加する。
        /// @param[in] name 要素名。
        /// @param[in] value JSON値。
        void addValue(const wchar_t* name, JsonValue value) override;

    private:
        struct Data;

        /// 内部データ。
        std::unique_ptr<Data> _data;
    };
} // namespace util
} // namespace amdaemon

#endif // AMDAEMON_UTIL_JSONTREE_H