private static void AssertBufferedValueScalarOrNull(JsonToken expected, JsonBufferWriter writer) { JsonBuffer buffer = writer.GetBuffer(); JsonBufferReader reader = buffer.CreateReader(); reader.Read(); reader.Read(); JsonBuffer value = reader.BufferValue(); if (expected.Class == JsonTokenClass.Null) { Assert.IsTrue(value.IsNull); } else { Assert.IsTrue(value.IsScalar); } JsonBufferReader vr = value.CreateReader(); Assert.AreEqual(1, vr.Depth); Assert.AreEqual(expected, vr.Token); vr.Read(); vr.ReadToken(JsonTokenClass.EndArray); Assert.IsTrue(vr.EOF); }
public void Issue26() { // 1. Create JsonBuffer from array with objects JsonBuffer buffer = JsonBuffer.From(@"[{},{a:{},b:{}}]"); // 2. Create reader from the buffer... JsonBufferReader reader = buffer.CreateReader(); // ...read in the first object while (reader.TokenClass != JsonTokenClass.Object) { reader.Read(); } reader.Read(); // Read Object token reader.Read(); // Read EndObject token // ...create a subbuffer to buffer the next object JsonBuffer subBuffer = JsonBuffer.From(reader); // ...create reader from the subbuffer JsonBufferReader reader2 = subBuffer.CreateReader(); // 3. Call reader.BufferValue() this should break JsonBuffer buffer2 = reader2.BufferValue(); Assert.IsTrue(buffer2.IsObject); }
public void BufferScalarValue() { JsonBufferWriter writer = new JsonBufferWriter(); writer.WriteString("foobar"); JsonBuffer buffer = writer.GetBuffer(); JsonBufferReader reader = buffer.CreateReader(); reader.Read(); // array start reader.Read(); // string Assert.AreEqual("foobar", reader.BufferValue().CreateReader().BufferValue().CreateReader().ReadString()); }
public static JsonBuffer From(JsonReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } JsonBufferReader bufferReader = reader as JsonBufferReader; if (bufferReader != null) { return(bufferReader.BufferValue()); } if (!reader.MoveToContent()) { return(Empty); } if (reader.TokenClass == JsonTokenClass.Member) { reader.Read(); } bool structured = reader.TokenClass == JsonTokenClass.Array || reader.TokenClass == JsonTokenClass.Object; JsonBufferWriter writer = new JsonBufferWriter(); writer.MaxDepth = reader.MaxDepth; writer.WriteFromReader(reader); JsonBuffer buffer = writer.GetBuffer(); if (!structured) { bufferReader = buffer.CreateReader(); bufferReader.MoveToContent(); bufferReader.Read(); buffer = bufferReader.BufferValue(); } return(buffer); }
public void WritingReading() { JsonBufferWriter writer = new JsonBufferWriter(); writer.WriteStartArray(); writer.WriteString("foo"); writer.WriteString("bar"); writer.WriteString("baz"); writer.WriteEndArray(); JsonBuffer buffer = writer.GetBuffer(); Assert.AreEqual(5, buffer.Length); JsonBufferReader reader = buffer.CreateReader(); reader.ReadToken(JsonTokenClass.Array); Assert.AreEqual("foo", reader.ReadString()); Assert.AreEqual("bar", reader.ReadString()); Assert.AreEqual("baz", reader.ReadString()); reader.ReadToken(JsonTokenClass.EndArray); Assert.IsTrue(reader.EOF); }
protected override JsonToken ReadTokenImpl() { JsonReader baseReader = _reader; int index = _index; if (index < 0) { // // If the base reader was never started then do it now. // Check for zero depth is the same as BOF. // if (baseReader.Depth == 0) { baseReader.ReadToken(JsonTokenClass.Object); _innerDepth = baseReader.Depth; } _index = 0; return(JsonToken.Object()); } // // Buffered members, if any, get served first. // NamedJsonBufferList bufferedMembers = _bufferedMembers; if (bufferedMembers != null && index < bufferedMembers.Count) { // // Is there a value to serve? // JsonBuffer value = _memberValue; if (!value.IsEmpty) { if (value.IsStructured) // JSON Array or Object { // // Get a reader on the structured (array or // object) value if not already acquired. // JsonReader valueReader = _memberStructuredValueReader; if (valueReader == null) { valueReader = _memberStructuredValueReader = value.CreateReader(); } // // Serve tokens from the value reader until OEF. // if (valueReader.Read()) { return(valueReader.Token); } // // Proceed with next. // _memberValue = JsonBuffer.Empty; _memberStructuredValueReader = null; _index++; return(ReadTokenImpl()); } else // JSON Null, Boolean, Number or String { Debug.Assert(value.IsNull || value.IsScalar); // // Establish state to proceed with next and // serve token pertaining to scalar value. // _memberValue = JsonBuffer.Empty; _index++; return(value.IsNull ? JsonToken.Null() : value.CreateReader().Token); } } // // Serve buffered member name and establish state so // that the value will be served next. // NamedJsonBuffer member = (NamedJsonBuffer)bufferedMembers[index]; _memberValue = member.Buffer; return(JsonToken.Member(member.Name)); } // // Done with buffered members so now move on to remaining // members from the underlying reader. // if (baseReader == null) { return(JsonToken.EOF()); // Done with serving } // // If base reader is on the object end at the same depth as // on entry then serve the last end token. The reader is // released so that on next read, the above will signal EOF. // if (baseReader.Depth == _innerDepth && baseReader.TokenClass == JsonTokenClass.EndObject) { _reader = null; } // // Move through the base reader. // JsonToken token = baseReader.Token; baseReader.Read(); return(token); }
/// <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); }