CJsonDocument.cpp

[詳解]

//=============================================================================
/// @file
/// JSONドキュメントクラス実装ファイル
///
/// JSONドキュメントクラス実装ファイルです。
///
/// $Id: CJsonDocument.cpp 245 2019-03-20 15:03:41Z admin $
/// $Date: 2019-03-21 00:03:41 +0900 (2019/03/21 (木)) $
/// $Author: admin $
///
/// @attention なし

#pragma managed( push, off )

//=============================================================================
// インクルードファイル
#include <CJsonDocument.h>
#include <CJsonObject.h>
#include <CJsonArray.h>
#include <CJsonString.h>
#include <CJsonNumber.h>
#include <CJsonFixed.h>
#include <CJsonPair.h>
#include <CJsonValue.h>
#include <CJsonContainer.h>
#include <CJsonToken.h>
#include <CStringStream.h>
#include <LibUtility.h>

//=============================================================================
// インクルード実装ファイル
#include <CArray.hpp>

//=============================================================================
// JSONライブラリ名前空間
namespace LibJson {
    //=========================================================================
    // JSONドキュメントクラス
    //=========================================================================
    // 構築子と解体子
    //-------------------------------------------------------------------------
    // コンストラクタ
    CJsonDocument::CJsonDocument( CJson* pcJson ) noexcept
        // メンバ変数初期化
        : m_pcJsonRoot( pcJson )
        , m_pcJsonCurrent( m_pcJsonRoot )
    {}

    //-------------------------------------------------------------------------
    // デストラクタ
    CJsonDocument::~CJsonDocument() noexcept {
        // クリアする
        ClearDocument();
    }

    //=========================================================================
    // 公開関数
    //-------------------------------------------------------------------------
    // ルートJSONクラス設定関数
    bool CJsonDocument::SetRootJson( CJson* pcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }
            // ルートJSONクラスを調べる
            else if ( pcJson != pcJson->GetJsonRoot() ) {
                // 失敗！
                break;
            }

            // クリアする
            ClearDocument();

            // JSONクラスポインタを設定する
            m_pcJsonRoot = m_pcJsonCurrent = pcJson;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレントJSONクラス設定関数
    bool CJsonDocument::SetCurrentJson( CJson* pcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }

            // ルートJSONクラスを取得する
            CJson* pcJsonRoot = pcJson->GetJsonRoot();

            // ルートJSONクラスポインタを調べる
            if ( nullptr == m_pcJsonRoot ) {
                // ルートJSONクラスを設定する
                if ( !SetRootJson( pcJsonRoot ) ) {
                    // 失敗！
                    break;
                }
            }
            // ルートJSONクラスを調べる
            else if ( m_pcJsonRoot != pcJsonRoot ) {
                // 失敗！
                break;
            }

            // カレントJSONクラスポインタを設定する
            m_pcJsonCurrent = pcJson;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // クリア関数
    void CJsonDocument::ClearDocument() noexcept {
        // ルートJSONクラスを削除する
        delete m_pcJsonRoot;
        m_pcJsonRoot    = nullptr;
        m_pcJsonCurrent = nullptr;
    }

    //-------------------------------------------------------------------------
    // コンパクト化関数
    bool CJsonDocument::CompactDocument() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ルートJSONクラスポインタを調べる
            if ( nullptr != m_pcJsonRoot ) {
                // ルートJSONクラスをコンパクト化する
                if ( !m_pcJsonRoot->CompactJson() ) {
                    // 失敗！
                    break;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONドキュメント入力関数
    bool CJsonDocument::InputDocument( CStream& rcStream ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ストリームポインタを取得する
            int nPoint = rcStream.GetStreamPoint();

            // 処理ブロック
            do {
                // クリアする
                ClearDocument();

                // JSONペアを作成する
                m_pcJsonRoot = CJsonPair::CreateInputJson( rcStream, nullptr );
                if ( nullptr == m_pcJsonRoot ) {
                    // JSONバリューを作成する
                    m_pcJsonRoot = CJsonValue::CreateInputJson( rcStream, nullptr );
                    if ( nullptr == m_pcJsonRoot ) {
                        // 失敗！
                        break;
                    }
                }

                // カレントJSONクラスを設定する
                m_pcJsonCurrent = m_pcJsonRoot;

                // 成功！
                result = true;
            }while ( false );

            // 実行結果を調べる
            if ( !result ) {
                // ストリームポインタを復元する
                rcStream.SetStreamPoint( nPoint );
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONドキュメント出力関数
    bool CJsonDocument::OutputDocument( CStreamOut& rcStreamOut ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // ルートJSONクラスポインタを調べる
            if ( nullptr != m_pcJsonRoot ) {
                // ルートJSONクラスを出力する
                if ( !m_pcJsonRoot->OutputJson( rcStreamOut ) ) {
                    // 失敗！
                    break;
                }
                // 改行を出力する
                else if ( !rcStreamOut.OutputNewLine() ) {
                    // 失敗！
                    break;
                }
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレントJSONクラス削除関数
    bool CJsonDocument::DeleteCurrentJson() noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスポインタを調べる
            if ( m_pcJsonRoot == m_pcJsonCurrent ) {
                // クリアする
                ClearDocument();
            }
            // JSONクラスを削除する
            else if ( !DeleteJson( m_pcJsonCurrent ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレントパス取得関数
    bool CJsonDocument::GetCurrentPath( CString& rcPath ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスのJSONパスを取得する
            result = GetJsonPath( rcPath, m_pcJsonCurrent );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレントパス設定関数
    bool CJsonDocument::SetCurrentPath( wchar_t const* pszPath ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスのJSONパスを検索する
            CJson* pcJson = FindJsonPath( pszPath, m_pcJsonCurrent );
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }

            // カレントJSONクラスポインタを設定する
            m_pcJsonCurrent = pcJson;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレント設定値文字列取得関数
    bool CJsonDocument::GetCurrentSetValue( CString& rcValue, bool bClassName, bool bQuotes ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスのJSON設定値文字列を取得する
            result = GetJsonSetValue( rcValue, m_pcJsonCurrent, bClassName, bQuotes );
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // カレント設定値文字列設定関数
    bool CJsonDocument::SetCurrentSetValue( wchar_t const* pszValue ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスのJSON設定値文字列を設定する
            CJson* pcJson = m_pcJsonCurrent;
            if ( !SetJsonSetValue( pszValue, pcJson ) ) {
                // 失敗！
                break;
            }
            // カレントJSONクラスポインタを調べる
            else if ( m_pcJsonRoot == m_pcJsonCurrent ) {
                // クリアする
                ClearDocument();

                // ルートJSONクラスポインタを設定する
                m_pcJsonRoot = pcJson;
            }

            // カレントJSONクラスポインタを設定する
            m_pcJsonCurrent = pcJson;

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONパス作成関数
    bool CJsonDocument::CreatePath( wchar_t const* pszPath ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // カレントJSONクラスポインタを調べる
            CString cPath( L"/" );
            if ( nullptr != m_pcJsonCurrent ) {
                // カレントJSONパスを取得する
                GetCurrentPath( cPath );
            }

            // カレントJSONクラス相対でJSONパスを作成する
            CJson* pcJson = m_pcJsonCurrent;
            if ( !CreateJsonPath( pszPath, pcJson ) || ( nullptr == pcJson ) ) {
                // 失敗！
                break;
            }

            // ルートJSONクラスポインタを調べる
            CJson* pcRoot = pcJson->GetJsonRoot();
            if ( ( nullptr == m_pcJsonRoot ) || ( pcRoot != m_pcJsonRoot->GetJsonRoot() ) ) {
                // クリアする
                ClearDocument();
            }

            // ルートJSONクラスポインタを設定する
            m_pcJsonRoot = pcRoot;

            // カレントJSONパスを検索する
            m_pcJsonCurrent = FindJsonPath( cPath, m_pcJsonRoot );
            if ( nullptr == m_pcJsonCurrent ) {
                // カレントJSONクラスポインタを設定する
                m_pcJsonCurrent = m_pcJsonRoot;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的公開関数
    //-------------------------------------------------------------------------
    // JSONパス取得関数
    bool CJsonDocument::GetJsonPath( CString& rcPath, CJson* pcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }

            // 巡回する
            rcPath = L"";
            CJson* pcParent = nullptr;
            for ( ; nullptr != pcJson; pcJson = pcParent ) {
                // 親JSONクラスを取得する
                pcParent = pcJson->GetJsonParent();
                if ( nullptr != pcParent ) {
                    // 親JSONクラス種別を調べる
                    if ( pcParent->IsJsonPair() ) {
                        // JSON文字列を取得する
                        CJsonString* pcJsonString = pcParent->GetJsonString();
                        if ( nullptr == pcJsonString ) {
                            // 失敗！
                            break;
                        }

                        // 文字列を取得する
                        wchar_t const* pszString = *pcJsonString;
                        if ( nullptr == pszString ) {
                            // 空文字列を設定する
                            pszString = L"";
                        }

                        // 二重引用符で括るか判断する
                        size_t len = ::wcslen( pszString );
                        if ( ( 0 == len ) || ( nullptr != ::wcschr( pszString, L' ' ) ) ) {
                            // 名前を二重引用符で括って挿入する
                            if ( !rcPath.Insert( 0, CString().Format( L"\"%s\"", pszString ) ) ) {
                                // 失敗！
                                break;
                            }
                        }
                        // 名前を挿入する
                        else if ( !rcPath.Insert( 0, pszString ) ) {
                            // 失敗！
                            break;
                        }

                        // セパレータを挿入する
                        rcPath.Insert( 0, L'/' );
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonArray() ) {
                        // JSON配列を取得する
                        CJsonArray* pcJsonArray = pcParent->GetJsonArray();
                        if ( nullptr == pcJsonArray ) {
                            // 失敗！
                            break;
                        }

                        // 巡回する
                        int nCount = pcJsonArray->GetCount();
                        int nIndex = 0;
                        for ( ;; ++nIndex ) {
                            // 調べる
                            if ( nCount <= nIndex ) {
                                // 失敗！
                                nIndex = -1;
                                break;
                            }
                            // JSONクラスポインタを調べる
                            else if ( pcJson == ( *pcJsonArray )[ nIndex ] ) {
                                // 終了！
                                break;
                            }
                        }

                        // インデックスを調べる
                        if ( 0 > nIndex ) {
                            // 失敗！
                            break;
                        }
                        // 配列添え字を挿入する
                        else if ( !rcPath.Insert( 0, CString().Format( L"[%d]", nIndex ) ) ) {
                            // 失敗！
                            break;
                        }
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonPair() ) {
                        // 子JSONクラス種別を調べる
                        if ( pcJson->IsJsonObject() ) {
                            // セパレータを挿入する
                            if ( !rcPath.Insert( 0, L'/' ) ) {
                                // 失敗！
                                break;
                            }
                        }
                    }
                }

                // 親JSONクラスポインタを調べる
                if ( nullptr == pcParent ) {
                    // 文字数を調べる
                    wchar_t ch = L'\0';
                    if ( 0 < rcPath.GetCount() ) {
                        // 先頭の文字を取得する
                        ch = rcPath[ 0 ];
                    }

                    // 先頭の文字を調べる
                    if ( L'/' != ch ) {
                        // セパレータを挿入する
                        rcPath.Insert( 0, L'/' );
                    }

                    // 成功！
                    result = true;
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONパス検索関数
    CJson* CJsonDocument::FindJsonPath( wchar_t const* pszPath, CJson* pcJson ) noexcept {
        // 処理ブロック
        CJson* result = nullptr;
        do {
            // パス文字列ポインタを調べる
            if ( nullptr == pszPath ) {
                // 失敗！
                break;
            }
            // JSONクラスポインタを調べる
            else if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }

            // 文字列ストリームを作成する
            CStringStream cStream( pszPath );

            // 巡回する
            EJsonPathToken eToken = EJsonPathToken::Invalid;
            for ( int nToken = 0; nullptr != pcJson; ) {
                // ストリーム終端か調べる
                if ( cStream.IsStreamEnd() ) {
                    // 成功！
                    result = pcJson;
                    break;
                }

                // JSONパストークンを入力する
                EJsonPathToken ePrev = eToken;
                CString        cToken;
                eToken = InputPathToken( cStream, cToken );
                ++nToken;

                // JSONパストークン種別を調べる
                if ( EJsonPathToken::Separator == eToken ) {
                    // 直前のJSONパストークン種別を調べる
                    if ( EJsonPathToken::Separator == ePrev ) {
                        // 失敗！
                        break;
                    }
                    // トークン入力カウントを調べる
                    else if ( 1 == nToken ) {
                        // ルートJSONクラスを取得する
                        pcJson = pcJson->GetJsonRoot();
                    }
                }
                // 直前のJSONパストークン種別を調べる
                else if ( ( EJsonPathToken::Dot == ePrev ) || ( EJsonPathToken::DotDot == ePrev ) ) {
                    // 失敗！
                    break;
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Dot == eToken ) {
                    // 何もしない
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::DotDot == eToken ) {
                    // 親JSONクラスを取得する
                    pcJson = pcJson->GetJsonParent();
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Name == eToken ) {
                    // JSONペアを取得する
                    CJsonPair* pcJsonPair = pcJson->GetJsonPair();
                    if ( nullptr == pcJsonPair ) {
                        // JSONオブジェクトを取得する
                        CJsonObject* pcJsonObject = pcJson->GetJsonObject();
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }

                        // JSONペアを取得する
                        pcJsonPair = pcJsonObject->GetJsonPair( cToken );
                        if ( nullptr == pcJsonPair ) {
                            // 失敗！
                            break;
                        }
                    }

                    // JSONバリューを取得する
                    pcJson = pcJsonPair->GetJsonValue();
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Index == eToken ) {
                    // JSON配列を取得する
                    CJsonArray* pcJsonArray = pcJson->GetJsonArray();
                    if ( nullptr == pcJsonArray ) {
                        // 失敗！
                        break;
                    }

                    // インデックスを取得する
                    int nIndex = static_cast< int >( ::wcstol( cToken, nullptr, 10 ) );

                    // JSONエレメントを取得する
                    pcJson = pcJsonArray->GetJsonElement( nIndex );
                }
                else {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSON設定値文字列取得関数
    bool CJsonDocument::GetJsonSetValue( CString& rcValue, CJson* pcJson, bool bClassName, bool bQuotes ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }

            // JSONクラス種別を調べる
            if ( pcJson->IsJsonToken() ) {
                // JSONトークンを取得する
                CJsonToken* pcJsonToken = pcJson->GetJsonToken();
                if ( nullptr == pcJsonToken ) {
                    // 失敗！
                    break;
                }

                // 文字列を取得する
                wchar_t const* pszString = *pcJsonToken;
                if ( nullptr == pszString ) {
                    // 空文字列を設定する
                    pszString = L"";
                }

                // JSONクラス種別を調べる
                if ( bQuotes && pcJson->IsJsonString() ) {
                    // 二重引用符で括ってトークン文字列を追加する
                    if ( !rcValue.Push( CString().Format( L"\"%s\"", pszString ) ) ) {
                        // 失敗！
                        break;
                    }
                }
                // トークン文字列を追加する
                else if ( !rcValue.Push( pszString ) ) {
                    // 失敗！
                    break;
                }
            }
            // JSONクラス種別を調べる
            else if ( pcJson->IsJsonContainer() ) {
                // JSONコンテナクラスを取得する
                CJsonContainer* pcJsonContainer = pcJson->GetJsonContainer();
                if ( nullptr == pcJsonContainer ) {
                    // 失敗！
                    break;
                }
                // JSONクラスエレメント数を調べる
                else if ( 0 == pcJsonContainer->GetCount() ) {
                    // JSONクラス種別を調べる
                    if ( pcJson->IsJsonObject() ) {
                        // 空オブジェクト文字列を追加する
                        if ( !rcValue.Push( L"{}" ) ) {
                            // 失敗！
                            break;
                        }
                    }
                    else if ( pcJson->IsJsonArray() ) {
                        // 空配列文字列を追加する
                        if ( !rcValue.Push( L"[]" ) ) {
                            // 失敗！
                            break;
                        }
                    }
                    else {
                        // 失敗！
                        break;
                    }
                }
                // JSONクラス種別を調べる
                else if ( pcJson->IsJsonObject() ) {
                    // オブジェクト文字列を追加する
                    if ( !rcValue.Push( L"{...}" ) ) {
                        // 失敗！
                        break;
                    }
                }
                else if ( pcJson->IsJsonArray() ) {
                    // 配列文字列を追加する
                    if ( !rcValue.Push( L"[...]" ) ) {
                        // 失敗！
                        break;
                    }
                }
                else {
                    // 失敗！
                    break;
                }
            }
            // JSONクラス種別を調べる
            else if ( pcJson->IsJsonPair() ) {
                // JSON文字列のJSON設定値文字列を取得する
                if ( !GetJsonSetValue( rcValue, pcJson->GetJsonString(), false ) ) {
                    // 失敗！
                    break;
                }
                // 区切り文字列を追加する
                else if ( !rcValue.Push( L": " ) ) {
                    // 失敗！
                    break;
                }
                // JSONバリューのJSON設定値文字列を取得する
                else if ( !GetJsonSetValue( rcValue, pcJson->GetJsonValue(), false ) ) {
                    // 失敗！
                    break;
                }
            }
            else {
                // 失敗！
                break;
            }

            // JSONクラス名取得フラグを調べる
            if ( bClassName ) {
                // JSONクラス種別を調べる
                wchar_t const* pszString = L"";
                switch ( pcJson->GetJsonClass() ) {
                case CJson::EJsonClass::JsonObject: pszString = L" ( JSONオブジェクト )";  break;
                case CJson::EJsonClass::JsonArray:  pszString = L" ( JSON配列 )";          break;
                case CJson::EJsonClass::JsonString: pszString = L" ( JSON文字列 )";        break;
                case CJson::EJsonClass::JsonNumber: pszString = L" ( JSON数値 )";          break;
                case CJson::EJsonClass::JsonFixed:  pszString = L" ( JSON固定値 )";        break;
                case CJson::EJsonClass::JsonPair:   pszString = L" ( JSONペア )";          break;
                }

                // JSONクラス種別文字列を追加する
                rcValue += pszString;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSON設定値設定関数
    bool CJsonDocument::SetJsonSetValue( wchar_t const* pszValue, CJson*& rpcJson ) noexcept {
        // 文字列ストリームでJSON設定値を設定する
        CStringStream cStream( pszValue );
        return SetJsonSetValueByStream( cStream, rpcJson );
    }

    //-------------------------------------------------------------------------
    // JSON設定値ストリーム設定関数
    bool CJsonDocument::SetJsonSetValueByStream( CStream& rcStream, CJson*& rpcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            CJson* pcParent = nullptr;
            if ( nullptr != rpcJson ) {
                // 親JSONクラスを取得する
                pcParent = rpcJson->GetJsonParent();
            }

            // 最初の親JSONクラスを保存する
            CJson* pcParentFirst = pcParent;

            // 親JSONクラスポインタを調べる
            CJson* pcJsonNew = nullptr;
            if ( nullptr == pcParent ) {
                // JSONペアを新規作成する
                pcJsonNew = CJsonPair::CreateInputJson( rcStream, pcParent );
                if ( nullptr == pcJsonNew ) {
                    // JSONバリューを新規作成する
                    pcJsonNew = CJsonValue::CreateInputJson( rcStream, pcParent );
                    if ( nullptr == pcJsonNew ) {
                        // 失敗！
                        break;
                    }
                }
            }
            // 親JSONクラス種別を調べる
            else if ( pcParent->IsJsonObject() ) {
                // JSONペアを新規作成する
                pcJsonNew = CJsonPair::CreateInputJson( rcStream, pcParent );
                if ( nullptr == pcJsonNew ) {
                    // 失敗！
                    break;
                }
            }
            // 親JSONクラス種別を調べる
            else if ( pcParent->IsJsonArray() ) {
                // JSONバリューを新規作成する
                pcJsonNew = CJsonValue::CreateInputJson( rcStream, pcParent );
                if ( nullptr == pcJsonNew ) {
                    // 失敗！
                    break;
                }
            }
            // 親JSONクラス種別を調べる
            else if ( pcParent->IsJsonPair() ) {
                // JSONバリューを新規作成する
                pcJsonNew = CJsonValue::CreateInputJson( rcStream, pcParent );
                if ( nullptr == pcJsonNew ) {
                    // 失敗！
                    break;
                }
            }
            else {
                // 失敗！
                break;
            }

            // 処理ブロック
            do {
                // 親JSONクラスポインタを調べる
                if ( nullptr == pcParent ) {
                    // JSONクラスポインタを設定する
                    rpcJson = pcJsonNew;
                }
                // 親JSONクラス種別を調べる
                else if ( pcParent->IsJsonContainer() ) {
                    // JSONコンテナを取得する
                    CJsonContainer* pcJsonContainer = pcParent->GetJsonContainer();
                    if ( nullptr == pcJsonContainer ) {
                        // 失敗！
                        break;
                    }

                    // JSONエレメントインデックスを取得する
                    int nIndex = pcJsonContainer->Find( rpcJson );
                    if ( 0 > nIndex ) {
                        // 失敗！
                        break;
                    }

                    // JSONエレメントを取得する
                    CJson* pcJsonElement = pcJsonContainer->GetJsonElement( nIndex );
                    if ( nullptr != pcJsonElement ) {
                        // JSONエレメントを削除する
                        delete pcJsonElement;
                    }

                    // JSONエレメントを設定する
                    if ( !pcJsonContainer->SetJsonElement( nIndex, pcJsonNew ) ) {
                        // 失敗！
                        break;
                    }

                    // 最初の親JSONクラス種別を調べる
                    if ( pcParentFirst->IsJsonPair() ) {
                        // JSONクラスポインタを設定する
                        rpcJson = pcJsonNew->GetJsonValue();
                    }
                    else {
                        // JSONクラスポインタを設定する
                        rpcJson = pcJsonNew;
                    }
                }
                // 親JSONクラス種別を調べる
                else if ( pcParent->IsJsonPair() ) {
                    // JSONペアを取得する
                    CJsonPair* pcJsonPair = pcParent->GetJsonPair();
                    if ( nullptr == pcJsonPair ) {
                        // 失敗！
                        break;
                    }

                    // JSONバリューを設定する
                    if ( !pcJsonPair->SetJsonValue( pcJsonNew->GetJsonValue() ) ) {
                        // 失敗！
                        break;
                    }

                    // JSONクラスポインタを設定する
                    rpcJson = pcJsonNew;
                }
                else {
                    // 失敗！
                    break;
                }

                // 成功！
                result = true;
            } while ( false );

            // 実行結果を調べる
            if ( !result ) {
                // 新規作成JSONクラスを削除する
                delete pcJsonNew;
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONクラス削除関数
    bool CJsonDocument::DeleteJson( CJson*& rpcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == rpcJson ) {
                // 失敗！
                break;
            }

            // 親JSONクラスを取得する
            CJson* pcParent = rpcJson->GetJsonParent();
            if ( nullptr != pcParent ) {
                // 親JSONクラス種別を調べる
                if ( pcParent->IsJsonContainer() ) {
                    // JSONコンテナクラスを取得する
                    CJsonContainer* pcJsonContainer = pcParent->GetJsonContainer();
                    if ( nullptr == pcJsonContainer ) {
                        // 失敗！
                        break;
                    }

                    // エレメントインデックスを取得する
                    int nIndex = pcJsonContainer->Find( rpcJson );
                    if ( 0 > nIndex ) {
                        // 失敗！
                        break;
                    }
                    // エレメントを削除する
                    else if ( !pcJsonContainer->Remove( nIndex ) ) {
                        // 失敗！
                        break;
                    }

                    // JSONクラスを削除する
                    delete rpcJson;

                    // エレメント数を調べる
                    int nCount = pcJsonContainer->GetCount();
                    if ( 0 == nCount ) {
                        // JSONクラスポインタを設定する
                        rpcJson = pcParent;
                    }
                    else {
                        // エレメント数を調べる
                        if ( nCount <= nIndex ) {
                            // インデックスを設定する
                            nIndex = ( nCount - 1 );
                        }

                        // JSONクラスポインタを設定する
                        rpcJson = ( *pcJsonContainer )[ nIndex ];
                    }
                }
                // 親JSONクラス種別を調べる
                else if ( pcParent->IsJsonPair() ) {
                    // 親JSONクラスを削除する
                    if ( !DeleteJson( pcParent ) ) {
                        // 失敗！
                        break;
                    }

                    // JSONクラスポインタを設定する
                    rpcJson = pcParent;
                }
                else {
                    // 失敗！
                    break;
                }
            }
            else {
                // JSONクラスを削除する
                delete rpcJson;

                // JSONクラスポインタをクリアする
                rpcJson = nullptr;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONパス作成関数
    bool CJsonDocument::CreateJsonPath( wchar_t const* pszPath, CJson*& rpcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONパス文字列ポインタを調べる
            if ( nullptr == pszPath ) {
                // 失敗！
                break;
            }

            // 文字列ストリームを作成する
            CStringStream cStream( pszPath );

            // 巡回する
            EJsonPathToken eToken = EJsonPathToken::Invalid;
            int            nToken = 0;
            for ( ;; ) {
                // ストリーム終端か調べる
                if ( cStream.IsStreamEnd() ) {
                    // 成功！
                    result = true;
                    break;
                }

                // JSONクラスポインタを調べる
                CJson* pcParent = nullptr;
                if ( nullptr != rpcJson ) {
                    // 親JSONクラスを取得する
                    pcParent = rpcJson->GetJsonParent();
                }

                // JSONパストークンを入力する
                EJsonPathToken ePrev = eToken;
                CString        cToken;
                eToken = InputPathToken( cStream, cToken, true );
                ++nToken;

                // JSONパストークン種別を調べる
                if ( EJsonPathToken::Separator == eToken ) {
                    // 直前のJSONパストークン種別を調べる
                    if ( EJsonPathToken::Separator == ePrev ) {
                        // 失敗！
                        break;
                    }
                    // トークン入力カウントを調べる
                    else if ( 1 == nToken ) {
                        // JSONクラスポインタを調べる
                        if ( nullptr != rpcJson ) {
                            // ルートJSONクラスを取得する
                            rpcJson = rpcJson->GetJsonRoot();
                        }
                    }
                }
                // 直前のJSONパストークン種別を調べる
                else if ( ( EJsonPathToken::Dot == ePrev ) || ( EJsonPathToken::DotDot == ePrev ) ) {
                    // 失敗！
                    break;
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Dot == eToken ) {
                    // 何もしない
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::DotDot == eToken ) {
                    // 親JSONクラスを調べる
                    if ( nullptr == pcParent ) {
                        // 失敗！
                        break;
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonPair() ) {
                        // 親の親JSONクラスを取得する
                        CJson* pcParentParent = pcParent->GetJsonParent();
                        if ( nullptr != pcParentParent ) {
                            // 親JSONクラスポインタを設定する
                            pcParent = pcParentParent;
                        }
                    }

                    // JSONクラスポインタを設定する
                    rpcJson = pcParent;
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Name == eToken ) {
                    // JSONクラスポインタを調べる
                    CJsonObject* pcJsonObject = nullptr;
                    CJsonPair*   pcJsonPair   = nullptr;
                    if ( nullptr == rpcJson ) {
                        // JSONオブジェクトを作成する
                        pcJsonObject = new CJsonObject( nullptr );
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }
                    }
                    // JSONクラス種別を調べる
                    else if ( rpcJson->IsJsonObject() ) {
                        // JSONオブジェクトを取得する
                        pcJsonObject = rpcJson->GetJsonObject();
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }
                    }
                    // 親JSONクラスポインタを調べる
                    else if ( nullptr == pcParent ) {
                        // JSONオブジェクトを作成する
                        pcJsonObject = new CJsonObject( nullptr );
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }
                        // JSONクラス種別を調べる
                        else if ( rpcJson->IsJsonPair() ) {
                            // JSONペアを取得する
                            pcJsonPair = rpcJson->GetJsonPair();
                            if ( nullptr == pcJsonPair ) {
                                // 失敗！
                                break;
                            }
                            // JSONペアを追加する
                            else if ( !pcJsonObject->Push( pcJsonPair ) ) {
                                // 失敗！
                                break;
                            }

                            // 親JSONクラスを設定する
                            rpcJson->SetJsonParent( pcJsonObject );
                        }
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonObject() ) {
                        // JSONオブジェクトを取得する
                        pcJsonObject = pcParent->GetJsonObject();
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonArray() ) {
                        // 親JSON配列を取得する
                        CJsonArray* pcParentArray = pcParent->GetJsonArray();
                        if ( nullptr == pcParentArray ) {
                            // 失敗！
                            break;
                        }

                        // エレメントインデックスを取得する
                        int nIndex = pcParentArray->Find( rpcJson );
                        if ( 0 > nIndex ) {
                            // 失敗！
                            break;
                        }

                        // JSONオブジェクトを作成する
                        pcJsonObject = new CJsonObject( pcParentArray );
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }

                        // JSONバリューを削除する
                        delete ( *pcParentArray )[ nIndex ];

                        // JSONバリューを設定する
                        ( *pcParentArray )[ nIndex ] = pcJsonObject;
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonPair() ) {
                        // 親JSONペアを取得する
                        CJsonPair* pcParentPair = pcParent->GetJsonPair();
                        if ( nullptr == pcParentPair ) {
                            // 失敗！
                            break;
                        }

                        // JSONオブジェクトを作成する
                        pcJsonObject = new CJsonObject( pcParentPair );
                        if ( nullptr == pcJsonObject ) {
                            // 失敗！
                            break;
                        }

                        // JSONバリューを設定する
                        pcParentPair->SetJsonValue( pcJsonObject );
                    }
                    else {
                        // 失敗！
                        break;
                    }

                    // JSONペアを取得する
                    pcJsonPair = pcJsonObject->GetJsonPair( cToken );
                    if ( nullptr == pcJsonPair ) {
                        // JSONペアを作成する
                        pcJsonPair = new CJsonPair( pcJsonObject, cToken );
                        if ( nullptr == pcJsonPair ) {
                            // 失敗！
                            break;
                        }
                        // JSONペアを追加する
                        else if ( !pcJsonObject->Push( pcJsonPair ) ) {
                            // 失敗！
                            break;
                        }
                    }

                    // JSONバリューを取得する
                    rpcJson = pcJsonPair->GetJsonValue();
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Index == eToken ) {
                    // JSONクラスポインタを調べる
                    CJsonArray* pcJsonArray = nullptr;
                    if ( nullptr == rpcJson ) {
                        // JSON配列を作成する
                        pcJsonArray = new CJsonArray( nullptr );
                        if ( nullptr == pcJsonArray ) {
                            // 失敗！
                            break;
                        }
                    }
                    // JSONクラス種別を調べる
                    else if ( rpcJson->IsJsonArray() ) {
                        // JSON配列を取得する
                        pcJsonArray = rpcJson->GetJsonArray();
                        if ( nullptr == pcJsonArray ) {
                            // 失敗！
                            break;
                        }
                    }
                    // 親JSONクラスポインタを調べる
                    else if ( nullptr == pcParent ) {
                        // JSONクラス種別を調べる
                        if ( rpcJson->IsJsonArray() ) {
                            // JSON配列を取得する
                            pcJsonArray = rpcJson->GetJsonArray();
                            if ( nullptr == pcJsonArray ) {
                                // 失敗！
                                break;
                            }
                        }
                        else {
                            // JSON配列を作成する
                            pcJsonArray = new CJsonArray( nullptr );
                            if ( nullptr == pcJsonArray ) {
                                // 失敗！
                                break;
                            }
                        }
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonArray() ) {
                        // 親JSON配列を取得する
                        CJsonArray* pcParentArray = pcParent->GetJsonArray();
                        if ( nullptr == pcParentArray ) {
                            // 失敗！
                            break;
                        }

                        // エレメントインデックスを取得する
                        int nIndex = pcParentArray->Find( rpcJson );
                        if ( 0 > nIndex ) {
                            // 失敗！
                            break;
                        }

                        // JSON配列を作成する
                        pcJsonArray = new CJsonArray( pcParentArray );
                        if ( nullptr == pcJsonArray ) {
                            // 失敗！
                            break;
                        }

                        // JSONバリューを削除する
                        delete ( *pcParentArray )[ nIndex ];

                        // JSONバリューを設定する
                        ( *pcParentArray )[ nIndex ] = pcJsonArray;
                    }
                    // 親JSONクラス種別を調べる
                    else if ( pcParent->IsJsonPair() ) {
                        // 親JSONペアを取得する
                        CJsonPair* pcParentPair = pcParent->GetJsonPair();
                        if ( nullptr == pcParentPair ) {
                            // 失敗！
                            break;
                        }

                        // JSON配列を作成する
                        pcJsonArray = new CJsonArray( pcParentPair );
                        if ( nullptr == pcJsonArray ) {
                            // 失敗！
                            break;
                        }

                        // JSONバリューを設定する
                        pcParentPair->SetJsonValue( pcJsonArray );
                    }
                    else {
                        // 失敗！
                        break;
                    }

                    // インデックスを調べる
                    int nIndex = static_cast< int >( ::wcstol( cToken, nullptr, 10 ) );
                    if ( pcJsonArray->GetCount() <= nIndex ) {
                        // JSONエレメント数を拡張する
                        if ( !pcJsonArray->ExtendJsonElementCount( nIndex + 1 ) ) {
                            // 失敗！
                            break;
                        }
                    }

                    // JSONエレメントを取得する
                    rpcJson = ( *pcJsonArray )[ nIndex ];
                }
                // JSONパストークン種別を調べる
                else if ( EJsonPathToken::Equal == eToken ) {
                    // JSON設定値を設定する
                    if ( !SetJsonSetValueByStream( cStream, rpcJson ) ) {
                        // 失敗！
                        break;
                    }
                }
                else {
                    // 失敗！
                    break;
                }
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSONパスリスト取得関数
    bool CJsonDocument::GetJsonPathList( CString& rcPathList, CJson* pcJson ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // JSONクラスポインタを調べる
            if ( nullptr == pcJson ) {
                // 失敗！
                break;
            }
            // JSONクラス種別を調べる
            else if ( pcJson->IsJsonContainer() ) {
                // JSONコンテナを取得する
                CJsonContainer* pcJsonContainer = pcJson->GetJsonContainer();
                if ( nullptr == pcJsonContainer ) {
                    // 失敗！
                    break;
                }

                // JSONクラスエレメント数を調べる
                int nCount = pcJsonContainer->GetCount();
                if ( 0 == nCount ) {
                    // JSONパスを取得する
                    CString cPath;
                    if ( !GetJsonPath( cPath, pcJson ) ) {
                        // 失敗！
                        break;
                    }
                    // パスリストに追加する
                    else if ( !rcPathList.Push( cPath ) ) {
                        // 失敗！
                        break;
                    }

                    // JSON設定値文字列を取得する
                    CString cValue;
                    if ( !GetJsonSetValue( cValue, pcJson, true ) ) {
                        // 失敗！
                        break;
                    }
                    // パスリストに追加する
                    else if ( !rcPathList.Push( CString().Format( L" = %s\n", cValue.GetBuffer() ) ) ) {
                        // 失敗！
                        break;
                    }
                }
                else {
                    // 巡回する
                    int nIndex = 0;
                    for ( ; nCount > nIndex; ++nIndex ) {
                        // JSONクラス要素を取得する
                        CJson* pcJsonElement = ( *pcJsonContainer )[ nIndex ];

                        // パスリストを取得する
                        if ( !GetJsonPathList( rcPathList, pcJsonElement ) ) {
                            // 失敗！
                            nIndex = -1;
                            break;
                        }
                    }

                    // インデックスを調べる
                    if ( 0 > nIndex ) {
                        // 失敗！
                        break;
                    }
                }
            }
            // JSONクラス種別を調べる
            else if ( pcJson->IsJsonToken() ) {
                // JSONパスを取得する
                CString cPath;
                if ( !GetJsonPath( cPath, pcJson ) ) {
                    // 失敗！
                    break;
                }
                // パスリストに追加する
                else if ( !rcPathList.Push( cPath ) ) {
                    // 失敗！
                    break;
                }

                // JSON設定値文字列を取得する
                CString cValue;
                if ( !GetJsonSetValue( cValue, pcJson, true ) ) {
                    // 失敗！
                    break;
                }
                // パスリストに追加する
                else if ( !rcPathList.Push( CString().Format( L" = %s\n", cValue.GetBuffer() ) ) ) {
                    // 失敗！
                    break;
                }
            }
            // JSONクラス種別を調べる
            else if ( pcJson->IsJsonPair() ) {
                // パスリストを取得する
                if ( !GetJsonPathList( rcPathList, pcJson->GetJsonValue() ) ) {
                    // 失敗！
                    break;
                }
            }
            else {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //=========================================================================
    // 静的限定公開関数
    //-------------------------------------------------------------------------
    // JSONパストークン入力関数
    CJsonDocument::EJsonPathToken CJsonDocument::InputPathToken( CStream& rcStream, CString& rcString, bool bEqual ) noexcept {
        // 処理ブロック
        EJsonPathToken result = EJsonPathToken::Invalid;
        do {
            // ストリームポインタを取得する
            int nPoint = rcStream.GetStreamPoint();

            // １文字入力する
            wchar_t ch;
            if ( !rcStream.InputChar( ch ) ) {
                // 失敗！
                break;
            }
            // 文字コードを調べる
            else if ( L'/' == ch ) {
                // JSONパスセパレータを設定する
                rcString.Push( ch );
                result = EJsonPathToken::Separator;
            }
            // 文字コードを調べる
            else if ( L'.' == ch ) {
                // JSONパスドットを設定する
                rcString.Push( ch );
                result = EJsonPathToken::Dot;

                // ストリームポインタを取得する
                nPoint = rcStream.GetStreamPoint();

                // １文字入力する
                if ( rcStream.InputChar( ch ) ) {
                    // 文字コードを調べる
                    if ( L'.' == ch ) {
                        // JSONパス二重ドットを設定する
                        rcString.Push( ch );
                        result = EJsonPathToken::DotDot;
                    }
                    else {
                        // ストリームポインタを設定する
                        rcStream.SetStreamPoint( nPoint );
                    }
                }
            }
            // 文字コードを調べる
            else if ( L'[' == ch ) {
                // 空白をスキップする
                rcStream.SkipSpace();

                // JSON整数を取得する
                CJsonToken cJsonToken( nullptr );
                if ( !cJsonToken.InputJsonInt( rcStream ) ) {
                    // 失敗！
                    break;
                }

                // 空白をスキップする
                rcStream.SkipSpace();

                // １文字スキップする
                if ( !rcStream.SkipChar( L']' ) ) {
                    // 失敗！
                    break;
                }

                // JSONパスインデックスを設定する
                rcString.Push( cJsonToken );
                result = EJsonPathToken::Index;
            }
            // 文字コードを調べる
            else if ( bEqual && ( L'=' == ch ) ) {
                // 空白をスキップする
                rcStream.SkipSpace();

                // JSONパス等号を設定する
                rcString.Push( L'=' );
                result = EJsonPathToken::Equal;
            }
            // 文字コードを調べる
            else if ( bEqual && ( 0 != ::iswspace( ch ) ) ) {
                // 空白をスキップする
                rcStream.SkipSpace();

                // １文字スキップする
                if ( !rcStream.SkipChar( L'=' ) ) {
                    // 失敗！
                    break;
                }

                // 空白をスキップする
                rcStream.SkipSpace();

                // JSONパス等号を設定する
                rcString.Push( L'=' );
                result = EJsonPathToken::Equal;
            }
            else {
                // 文字コードを調べる
                CJsonToken cJsonToken( nullptr );
                if ( L'\"' == ch ) {
                    // JSON文字集合を取得する
                    if ( !cJsonToken.InputJsonChars( rcStream ) ) {
                        // 失敗！
                        break;
                    }
                    // １文字スキップする
                    else if ( !rcStream.SkipChar( L'\"' ) ) {
                        // 失敗！
                        break;
                    }
                }
                else {
                    // ストリームポインタを設定する
                    rcStream.SetStreamPoint( nPoint );

                    // JSON文字集合を取得する
                    if ( !cJsonToken.InputJsonChars( rcStream, L"/[= " ) ) {
                        // 失敗！
                        break;
                    }
                }

                // JSONパス名前を設定する
                rcString.Push( cJsonToken );
                result = EJsonPathToken::Name;
            }
        } while ( false );

        // 実行結果を返す
        return result;
    }

    //-------------------------------------------------------------------------
    // JSON文字列二重引用符削除関数
    bool CJsonDocument::DeleteQuotes( CString& rcString ) noexcept {
        // 処理ブロック
        bool result = false;
        do {
            // 文字列長を取得する
            int nLen = rcString.GetCount();
            if ( 2 > nLen ) {
                // 失敗！
                break;
            }
            // 先頭の文字コードを調べる
            else if ( L'\"' != rcString[ 0 ] ) {
                // 失敗！
                break;
            }
            // 最後尾の文字コードを調べる
            else if ( L'\"' != rcString[ nLen - 1 ] ) {
                // 失敗！
                break;
            }
            // 最後尾の文字を削除する
            else if ( rcString.Remove( ( nLen - 1 ) ) ) {
                // 失敗！
                break;
            }
            // 先頭の文字を削除する
            else if ( rcString.Remove( 0 ) ) {
                // 失敗！
                break;
            }

            // 成功！
            result = true;
        } while ( false );

        // 実行結果を返す
        return result;
    }
}

#pragma managed( pop )