/// <summary> /// for UnitTest. Use explicit GetT() or Deserialize(ref T) /// </summary> /// <returns></returns> // public static object GetValue(this JsonTreeNode self) // { // return self.Value.GetValue<object>(); // } #endregion public static IEnumerable <JsonTreeNode> Traverse(this JsonTreeNode self) { yield return(self); if (self.IsArray()) { foreach (var x in self.ArrayItems()) { foreach (var y in x.Traverse()) { yield return(y); } } } else if (self.IsObject()) { foreach (var kv in self.ObjectItems()) { foreach (var y in kv.Value.Traverse()) { yield return(y); } } } }
public static bool IsFloat(this JsonTreeNode self) { return(self.Value.ValueType == ValueNodeType.Number || self.Value.ValueType == ValueNodeType.NaN || self.Value.ValueType == ValueNodeType.Infinity || self.Value.ValueType == ValueNodeType.MinusInfinity); }
public static JsonPointer Create(JsonTreeNode node) { return(new JsonPointer { Path = new ArraySegment <Utf8String>(node.Path().Skip(1).Select(x => GetKeyFromParent(x)).ToArray()) }); }
public static IEnumerable <JsonTreeNode> ArrayItems(this JsonTreeNode self) { if (!self.IsArray()) { throw new DeserializationException("is not array"); } return(self.Children); }
public static int GetObjectCount(this JsonTreeNode self) { if (!self.IsObject()) { throw new DeserializationException("is not object"); } return(self.Children.Count() / 2); }
public static int GetArrayCount(this JsonTreeNode self) { if (!self.IsArray()) { throw new DeserializationException("is not array"); } return(self.Children.Count()); }
public static JsonDiff Create(JsonTreeNode node, JsonDiffType diffType, string msg) { return(new JsonDiff { Path = JsonPointer.Create(node), DiffType = diffType, Msg = msg, }); }
public U Create(JsonTreeNode src) { if (s_creator == null) { var d = GetCreator(); s_creator = new Creator(d); } return(s_creator(src)); }
static V[] ArrayCreator <V>(JsonTreeNode src) { if (!src.IsArray()) { throw new ArgumentException("value is not array"); } var count = src.GetArrayCount(); return(new V[count]); }
public static void SetValue(this JsonTreeNode self, Utf8String jsonPointer, ArraySegment <Byte> bytes) { foreach (var node in self.GetNodes(jsonPointer)) { node.SetValue(default(JsonValue).New( bytes, ValueNodeType.Boolean, node.Value.ParentIndex)); } }
public static IEnumerable <JsonTreeNode> Path(this JsonTreeNode self) { if (self.HasParent) { foreach (var x in self.Parent.Path()) { yield return(x); } } yield return(self); }
public static void RemoveValue(this JsonTreeNode self, Utf8String jsonPointer) { foreach (var node in self.GetNodes(new JsonPointer(jsonPointer))) { if (node.Parent.IsObject()) { node.Prev.SetValue(default(JsonValue)); // remove key } node.SetValue(default(JsonValue)); // remove } }
public static Utf8String KeyOf(this JsonTreeNode self, JsonTreeNode node) { foreach (var kv in self.ObjectItems()) { if (node.ValueIndex == kv.Value.ValueIndex) { return(kv.Key.GetUtf8String()); } } throw new KeyNotFoundException(); }
public static JsonTreeNode GetObjectItem(this JsonTreeNode self, Utf8String key) { foreach (var kv in self.ObjectItems()) { if (kv.Key.GetUtf8String() == key) { return(kv.Value); } } throw new KeyNotFoundException(); }
public static JsonTreeNode GetArrrayItem(this JsonTreeNode self, int index) { int i = 0; foreach (var v in self.ArrayItems()) { if (i++ == index) { return(v); } } throw new KeyNotFoundException(); }
static JsonTreeNode ParseString(JsonTreeNode tree, Utf8String segment) { int pos; if (segment.TrySearchAscii((Byte)'"', 1, out pos)) { return(tree.AddValue(segment.Subbytes(0, pos + 1).Bytes, ValueNodeType.String)); } else { throw new ParserException("no close string: " + segment); } }
public static int IndexOf(this JsonTreeNode self, JsonTreeNode child) { int i = 0; foreach (var v in self.ArrayItems()) { if (v.ValueIndex == child.ValueIndex) { return(i); } ++i; } throw new KeyNotFoundException(); }
/// <summary> /// Expected null, boolean, integer, number /// </summary> /// <param name="segment"></param> /// <param name="valueType"></param> /// <param name="parentIndex"></param> /// <returns></returns> static JsonTreeNode ParsePrimitive(JsonTreeNode tree, Utf8String segment, ValueNodeType valueType) { int i = 1; for (; i < segment.ByteLength; ++i) { if (Char.IsWhiteSpace((char)segment[i]) || segment[i] == '}' || segment[i] == ']' || segment[i] == ',' || segment[i] == ':' ) { break; } } return(tree.AddValue(segment.Subbytes(0, i).Bytes, valueType)); }
static Utf8String GetKeyFromParent(JsonTreeNode json) { var parent = json.Parent; if (parent.IsArray()) { var index = parent.IndexOf(json); return(Utf8String.From(index)); } else if (parent.IsObject()) { return(parent.KeyOf(json)); } else { throw new NotImplementedException(); } }
public static JsonTreeNode Parse(JsonTreeNode tree, Utf8String segment) { // skip white space int pos; if (!segment.TrySearchByte(x => !char.IsWhiteSpace((char)x), out pos)) { throw new ParserException("only whitespace"); } segment = segment.Subbytes(pos); var valueType = GetValueType(segment); switch (valueType) { case ValueNodeType.Boolean: case ValueNodeType.Integer: case ValueNodeType.Number: case ValueNodeType.Null: case ValueNodeType.NaN: case ValueNodeType.Infinity: case ValueNodeType.MinusInfinity: return(ParsePrimitive(tree, segment, valueType)); case ValueNodeType.String: return(ParseString(tree, segment)); case ValueNodeType.Array: // fall through return(ParseArray(tree, segment)); case ValueNodeType.Object: // fall through return(ParseObject(tree, segment)); default: throw new NotImplementedException(); } }
public static ulong GetUInt64(this JsonTreeNode self) { return(self.Value.GetUInt64()); }
public static uint GetUInt32(this JsonTreeNode self) { return(self.Value.GetUInt32()); }
public static ushort GetUInt16(this JsonTreeNode self) { return(self.Value.GetUInt16()); }
public static byte GetByte(this JsonTreeNode self) { return(self.Value.GetByte()); }
public static bool IsNull(this JsonTreeNode self) { return(self.Value.ValueType == ValueNodeType.Null); }
public static Utf8String GetUtf8String(this JsonTreeNode self) { return(self.Value.GetUtf8String()); }
public static bool GetBoolean(this JsonTreeNode self) { return(self.Value.GetBoolean()); }
public static bool IsObject(this JsonTreeNode self) { return(self.Value.ValueType == ValueNodeType.Object); }
public static bool IsArray(this JsonTreeNode self) { return(self.Value.ValueType == ValueNodeType.Array); }
public static bool IsInteger(this JsonTreeNode self) { return(self.Value.ValueType == ValueNodeType.Integer); }