/// <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 TsvTokeniser(ParsingTextReader.Create(input)));
TryParseResults(context);
input.Close();
}
catch
{
try
{
input.Close();
}
catch
{
// No catch actions just trying to clean up
}
throw;
}
}
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:
case Token.LITERAL:
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;
}
}
}
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));
}
}
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
TryParseHeaderRow(context);
// Then while not EOF try parse result rows
IToken next = context.Tokens.Peek();
while (next.TokenType != Token.EOF)
{
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, 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 = 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 (v < context.Variables.Count)
{
throw ParserHelper.Error("Too few RDF Terms, got " + v + " but expected " + context.Variables.Count, next);
}
result.SetVariableOrdering(context.Variables);
if (!context.Handler.HandleResult(result))
{
ParserHelper.Stop();
}
}
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 = ParserHelper.TryResolveUri(context, next);
}
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;
}
}
result.SetVariableOrdering(context.Variables);
if (!context.Handler.HandleResult(result))
{
ParserHelper.Stop();
}
}