private void TryParseResults(TokenisingResultParserContext context) { try { context.Handler.StartResults(); context.Tokens.InitialiseBuffer(); //Thrown away the BOF if present if (context.Tokens.Peek().TokenType == Token.BOF) context.Tokens.Dequeue(); //Firstly parse the Header Row this.TryParseHeaderRow(context); //Then while not EOF try parse result rows IToken next = context.Tokens.Peek(); while (next.TokenType != Token.EOF) { this.TryParseResultRow(context); if (context.Tokens.LastTokenType == Token.EOF) break; } context.Handler.EndResults(true); } catch (RdfParsingTerminatedException) { context.Handler.EndResults(true); } catch { //Some Other Error context.Handler.EndResults(false); throw; } }
private void TryParseResultRow(TokenisingResultParserContext context) { IToken next = context.Tokens.Peek(); if (next.TokenType == Token.EOF) { context.Tokens.Dequeue(); return; } bool allowEOL = true, expectComma = false; int v = 0; SparqlResult result = new SparqlResult(); while (true) { next = context.Tokens.Dequeue(); switch (next.TokenType) { case Token.BLANKNODEWITHID: if (expectComma) throw ParserHelper.Error("Unexpected Blank Node, expected a comma between RDF Terms", next); if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); INode blank = context.Handler.CreateBlankNode(next.Value.Substring(2)); result.SetValue(context.Variables[v], blank); v++; allowEOL = true; expectComma = true; break; case Token.LITERAL: case Token.PLAINLITERAL: if (expectComma) throw ParserHelper.Error("Unexpected Blank Node, expected a comma between RDF Terms", next); if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); //Try and guess what kind of term this is String lexicalForm = next.Value; INode value; if (lexicalForm.StartsWith("http://") || lexicalForm.StartsWith("https://") || lexicalForm.StartsWith("mailto:") || lexicalForm.StartsWith("ftp://")) { try { //Guessing a URI if starts with common URI prefix value = context.Handler.CreateUriNode(UriFactory.Create(lexicalForm)); } catch { //If invalid URI fall back to treating as literal value = context.Handler.CreateLiteralNode(lexicalForm); } } else { value = context.Handler.CreateLiteralNode(lexicalForm); } result.SetValue(context.Variables[v], value); v++; allowEOL = true; expectComma = true; break; case Token.EOL: if (allowEOL) { break; } else { if (v == context.Variables.Count - 1) { //If this is the last expected term then this must be an empty term v++; break; } throw ParserHelper.Error("Unexpected End of Line, expected a RDF Term Token", next); } case Token.COMMA: if (!expectComma) { //This is an empty field if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); v++; } expectComma = false; allowEOL = false; break; case Token.EOF: if (!allowEOL) throw ParserHelper.Error("Unexpected EOF, expected another RDF Term for the Result Row", next); break; default: throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered", next); } //Stop when we've hit the End of the Line/File if (next.TokenType == Token.EOL || next.TokenType == Token.EOF) break; } if (!context.Handler.HandleResult(result)) ParserHelper.Stop(); }
private void TryParseHeaderRow(TokenisingResultParserContext context) { IToken next = context.Tokens.Peek(); bool allowEOL = true, expectComma = false; while (true) { next = context.Tokens.Dequeue(); switch (next.TokenType) { case Token.EOL: if (allowEOL) { break; } else { throw ParserHelper.Error("Unexpected End of Line, expected a Variable", next); } case Token.PLAINLITERAL: if (expectComma) throw ParserHelper.Error("Unexpected Variable, expected a comma between each Variable", next); context.Variables.Add(next.Value); if (!context.Handler.HandleVariable(next.Value)) ParserHelper.Stop(); allowEOL = true; expectComma = true; break; case Token.COMMA: expectComma = false; allowEOL = false; break; case Token.EOF: if (!allowEOL) throw ParserHelper.Error("Unexpected EOF, expected another Variable for the Header Row", next); break; default: throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered", next); } //Stop when we've hit the End of the Line/File if (next.TokenType == Token.EOL || next.TokenType == Token.EOF) break; } }
/// <summary> /// Loads a Result Set from an Input using a Results Handler /// </summary> /// <param name="handler">Results Handler to use</param> /// <param name="input">Input to read from</param> public void Load(ISparqlResultsHandler handler, TextReader input) { if (handler == null) throw new RdfParseException("Cannot parse SPARQL Results into a null Result Handler"); if (input == null) throw new RdfParseException("Cannot parse SPARQL Results from a null input stream"); try { TokenisingResultParserContext context = new TokenisingResultParserContext(handler, new CsvTokeniser(BlockingTextReader.Create(input))); this.TryParseResults(context); input.Close(); } catch { try { input.Close(); } catch { //No catch actions just trying to clean up } throw; } }
private void TryParseResultRow(TokenisingResultParserContext context) { IToken next = context.Tokens.Peek(); if (next.TokenType == Token.EOF) { context.Tokens.Dequeue(); return; } bool allowEOL = true, expectTab = false; int v = 0; SparqlResult result = new SparqlResult(); while (true) { next = context.Tokens.Dequeue(); switch (next.TokenType) { case Token.URI: if (expectTab) throw ParserHelper.Error("Unexpected URI, expected a Tab between RDF Terms", next); if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); INode uri = ParserHelper.TryResolveUri(context, next); result.SetValue(context.Variables[v], uri); v++; allowEOL = true; expectTab = true; break; case Token.BLANKNODEWITHID: if (expectTab) throw ParserHelper.Error("Unexpected Blank Node, expected a Tab between RDF Terms", next); if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); INode blank = context.Handler.CreateBlankNode(next.Value.Substring(2)); result.SetValue(context.Variables[v], blank); v++; allowEOL = true; expectTab = true; break; case Token.LITERAL: case Token.LONGLITERAL: case Token.PLAINLITERAL: if (expectTab) throw ParserHelper.Error("Unexpected Blank Node, expected a Tab between RDF Terms", next); if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); INode lit = this.TryParseLiteral(context, next); result.SetValue(context.Variables[v], lit); v++; allowEOL = true; expectTab = true; break; case Token.EOL: if (allowEOL) { break; } else { if (v == context.Variables.Count - 1) { //If this is the last expected term then this must be an empty term v++; break; } throw ParserHelper.Error("Unexpected End of Line, expected a RDF Term Token", next); } case Token.TAB: if (!expectTab) { //This is an empty field if (v >= context.Variables.Count) throw ParserHelper.Error("Too many RDF Terms, only expecting " + context.Variables.Count + " terms", next); v++; } expectTab = false; allowEOL = false; break; case Token.EOF: if (!allowEOL) throw ParserHelper.Error("Unexpected EOF, expected another RDF Term for the Result Row", next); break; default: throw ParserHelper.Error("Unexpected Token '" + next.GetType().ToString() + "' encountered", next); } //Stop when we've hit the End of the Line/File if (next.TokenType == Token.EOL || next.TokenType == Token.EOF) break; } if (!context.Handler.HandleResult(result)) ParserHelper.Stop(); }
private INode TryParseLiteral(TokenisingResultParserContext context, IToken t) { String value; if (t.TokenType == Token.LITERAL) { value = t.Value; } else if (t.TokenType == Token.LONGLITERAL) { value = t.Value; } else { value = t.Value; if (value.Equals("true") || value.Equals("false")) { return context.Handler.CreateLiteralNode(value, UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeBoolean)); } else { Uri plUri = TurtleSpecsHelper.InferPlainLiteralType((PlainLiteralToken)t, TurtleSyntax.Original); return context.Handler.CreateLiteralNode(value, plUri); } } //Check for DataType/Language Specifier IToken next = context.Tokens.Peek(); if (next.TokenType == Token.DATATYPE) { next = context.Tokens.Dequeue(); Uri dtUri = UriFactory.Create(next.Value.Substring(1, next.Length - 2)); return context.Handler.CreateLiteralNode(value, dtUri); } else if (next.TokenType == Token.LANGSPEC) { next = context.Tokens.Dequeue(); return context.Handler.CreateLiteralNode(value, next.Value); } else { return context.Handler.CreateLiteralNode(value); } }