public void AlternateKeyDelimiters() { JsonReader reader = CreateReader("{ 'm1' = 'v1', 'm2' => 'v2' }"); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("m1", reader.ReadMember()); Assert.AreEqual("v1", reader.ReadString()); Assert.AreEqual("m2", reader.ReadMember()); Assert.AreEqual("v2", reader.ReadString()); Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass); }
public void MemberValuesMayBeDelimitedBySemiColon() { JsonReader reader = CreateReader("{ 'm1' = 'v1'; 'm2' => 'v2' }"); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("m1", reader.ReadMember()); Assert.AreEqual("v1", reader.ReadString()); Assert.AreEqual("m2", reader.ReadMember()); Assert.AreEqual("v2", reader.ReadString()); Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass); }
public void TailReadingWithNoBufferedMembers() { JsonReader tail = CreateHelper(@"{ y: 456, x: 123, z: 789 }").GetTailReader(); Assert.AreEqual("y", tail.ReadMember()); Assert.AreEqual(456, tail.ReadNumber().ToInt32()); Assert.AreEqual("x", tail.ReadMember()); Assert.AreEqual(123, tail.ReadNumber().ToInt32()); Assert.AreEqual("z", tail.ReadMember()); Assert.AreEqual(789, tail.ReadNumber().ToInt32()); tail.ReadToken(JsonTokenClass.EndObject); Assert.IsFalse(tail.Read()); }
protected virtual void Import(ImportContext context, JsonReader reader) { if (context == null) { throw new ArgumentNullException("context"); } if (reader == null) { throw new ArgumentNullException("reader"); } // FIXME: Consider making this method exception-safe. // Right now this is a problem because of reliance on // DictionaryBase. Clear(); reader.ReadToken(JsonTokenClass.Object); while (reader.TokenClass != JsonTokenClass.EndObject) { Put(reader.ReadMember(), context.Import(reader)); } reader.Read(); }
/// <summary> /// Writes the next value from the given <see cref="JsonReader"/> /// into this writer's output. If the reader is positioned /// at the root of JSON data, then the entire data will be /// written. /// </summary> public virtual void WriteFromReader(JsonReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } if (!reader.MoveToContent()) { return; } if (reader.TokenClass == JsonTokenClass.String) { WriteString(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Number) { WriteNumber(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Boolean) { WriteBoolean(reader.Text == JsonBoolean.TrueText); } else if (reader.TokenClass == JsonTokenClass.Null) { WriteNull(); } else if (reader.TokenClass == JsonTokenClass.Array) { WriteStartArray(); reader.Read(); while (reader.TokenClass != JsonTokenClass.EndArray) { WriteFromReader(reader); } WriteEndArray(); } else if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); WriteStartObject(); while (reader.TokenClass != JsonTokenClass.EndObject) { WriteMember(reader.ReadMember()); WriteFromReader(reader); } WriteEndObject(); } else { throw new JsonException(string.Format("{0} not expected.", reader.TokenClass)); } reader.Read(); }
public void ExtraCommaAfterLastObjectMemberAllowded() { JsonReader reader = CreateReader("{ 'member':'value',}"); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("member", reader.ReadMember()); Assert.AreEqual("value", reader.ReadString()); Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass); }
public void NullMemberNameHarmless() { JsonReader reader = CreateReader("{null:null}"); reader.MoveToContent(); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("null", reader.ReadMember()); reader.ReadNull(); Assert.AreSame(JsonTokenClass.EndObject, reader.TokenClass); Assert.IsFalse(reader.Read()); }
public void TailMemberAfterUnorderedReader() { FreeJsonMemberReadingHelper helper = CreateHelper(@" { y: 456, x: 123, z: 789, comment: tail }"); Assert.AreEqual(123, helper.ReadMember("x").ReadNumber().ToInt32()); Assert.AreEqual(456, helper.ReadMember("y").ReadNumber().ToInt32()); Assert.AreEqual(789, helper.ReadMember("z").ReadNumber().ToInt32()); JsonReader reader = helper.BaseReader; Assert.AreEqual("comment", reader.ReadMember()); Assert.AreEqual("tail", reader.ReadString()); }
public void ImportNonObjectMember() { Surrogate surrogate = new Surrogate(new object()); ImportContext context = new ImportContext(); surrogate.Import(context, "foo", JsonText.CreateReader("bar")); JsonReader tail = surrogate.CreateObject(context).TailReader; tail.ReadToken(JsonTokenClass.Object); Assert.AreEqual("foo", tail.ReadMember()); Assert.AreEqual("bar", tail.ReadString()); tail.ReadToken(JsonTokenClass.EndObject); }
public void Export() { JsonObject o = new JsonObject(); o.Put("Number", 123); o.Put("String", "Hello World"); o.Put("Boolean", true); JsonRecorder writer = new JsonRecorder(); o.Export(writer); JsonReader reader = writer.CreatePlayer(); reader.ReadToken(JsonTokenClass.Object); string[] members = (string[])o.GetNamesArray().ToArray(typeof(string)); Assert.AreEqual(members[0], reader.ReadMember()); Assert.AreEqual(o[members[0]], reader.ReadNumber().ToInt32()); Assert.AreEqual(members[1], reader.ReadMember()); Assert.AreEqual(o[members[1]], reader.ReadString()); Assert.AreEqual(members[2], reader.ReadMember()); Assert.AreEqual(o[members[2]], reader.ReadBoolean()); Assert.AreEqual(JsonTokenClass.EndObject, reader.TokenClass); }
public void AutoCompletion() { JsonRecorder writer = new JsonRecorder(); writer.WriteStartArray(); writer.WriteStartObject(); writer.WriteMember("outer"); writer.WriteStartObject(); writer.WriteMember("inner"); writer.AutoComplete(); JsonReader reader = writer.CreatePlayer(); reader.ReadToken(JsonTokenClass.Array); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("outer", reader.ReadMember()); reader.ReadToken(JsonTokenClass.Object); Assert.AreEqual("inner", reader.ReadMember()); reader.ReadNull(); reader.ReadToken(JsonTokenClass.EndObject); reader.ReadToken(JsonTokenClass.EndObject); reader.ReadToken(JsonTokenClass.EndArray); Assert.IsTrue(reader.EOF); }
protected virtual void Import(ImportContext context, JsonReader reader) { if (context == null) { throw new ArgumentNullException("context"); } if (reader == null) { throw new ArgumentNullException("reader"); } Clear(); reader.ReadToken(JsonTokenClass.Object); while (reader.TokenClass != JsonTokenClass.EndObject) { Put(reader.ReadMember(), context.Import(reader)); } reader.Read(); }
public void TailReading() { FreeJsonMemberReadingHelper helper = CreateHelper(@" { y: 456, x: 123, z: 789, obj1: { foo: bar }, comment: null, arr: [ 123, 456, 789 ], obj2: { a: 1, b: 2, }, }"); Assert.AreEqual(123, helper.ReadMember("x").ReadNumber().ToInt32()); helper.ReadMember("comment").ReadNull(); JsonReader reader = helper.BaseReader; Assert.AreEqual(JsonTokenClass.Member, reader.TokenClass); Assert.AreEqual("arr", reader.Text); JsonReader tail = helper.GetTailReader(); Assert.AreEqual("y", tail.ReadMember()); Assert.AreEqual(456, tail.ReadNumber().ToInt32()); Assert.AreEqual("z", tail.ReadMember()); Assert.AreEqual(789, tail.ReadNumber().ToInt32()); Assert.AreEqual("obj1", tail.ReadMember()); tail.ReadToken(JsonTokenClass.Object); Assert.AreEqual("foo", tail.ReadMember()); Assert.AreEqual("bar", tail.ReadString()); tail.ReadToken(JsonTokenClass.EndObject); Assert.AreEqual("arr", tail.ReadMember()); tail.ReadToken(JsonTokenClass.Array); Assert.AreEqual(123, tail.ReadNumber().ToInt32()); Assert.AreEqual(456, tail.ReadNumber().ToInt32()); Assert.AreEqual(789, tail.ReadNumber().ToInt32()); tail.ReadToken(JsonTokenClass.EndArray); Assert.AreEqual("obj2", tail.ReadMember()); tail.StepOut(); Assert.IsFalse(reader.Read()); }
/// <summary> /// Attempts to locate a member with a given (case-sensitive) name /// and returns a <see cref="JsonReader"/> that can be used to read /// the value. Otherwise it returns <c>null</c>. /// </summary> /// <remarks> /// The caller should not use the returned <see cref="JsonReader"/> /// instance for any other purpose but reading the value. It is /// possible that this method will return the same instance as /// <see cref="BaseReader"/> or a separate instance. /// </remarks> public JsonReader TryReadMember(string name) { // // Is the member already buffered? If yes then return a reader // on its buffered value. // JsonBuffer value = TryPopBufferedMember(name); if (!value.IsEmpty) { return(value.CreateReader()); } // // Use the base reader from here on if it has not already been // exhausted... // if (_ended) { return(null); } JsonReader reader = BaseReader; if (!_started) { _started = true; if (!reader.MoveToContent()) { throw new JsonException(string.Format( @"Unexpected EOF while attempting to look for member named '{0}'.", name)); } JsonTokenClass clazz = reader.TokenClass; if (clazz != JsonTokenClass.Object && clazz != JsonTokenClass.Member) { throw new JsonException(string.Format( @"Found {0} where a JSON Object or Member was expected.", clazz)); } } // // If the base reader is sitting on the start of an object then // move into it. This case should only arise on the first read // into a JSON object. // if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); } // // Go over the entire JSON object until its end. // while (reader.TokenClass != JsonTokenClass.EndObject) { // // Read the next member and if it matches what's being // sought then simply return the base reader that // should be aligned on the value. // string actualName = reader.ReadMember(); if (string.CompareOrdinal(actualName, name) == 0) { return(reader); } // // Not the sought member so buffer it to be served // later when it is sought or as part of the tail. // NamedJsonBufferList members = _members; if (members == null) { members = _members = new NamedJsonBufferList(4); } members.Add(new NamedJsonBuffer(actualName, JsonBuffer.From(reader))); } _ended = true; // // Member not found. // return(null); }
private static object ReadParameters(Method method, JsonReader reader, ImportContext importContext) { Debug.Assert(method != null); Debug.Assert(reader != null); Debug.Assert(importContext != null); reader.MoveToContent(); Parameter[] parameters = method.GetParameters(); if (reader.TokenClass == JsonTokenClass.Array) { reader.Read(); ArrayList argList = new ArrayList(parameters.Length); // TODO: This loop could bomb when more args are supplied that parameters available. for (int i = 0; i < parameters.Length && reader.TokenClass != JsonTokenClass.EndArray; i++) argList.Add(importContext.Import(parameters[i].ParameterType, reader)); reader.StepOut(); return argList.ToArray(); } else if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); JsonObject argByName = new JsonObject(); while (reader.TokenClass != JsonTokenClass.EndObject) { // TODO: Imporve this lookup. // FIXME: Does not work when argument is positional. Type parameterType = AnyType.Value; string name = reader.ReadMember(); foreach (Parameter parameter in parameters) { if (parameter.Name.Equals(name)) { parameterType = parameter.ParameterType; break; } } argByName.Put(name, importContext.Import(parameterType, reader)); } reader.Read(); return argByName; } else { return importContext.Import(reader); } }
/// <remarks> /// This method is not exception-safe. If an error occurs while /// reading then the object may be partially imported. /// </remarks> public virtual void Import(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); // FIXME: Consider making this method exception-safe. // Right now this is a problem because of reliance on // DictionaryBase. Clear(); reader.ReadToken(JsonTokenClass.Object); while (reader.TokenClass != JsonTokenClass.EndObject) Put(reader.ReadMember(), reader.ReadValue()); reader.Read(); }
/// <summary> /// Writes the next value from the given <see cref="JsonReader"/> /// into this writer's output. If the reader is positioned /// at the root of JSON data, then the entire data will be /// written. /// </summary> public virtual void WriteFromReader(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); if (!reader.MoveToContent()) return; if (reader.TokenClass == JsonTokenClass.String) { WriteString(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Number) { WriteNumber(reader.Text); } else if (reader.TokenClass == JsonTokenClass.Boolean) { WriteBoolean(reader.Text == JsonBoolean.TrueText); } else if (reader.TokenClass == JsonTokenClass.Null) { WriteNull(); } else if (reader.TokenClass == JsonTokenClass.Array) { WriteStartArray(); reader.Read(); while (reader.TokenClass != JsonTokenClass.EndArray) WriteFromReader(reader); WriteEndArray(); } else if (reader.TokenClass == JsonTokenClass.Object) { reader.Read(); WriteStartObject(); while (reader.TokenClass != JsonTokenClass.EndObject) { WriteMember(reader.ReadMember()); WriteFromReader(reader); } WriteEndObject(); } else { throw new JsonException(string.Format("{0} not expected.", reader.TokenClass)); } reader.Read(); }
public void WriteValueFromReader(JsonReader reader) { if (reader == null) throw new ArgumentNullException("reader"); if (!reader.MoveToContent()) return; switch (reader.Token) { case JsonToken.String: WriteString(reader.Text); break; case JsonToken.Number: WriteNumber(reader.Text); break; case JsonToken.Boolean : WriteBoolean(reader.Text == JsonReader.FalseText); break; case JsonToken.Null : WriteNull(); break; case JsonToken.Object : { WriteStartObject(); reader.ReadMember(); do { WriteMember(reader.Text); reader.Read(); WriteValueFromReader(reader); } while (reader.Token != JsonToken.EndObject); WriteEndObject(); break; } case JsonToken.Array : { WriteStartArray(); reader.Read(); while (reader.Token != JsonToken.EndArray) WriteValueFromReader(reader); WriteEndArray(); break; } default : throw new JsonException(string.Format("{0} not expected.", reader.Token)); } reader.Read(); }
void IJsonImportable.Import(ImportContext context, JsonReader reader) { reader.MoveToContent(); if (reader.TokenClass != JsonTokenClass.Object) { reader.Skip(); return; } reader.Read(/* object */); do { var brushName = reader.ReadMember().ToLowerInvariant(); var color = reader.ReadString(); var foreground = EnumHelper.TryParse<ConsoleColor>(color, true) ?? DefaultBrush.Foreground; switch (brushName) { case "arr": case "array": Array = Array.ResetForeground(foreground); break; case "obj": case "object": Object = Object.ResetForeground(foreground); break; case "mem": case "member": Member = Member.ResetForeground(foreground); break; case "str": case "string": String = String.ResetForeground(foreground); break; case "num": case "number": Number = Number.ResetForeground(foreground); break; case "bit": case "boolean": Boolean = Boolean.ResetForeground(foreground); break; case "nil": case "null": Null = Null.ResetForeground(foreground); break; default: continue; } } while (reader.TokenClass != JsonTokenClass.EndObject); reader.Read( /* end object */); }