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>
/// 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(_format));
}
return(b.ToString());
}
/// <summary>
/// Formats a SPARQL Result
/// </summary>
/// <param name="result">SPARQL Result</param>
/// <returns></returns>
public string Format(SparqlResult result)
{
StringBuilder output = new StringBuilder();
output.AppendLine(" <result>");
foreach (String var in result.Variables)
{
if (result.HasValue(var))
{
INode value = result[var];
if (value != null)
{
output.Append(" <binding name=\"" + var + "\">");
switch (value.NodeType)
{
case NodeType.Blank:
output.Append("<bnode>" + ((IBlankNode)value).InternalID + "</bnode>");
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("SPARQL XML Results"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)value;
output.Append("<literal");
if (lit.DataType != null)
{
output.Append(" datatype=\"" + WriterHelper.EncodeForXml(lit.DataType.AbsoluteUri) + "\">" + WriterHelper.EncodeForXml(lit.Value) + "</literal>");
}
else if (!lit.Language.Equals(String.Empty))
{
output.Append(" xml:lang=\"" + lit.Language + "\">" + lit.Value + "</literal>");
}
else
{
output.Append(">" + WriterHelper.EncodeForXml(lit.Value) + "</literal>");
}
break;
case NodeType.Uri:
output.Append("<uri>" + WriterHelper.EncodeForXml(value.ToString()) + "</uri>");
break;
case NodeType.Variable:
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("SPARQL XML Results"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("SPARQL XML Results"));
}
output.AppendLine("</binding>");
}
}
}
output.Append(" </result>");
return(output.ToString());
}
//
// Helpers
//
public string FormatNodeToNTripleString(INode node, TripleSegment?segment)
{
return(node.NodeType switch
{
NodeType.Blank => FormatBlankNode((IBlankNode)node, segment),
NodeType.GraphLiteral => FormatGraphLiteralNode((IGraphLiteralNode)node, segment),
NodeType.Literal => FormatLiteralNode((ILiteralNode)node, segment),
NodeType.Uri => FormatUriNode((IUriNode)node, segment),
NodeType.Variable => FormatVariableNode((IVariableNode)node, segment),
_ => throw new RdfOutputException(
WriterErrorMessages.UnknownNodeTypeUnserializable("Node not supported."))
});
/// <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(FormatName));
}
StringBuilder output = new StringBuilder();
output.Append("{");
foreach (Triple t in glit.SubGraph.Triples)
{
output.Append(Format(t));
}
output.Append("}");
return(output.ToString());
}
/// <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(FormatBlankNode((IBlankNode)n, segment));
case NodeType.GraphLiteral:
return(FormatGraphLiteralNode((IGraphLiteralNode)n, segment));
case NodeType.Literal:
return(FormatLiteralNode((ILiteralNode)n, segment));
case NodeType.Uri:
return(FormatUriNode((IUriNode)n, segment));
case NodeType.Variable:
return(FormatVariableNode((IVariableNode)n, segment));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable(_format));
}
}
/// <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(_format));
}
/// <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(_format));
}
/// <summary>
/// Formats a Triple as a <strong><rdf:Description></strong> element.
/// </summary>
/// <param name="t">Triple.</param>
/// <returns></returns>
public string Format(Triple t)
{
StringBuilder output = new StringBuilder();
output.Append("<rdf:Description ");
switch (t.Subject.NodeType)
{
case NodeType.Uri:
output.Append("rdf:about=\"" + WriterHelper.EncodeForXml(t.Subject.ToString()) + "\"");
break;
case NodeType.Blank:
output.Append("rdf:nodeID=\"" + ((IBlankNode)t.Subject).InternalID + "\"");
break;
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("RDF/XML"));
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Variable:
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("RDF/XML"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
output.AppendLine(">");
String qname;
String ns;
switch (t.Predicate.NodeType)
{
case NodeType.Uri:
Uri u = ((IUriNode)t.Predicate).Uri;
GetQName(u, out qname, out ns);
output.Append('\t');
if (ns.Equals(String.Empty))
{
output.Append("<" + qname);
}
else
{
output.Append("<" + qname + " xmlns=\"" + WriterHelper.EncodeForXml(ns) + "\"");
}
break;
case NodeType.Blank:
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("RDF/XML"));
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Variable:
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("RDF/XML"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
switch (t.Object.NodeType)
{
case NodeType.Blank:
output.AppendLine(" rdf:nodeID=\"" + ((IBlankNode)t.Object).InternalID + "\" />");
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)t.Object;
if (lit.DataType != null)
{
if (lit.DataType.ToString().Equals(RdfSpecsHelper.RdfXmlLiteral))
{
output.AppendLine(" rdf:parseType=\"Literal\">" + lit.Value + "</" + qname + ">");
}
else
{
output.AppendLine(" rdf:datatype=\"" + WriterHelper.EncodeForXml(lit.DataType.AbsoluteUri) + "\">" + WriterHelper.EncodeForXml(lit.Value) + "</" + qname + ">");
}
}
else if (!lit.Language.Equals(String.Empty))
{
output.AppendLine(" xml:lang=\"" + lit.Language + "\">" + WriterHelper.EncodeForXml(lit.Value) + "</" + qname + ">");
}
else
{
output.AppendLine(">" + WriterHelper.EncodeForXml(lit.Value) + "</" + qname + ">");
}
break;
case NodeType.Uri:
output.AppendLine(" rdf:resource=\"" + WriterHelper.EncodeForXml(t.Object.ToString()) + "\" />");
break;
case NodeType.Variable:
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("RDF/XML"));
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
output.Append("</rdf:Description>");
return(output.ToString());
}
