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);
}
