public string ReadToken(JsonTokenClass token) { int depth = Depth; if (!token.IsTerminator) { MoveToContent(); } string result; if (depth == 0 && TokenClass == JsonTokenClass.Array && (token.IsScalar || token == JsonTokenClass.Null)) { Read(); result = ReadToken(token); ReadToken(JsonTokenClass.EndArray); } else { if (TokenClass != token) { throw new JsonException($"Found {TokenClass} where {token} was expected."); } result = Text; Read(); } return(result); }
private void AssertTokenText(JsonTokenClass token, string text) { Assert.IsTrue(_reader.Read()); Assert.AreEqual(token, _reader.TokenClass, "Found {0} (with text \x201c{1}\x201d) when expecting {2} (with text \x201c{3}\x201d).", _reader.TokenClass, _reader.Text, token, text); if (text != null) { Assert.AreEqual(text, _reader.Text); } }
private NamedJsonBufferList _members; // buffered ones public FreeJsonMemberReadingHelper(JsonReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } JsonTokenClass clazz = reader.TokenClass; if (clazz != JsonTokenClass.BOF && clazz != JsonTokenClass.Object && clazz != JsonTokenClass.Member) { throw new ArgumentException(null, "reader"); } _reader = reader; }
/// <summary> /// Reads the next token ensuring that it matches the specified /// token. If not, an exception is thrown. /// </summary> public string ReadToken(JsonTokenClass token) { int depth = Depth; if (!token.IsTerminator) { MoveToContent(); } // // We allow an exception to the simple case of validating // the token and returning its value. If the reader is still at // the start (depth is zero) and we're being asked to check // for the null token or a scalar-type token then we allow that // to be appear within a one-length array. This is done because // valid JSON text must begin with an array or object. Our // JsonWriterBase automatically wraps a scalar value in an // array if not done explicitly. This exception here allow // that case to pass as being logically valid, as if the // token appeared entirely on its own between BOF and EOF. // string text; if (depth == 0 && TokenClass == JsonTokenClass.Array && (token.IsScalar || token == JsonTokenClass.Null)) { Read(/* array */); text = ReadToken(token); ReadToken(JsonTokenClass.EndArray); } else { if (TokenClass != token) { throw new JsonException(string.Format("Found {0} where {1} was expected.", TokenClass, token)); } text = Text; Read(); } return(text); }
/// <summary> /// Buffers the value at which the reader is positioned. /// </summary> /// <returns>Returns a <see cref="JsonBuffer" /> object that holds /// the buffered value.</returns> public JsonBuffer BufferValue() { if (EOF) { return(JsonBuffer.Empty); } JsonTokenClass tokenClass = TokenClass; if (tokenClass.IsTerminator || tokenClass == JsonTokenClass.Member) { Read(); } int start = _index; Skip(); return(_buffer.Slice(start, _index)); }
public static JsonBuffer From(JsonToken token) { JsonTokenClass clazz = token.Class; if (clazz == JsonTokenClass.Null) { return(_null); } if (!clazz.IsScalar) { throw new ArgumentException("Token must represent a JSON scalar value or null.", "token"); } if (clazz == JsonTokenClass.Boolean) { return(token.Equals(JsonToken.True()) ? _true : _false); } JsonBufferStorage storage = new JsonBufferStorage(1); storage.Write(token); return(storage.ToBuffer()); }
JsonToken(JsonTokenClass clazz, string text = null) { Class = clazz; Text = text; }
private JsonToken(JsonTokenClass clazz, string text) { _class = clazz; _text = text; }
private void ExitBracket() { JsonTokenClass bracket = (JsonTokenClass) _brackets.Pop(); if (bracket == JsonTokenClass.BOF) bracket = JsonTokenClass.EOF; _currentBracket = bracket; }
private JsonToken(JsonTokenClass clazz) : this(clazz, null) {}
private void AssertMember(string name, JsonTokenClass valueToken) { AssertMember(name, valueToken, null); }
private void AssertToken(JsonTokenClass token) { AssertTokenText(token, null); }
private JsonToken(JsonTokenClass clazz) : this(clazz, null) { }
/// <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); }
public JsonWriter() { _brackets = new Stack(4); _currentBracket = JsonTokenClass.BOF; }
/// <summary> /// Reads the next token ensuring that it matches the specified /// token. If not, an exception is thrown. /// </summary> public string ReadToken(JsonTokenClass token) { MoveToContent(); if (TokenClass != token) throw new JsonException(string.Format("Found {0} where {1} was expected.", TokenClass.ToString(), token.ToString())); string s = Text; Read(); return s; }
private void AssertTokenText(JsonTokenClass token, string text) { Assert.IsTrue(_reader.Read()); Assert.AreEqual(token, _reader.TokenClass, "Found {0} (with text \x201c{1}\x201d) when expecting {2} (with text \x201c{3}\x201d).", _reader.TokenClass, _reader.Text, token, text); if (text != null) Assert.AreEqual(text, _reader.Text); }
private void AssertMember(string name, JsonTokenClass valueToken, string valueText) { AssertTokenText(JsonTokenClass.Member, name); AssertTokenText(valueToken, valueText); }
/// <summary> /// Reads the next token ensuring that it matches the specified /// token. If not, an exception is thrown. /// </summary> public string ReadToken(JsonTokenClass token) { int depth = Depth; if (!token.IsTerminator) MoveToContent(); // // We allow an exception to the simple case of validating // the token and returning its value. If the reader is still at // the start (depth is zero) and we're being asked to check // for the null token or a scalar-type token then we allow that // to be appear within a one-length array. This is done because // valid JSON text must begin with an array or object. Our // JsonWriterBase automatically wraps a scalar value in an // array if not done explicitly. This exception here allow // that case to pass as being logically valid, as if the // token appeared entirely on its own between BOF and EOF. // string text; if (depth == 0 && TokenClass == JsonTokenClass.Array && (token.IsScalar || token == JsonTokenClass.Null)) { Read(/* array */); text = ReadToken(token); ReadToken(JsonTokenClass.EndArray); } else { if (TokenClass != token) throw new JsonException(string.Format("Found {0} where {1} was expected.", TokenClass, token)); text = Text; Read(); } return text; }
private JsonToken(JsonTokenClass clazz) { this = new JsonToken(clazz, null); }
private void EnterBracket(JsonTokenClass newBracket) { Debug.Assert(newBracket == JsonTokenClass.Array || newBracket == JsonTokenClass.Object); _brackets.Push(_currentBracket); _currentBracket = newBracket; }