public JsonReader CreatePlayer()
{
int num = (_tokenList != null) ? _tokenList.Count : 0;
JsonToken[] array = new JsonToken[num + 2];
if (num > 0)
{
_tokenList.CopyTo(array, 1);
}
array[0] = JsonToken.BOF();
array[array.Length - 1] = JsonToken.EOF();
return(new JsonPlayer(array));
}
public JsonReader CreatePlayer()
{
JsonToken[] tokens = new JsonToken[_count + 2];
if (_count > 0)
{
Array.Copy(_tokens, 0, tokens, 1, _count);
}
tokens[0] = JsonToken.BOF();
tokens[tokens.Length - 1] = JsonToken.EOF();
return(new JsonPlayer(tokens));
}
protected override JsonToken ReadTokenImpl()
{
if (_stack == null)
{
return(JsonToken.EOF());
}
if (_stack.Count == 0)
{
_stack = null;
_reader = null;
return(JsonToken.EOF());
}
return(Pop()());
}
public void JsonTokenString()
{
Assert.AreEqual("String:hello", JsonToken.String("hello").ToString());
Assert.AreEqual("Number:123", JsonToken.Number("123").ToString());
Assert.AreEqual("Boolean:true", JsonToken.Boolean(true).ToString());
Assert.AreEqual("Boolean:false", JsonToken.Boolean(false).ToString());
Assert.AreEqual("Null:null", JsonToken.Null().ToString());
Assert.AreEqual("Array", JsonToken.Array().ToString());
Assert.AreEqual("EndArray", JsonToken.EndArray().ToString());
Assert.AreEqual("Object", JsonToken.Object().ToString());
Assert.AreEqual("EndObject", JsonToken.EndObject().ToString());
Assert.AreEqual("Member:test", JsonToken.Member("test").ToString());
Assert.AreEqual("BOF", JsonToken.BOF().ToString());
Assert.AreEqual("EOF", JsonToken.EOF().ToString());
}
public JsonReader CreatePlayer()
{
int count = _tokenList == null ? 0 : _tokenList.Count;
JsonToken[] tokens = new JsonToken[count + 2];
if (count > 0)
{
_tokenList.CopyTo(tokens, 1);
}
tokens[0] = JsonToken.BOF();
tokens[tokens.Length - 1] = JsonToken.EOF();
return(new JsonPlayer(tokens));
}
public JsonReader CreatePlayer()
{
if (Bracket != JsonWriterBracket.Pending &&
Bracket != JsonWriterBracket.Closed)
{
throw new InvalidOperationException("JSON data cannot be read before it is complete.");
}
var tokens = new JsonToken[_count + 2];
if (_count > 0)
{
Array.Copy(_tokens, 0, tokens, 1, _count);
}
tokens[0] = JsonToken.BOF();
tokens[tokens.Length - 1] = JsonToken.EOF();
return(new JsonPlayer(tokens));
}
/// <summary>
/// Reads the next token and returns it.
/// </summary>
protected override JsonToken ReadTokenImpl()
{
if (_stack == null)
{
return(JsonToken.EOF());
}
else if (_stack.Count == 0)
{
_stack = null;
_endLineNumber = _reader.LineNumber;
_endLinePosition = _reader.LinePosition;
_endCharCount = _reader.CharCount;
_reader = null;
return(JsonToken.EOF());
}
else
{
return(Pop()());
}
}
protected override JsonToken ReadTokenImpl()
{
if (_buffer.IsStructured)
{
Debug.Assert(!EOF); // sanity check
if (++_index < _buffer.Length)
{
return(_buffer[_index]);
}
}
else
{
switch (++_index)
{
case 0: return(JsonToken.Array());
case 1: return(_buffer[0]);
case 2: return(JsonToken.EndArray());
}
}
return(JsonToken.EOF());
}
protected override JsonToken ReadTokenImpl()
{
var baseReader = _reader;
var 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.
//
var bufferedMembers = _bufferedMembers;
if (bufferedMembers != null && index < bufferedMembers.Count)
{
//
// Is there a value to serve?
//
var 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.
//
var valueReader = _memberStructuredValueReader
?? (_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.
//
var member = 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.
//
var token = baseReader.Token;
baseReader.Read();
return(token);
}
public void HashCodeNonZero()
{
Assert.AreNotEqual(0, JsonToken.EOF().GetHashCode());
Assert.AreNotEqual(0, JsonToken.String("string").GetHashCode());
}
public void BOFEOF()
{
Assert.AreEqual(JsonTokenClass.BOF, JsonToken.BOF().Class);
Assert.AreEqual(JsonTokenClass.EOF, JsonToken.EOF().Class);
}
public MockedJsonReader End()
{
return(Append(JsonToken.EOF()));
}
