private void SplitFile(string filePath, IEnumerable <string> lines, TripleSegment tripleSegment)
{
Log.LogDebug("SplitFile: {0}", filePath);
_splitDirPath = filePath.Substring(0, filePath.IndexOf('.'));
if (!Directory.Exists(Path.Combine(_baseDirectory.FullName, _splitDirPath)))
{
Directory.CreateDirectory(Path.Combine(_baseDirectory.FullName, _splitDirPath));
var prefixString =
_splitDirPath.Replace(Path.DirectorySeparatorChar.ToString(), "")
.Replace(Path.AltDirectorySeparatorChar.ToString(), "");
_directoryMap.Add(prefixString, _splitDirPath);
}
var handler = new ImportHandler(this, tripleSegment);
_lineReader.Load(handler, new StringReader(string.Join("\n", lines)));
// Drop the old file
_cache.Remove(filePath);
var deletePath = Path.Combine(_baseDirectory.FullName, filePath);
if (File.Exists(deletePath))
{
File.Delete(deletePath);
}
}
private string GenerateNodeOutput(INode node, TripleSegment segment)
{
switch (node.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("Turtle"));
}
return(Format(node, segment));
case NodeType.Uri:
return(Format(node, segment));
case NodeType.Literal:
if (segment == TripleSegment.Subject)
{
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("Turtle"));
}
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Turtle"));
}
return(Format(node, segment));
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("Turtle"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Turtle"));
}
}
/// <summary>
/// Converts a Node into relevant NTriples Syntax
/// </summary>
/// <param name="n">Node to convert</param>
/// <param name="context">Writer Context</param>
/// <param name="segment">Triple Segment being written</param>
/// <returns></returns>
private String NodeToNTriples(NTriplesWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("NQuads"));
}
break;
case NodeType.Literal:
if (segment == TripleSegment.Subject)
{
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("NQuads"));
}
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("NQuads"));
}
break;
case NodeType.Uri:
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("NQuads"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("NQuads"));
}
return(context.NodeFormatter.Format(n));
}
/// <summary>
/// Formats a URI Node
/// </summary>
/// <param name="u">URI Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatUriNode(IUriNode u, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
output.Append('<');
output.Append(this.FormatUri(u.Uri));
output.Append('>');
return output.ToString();
}
private bool HandleTriple(Triple t, TripleSegment tripleSegment)
{
var line = FormatTriple(t.Subject, t.Predicate, t.Object, t.GraphUri);
var targetFileName = GetTripleSegmentFileName(t, tripleSegment);
var targetPath = GetFilePath(targetFileName);
Assert(tripleSegment, line, targetPath, true);
return(true);
}
/// <summary>
/// Formats Literals for CSV output
/// </summary>
/// <param name="l">Literal</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
String value = l.Value;
if (value.Contains('"') || value.Contains(',') || value.Contains('\n') || value.Contains('\r'))
{
return '"' + value.Replace("\"", "\"\"") + '"';
}
else
{
return value;
}
}
/// <summary>
/// Formats a Graph Literal Node for Notation 3
/// </summary>
/// <param name="glit">Graph Literal</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatGraphLiteralNode(IGraphLiteralNode glit, TripleSegment? segment)
{
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.GraphLiteralPredicatesUnserializable(this.FormatName));
StringBuilder output = new StringBuilder();
output.Append("{");
foreach (Triple t in glit.SubGraph.Triples)
{
output.Append(this.Format(t));
}
output.Append("}");
return output.ToString();
}
private bool Assert(TripleSegment segment, string line, string storePath, bool flushing = false)
{
Log.LogTrace("Assert: path={0}, data={1}", storePath, line);
var lines = GetFileContent(storePath, flushing);
var ix = lines.BinarySearch(line);
if (ix >= 0)
{
return(false);
}
lines.Insert(~ix, line);
return(true);
}
private static INode GetNode(Triple t, TripleSegment segment)
{
switch (segment)
{
case TripleSegment.Subject:
return(t.Subject);
case TripleSegment.Object:
return(t.Object);
default:
return(null);
}
}
// KA - Regex-based checking is slightly faster than using the DNR parser, but the parser is less likely to be wrong :-)
/*
* private Regex SplitRegex = new Regex("(?<s>(_:[^\\s]+)|(<[^>]+>))\\s+(?<p>(_:[^\\s]+)|(<[^>]+>))\\s+(?<o>(_:[^\\s]+)|(<[^>]+>)|\"[^\"]*\"(@\\S+)?(\\^\\^<[^>]+>)?)\\s+(?<g>(_:[^\\s]+)|(<[^>]+>))\\s*\\.");
*
* private bool CanSplitRegex(IReadOnlyList<string> lines, TripleSegment segment)
* {
* var segmentGroup = segment == TripleSegment.Subject ? "s" : segment == TripleSegment.Predicate ? "p" : "o";
* var firstNode = SplitRegex.Match(lines[0]).Groups[segmentGroup].Value;
* return lines.Skip(1).Any(l => SplitRegex.Match(l).Groups[segmentGroup].Value != firstNode);
* }
*/
private bool CanSplitParser(IReadOnlyList <string> lines, TripleSegment segment)
{
var singleLineHandler = new SingleLineHandler();
_lineReader.Load(singleLineHandler, new StringReader(lines[0]));
var firstNode = segment == TripleSegment.Subject
? singleLineHandler.LastTriple.Subject
: segment == TripleSegment.Predicate
? singleLineHandler.LastTriple.Predicate
: singleLineHandler.LastTriple.Object;
var matchHandler = new WhileMatchHandler(segment, firstNode);
_lineReader.Load(matchHandler, new StringReader(string.Join("\n", lines)));
return(!matchHandler.Match);
}
private static INode GetNode(Triple triple, TripleSegment segment)
{
switch (segment)
{
case TripleSegment.Subject:
return(triple.Subject);
case TripleSegment.Predicate:
return(triple.Predicate);
case TripleSegment.Object:
return(triple.Object);
default:
throw new InvalidOperationException();
}
}
/// <summary>
/// Generates Output for the given Node
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node</param>
/// <param name="segment">Triple Context</param>
private void GenerateNodeOutput(BaseWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("TSV"));
case NodeType.Blank:
case NodeType.Literal:
case NodeType.Uri:
context.Output.Write(this._formatter.Format(n));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("TSV"));
}
}
private string GetTripleSegmentFileName(Triple t, TripleSegment segment)
{
switch (segment)
{
case TripleSegment.Subject:
return(GetSubjectFileName(t.Subject));
case TripleSegment.Predicate:
return(GetPredicateFileName(t.Predicate));
case TripleSegment.Object:
return(GetObjectFileName(t.Object));
default:
throw new ArgumentException("Segment must be subject, predicate or object", nameof(segment));
}
}
private INode TryParseNode(JsonParserContext context, out TripleSegment segment)
{
if (context.Input.Read())
{
if (context.Input.TokenType == JsonToken.PropertyName)
{
//Determine the Triple Segment
switch (context.Input.Value.ToString())
{
case "subject":
segment = TripleSegment.Subject;
break;
case "predicate":
segment = TripleSegment.Predicate;
break;
case "object":
segment = TripleSegment.Object;
break;
default:
throw Error(context, "Unexpected Property '" + context.Input.Value.ToString() + "' encountered, expected one of 'subject', 'predicate' or 'object'");
}
if (context.Input.Read())
{
String value = context.Input.Value.ToString();
return(this.TryParseNodeValue(context, value));
}
else
{
throw Error(context, "Unexpected End of Input when a Value for a Node of a Triple was expected");
}
}
else
{
throw Error(context, "Unexpected Token '" + context.Input.TokenType.ToString() + "' encountered, expected a Property Name for the node of a Triple");
}
}
else
{
throw Error(context, "Unexpected End of Input when a Property Value pair for a Node of a Triple was expected");
}
}
/// <summary>
/// Formats a Node as a String
/// </summary>
/// <param name="n">Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
public virtual String Format(INode n, TripleSegment? segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
return this.FormatBlankNode((IBlankNode)n, segment);
case NodeType.GraphLiteral:
return this.FormatGraphLiteralNode((IGraphLiteralNode)n, segment);
case NodeType.Literal:
return this.FormatLiteralNode((ILiteralNode)n, segment);
case NodeType.Uri:
return this.FormatUriNode((IUriNode)n, segment);
case NodeType.Variable:
return this.FormatVariableNode((IVariableNode)n, segment);
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable(this._format));
}
}
private static string ProcessNode(Triple t, TripleSegment segment, BaseWriterContext context, bool collapseLiterals)
{
var node = GraphVizWriter.GetNode(t, segment);
switch (node)
{
case ILiteralNode literalnode:
return(GraphVizWriter.WriteLiteralNode(literalnode, t, context, collapseLiterals));
case IUriNode uriNode:
return(GraphVizWriter.ReduceToQName(uriNode.Uri, context));
case IBlankNode blankNode:
return(blankNode.ToString());
default:
throw new RdfOutputException("Only Uri nodes, literal nodes and blank nodes can be converted to GraphViz DOT Format.");
}
}
/// <summary>
/// Generates Output for the given Node.
/// </summary>
/// <param name="context">Writer Context.</param>
/// <param name="n">Node.</param>
/// <param name="segment">Triple Segment.</param>
private void GenerateNodeOutput(BaseWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("CSV"));
}
context.Output.Write(_formatter.Format(n));
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("CSV"));
case NodeType.Literal:
if (segment == TripleSegment.Subject)
{
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("CSV"));
}
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("CSV"));
}
context.Output.Write(_formatter.Format(n));
break;
case NodeType.Uri:
context.Output.Write(_formatter.Format(n));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("CSV"));
}
}
private INode TryParseNode(JsonParserContext context, out TripleSegment segment)
{
if (context.Input.Read())
{
if (context.Input.TokenType == JsonToken.PropertyName)
{
//Determine the Triple Segment
switch (context.Input.Value.ToString())
{
case "subject":
segment = TripleSegment.Subject;
break;
case "predicate":
segment = TripleSegment.Predicate;
break;
case "object":
segment = TripleSegment.Object;
break;
default:
throw Error(context, "Unexpected Property '" + context.Input.Value.ToString() + "' encountered, expected one of 'subject', 'predicate' or 'object'");
}
if (context.Input.Read())
{
String value = context.Input.Value.ToString();
return this.TryParseNodeValue(context, value);
}
else
{
throw Error(context, "Unexpected End of Input when a Value for a Node of a Triple was expected");
}
}
else
{
throw Error(context, "Unexpected Token '" + context.Input.TokenType.ToString() + "' encountered, expected a Property Name for the node of a Triple");
}
}
else
{
throw Error(context, "Unexpected End of Input when a Property Value pair for a Node of a Triple was expected");
}
}
/// <summary>
/// Generates Output for Nodes in Notation 3 syntax.
/// </summary>
/// <param name="context">Writer Context.</param>
/// <param name="n">Node to generate output for.</param>
/// <param name="segment">Segment of the Triple being output.</param>
/// <param name="indent">Indent to use for pretty printing.</param>
/// <returns></returns>
private String GenerateNodeOutput(CompressingTurtleWriterContext context, INode n, TripleSegment segment, int indent)
{
StringBuilder output = new StringBuilder();
switch (n.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(n))
{
output.Append(GenerateCollectionOutput(context, context.Collections[n], indent));
}
else
{
return(context.NodeFormatter.Format(n, segment));
}
break;
case NodeType.GraphLiteral:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.GraphLiteralPredicatesUnserializable("Notation 3"));
}
output.Append("{");
IGraphLiteralNode glit = (IGraphLiteralNode)n;
StringBuilder temp = new StringBuilder();
CompressingTurtleWriterContext subcontext = new CompressingTurtleWriterContext(glit.SubGraph, new System.IO.StringWriter(temp));
subcontext.NodeFormatter = context.NodeFormatter;
bool contextWritten = false;
// Write Triples 1 at a Time on a single line
foreach (Triple t in subcontext.Graph.Triples)
{
if (!contextWritten && t.Context != null && t.Context is VariableContext)
{
contextWritten = GenerateVariableQuantificationOutput(subcontext, (VariableContext)t.Context);
if (contextWritten)
{
output.Append(temp.ToString());
}
}
output.Append(GenerateNodeOutput(subcontext, t.Subject, TripleSegment.Subject, 0));
output.Append(" ");
output.Append(GenerateNodeOutput(subcontext, t.Predicate, TripleSegment.Predicate, 0));
output.Append(" ");
output.Append(GenerateNodeOutput(subcontext, t.Object, TripleSegment.Object, 0));
output.Append(". ");
}
output.Append("}");
break;
case NodeType.Literal:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Notation 3"));
}
return(context.NodeFormatter.Format(n, segment));
case NodeType.Uri:
return(context.NodeFormatter.Format(n, segment));
case NodeType.Variable:
return(context.NodeFormatter.Format(n, segment));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Notation 3"));
}
return(output.ToString());
}
/// <summary>
/// Formats a Blank Node as a String
/// </summary>
/// <param name="b">Blank Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatBlankNode(IBlankNode b, TripleSegment? segment)
{
return "_:" + this._bnodeMapper.GetOutputID(b.InternalID);
}
/// <summary>
/// Generates the Output for a Node in Turtle Syntax
/// </summary>
/// <param name="context">Context for writing the Graph</param>
/// <param name="n">Node to generate Output for</param>
/// <param name="segment">Segment of the Triple being written</param>
/// <returns></returns>
private String GenerateNodeOutput(TurtleWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("Turtle"));
return context.NodeFormatter.Format(n, segment);
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("Turtle"));
case NodeType.Literal:
if (segment == TripleSegment.Subject) throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("Turtle"));
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Turtle"));
return context.NodeFormatter.Format(n, segment);
case NodeType.Uri:
return context.NodeFormatter.Format(n, segment);
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Turtle"));
}
}
private INode TryParseNode(XmlReader reader, IRdfHandler handler, TripleSegment segment)
{
//Only need to Read() if getting the Subject
//The previous calls will have resulted in us already reading to the start element for this node
if (segment == TripleSegment.Subject)
{
reader.Read();
}
if (reader.NodeType != XmlNodeType.Element)
{
if (reader.NodeType == XmlNodeType.EndElement)
{
throw Error("Unexpected end element while trying to parse the nodes of a <triple> element", reader);
}
}
if (reader.Name.Equals("uri"))
{
return(handler.CreateUriNode(new Uri(reader.ReadInnerXml())));
}
else if (reader.Name.Equals("id"))
{
if (segment == TripleSegment.Predicate)
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <uri> element as the Predicate of a Triple", reader);
}
return(handler.CreateBlankNode(reader.ReadInnerXml()));
}
else if (reader.Name.Equals("plainLiteral"))
{
if (segment == TripleSegment.Subject)
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri> element as the Subject of a Triple", reader);
}
if (reader.AttributeCount > 0)
{
String lang = String.Empty;
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("xml:lang"))
{
lang = reader.Value;
}
}
reader.MoveToContent();
if (!lang.Equals(String.Empty))
{
return(handler.CreateLiteralNode(reader.ReadElementContentAsString(), lang));
}
else
{
return(handler.CreateLiteralNode(reader.ReadElementContentAsString()));
}
}
else
{
return(handler.CreateLiteralNode(reader.ReadElementContentAsString()));
}
}
else if (reader.Name.Equals("typedLiteral"))
{
if (reader.AttributeCount > 0)
{
Uri dtUri = null;
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("datatype"))
{
dtUri = new Uri(reader.Value);
}
}
if (dtUri == null)
{
throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
}
reader.MoveToContent();
return(handler.CreateLiteralNode(reader.ReadInnerXml(), dtUri));
}
else
{
throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
}
}
else
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri>/<plainLiteral>/<typedLiteral> element as part of a Triple", reader);
}
}
/// <summary>
/// Formats a Blank Node as a String for the given Format
/// </summary>
/// <param name="b">Blank Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected virtual String FormatBlankNode(IBlankNode b, TripleSegment? segment)
{
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable(this._format));
return b.ToString();
}
/// <summary>
/// Generates Output for Nodes in Turtle syntax
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node to generate output for</param>
/// <param name="segment">Segment of the Triple being written</param>
/// <param name="indent">Indentation</param>
/// <returns></returns>
private String GenerateNodeOutput(CompressingTurtleWriterContext context, INode n, TripleSegment segment, int indent)
{
StringBuilder output = new StringBuilder();
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("Turtle"));
}
if (context.Collections.ContainsKey(n))
{
output.Append(this.GenerateCollectionOutput(context, context.Collections[n], indent));
}
else
{
return(context.NodeFormatter.Format(n, segment));
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("Turtle"));
case NodeType.Literal:
if (segment == TripleSegment.Subject)
{
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("Turtle"));
}
if (segment == TripleSegment.Predicate)
{
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Turtle"));
}
return(context.NodeFormatter.Format(n, segment));
case NodeType.Uri:
return(context.NodeFormatter.Format(n, segment));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Turtle"));
}
return(output.ToString());
}
/// <summary>
/// Formats a Graph Literal Node as a String for the given Format
/// </summary>
/// <param name="glit">Graph Literal</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected virtual String FormatGraphLiteralNode(IGraphLiteralNode glit, TripleSegment? segment)
{
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable(this._format));
}
/// <summary> /// Formats a URI Node as a String for the given Format /// </summary> /// <param name="u">URI Node</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected abstract String FormatUriNode(IUriNode u, TripleSegment? segment);
/// <summary>
/// Formats a URI Node using QName compression if possible
/// </summary>
/// <param name="u">URI</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatUriNode(IUriNode u, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
String qname;
if (this._allowAKeyword && segment == TripleSegment.Predicate && u.Uri.ToString().Equals(RdfSpecsHelper.RdfType))
{
output.Append('a');
}
else if (this._qnameMapper.ReduceToQName(u.Uri.ToString(), out qname))
{
if (this.IsValidQName(qname))
{
output.Append(qname);
}
else
{
output.Append('<');
output.Append(this.FormatUri(u.Uri));
output.Append('>');
}
}
else
{
output.Append('<');
output.Append(this.FormatUri(u.Uri));
output.Append('>');
}
return output.ToString();
}
/// <summary>
/// Formats URIs for CSV output
/// </summary>
/// <param name="u">URI</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatUriNode(IUriNode u, TripleSegment? segment)
{
return this.FormatUri(u.Uri);
}
/// <summary>
/// Gets the String representation of the Node formatted with the given Node formatter
/// </summary>
/// <param name="formatter">Formatter</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
public virtual String ToString(INodeFormatter formatter, TripleSegment segment)
{
return formatter.Format(this, segment);
}
/// <summary>
/// Formats a Variable Node as a String for the given Format
/// </summary>
/// <param name="v">Variable Name</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected virtual String FormatVariableNode(IVariableNode v, TripleSegment? segment)
{
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable(this._format));
}
private bool CanSplit(IReadOnlyList <string> lines, TripleSegment segment)
{
return(lines.Count >= _splitThreshold && CanSplitParser(lines, segment));
//return CanSplitRegex(lines, segment);
}
/// <summary>
/// Formats a URI Node
/// </summary>
/// <param name="u">URI Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatUriNode(IUriNode u, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
if (this._uriStartChar != null) output.Append(this._uriStartChar);
if (this._uriEndChar != null)
{
output.Append(this.FormatUri(u.Uri));
output.Append(this._uriEndChar);
}
else
{
output.Append(this.FormatUri(u.Uri));
}
return output.ToString();
}
/// <summary>
/// Formats a Literal Node
/// </summary>
/// <param name="l">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
String value;
output.Append('"');
value = l.Value;
if (!value.IsFullyEscaped(this._validEscapes, this._litEscapes))
{
//This first replace escapes all back slashes for good measure
value = value.EscapeBackslashes(this._validEscapes);
//Then these escape characters that can't occur in a NTriples literal
value = value.Replace("\n", "\\n");
value = value.Replace("\r", "\\r");
value = value.Replace("\t", "\\t");
value = value.Escape('"');
//Then remove null character since it doesn't change the meaning of the Literal
value = value.Replace("\0", "");
}
foreach (char c in value.ToCharArray())
{
output.Append(this.FormatChar(c));
}
output.Append('"');
if (!l.Language.Equals(String.Empty))
{
output.Append('@');
output.Append(l.Language.ToLower());
}
else if (l.DataType != null)
{
output.Append("^^<");
foreach (char c in this.FormatUri(l.DataType))
{
output.Append(this.FormatChar(c));
}
output.Append('>');
}
return output.ToString();
}
/// <summary>
/// Generates Node Output for the given Node
/// </summary>
/// <param name="output">Text Writer</param>
/// <param name="n">Node</param>
/// <param name="segment">Triple Segment</param>
private void GenerateNodeOutput(TextWriter output, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("CSV"));
output.Write(this._formatter.Format(n));
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("CSV"));
case NodeType.Literal:
if (segment == TripleSegment.Subject) throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("CSV"));
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("CSV"));
output.Write(this._formatter.Format(n));
break;
case NodeType.Uri:
output.Write(this._formatter.Format(n));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("CSV"));
}
}
private string Format(INode node, TripleSegment segment)
{
return(_turtleFormatter.Format(node, segment));
}
public ImportHandler(DynamicFileStore fileStore, TripleSegment importSegment)
{
_fileStore = fileStore;
_importSegment = importSegment;
}
private static void WriteNode(XmlWriter writer, Triple triple, Dictionary <IUriNode, string> labelMapping, TripleSegment segment)
{
var node = HtmlWriter.GetNode(triple, segment);
if (node is IUriNode uriNode)
{
var uri = uriNode.Uri.AbsoluteUri;
if (segment == TripleSegment.Object && HtmlWriter.IsPhoto(triple.Predicate))
{
var id = Global.InstanceUri.MakeRelativeUri(uriNode.Uri);
writer.WriteStartElement("a");
writer.WriteAttributeString("href", "resource?uri=" + WebUtility.UrlEncode(uri));
writer.WriteStartElement("data");
writer.WriteAttributeString("value", uri);
writer.WriteStartElement("img");
writer.WriteAttributeString("src", $"https://api.parliament.uk/photo/{id}.jpeg?crop=MCU_3:2&width=260&quality=80");
writer.WriteEndElement(); // data
writer.WriteEndElement(); // img
writer.WriteEndElement(); // a
return;
}
if (!labelMapping.TryGetValue(uriNode, out string label))
{
label = uri
.Replace(Global.SchemaUri.AbsoluteUri, string.Empty)
.Replace(Global.InstanceUri.AbsoluteUri, string.Empty)
.Replace(RdfSpecsHelper.RdfType, "a")
.Replace("http://example.com/", string.Empty)
.Replace("http://www.w3.org/2000/01/rdf-schema#", string.Empty)
.Replace("http://www.w3.org/2002/07/owl#", string.Empty)
.Replace("http://www.w3.org/1999/02/22-rdf-syntax-ns#", string.Empty);
}
writer.WriteStartElement("div");
writer.WriteStartElement("a");
writer.WriteAttributeString("href", "resource?uri=" + WebUtility.UrlEncode(uri));
writer.WriteStartElement("data");
writer.WriteAttributeString("value", uri);
writer.WriteString(label);
writer.WriteEndElement(); // data
writer.WriteEndElement(); // a
writer.WriteEndElement(); // div
return;
}
if (node is IBlankNode blankNode)
{
if (segment == TripleSegment.Subject)
{
writer.WriteStartElement("div");
writer.WriteStartElement("a");
writer.WriteAttributeString("name", blankNode.InternalID);
writer.WriteFullEndElement(); // a
writer.WriteString(blankNode.InternalID);
writer.WriteEndElement(); // div
return;
}
if (segment == TripleSegment.Object)
{
writer.WriteStartElement("a");
writer.WriteAttributeString("href", "#" + blankNode.InternalID);
writer.WriteString(blankNode.InternalID);
writer.WriteEndElement(); // a
return;
}
}
if (node is ILiteralNode literalNode)
{
var datatype = literalNode.DataType?.AbsoluteUri;
if (datatype == XmlSpecsHelper.XmlSchemaDataTypeDate)
{
if (DateTimeOffset.TryParse(literalNode.Value, out DateTimeOffset dto))
{
writer.WriteStartElement("time");
writer.WriteString(dto.ToString("yyyy-MM-dd"));
writer.WriteEndElement(); // time
return;
}
}
if (datatype == "http://www.opengis.net/ont/geosparql#wktLiteral")
{
if (HtmlWriter.IsGeography(triple.Predicate))
{
writer.WriteStartElement("data");
writer.WriteAttributeString("class", "map");
writer.WriteAttributeString("value", literalNode.Value);
writer.WriteEndElement(); // data
return;
}
}
writer.WriteString(literalNode.Value);
return;
}
writer.WriteString(node.ToString());
}
/// <summary>
/// Formats a Pattern Item in nicely formatted SPARQL syntax
/// </summary>
/// <param name="item">Pattern Item</param>
/// <param name="segment">Triple Pattern Segment</param>
/// <returns></returns>
public virtual String Format(PatternItem item, TripleSegment? segment)
{
if (item is VariablePattern)
{
return item.ToString();
}
else if (item is NodeMatchPattern)
{
NodeMatchPattern match = (NodeMatchPattern)item;
return this.Format(match.Node, segment);
}
else if (item is FixedBlankNodePattern)
{
if (segment != null)
{
if (segment == TripleSegment.Predicate) throw new RdfOutputException("Cannot format a Fixed Blank Node Pattern Item as the Predicate of a Triple Pattern as Blank Nodes are not permitted as Predicates");
}
return item.ToString();
}
else if (item is BlankNodePattern)
{
return item.ToString();
}
else
{
throw new RdfOutputException("Unable to Format an unknown PatternItem implementation as a String");
}
}
/// <summary>
/// Formats a Literal Node as a String
/// </summary>
/// <param name="l">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
String value, qname;
bool longlit = false, plainlit = false;
longlit = TurtleSpecsHelper.IsLongLiteral(l.Value);
plainlit = TurtleSpecsHelper.IsValidPlainLiteral(l.Value, l.DataType);
if (plainlit)
{
if (TurtleSpecsHelper.IsValidDecimal(l.Value) && l.Value.EndsWith("."))
{
//Ensure we strip the trailing dot of any xsd:decimal and add a datatype definition
output.Append('"');
output.Append(l.Value.Substring(0, l.Value.Length - 1));
output.Append("\"^^<");
output.Append(this.FormatUri(XmlSpecsHelper.XmlSchemaDataTypeDecimal));
output.Append('>');
}
else
{
//Otherwise just write out the value
output.Append(l.Value);
}
//For integers ensure we insert a space after the literal to ensure it can't ever be confused with a decimal
if (TurtleSpecsHelper.IsValidInteger(l.Value))
{
output.Append(' ');
}
}
else
{
output.Append('"');
if (longlit) output.Append("\"\"");
value = l.Value;
bool fullyEscaped = (longlit) ? value.IsFullyEscaped(this._validEscapes, this._longLitMustEscape) : value.IsFullyEscaped(this._validEscapes, this._litMustEscape);
if (!fullyEscaped)
{
//This first replace escapes all back slashes for good measure
value = value.EscapeBackslashes(this._validEscapes);
//Then remove null character since it doesn't change the meaning of the Literal
value = value.Replace("\0", "");
//Don't need all the other escapes for long literals as the characters that would be escaped are permitted in long literals
//Need to escape " still
value = value.Escape('"');
if (!longlit)
{
//Then if we're not a long literal we'll escape tabs
value = value.Replace("\t", "\\t");
}
}
output.Append(value);
output.Append('"');
if (longlit) output.Append("\"\"");
if (!l.Language.Equals(String.Empty))
{
output.Append('@');
output.Append(l.Language.ToLower());
}
else if (l.DataType != null)
{
output.Append("^^");
if (this._qnameMapper.ReduceToQName(l.DataType.ToString(), out qname))
{
if (TurtleSpecsHelper.IsValidQName(qname))
{
output.Append(qname);
}
else
{
output.Append('<');
output.Append(this.FormatUri(l.DataType));
output.Append('>');
}
}
else
{
output.Append('<');
output.Append(this.FormatUri(l.DataType));
output.Append('>');
}
}
}
return output.ToString();
}
/// <summary>
/// Generates Output for Nodes in Notation 3 syntax
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node to generate output for</param>
/// <param name="segment">Segment of the Triple being output</param>
/// <param name="indent">Indent to use for pretty printing</param>
/// <returns></returns>
private String GenerateNodeOutput(CompressingTurtleWriterContext context, INode n, TripleSegment segment, int indent)
{
StringBuilder output = new StringBuilder();
switch (n.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(n))
{
output.Append(this.GenerateCollectionOutput(context, context.Collections[n], indent));
}
else
{
return context.NodeFormatter.Format(n, segment);
}
break;
case NodeType.GraphLiteral:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.GraphLiteralPredicatesUnserializable("Notation 3"));
output.Append("{");
IGraphLiteralNode glit = (IGraphLiteralNode)n;
StringBuilder temp = new StringBuilder();
CompressingTurtleWriterContext subcontext = new CompressingTurtleWriterContext(glit.SubGraph, new System.IO.StringWriter(temp));
subcontext.NodeFormatter = context.NodeFormatter;
bool contextWritten = false;
//Write Triples 1 at a Time on a single line
foreach (Triple t in subcontext.Graph.Triples)
{
if (!contextWritten && t.Context != null && t.Context is VariableContext)
{
contextWritten = this.GenerateVariableQuantificationOutput(subcontext, (VariableContext)t.Context);
if (contextWritten) output.Append(temp.ToString());
}
output.Append(this.GenerateNodeOutput(subcontext, t.Subject, TripleSegment.Subject, 0));
output.Append(" ");
output.Append(this.GenerateNodeOutput(subcontext, t.Predicate, TripleSegment.Predicate, 0));
output.Append(" ");
output.Append(this.GenerateNodeOutput(subcontext, t.Object, TripleSegment.Object, 0));
output.Append(". ");
}
output.Append("}");
break;
case NodeType.Literal:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Notation 3"));
return context.NodeFormatter.Format(n, segment);
case NodeType.Uri:
return context.NodeFormatter.Format(n, segment);
case NodeType.Variable:
return context.NodeFormatter.Format(n, segment);
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Notation 3"));
}
return output.ToString();
}
/// <summary>
/// Generates Output for Nodes in Turtle syntax
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node to generate output for</param>
/// <param name="segment">Segment of the Triple being written</param>
/// <param name="indent">Indentation</param>
/// <returns></returns>
private String GenerateNodeOutput(CompressingTurtleWriterContext context, INode n, TripleSegment segment, int indent)
{
StringBuilder output = new StringBuilder();
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("Turtle"));
if (context.Collections.ContainsKey(n))
{
output.Append(this.GenerateCollectionOutput(context, context.Collections[n], indent));
}
else
{
return context.NodeFormatter.Format(n, segment);
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("Turtle"));
case NodeType.Literal:
if (segment == TripleSegment.Subject) throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("Turtle"));
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("Turtle"));
return context.NodeFormatter.Format(n, segment);
case NodeType.Uri:
return context.NodeFormatter.Format(n, segment);
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("Turtle"));
}
return output.ToString();
}
/// <inheritdoc/>
public string ToString(INodeFormatter formatter, TripleSegment segment)
{
return(Node.ToString(formatter, segment));
}
private static void WriteCell(XmlWriter writer, Triple t, Dictionary <IUriNode, string> labelMapping, TripleSegment segment, int tripleCount)
{
writer.WriteStartElement("td");
if (tripleCount > 1)
{
writer.WriteAttributeString("rowspan", tripleCount.ToString());
}
HtmlWriter.WriteNode(writer, t, labelMapping, segment);
writer.WriteEndElement(); // td
}
/// <summary>
/// Generates Output for the given Node
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node</param>
/// <param name="segment">Triple Context</param>
private void GenerateNodeOutput(BaseWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("TSV"));
case NodeType.Blank:
case NodeType.Literal:
case NodeType.Uri:
context.Output.Write(this._formatter.Format(n));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("TSV"));
}
}
/// <summary>
/// Converts a Node into relevant NTriples Syntax
/// </summary>
/// <param name="n">Node to convert</param>
/// <param name="context">Writer Context</param>
/// <param name="segment">Triple Segment being written</param>
/// <returns></returns>
private String NodeToNTriples(NTriplesWriterContext context, INode n, TripleSegment segment)
{
switch (n.NodeType)
{
case NodeType.Blank:
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("NQuads"));
break;
case NodeType.Literal:
if (segment == TripleSegment.Subject) throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("NQuads"));
if (segment == TripleSegment.Predicate) throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("NQuads"));
break;
case NodeType.Uri:
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("NQuads"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("NQuads"));
}
return context.NodeFormatter.Format(n);
}
/// <summary>
/// Formats a Variable Node in SPARQL Syntax
/// </summary>
/// <param name="v">Variable Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatVariableNode(IVariableNode v, TripleSegment? segment)
{
return v.ToString();
}
/// <summary> /// Formats a Literal Node using QName compression for the datatype if possible /// </summary> /// <param name="l">Literal Node</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected abstract override string FormatLiteralNode(ILiteralNode l, TripleSegment? segment);
public WhileMatchHandler(TripleSegment segment, INode node)
{
_segmentToMatch = segment;
_nodeToMatch = node;
}
public string ToString(INodeFormatter formatter, TripleSegment segment)
{
return(formatter.Format(this, segment));
}
private INode TryParseNode(XmlReader reader, IRdfHandler handler, TripleSegment segment)
{
// Only need to Read() if getting the Subject
// The previous calls will have resulted in us already reading to the start element for this node
if (segment == TripleSegment.Subject)
{
reader.Read();
}
ValidateNamespace(reader);
if (reader.NamespaceURI != TriXNamespaceURI)
{
throw Error("Unexpected element namespace " + reader.NamespaceURI + ".", reader);
}
if (reader.LocalName.Equals("uri"))
{
return(handler.CreateUriNode(new Uri(reader.ReadInnerXml())));
}
if (reader.LocalName.Equals("id"))
{
if (segment == TripleSegment.Predicate)
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <uri> element as the Predicate of a Triple", reader);
}
return(handler.CreateBlankNode(reader.ReadInnerXml()));
}
if (reader.LocalName.Equals("plainLiteral"))
{
if (segment == TripleSegment.Subject)
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri> element as the Subject of a Triple", reader);
}
if (reader.AttributeCount > 0)
{
var lang = string.Empty;
for (var i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("xml:lang"))
{
lang = reader.Value;
}
}
reader.MoveToContent();
if (!lang.Equals(string.Empty))
{
return(handler.CreateLiteralNode(reader.ReadElementContentAsString(), lang));
}
return(handler.CreateLiteralNode(reader.ReadElementContentAsString()));
}
return(handler.CreateLiteralNode(reader.ReadElementContentAsString()));
}
if (reader.LocalName.Equals("typedLiteral"))
{
if (reader.AttributeCount > 0)
{
Uri dtUri = null;
for (var i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("datatype"))
{
dtUri = new Uri(reader.Value);
}
}
if (dtUri == null)
{
throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
}
reader.MoveToContent();
// KA: Why ReadInnerXml here and not in other places?
// return handler.CreateLiteralNode(reader.ReadInnerXml(), dtUri);
return(handler.CreateLiteralNode(reader.ReadElementContentAsString(), dtUri));
}
throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
}
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri>/<plainLiteral>/<typedLiteral> element as part of a Triple", reader);
}
/// <summary>
/// Formats a Literal Node
/// </summary>
/// <param name="lit">Literal Node</param>
/// <param name="segment">Triple Segment</param>
/// <returns></returns>
protected override string FormatLiteralNode(ILiteralNode lit, TripleSegment? segment)
{
StringBuilder output = new StringBuilder();
if (TurtleSpecsHelper.IsValidPlainLiteral(lit.Value, lit.DataType))
{
output.Append(lit.Value);
}
else
{
String value = lit.Value;
if (TurtleSpecsHelper.IsLongLiteral(value))
{
value = value.Replace("\n", "\\n");
value = value.Replace("\r", "\\r");
value = value.Escape('"');
value = value.Replace("\t", "\\t");
//If there are no wrapper characters then we must escape the deliminator
if (value.Contains(this._deliminatorChar))
{
if (this._literalWrapperChar == null && this._longLiteralWrapperChar == null)
{
//Replace the deliminator
value = value.Replace(new String(new char[] { this._deliminatorChar }), new String(new char[] { this._escapeChar, this._deliminatorChar }));
}
}
//Apply appropriate wrapper characters
if (this._longLiteralWrapperChar != null)
{
output.Append(this._longLiteralWrapperChar + value + this._longLiteralWrapperChar);
}
else if (this._literalWrapperChar != null)
{
output.Append(this._literalWrapperChar + value + this._literalWrapperChar);
}
else
{
output.Append(value);
}
}
else
{
//Replace the deliminator
value = value.Replace(new String(new char[] { this._deliminatorChar }), new String(new char[] { this._escapeChar, this._deliminatorChar }));
//Apply appropriate wrapper characters
if (this._literalWrapperChar != null)
{
output.Append(this._literalWrapperChar + value + this._literalWrapperChar);
}
else
{
output.Append(value);
}
}
if (this._fullLiteralOutput)
{
if (!lit.Language.Equals(String.Empty))
{
output.Append("@" + lit.Language.ToLower());
}
else if (lit.DataType != null)
{
output.Append("^^");
if (this._uriStartChar != null) output.Append(this._uriStartChar);
if (this._uriEndChar != null)
{
output.Append(this.FormatUri(lit.DataType));
output.Append(this._uriEndChar);
}
else
{
output.Append(this.FormatUri(lit.DataType));
}
}
}
}
return output.ToString();
}
private INode TryParseNode(XmlReader reader, IRdfHandler handler, TripleSegment segment)
{
//Only need to Read() if getting the Subject
//The previous calls will have resulted in us already reading to the start element for this node
if (segment == TripleSegment.Subject) reader.Read();
if (reader.NodeType != XmlNodeType.Element)
{
if (reader.NodeType == XmlNodeType.EndElement) throw Error("Unexpected end element while trying to parse the nodes of a <triple> element", reader);
}
if (reader.Name.Equals("uri"))
{
return handler.CreateUriNode(new Uri(reader.ReadInnerXml()));
}
else if (reader.Name.Equals("id"))
{
if (segment == TripleSegment.Predicate) throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <uri> element as the Predicate of a Triple", reader);
return handler.CreateBlankNode(reader.ReadInnerXml());
}
else if (reader.Name.Equals("plainLiteral"))
{
if (segment == TripleSegment.Subject) throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri> element as the Subject of a Triple", reader);
if (reader.AttributeCount > 0)
{
String lang = String.Empty;
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("xml:lang")) lang = reader.Value;
}
reader.MoveToContent();
if (!lang.Equals(String.Empty))
{
return handler.CreateLiteralNode(reader.ReadInnerXml(), lang);
}
else
{
return handler.CreateLiteralNode(reader.ReadInnerXml());
}
}
else
{
return handler.CreateLiteralNode(reader.ReadInnerXml());
}
}
else if (reader.Name.Equals("typedLiteral"))
{
if (reader.AttributeCount > 0)
{
Uri dtUri = null;
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToNextAttribute();
if (reader.Name.Equals("datatype")) dtUri = new Uri(reader.Value);
}
if (dtUri == null) throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
reader.MoveToContent();
return handler.CreateLiteralNode(reader.ReadInnerXml(), dtUri);
}
else
{
throw Error("<typedLiteral> element does not have the required datatype attribute", reader);
}
}
else
{
throw Error("Unexpected element <" + reader.Name + "> encountered, expected a <id>/<uri>/<plainLiteral>/<typedLiteral> element as part of a Triple", reader);
}
}
