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