892 lines
32 KiB
C#
892 lines
32 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Globalization;
|
||
using System.Text;
|
||
using System.Text.Json;
|
||
using System.Text.Json.Nodes;
|
||
|
||
namespace GameLauncher.Services.Codecs.Es3
|
||
{
|
||
/// <summary>
|
||
/// ES3 のシリアライズ要素が持つ「型」の種別。
|
||
/// ES3 は <c>{ "__type": "System.Int32", "value": 42 }</c> 形式で値を格納するため、
|
||
/// この列挙子で GUI 側へ型情報を伝えます。
|
||
/// </summary>
|
||
public enum Es3ValueKind
|
||
{
|
||
/// <summary>不明・未判定。</summary>
|
||
Unknown,
|
||
|
||
/// <summary>真偽値。</summary>
|
||
Boolean,
|
||
|
||
/// <summary>整数(Int32 / Int64 / UInt32 等)。</summary>
|
||
Integer,
|
||
|
||
/// <summary>浮動小数(Single / Double / Decimal)。</summary>
|
||
Float,
|
||
|
||
/// <summary>文字列。</summary>
|
||
String,
|
||
|
||
/// <summary>列挙体。</summary>
|
||
Enum,
|
||
|
||
/// <summary>配列。</summary>
|
||
Array,
|
||
|
||
/// <summary>辞書(キーと値の組)。</summary>
|
||
Dictionary,
|
||
|
||
/// <summary>入れ子オブジェクト。</summary>
|
||
Object
|
||
}
|
||
|
||
/// <summary>
|
||
/// ES3 ファイル内の 1 項目を表す型付きノード。
|
||
/// JSON ツリー上の位置(<see cref="Path"/>)を保持するため、編集後の書き戻しが安全に行えます。
|
||
/// </summary>
|
||
public sealed class Es3Node
|
||
{
|
||
/// <summary>キー名(辞書・オブジェクトの子の場合)。</summary>
|
||
public string Key { get; set; } = string.Empty;
|
||
|
||
/// <summary>親をたどる JSON パス(例: <c>$.player.stats.hp</c>)。</summary>
|
||
public string Path { get; set; } = "$";
|
||
|
||
/// <summary>ES3 が示す型名(例: <c>System.Int32</c>、<c>System.Collections.Generic.List`1</c>)。</summary>
|
||
public string TypeName { get; set; } = string.Empty;
|
||
|
||
/// <summary>判定した値種別。</summary>
|
||
public Es3ValueKind Kind { get; set; } = Es3ValueKind.Unknown;
|
||
|
||
/// <summary>現在の値(文字列化した表示・編集用の値)。</summary>
|
||
public string DisplayValue { get; set; } = string.Empty;
|
||
|
||
/// <summary>元の JSON 値(書き戻し時の型再現に使用)。</summary>
|
||
public JsonNode? OriginalNode { get; set; }
|
||
|
||
/// <summary>配列・辞書・オブジェクトの場合の子要素。</summary>
|
||
public List<Es3Node> Children { get; } = [];
|
||
|
||
/// <summary>子要素を持つか。</summary>
|
||
public bool HasChildren => this.Children.Count > 0;
|
||
|
||
/// <summary>エディタで直接値を編集できる型か。</summary>
|
||
public bool IsEditable => this.Kind is Es3ValueKind.Boolean
|
||
or Es3ValueKind.Integer
|
||
or Es3ValueKind.Float
|
||
or Es3ValueKind.String
|
||
or Es3ValueKind.Enum;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ES3 (Easy Save 3) のセーブデータ本体(復号後の JSON)を解析し、
|
||
/// キー名・型・値を読み取るとともに、編集結果を安全に書き戻すパーサ/ライタ。
|
||
///
|
||
/// ES3 の内部形式は次の 2 通りが混在します:
|
||
/// <c>{ "key": { "__type": "System.Int32", "value": 100 } }</c>
|
||
/// <c>{ "key": { "__type": "System.Collections.Generic.Dictionary`2[...]", "value": { ... } } }</c>
|
||
/// 本クラスは両形式を展開し、編集後は元の型情報を保持したまま再構築します。
|
||
/// </summary>
|
||
public sealed class Es3SaveDocument
|
||
{
|
||
/// <summary>ES3 が型情報を格納するプロパティ名。</summary>
|
||
public const string TypePropertyName = "__type";
|
||
|
||
/// <summary>ES3 が値を格納するプロパティ名。</summary>
|
||
public const string ValuePropertyName = "value";
|
||
|
||
/// <summary>解析対象のルート JSON オブジェクト(編集はこのインスタンスを直接書き換えます)。</summary>
|
||
private JsonNode? _root;
|
||
|
||
/// <summary>復号直後の JSON 文字列(差分検出・バックアップ用)。</summary>
|
||
public string OriginalJson { get; private set; } = string.Empty;
|
||
|
||
/// <summary>解析に成功したか。</summary>
|
||
public bool IsLoaded => this._root != null;
|
||
|
||
/// <summary>解析時の警告(解釈できなかった要素など)。</summary>
|
||
public List<string> Warnings { get; } = [];
|
||
|
||
/// <summary>ルート直下の項目一覧。</summary>
|
||
public List<Es3Node> RootNodes { get; } = [];
|
||
|
||
/// <summary>
|
||
/// ES3 の平文 JSON 文字列を解析してドキュメントを構築します。
|
||
/// </summary>
|
||
/// <param name="json">復号済みの平文 JSON</param>
|
||
/// <returns>解析されたドキュメント</returns>
|
||
public static Es3SaveDocument Parse(string json)
|
||
{
|
||
var document = new Es3SaveDocument { OriginalJson = json ?? string.Empty };
|
||
|
||
if (string.IsNullOrWhiteSpace(json))
|
||
{
|
||
document.Warnings.Add("平文 JSON が空です。");
|
||
return document;
|
||
}
|
||
|
||
JsonNode? root;
|
||
try
|
||
{
|
||
root = JsonNode.Parse(json, documentOptions: new JsonDocumentOptions
|
||
{
|
||
AllowTrailingCommas = true,
|
||
CommentHandling = JsonCommentHandling.Skip,
|
||
MaxDepth = 256
|
||
});
|
||
}
|
||
catch (JsonException ex)
|
||
{
|
||
document.Warnings.Add($"JSON 解析に失敗しました: {ex.Message}");
|
||
return document;
|
||
}
|
||
|
||
if (root == null)
|
||
{
|
||
document.Warnings.Add("JSON のルートが null です。");
|
||
return document;
|
||
}
|
||
|
||
document._root = root;
|
||
document.BuildTree(root, "$", string.Empty);
|
||
return document;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 解析ツリーを走査してルート直下の項目一覧を構築します。
|
||
/// </summary>
|
||
/// <param name="root">JSON ルート</param>
|
||
/// <param name="path">ルートパス</param>
|
||
/// <param name="key">キー名</param>
|
||
private void BuildTree(JsonNode root, string path, string key)
|
||
{
|
||
if (root is JsonObject rootObject)
|
||
{
|
||
foreach (var kvp in rootObject)
|
||
{
|
||
var childPath = $"{path}.{kvp.Key}";
|
||
var node = this.CreateNode(kvp.Key, childPath, kvp.Value);
|
||
if (node != null)
|
||
{
|
||
this.RootNodes.Add(node);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
if (root is JsonArray rootArray)
|
||
{
|
||
for (int i = 0; i < rootArray.Count; i++)
|
||
{
|
||
var childPath = $"{path}[{i}]";
|
||
var node = this.CreateNode($"[{i}]", childPath, rootArray[i]);
|
||
if (node != null)
|
||
{
|
||
this.RootNodes.Add(node);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
this.Warnings.Add($"ルート要素を解釈できませんでした({root.GetValueKind()})。");
|
||
}
|
||
|
||
/// <summary>
|
||
/// JSON ノードから型付きの <see cref="Es3Node"/> を生成します。
|
||
/// </summary>
|
||
/// <param name="key">キー名</param>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <param name="node">対象ノード</param>
|
||
/// <returns>生成されたノード。解釈不能な場合は null</returns>
|
||
private Es3Node? CreateNode(string key, string path, JsonNode? node)
|
||
{
|
||
var result = new Es3Node
|
||
{
|
||
Key = key,
|
||
Path = path,
|
||
OriginalNode = node
|
||
};
|
||
|
||
if (node == null)
|
||
{
|
||
result.Kind = Es3ValueKind.Unknown;
|
||
result.DisplayValue = "null";
|
||
return result;
|
||
}
|
||
|
||
switch (node.GetValueKind())
|
||
{
|
||
case JsonValueKind.Object:
|
||
this.PopulateObject(result, path, node.AsObject());
|
||
return result;
|
||
|
||
case JsonValueKind.Array:
|
||
result.Kind = Es3ValueKind.Array;
|
||
result.TypeName = "System.Array";
|
||
PopulateArray(result, path, node.AsArray());
|
||
return result;
|
||
|
||
case JsonValueKind.String:
|
||
result.Kind = Es3ValueKind.String;
|
||
result.TypeName = "System.String";
|
||
result.DisplayValue = node.GetValue<string>();
|
||
return result;
|
||
|
||
case JsonValueKind.Number:
|
||
PopulateNumber(result, node);
|
||
return result;
|
||
|
||
case JsonValueKind.True:
|
||
case JsonValueKind.False:
|
||
result.Kind = Es3ValueKind.Boolean;
|
||
result.TypeName = "System.Boolean";
|
||
result.DisplayValue = node.GetValue<bool>() ? "true" : "false";
|
||
return result;
|
||
|
||
case JsonValueKind.Null:
|
||
result.Kind = Es3ValueKind.Unknown;
|
||
result.DisplayValue = "null";
|
||
return result;
|
||
|
||
default:
|
||
result.Kind = Es3ValueKind.Unknown;
|
||
result.DisplayValue = node.ToJsonString();
|
||
return result;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// JSON オブジェクトが ES3 の型付き要素か、単なる入れ子オブジェクトかを判定して展開します。
|
||
/// </summary>
|
||
/// <param name="target">構築対象のノード</param>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <param name="jsonObject">対象の JSON オブジェクト</param>
|
||
private void PopulateObject(Es3Node target, string path, JsonObject jsonObject)
|
||
{
|
||
// ES3 の型付き要素(__type と value を持つ)か判定
|
||
bool isTyped = jsonObject.ContainsKey(TypePropertyName);
|
||
|
||
if (isTyped)
|
||
{
|
||
target.TypeName = jsonObject[TypePropertyName]?.GetValue<string>() ?? string.Empty;
|
||
var inner = jsonObject[ValuePropertyName];
|
||
|
||
if (inner == null)
|
||
{
|
||
target.Kind = MapTypeNameToKind(target.TypeName);
|
||
target.DisplayValue = "null";
|
||
return;
|
||
}
|
||
|
||
var innerKind = inner.GetValueKind();
|
||
|
||
if (innerKind == JsonValueKind.Object)
|
||
{
|
||
// 辞書・入れ子オブジェクト
|
||
var innerObject = inner.AsObject();
|
||
target.Kind = LooksLikeDictionary(innerObject, target.TypeName)
|
||
? Es3ValueKind.Dictionary
|
||
: Es3ValueKind.Object;
|
||
|
||
foreach (var kvp in innerObject)
|
||
{
|
||
var childPath = $"{path}.{kvp.Key}";
|
||
var child = this.CreateNode(kvp.Key, childPath, kvp.Value);
|
||
if (child != null)
|
||
{
|
||
target.Children.Add(child);
|
||
}
|
||
}
|
||
|
||
target.DisplayValue = $"({target.Children.Count} 項目)";
|
||
return;
|
||
}
|
||
|
||
if (innerKind == JsonValueKind.Array)
|
||
{
|
||
target.Kind = Es3ValueKind.Array;
|
||
PopulateArray(target, path, inner.AsArray());
|
||
return;
|
||
}
|
||
|
||
// プリミティブ値
|
||
target.Kind = MapTypeNameToKind(target.TypeName);
|
||
target.DisplayValue = FormatScalar(inner, target.Kind);
|
||
return;
|
||
}
|
||
|
||
// 型情報なしの入れ子オブジェクト
|
||
target.Kind = Es3ValueKind.Object;
|
||
target.TypeName = "System.Object";
|
||
|
||
foreach (var kvp in jsonObject)
|
||
{
|
||
var childPath = $"{path}.{kvp.Key}";
|
||
var child = this.CreateNode(kvp.Key, childPath, kvp.Value);
|
||
if (child != null)
|
||
{
|
||
target.Children.Add(child);
|
||
}
|
||
}
|
||
|
||
target.DisplayValue = $"({target.Children.Count} 項目)";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配列を走査して子要素を追加します。
|
||
/// </summary>
|
||
/// <param name="target">構築対象のノード</param>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <param name="array">対象の JSON 配列</param>
|
||
private static void PopulateArray(Es3Node target, string path, JsonArray array)
|
||
{
|
||
for (int i = 0; i < array.Count; i++)
|
||
{
|
||
var childPath = $"{path}[{i}]";
|
||
var elementNode = array[i];
|
||
|
||
var child = new Es3Node
|
||
{
|
||
Key = $"[{i}]",
|
||
Path = childPath,
|
||
OriginalNode = elementNode
|
||
};
|
||
|
||
if (elementNode == null)
|
||
{
|
||
child.Kind = Es3ValueKind.Unknown;
|
||
child.DisplayValue = "null";
|
||
}
|
||
else if (elementNode.GetValueKind() == JsonValueKind.Object &&
|
||
elementNode.AsObject().ContainsKey(TypePropertyName))
|
||
{
|
||
// 配列要素が型付き要素の場合は再帰的に展開する
|
||
var innerObject = elementNode.AsObject();
|
||
child.TypeName = innerObject[TypePropertyName]?.GetValue<string>() ?? string.Empty;
|
||
var inner = innerObject[ValuePropertyName];
|
||
|
||
if (inner != null && inner.GetValueKind() == JsonValueKind.Object)
|
||
{
|
||
child.Kind = Es3ValueKind.Object;
|
||
foreach (var kvp in inner.AsObject())
|
||
{
|
||
var grandChild = new Es3Node
|
||
{
|
||
Key = kvp.Key,
|
||
Path = $"{childPath}.{kvp.Key}",
|
||
OriginalNode = kvp.Value,
|
||
Kind = MapValueKind(kvp.Value),
|
||
DisplayValue = FormatScalar(kvp.Value, MapValueKind(kvp.Value))
|
||
};
|
||
child.Children.Add(grandChild);
|
||
}
|
||
|
||
child.DisplayValue = $"({child.Children.Count} 項目)";
|
||
}
|
||
else
|
||
{
|
||
child.Kind = MapTypeNameToKind(child.TypeName);
|
||
child.DisplayValue = inner == null ? "null" : FormatScalar(inner, child.Kind);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
child.Kind = MapValueKind(elementNode);
|
||
child.DisplayValue = FormatScalar(elementNode, child.Kind);
|
||
}
|
||
|
||
target.Children.Add(child);
|
||
}
|
||
|
||
target.DisplayValue = $"({target.Children.Count} 件)";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 数値ノードの型情報と表示値を設定します。
|
||
/// </summary>
|
||
/// <param name="target">構築対象のノード</param>
|
||
/// <param name="node">数値ノード</param>
|
||
private void PopulateNumber(Es3Node target, JsonNode node)
|
||
{
|
||
var raw = node.ToJsonString();
|
||
|
||
if (raw.Contains('.') || raw.Contains('e', StringComparison.OrdinalIgnoreCase) &&
|
||
!raw.Contains("0x", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
target.Kind = Es3ValueKind.Float;
|
||
target.TypeName = "System.Single";
|
||
}
|
||
else
|
||
{
|
||
target.Kind = Es3ValueKind.Integer;
|
||
target.TypeName = "System.Int32";
|
||
}
|
||
|
||
target.DisplayValue = raw;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ES3 の型名から値種別を推定します。
|
||
/// </summary>
|
||
/// <param name="typeName">ES3 の型名</param>
|
||
/// <returns>推定した値種別</returns>
|
||
public static Es3ValueKind MapTypeNameToKind(string typeName)
|
||
{
|
||
if (string.IsNullOrEmpty(typeName))
|
||
{
|
||
return Es3ValueKind.Unknown;
|
||
}
|
||
|
||
var normalized = typeName.Replace(" ", string.Empty);
|
||
|
||
if (normalized.Contains("System.Boolean", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Boolean;
|
||
}
|
||
|
||
if (normalized.Contains("System.Single", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Double", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Decimal", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Float;
|
||
}
|
||
|
||
if (normalized.Contains("System.Int", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.UInt", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Byte", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Int64", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Int16", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Integer;
|
||
}
|
||
|
||
if (normalized.Contains("System.String", StringComparison.Ordinal) ||
|
||
normalized.Contains("System.Char", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.String;
|
||
}
|
||
|
||
if (normalized.Contains("Dictionary", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Dictionary;
|
||
}
|
||
|
||
if (normalized.Contains("[]", StringComparison.Ordinal) ||
|
||
normalized.Contains("List`1", StringComparison.Ordinal) ||
|
||
normalized.Contains("HashSet", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Array;
|
||
}
|
||
|
||
if (normalized.Contains("System.Enum", StringComparison.Ordinal))
|
||
{
|
||
return Es3ValueKind.Enum;
|
||
}
|
||
|
||
return Es3ValueKind.Object;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 辞書形式(キーと値の組)かどうかを推定します。
|
||
/// </summary>
|
||
/// <param name="jsonObject">対象オブジェクト</param>
|
||
/// <param name="typeName">型名</param>
|
||
/// <returns>辞書と判断できる場合 true</returns>
|
||
private static bool LooksLikeDictionary(JsonObject jsonObject, string typeName)
|
||
{
|
||
if (!string.IsNullOrEmpty(typeName) &&
|
||
typeName.Contains("Dictionary", StringComparison.Ordinal))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// ES3 の辞書は {"key": "...", "value": ...} の対を持つ
|
||
return jsonObject.ContainsKey("key") && jsonObject.ContainsKey(ValuePropertyName);
|
||
}
|
||
|
||
/// <summary>
|
||
/// JSON 値の種別を簡易判定します。
|
||
/// </summary>
|
||
/// <param name="node">対象ノード</param>
|
||
/// <returns>判定した値種別</returns>
|
||
private static Es3ValueKind MapValueKind(JsonNode? node)
|
||
{
|
||
if (node == null)
|
||
{
|
||
return Es3ValueKind.Unknown;
|
||
}
|
||
|
||
return node.GetValueKind() switch
|
||
{
|
||
JsonValueKind.Object => Es3ValueKind.Object,
|
||
JsonValueKind.Array => Es3ValueKind.Array,
|
||
JsonValueKind.String => Es3ValueKind.String,
|
||
JsonValueKind.Number => node.ToJsonString().Contains('.')
|
||
? Es3ValueKind.Float
|
||
: Es3ValueKind.Integer,
|
||
JsonValueKind.True or JsonValueKind.False => Es3ValueKind.Boolean,
|
||
_ => Es3ValueKind.Unknown
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// スカラー値を表示用文字列へ整形します。
|
||
/// </summary>
|
||
/// <param name="node">対象ノード</param>
|
||
/// <param name="kind">値種別</param>
|
||
/// <returns>表示用文字列</returns>
|
||
private static string FormatScalar(JsonNode? node, Es3ValueKind kind)
|
||
{
|
||
if (node == null)
|
||
{
|
||
return "null";
|
||
}
|
||
|
||
try
|
||
{
|
||
return kind switch
|
||
{
|
||
Es3ValueKind.Boolean => node.GetValue<bool>() ? "true" : "false",
|
||
Es3ValueKind.String => node.GetValue<string>(),
|
||
Es3ValueKind.Enum => node.GetValueKind() == JsonValueKind.Number
|
||
? node.ToJsonString()
|
||
: node.GetValue<string>(),
|
||
_ => node.ToJsonString()
|
||
};
|
||
}
|
||
catch
|
||
{
|
||
return node.ToJsonString();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定パスのノードへ編集値を適用します。
|
||
/// </summary>
|
||
/// <param name="path">JSON パス(<see cref="Es3Node.Path"/>)</param>
|
||
/// <param name="newValue">新しい値(表示文字列)</param>
|
||
/// <param name="error">失敗理由</param>
|
||
/// <returns>適用に成功した場合 true</returns>
|
||
public bool TrySetValue(string path, string newValue, out string error)
|
||
{
|
||
error = string.Empty;
|
||
|
||
if (this._root == null)
|
||
{
|
||
error = "ドキュメントが読み込まれていません。";
|
||
return false;
|
||
}
|
||
|
||
if (!this.TryResolveParent(path, out var parent, out var key, out error))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 既存ノードから型情報を取得
|
||
var existing = this.FindNode(path);
|
||
var kind = existing?.Kind ?? Es3ValueKind.String;
|
||
var typeName = existing?.TypeName ?? "System.String";
|
||
|
||
if (existing != null && !existing.IsEditable)
|
||
{
|
||
error = $"型 {typeName} は直接編集できません。";
|
||
return false;
|
||
}
|
||
|
||
JsonNode? parsed = this.BuildValueNode(newValue, kind, typeName, out error);
|
||
if (parsed == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
// ES3 の型付き要素として書き戻す
|
||
if (parent is JsonObject parentObject && parentObject.ContainsKey(TypePropertyName))
|
||
{
|
||
parentObject[ValuePropertyName] = parsed;
|
||
}
|
||
else if (parent is JsonObject plainObject)
|
||
{
|
||
plainObject[key] = parsed;
|
||
}
|
||
else if (parent is JsonArray array && int.TryParse(key, out int index) &&
|
||
index >= 0 && index < array.Count)
|
||
{
|
||
array[index] = parsed;
|
||
}
|
||
else
|
||
{
|
||
error = "書き戻し先の親要素を特定できませんでした。";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
error = $"書き戻しに失敗しました: {ex.Message}";
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 編集後の JSON を文字列として取得します。
|
||
/// </summary>
|
||
/// <returns>整形済み JSON 文字列</returns>
|
||
public string ToJson()
|
||
{
|
||
if (this._root == null)
|
||
{
|
||
return this.OriginalJson;
|
||
}
|
||
|
||
return this._root.ToJsonString(new JsonSerializerOptions { WriteIndented = false });
|
||
}
|
||
|
||
/// <summary>
|
||
/// 元の JSON から変更があったかを判定します。
|
||
/// </summary>
|
||
/// <returns>変更がある場合 true</returns>
|
||
public bool HasChanges()
|
||
{
|
||
if (this._root == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return !string.Equals(this.ToJson(), this.OriginalJson, StringComparison.Ordinal);
|
||
}
|
||
|
||
/// <summary>
|
||
/// パスから親ノードと最終キーを解決します。
|
||
/// </summary>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <param name="parent">親ノード</param>
|
||
/// <param name="key">最終キー(配列の場合はインデックス文字列)</param>
|
||
/// <param name="error">失敗理由</param>
|
||
/// <returns>解決に成功した場合 true</returns>
|
||
private bool TryResolveParent(string path, out JsonNode? parent, out string key, out string error)
|
||
{
|
||
parent = null;
|
||
key = string.Empty;
|
||
error = string.Empty;
|
||
|
||
if (path == "$")
|
||
{
|
||
error = "ルート要素は編集できません。";
|
||
return false;
|
||
}
|
||
|
||
var segments = SplitPath(path);
|
||
if (segments.Count < 2)
|
||
{
|
||
error = $"パスの解析に失敗しました: {path}";
|
||
return false;
|
||
}
|
||
|
||
JsonNode? current = this._root;
|
||
|
||
for (int i = 1; i < segments.Count - 1; i++)
|
||
{
|
||
if (current == null)
|
||
{
|
||
break;
|
||
}
|
||
|
||
current = Descend(current, segments[i], out _);
|
||
}
|
||
|
||
if (current == null)
|
||
{
|
||
error = $"パス {path} を解決できませんでした。";
|
||
return false;
|
||
}
|
||
|
||
key = segments[^1];
|
||
parent = current;
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// パス文字列をセグメントへ分割します。
|
||
/// </summary>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <returns>セグメント一覧(先頭は "$")</returns>
|
||
private static List<string> SplitPath(string path)
|
||
{
|
||
var segments = new List<string>();
|
||
var buffer = new StringBuilder();
|
||
|
||
foreach (var ch in path)
|
||
{
|
||
if (ch == '.' || ch == '[' || ch == ']')
|
||
{
|
||
if (buffer.Length > 0)
|
||
{
|
||
segments.Add(buffer.ToString());
|
||
buffer.Clear();
|
||
}
|
||
|
||
continue;
|
||
}
|
||
|
||
buffer.Append(ch);
|
||
}
|
||
|
||
if (buffer.Length > 0)
|
||
{
|
||
segments.Add(buffer.ToString());
|
||
}
|
||
|
||
return segments;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定キーで子要素へ降下します(ES3 の型付き要素は value を透過します)。
|
||
/// </summary>
|
||
/// <param name="current">現在のノード</param>
|
||
/// <param name="key">キー</param>
|
||
/// <param name="found">見つかった子ノード</param>
|
||
/// <returns>降下先ノード。見つからない場合は null</returns>
|
||
private static JsonNode? Descend(JsonNode current, string key, out JsonNode? found)
|
||
{
|
||
found = null;
|
||
|
||
if (current is JsonObject obj)
|
||
{
|
||
// ES3 の型付き要素は value の中身を透過的に扱う
|
||
if (obj.ContainsKey(TypePropertyName) && obj[ValuePropertyName] is JsonNode inner)
|
||
{
|
||
return Descend(inner, key, out found);
|
||
}
|
||
|
||
if (obj.TryGetPropertyValue(key, out var child))
|
||
{
|
||
found = child;
|
||
return child;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
if (current is JsonArray array && int.TryParse(key, out int index) &&
|
||
index >= 0 && index < array.Count)
|
||
{
|
||
found = array[index];
|
||
return array[index];
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定パスに対応するノードを探索します。
|
||
/// </summary>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <returns>見つかったノード。見つからない場合は null</returns>
|
||
private Es3Node? FindNode(string path)
|
||
{
|
||
return FindNodeRecursive(this.RootNodes, path);
|
||
}
|
||
|
||
/// <summary>
|
||
/// ノードツリーを再帰的に探索します。
|
||
/// </summary>
|
||
/// <param name="nodes">探索対象</param>
|
||
/// <param name="path">JSON パス</param>
|
||
/// <returns>見つかったノード</returns>
|
||
private static Es3Node? FindNodeRecursive(List<Es3Node> nodes, string path)
|
||
{
|
||
foreach (var node in nodes)
|
||
{
|
||
if (node.Path == path)
|
||
{
|
||
return node;
|
||
}
|
||
|
||
var found = FindNodeRecursive(node.Children, path);
|
||
if (found != null)
|
||
{
|
||
return found;
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 編集値から実際の JSON ノードを構築します。
|
||
/// </summary>
|
||
/// <param name="newValue">編集された値文字列</param>
|
||
/// <param name="kind">型種別</param>
|
||
/// <param name="typeName">ES3 の型名</param>
|
||
/// <param name="error">失敗理由</param>
|
||
/// <returns>構築された JSON ノード。失敗時は null</returns>
|
||
private JsonNode? BuildValueNode(string newValue, Es3ValueKind kind, string typeName, out string error)
|
||
{
|
||
error = string.Empty;
|
||
|
||
switch (kind)
|
||
{
|
||
case Es3ValueKind.Boolean:
|
||
if (bool.TryParse(newValue, out var boolValue))
|
||
{
|
||
return JsonValue.Create(boolValue);
|
||
}
|
||
|
||
if (newValue.Trim() == "1")
|
||
{
|
||
return JsonValue.Create(true);
|
||
}
|
||
|
||
if (newValue.Trim() == "0")
|
||
{
|
||
return JsonValue.Create(false);
|
||
}
|
||
|
||
error = $"真偽値として解釈できません: {newValue}";
|
||
return null;
|
||
|
||
case Es3ValueKind.Integer:
|
||
if (long.TryParse(newValue.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var longValue))
|
||
{
|
||
return JsonValue.Create(longValue);
|
||
}
|
||
|
||
error = $"整数として解釈できません: {newValue}";
|
||
return null;
|
||
|
||
case Es3ValueKind.Float:
|
||
if (double.TryParse(newValue.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
|
||
{
|
||
return JsonValue.Create(doubleValue);
|
||
}
|
||
|
||
error = $"小数として解釈できません: {newValue}";
|
||
return null;
|
||
|
||
case Es3ValueKind.Enum:
|
||
// 列挙体は元が数値なら数値、文字列なら文字列として保持する
|
||
if (long.TryParse(newValue.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var enumNumeric))
|
||
{
|
||
return JsonValue.Create(enumNumeric);
|
||
}
|
||
|
||
return JsonValue.Create(newValue);
|
||
|
||
case Es3ValueKind.String:
|
||
return JsonValue.Create(newValue);
|
||
|
||
default:
|
||
error = $"型 {typeName} は直接編集できません。";
|
||
return null;
|
||
}
|
||
}
|
||
}
|
||
}
|