private void GeneratePredicateNode(RdfXmlWriterContext context, INode p)
{
switch (p.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Blank:
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("RDF/XML"));
case NodeType.Uri:
//OK
UriRefType rtype;
String predRef = this.GenerateUriRef(context, ((IUriNode)p).Uri, UriRefType.QName, out rtype);
String prefix, uri;
prefix = uri = null;
if (rtype != UriRefType.QName)
{
this.GenerateTemporaryNamespace(context, (IUriNode)p, out prefix, out uri);
predRef = this.GenerateUriRef(context, ((IUriNode)p).Uri, UriRefType.QName, out rtype);
if (rtype != UriRefType.QName)
{
throw new RdfOutputException(WriterErrorMessages.UnreducablePropertyURIUnserializable + " - '" + p.ToString() + "'");
}
}
this.GenerateElement(context, predRef);
//Add Temporary Namespace to current XML Element
if (prefix != null && uri != null)
{
context.Writer.WriteStartAttribute("xmlns", prefix, null);
context.Writer.WriteRaw(Uri.EscapeUriString(WriterHelper.EncodeForXml(uri)));
context.Writer.WriteEndAttribute();
}
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
//Write the Predicate
}
/// <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>
/// 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());
}
private XmlElement GeneratePredicateNode(RdfXmlWriterContext context, INode p, ref int nextNamespaceID, List <String> tempNamespaces, XmlDocument doc, XmlElement subj)
{
XmlElement pred;
switch (p.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Blank:
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("RDF/XML"));
case NodeType.Uri:
//OK
UriRefType rtype;
String predRef = this.GenerateUriRef(context, (IUriNode)p, UriRefType.QName, tempNamespaces, out rtype);
if (rtype != UriRefType.QName)
{
this.GenerateTemporaryNamespace(context, (IUriNode)p, ref nextNamespaceID, tempNamespaces, doc);
predRef = this.GenerateUriRef(context, (IUriNode)p, UriRefType.QName, tempNamespaces, out rtype);
if (rtype != UriRefType.QName)
{
throw new RdfOutputException(WriterErrorMessages.UnreducablePropertyURIUnserializable + " - '" + p.ToString() + "'");
}
}
pred = this.GenerateElement(context, predRef, doc);
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
//Write the Predicate
subj.AppendChild(pred);
return(pred);
}
/// <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 void GenerateObjectOutput(RdfXmlWriterContext context, Triple t)
{
// Take different actions depending on the Node Type to be written
switch (t.Object.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(t.Object))
{
// Blank Node has a collection associated with it
GenerateCollectionOutput(context, t.Object);
}
else
{
// Isolated Blank Node so use nodeID
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)t.Object).InternalID));
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
// Write as content of the current element
ILiteralNode lit = (ILiteralNode)t.Object;
if (lit.DataType != null)
{
if (lit.DataType.AbsoluteUri.Equals(RdfSpecsHelper.RdfXmlLiteral))
{
// XML Literal
context.Writer.WriteAttributeString("rdf", "parseType", NamespaceMapper.RDF, "Literal");
context.Writer.WriteRaw(lit.Value);
}
else
{
// Datatyped Literal
context.Writer.WriteAttributeString("rdf", "datatype", NamespaceMapper.RDF, lit.DataType.AbsoluteUri); //Uri.EscapeUriString(lit.DataType.ToString()));
context.Writer.WriteString(lit.Value);
}
}
else if (!lit.Language.Equals(String.Empty))
{
// Language specified Literal
context.Writer.WriteAttributeString("xml", "lang", null, lit.Language);
context.Writer.WriteString(lit.Value);
}
else
{
// Simple Literal
context.Writer.WriteString(lit.Value);
}
break;
case NodeType.Uri:
// Simple rdf:resource
// TODO: Compress this into UriRef where possible
context.Writer.WriteAttributeString("rdf", "resource", NamespaceMapper.RDF, t.Object.ToString()); //Uri.EscapeUriString(t.Object.ToString()));
break;
case NodeType.Variable:
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("RDF/XML"));
}
}
/// <summary>
/// Internal method which generates the RDF/Json Output for a Graph.
/// </summary>
/// <param name="g">Graph to save.</param>
/// <param name="output">Stream to save to.</param>
private void GenerateOutput(IGraph g, TextWriter output)
{
// Always force RDF Namespace to be correctly defined
g.NamespaceMap.Import(_defaultNamespaces);
g.NamespaceMap.AddNamespace("rdf", UriFactory.Create(NamespaceMapper.RDF));
// Create our Writer Context and start the XML Document
RdfXmlWriterContext context = new RdfXmlWriterContext(g, output);
context.CompressionLevel = _compressionLevel;
context.UseDtd = _useDTD;
context.UseAttributes = _useAttributes;
context.Writer.WriteStartDocument();
if (context.UseDtd)
{
// Create the DOCTYPE declaration
StringBuilder entities = new StringBuilder();
String uri;
entities.Append('\n');
foreach (String prefix in context.NamespaceMap.Prefixes)
{
uri = context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri;
if (!uri.Equals(context.NamespaceMap.GetNamespaceUri(prefix).ToString()))
{
context.UseDtd = false;
break;
}
if (!prefix.Equals(String.Empty))
{
entities.AppendLine("\t<!ENTITY " + prefix + " '" + uri + "'>");
}
}
if (context.UseDtd)
{
context.Writer.WriteDocType("rdf:RDF", null, null, entities.ToString());
}
}
// Create the rdf:RDF element
context.Writer.WriteStartElement("rdf", "RDF", NamespaceMapper.RDF);
if (context.Graph.BaseUri != null)
{
context.Writer.WriteAttributeString("xml", "base", null, context.Graph.BaseUri.AbsoluteUri);
}
// Add all the existing Namespace Definitions here
context.NamespaceMap.IncrementNesting();
foreach (String prefix in context.NamespaceMap.Prefixes)
{
if (prefix.Equals("rdf"))
{
continue;
}
if (!prefix.Equals(String.Empty))
{
context.Writer.WriteStartAttribute("xmlns", prefix, null);
context.Writer.WriteString(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri);//Uri.EscapeUriString(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri));
context.Writer.WriteEndAttribute();
}
else
{
context.Writer.WriteStartAttribute("xmlns");
context.Writer.WriteString(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri);//Uri.EscapeUriString(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri));
context.Writer.WriteEndAttribute();
}
}
// Find the Collections and Type References
if (context.CompressionLevel >= WriterCompressionLevel.More)
{
WriterHelper.FindCollections(context, CollectionSearchMode.All);
}
// Get the Triples as a Sorted List
List <Triple> ts = context.Graph.Triples.Where(t => !context.TriplesDone.Contains(t)).ToList();
ts.Sort(new RdfXmlTripleComparer());
INode lastSubj = null;
List <Triple> sameSubject = new List <Triple>();
for (int i = 0; i < ts.Count; i++)
{
// Find the first group of Triples with the same subject
if (lastSubj == null)
{
// Start of new set of Triples with the same subject
lastSubj = ts[i].Subject;
sameSubject.Add(ts[i]);
if (lastSubj.NodeType == NodeType.GraphLiteral)
{
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
}
else if (lastSubj.NodeType == NodeType.Variable)
{
throw new RdfOutputException(WriterErrorMessages.VariableNodesUnserializable("RDF/XML"));
}
}
else
{
if (ts[i].Subject.Equals(lastSubj))
{
// Still finding Triples with same subject
sameSubject.Add(ts[i]);
}
else
{
// Found the end of current set of Triples with same subject
GenerateSubjectOutput(context, sameSubject, true);
// Reset so we'll start from a new subject on next iteration
sameSubject.Clear();
lastSubj = null;
i--;
}
}
}
// Ensure last set of Triples with same subject gets written
if (sameSubject.Count > 0)
{
GenerateSubjectOutput(context, sameSubject, true);
}
// Take care of any collections that weren't yet written
foreach (KeyValuePair <INode, OutputRdfCollection> kvp in context.Collections)
{
if (!kvp.Value.HasBeenWritten)
{
// Generate a rdf:Description node and then write the collection
context.Writer.WriteStartElement("rdf", "Description", NamespaceMapper.RDF);
if (kvp.Value.Triples.Count > 0 || !kvp.Value.IsExplicit)
{
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)kvp.Key).InternalID));
}
GenerateCollectionOutput(context, kvp.Key);
context.Writer.WriteEndElement();
}
}
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndDocument();
// Save to the Output Stream
context.Writer.Flush();
}
private void GenerateCollectionOutput(RdfXmlWriterContext context, INode key)
{
OutputRdfCollection c = context.Collections[key];
if (!c.IsExplicit)
{
if (context.NamespaceMap.NestingLevel > 2)
{
// Need to set the Predicate to have a rdf:parseType of Resource
context.Writer.WriteAttributeString("rdf", "parseType", NamespaceMapper.RDF, "Resource");
}
int length = c.Triples.Count;
while (c.Triples.Count > 0)
{
// Get the Next Item and generate the rdf:first element
INode next = c.Triples.First().Object;
c.Triples.RemoveAt(0);
context.NamespaceMap.IncrementNesting();
context.Writer.WriteStartElement("rdf", "first", NamespaceMapper.RDF);
// Set the value of the rdf:first Item
switch (next.NodeType)
{
case NodeType.Blank:
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)next).InternalID));
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
this.GenerateLiteralOutput(context, (ILiteralNode)next);
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)next, "rdf:resource");
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
// Now generate the rdf:rest element
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
context.NamespaceMap.IncrementNesting();
context.Writer.WriteStartElement("rdf", "rest", NamespaceMapper.RDF);
if (c.Triples.Count >= 1)
{
// Set Parse Type to resource
context.Writer.WriteAttributeString("rdf", "parseType", NamespaceMapper.RDF, "Resource");
}
else
{
// Terminate list with an rdf:nil
context.Writer.WriteStartAttribute("rdf", "resource", NamespaceMapper.RDF);
if (context.UseDtd)
{
context.Writer.WriteRaw("&rdf;nil");
}
else
{
context.Writer.WriteRaw(NamespaceMapper.RDF + "nil");
}
context.Writer.WriteEndAttribute();
}
}
for (int i = 0; i < length; i++)
{
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
}
}
else
{
if (c.Triples.Count == 0)
{
// Terminate the Blank Node triple by adding a rdf:nodeID attribute
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)key).InternalID));
}
else
{
// Need to set the Predicate to have a rdf:parseType of Resource
if (context.NamespaceMap.NestingLevel > 2)
{
// Need to set the Predicate to have a rdf:parseType of Resource
context.Writer.WriteAttributeString("rdf", "parseType", NamespaceMapper.RDF, "Resource");
}
// Output the Predicate Object list
while (c.Triples.Count > 0)
{
Triple t = c.Triples[0];
c.Triples.RemoveAt(0);
INode nextPred = t.Predicate;
INode nextObj = t.Object;
// Generate the predicate
this.GeneratePredicateNode(context, nextPred);
// Output the Object
switch (nextObj.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(nextObj))
{
// Output a Collection
this.GenerateCollectionOutput(context, nextObj);
}
else
{
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)key).InternalID));
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
this.GenerateLiteralOutput(context, (ILiteralNode)nextObj);
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)nextObj, "rdf:resource");
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
context.Writer.WriteEndElement();
}
}
}
}
/// <summary>
/// Internal method which generates the RDF/Json Output for a Graph
/// </summary>
/// <param name="g">Graph to save</param>
/// <param name="output">Stream to save to</param>
private void GenerateOutput(IGraph g, TextWriter output)
{
// Always force RDF Namespace to be correctly defined
g.NamespaceMap.Import(this._defaultNamespaces);
g.NamespaceMap.AddNamespace("rdf", UriFactory.Create(NamespaceMapper.RDF));
// Create our Writer Context and start the XML Document
RdfXmlWriterContext context = new RdfXmlWriterContext(g, output);
context.CompressionLevel = this._compressionLevel;
context.UseDtd = this._useDTD;
context.Writer.WriteStartDocument();
if (context.UseDtd)
{
// Create the DOCTYPE declaration
StringBuilder entities = new StringBuilder();
String uri;
entities.Append('\n');
foreach (String prefix in context.NamespaceMap.Prefixes)
{
uri = context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri;
if (!uri.Equals(context.NamespaceMap.GetNamespaceUri(prefix).ToString()))
{
context.UseDtd = false;
break;
}
if (!prefix.Equals(String.Empty))
{
entities.AppendLine("\t<!ENTITY " + prefix + " '" + uri + "'>");
}
}
if (context.UseDtd)
{
context.Writer.WriteDocType("rdf:RDF", null, null, entities.ToString());
}
}
// Create the rdf:RDF element
context.Writer.WriteStartElement("rdf", "RDF", NamespaceMapper.RDF);
if (context.Graph.BaseUri != null)
{
context.Writer.WriteAttributeString("xml", "base", null, context.Graph.BaseUri.AbsoluteUri);//Uri.EscapeUriString(context.Graph.BaseUri.ToString()));
}
context.NamespaceMap.IncrementNesting();
foreach (String prefix in context.NamespaceMap.Prefixes)
{
if (prefix.Equals("rdf"))
{
continue;
}
if (!prefix.Equals(String.Empty))
{
context.Writer.WriteStartAttribute("xmlns", prefix, null);
// String nsRef = "&" + prefix + ";";
// context.Writer.WriteRaw(nsRef);
// context.Writer.WriteEntityRef(prefix);
context.Writer.WriteRaw(WriterHelper.EncodeForXml(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri));//Uri.EscapeUriString(WriterHelper.EncodeForXml(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri)));
context.Writer.WriteEndAttribute();
}
else
{
context.Writer.WriteStartAttribute("xmlns");
context.Writer.WriteRaw(WriterHelper.EncodeForXml(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri));//Uri.EscapeUriString(WriterHelper.EncodeForXml(context.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri)));
context.Writer.WriteEndAttribute();
}
}
// Find the Collections and Type References
if (context.CompressionLevel >= WriterCompressionLevel.More)
{
WriterHelper.FindCollections(context, CollectionSearchMode.ImplicitOnly);
// WriterHelper.FindCollections(context, CollectionSearchMode.All);
}
Dictionary <INode, String> typerefs = this.FindTypeReferences(context);
// Get the Triples as a Sorted List
List <Triple> ts = context.Graph.Triples.Where(t => !context.TriplesDone.Contains(t)).ToList();
ts.Sort(new RdfXmlTripleComparer());
// Variables we need to track our writing
INode lastSubj, lastPred, lastObj;
lastSubj = lastPred = lastObj = null;
for (int i = 0; i < ts.Count; i++)
{
Triple t = ts[i];
if (context.TriplesDone.Contains(t))
{
continue; //Skip if already done
}
if (lastSubj == null || !t.Subject.Equals(lastSubj))
{
// Start a new set of Triples
if (lastSubj != null)
{
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
}
if (lastPred != null)
{
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
}
// Write out the Subject
// Validate Subject
// Use a Type Reference if applicable
context.NamespaceMap.IncrementNesting();
if (typerefs.ContainsKey(t.Subject))
{
String tref = typerefs[t.Subject];
if (tref.StartsWith(":"))
{
context.Writer.WriteStartElement(tref.Substring(1));
}
else if (tref.Contains(":"))
{
context.Writer.WriteStartElement(tref.Substring(0, tref.IndexOf(':')), tref.Substring(tref.IndexOf(':') + 1), null);
}
else
{
context.Writer.WriteStartElement(tref);
}
}
else
{
context.Writer.WriteStartElement("rdf", "Description", NamespaceMapper.RDF);
}
lastSubj = t.Subject;
// Apply appropriate attributes
switch (t.Subject.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("RDF/XML"));
case NodeType.Blank:
if (context.Collections.ContainsKey(t.Subject))
{
this.GenerateCollectionOutput(context, t.Subject);
}
else
{
context.Writer.WriteAttributeString("rdf", "nodeID", null, context.BlankNodeMapper.GetOutputID(((IBlankNode)t.Subject).InternalID));
}
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Subject, "rdf:about");
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
// Write the Predicate
context.NamespaceMap.IncrementNesting();
this.GeneratePredicateNode(context, t.Predicate);
lastPred = t.Predicate;
lastObj = null;
}
else if (lastPred == null || !t.Predicate.Equals(lastPred))
{
if (lastPred != null)
{
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
}
// Write the Predicate
context.NamespaceMap.IncrementNesting();
this.GeneratePredicateNode(context, t.Predicate);
lastPred = t.Predicate;
lastObj = null;
}
// Write the Object
if (lastObj != null)
{
// Terminate the previous Predicate Node
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
// Start a new Predicate Node
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
context.NamespaceMap.IncrementNesting();
this.GeneratePredicateNode(context, t.Predicate);
}
// Create an Object for the Object
switch (t.Object.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(t.Object))
{
// Output a Collection
this.GenerateCollectionOutput(context, t.Object);
}
else
{
// Terminate the Blank Node triple by adding a rdf:nodeID attribute
context.Writer.WriteAttributeString("rdf", "nodeID", null, context.BlankNodeMapper.GetOutputID(((IBlankNode)t.Object).InternalID));
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)t.Object;
this.GenerateLiteralOutput(context, lit);
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Object, "rdf:resource");
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
lastObj = t.Object;
// Force a new Predicate Node
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndElement();
lastPred = null;
context.TriplesDone.Add(t);
}
// Check we haven't failed to output any collections
foreach (KeyValuePair <INode, OutputRdfCollection> pair in context.Collections)
{
if (pair.Value.Triples.Count > 0)
{
if (typerefs.ContainsKey(pair.Key))
{
String tref = typerefs[pair.Key];
context.NamespaceMap.IncrementNesting();
if (tref.StartsWith(":"))
{
context.Writer.WriteStartElement(tref.Substring(1));
}
else if (tref.Contains(":"))
{
context.Writer.WriteStartElement(tref.Substring(0, tref.IndexOf(':')), tref.Substring(tref.IndexOf(':') + 1), null);
}
else
{
context.Writer.WriteStartElement(tref);
}
this.GenerateCollectionOutput(context, pair.Key);
context.Writer.WriteEndElement();
}
else
{
context.Writer.WriteStartElement("rdf", "Description", NamespaceMapper.RDF);
context.Writer.WriteAttributeString("rdf", "nodeID", NamespaceMapper.RDF, context.BlankNodeMapper.GetOutputID(((IBlankNode)pair.Key).InternalID));
this.GenerateCollectionOutput(context, pair.Key);
context.Writer.WriteEndElement();
// throw new RdfOutputException("Failed to output a Collection due to an unknown error");
}
}
}
context.NamespaceMap.DecrementNesting();
context.Writer.WriteEndDocument();
// Save to the Output Stream
context.Writer.Flush();
}
/// <summary>
/// Generates Output for a given Node
/// </summary>
/// <param name="context">Writer Context</param>
/// <param name="n">Node</param>
/// <param name="t">Triple being written</param>
private void GenerateNodeOutput(HtmlWriterContext context, INode n, Triple t)
{
// Embed RDFa on the Node Output
bool rdfASerializable = false;
if (t != null)
{
if (t.Predicate.NodeType == NodeType.Uri)
{
// Use @about to specify the Subject
if (t.Subject.NodeType == NodeType.Uri)
{
rdfASerializable = true;
context.HtmlWriter.AddAttribute("about", context.UriFormatter.FormatUri(t.Subject.ToString()));
}
else if (t.Subject.NodeType == NodeType.Blank)
{
rdfASerializable = true;
context.HtmlWriter.AddAttribute("about", "[" + t.Subject.ToString() + "]");
}
else
{
RaiseWarning("Cannot serialize a Triple since the Subject is not a URI/Blank Node: " + t.Subject.ToString());
}
// Then if we can serialize this Triple we serialize the Predicate
if (rdfASerializable)
{
// Get the CURIE for the Predicate
String curie;
String tempNamespace;
if (context.QNameMapper.ReduceToQName(t.Predicate.ToString(), out curie, out tempNamespace))
{
// Extract the Namespace and make sure it's registered on this Attribute
String ns = curie.Substring(0, curie.IndexOf(':'));
context.HtmlWriter.AddAttribute("xmlns:" + ns, context.UriFormatter.FormatUri(context.QNameMapper.GetNamespaceUri(ns)));
}
else
{
RaiseWarning("Cannot serialize a Triple since the Predicate cannot be reduced to a QName: " + t.Predicate.ToString());
rdfASerializable = false;
}
if (rdfASerializable)
{
switch (t.Object.NodeType)
{
case NodeType.Blank:
case NodeType.Uri:
// If the Object is a URI or a Blank then we specify the predicate with @rel
context.HtmlWriter.AddAttribute("rel", curie);
break;
case NodeType.Literal:
// If the Object is a Literal we specify the predicate with @property
context.HtmlWriter.AddAttribute("property", curie);
break;
default:
RaiseWarning("Cannot serialize a Triple since the Object is not a URI/Blank/Literal Node: " + t.Object.ToString());
rdfASerializable = false;
break;
}
}
}
}
else
{
RaiseWarning("Cannot serialize a Triple since the Predicate is not a URI Node: " + t.Predicate.ToString());
}
}
String qname;
switch (n.NodeType)
{
case NodeType.Blank:
if (rdfASerializable)
{
// Need to embed the CURIE for the BNode in the @resource attribute
context.HtmlWriter.AddAttribute("resource", "[" + n.ToString() + "]");
}
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassBlankNode);
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Span);
context.HtmlWriter.WriteEncodedText(n.ToString());
context.HtmlWriter.RenderEndTag();
break;
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)n;
if (lit.DataType != null)
{
if (rdfASerializable)
{
// Need to embed the datatype in the @datatype attribute
String dtcurie, dtnamespace;
if (context.QNameMapper.ReduceToQName(lit.DataType.AbsoluteUri, out dtcurie, out dtnamespace))
{
// Extract the Namespace and make sure it's registered on this Attribute
String ns = dtcurie.Substring(0, dtcurie.IndexOf(':'));
context.HtmlWriter.AddAttribute("xmlns:" + ns, context.UriFormatter.FormatUri(context.QNameMapper.GetNamespaceUri(ns)));
context.HtmlWriter.AddAttribute("datatype", dtcurie);
}
}
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassLiteral);
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Span);
if (lit.DataType.AbsoluteUri.Equals(Parsing.RdfSpecsHelper.RdfXmlLiteral))
{
context.HtmlWriter.Write(lit.Value);
}
else
{
context.HtmlWriter.WriteEncodedText(lit.Value);
}
context.HtmlWriter.RenderEndTag();
// Output the Datatype
context.HtmlWriter.WriteEncodedText("^^");
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Href, lit.DataType.AbsoluteUri);
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassDatatype);
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A);
if (context.QNameMapper.ReduceToQName(lit.DataType.AbsoluteUri, out qname))
{
context.HtmlWriter.WriteEncodedText(qname);
}
else
{
context.HtmlWriter.WriteEncodedText(lit.DataType.AbsoluteUri);
}
context.HtmlWriter.RenderEndTag();
}
else
{
if (rdfASerializable)
{
if (!lit.Language.Equals(String.Empty))
{
// Need to add the language as an xml:lang attribute
context.HtmlWriter.AddAttribute("xml:lang", lit.Language);
}
}
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassLiteral);
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Span);
context.HtmlWriter.WriteEncodedText(lit.Value);
context.HtmlWriter.RenderEndTag();
if (!lit.Language.Equals(String.Empty))
{
context.HtmlWriter.WriteEncodedText("@");
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassLangSpec);
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Span);
context.HtmlWriter.WriteEncodedText(lit.Language);
context.HtmlWriter.RenderEndTag();
}
}
break;
case NodeType.GraphLiteral:
// Error
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("HTML"));
case NodeType.Uri:
if (rdfASerializable && !UriPrefix.Equals(String.Empty))
{
// If the URIs are being prefixed with something then we need to set the original
// URI in the resource attribute to generate the correct triple
context.HtmlWriter.AddAttribute("resource", n.ToString());
}
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, CssClassUri);
context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Href, UriPrefix + n.ToString());
context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A);
if (context.QNameMapper.ReduceToQName(n.ToString(), out qname))
{
context.HtmlWriter.WriteEncodedText(qname);
}
else
{
context.HtmlWriter.WriteEncodedText(n.ToString());
}
context.HtmlWriter.RenderEndTag();
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("HTML"));
}
}
/// <summary>
/// Saves a SPARQL Result Set to TSV format
/// </summary>
/// <param name="results">Result Set</param>
/// <param name="output">Writer to save to</param>
public void Save(SparqlResultSet results, TextWriter output)
{
try
{
if (results.ResultsType == SparqlResultsType.VariableBindings)
{
//Output Variables first
String[] vars = results.Variables.ToArray();
for (int i = 0; i < vars.Length; i++)
{
output.Write("?" + vars[i]);
if (i < vars.Length - 1)
{
output.Write('\t');
}
}
output.Write('\n');
foreach (SparqlResult result in results)
{
for (int i = 0; i < vars.Length; i++)
{
if (result.HasValue(vars[i]))
{
INode temp = result[vars[i]];
if (temp != null)
{
switch (temp.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("SPARQL TSV"));
case NodeType.Blank:
case NodeType.Literal:
case NodeType.Uri:
output.Write(this._formatter.Format(temp));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("SPARQL TSV"));
}
}
}
if (i < vars.Length - 1)
{
output.Write('\t');
}
}
output.Write('\n');
}
}
else
{
output.Write(results.Result.ToString());
}
output.Close();
}
catch
{
try
{
output.Close();
}
catch
{
//No error handling, just trying to clean up
}
throw;
}
}
/// <summary>
/// Internal method which generates the RDF/Json Output for a Graph.
/// </summary>
/// <param name="g">Graph to save.</param>
/// <param name="output">Stream to save to.</param>
private void GenerateOutput(IGraph g, TextWriter output)
{
// Get a Blank Node Output Mapper
BlankNodeOutputMapper bnodeMapper = new BlankNodeOutputMapper(WriterHelper.IsValidBlankNodeID);
// Get the Writer and Configure Options
JsonTextWriter writer = new JsonTextWriter(output);
if (_prettyprint)
{
writer.Formatting = Newtonsoft.Json.Formatting.Indented;
}
else
{
writer.Formatting = Newtonsoft.Json.Formatting.None;
}
// Start the overall Object which represents the Graph
writer.WriteStartObject();
// Get the Triples as a Sorted List
List <Triple> ts = g.Triples.ToList();
ts.Sort(new FullTripleComparer(new FastNodeComparer()));
// Variables we need to track our writing
INode lastSubj, lastPred;
lastSubj = lastPred = null;
for (int i = 0; i < ts.Count; i++)
{
Triple t = ts[i];
if (lastSubj == null || !t.Subject.Equals(lastSubj))
{
// Terminate previous Triples
if (lastSubj != null)
{
writer.WriteEndArray();
writer.WriteEndObject();
}
// Start a new set of Triples
// Validate Subject
switch (t.Subject.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/JSON"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("RDF/JSON"));
case NodeType.Blank:
break;
case NodeType.Uri:
// OK
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/JSON"));
}
// Write out the Subject
if (t.Subject.NodeType != NodeType.Blank)
{
writer.WritePropertyName(t.Subject.ToString());
}
else
{
// Remap Blank Node IDs as appropriate
writer.WritePropertyName("_:" + bnodeMapper.GetOutputID(((IBlankNode)t.Subject).InternalID));
}
// Start an Object for the Subject
writer.WriteStartObject();
lastSubj = t.Subject;
// Write the first Predicate
// Validate Predicate
switch (t.Predicate.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/JSON"));
case NodeType.Blank:
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("RDF/JSON"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("RDF/JSON"));
case NodeType.Uri:
// OK
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/JSON"));
}
// Write the Predicate
writer.WritePropertyName(t.Predicate.ToString());
// Create an Array for the Objects
writer.WriteStartArray();
lastPred = t.Predicate;
}
else if (lastPred == null || !t.Predicate.Equals(lastPred))
{
// Terminate previous Predicate Object list
writer.WriteEndArray();
// Write the next Predicate
// Validate Predicate
switch (t.Predicate.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/JSON"));
case NodeType.Blank:
throw new RdfOutputException(WriterErrorMessages.BlankPredicatesUnserializable("RDF/JSON"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralPredicatesUnserializable("RDF/JSON"));
case NodeType.Uri:
// OK
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/JSON"));
}
// Write the Predicate
writer.WritePropertyName(t.Predicate.ToString());
// Create an Array for the Objects
writer.WriteStartArray();
lastPred = t.Predicate;
}
// Write the Object
// Create an Object for the Object
INode obj = t.Object;
writer.WriteStartObject();
writer.WritePropertyName("value");
switch (obj.NodeType)
{
case NodeType.Blank:
// Remap Blank Node IDs as appropriate
writer.WriteValue("_:" + bnodeMapper.GetOutputID(((IBlankNode)obj).InternalID));
writer.WritePropertyName("type");
writer.WriteValue("bnode");
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/JSON"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)obj;
writer.WriteValue(lit.Value);
if (!lit.Language.Equals(String.Empty))
{
writer.WritePropertyName("lang");
writer.WriteValue(lit.Language);
}
else if (lit.DataType != null)
{
writer.WritePropertyName("datatype");
writer.WriteValue(lit.DataType.AbsoluteUri);
}
writer.WritePropertyName("type");
writer.WriteValue("literal");
break;
case NodeType.Uri:
writer.WriteValue(obj.ToString());
writer.WritePropertyName("type");
writer.WriteValue("uri");
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/JSON"));
}
writer.WriteEndObject();
}
// Terminate the Object which represents the Graph
writer.WriteEndObject();
}
/// <summary>
/// Method which generates the RDF Graph of a SPARQL Result Set
/// </summary>
/// <param name="results">Result Set</param>
/// <returns></returns>
public IGraph GenerateOutput(SparqlResultSet results)
{
// Create the Graph for the Output
IGraph g = new Graph();
// Add the relevant namespaces
g.NamespaceMap.AddNamespace("rs", UriFactory.Create(SparqlSpecsHelper.SparqlRdfResultsNamespace));
// Create relevant Nodes
IUriNode rdfType = g.CreateUriNode("rdf:type");
IUriNode resultSetClass = g.CreateUriNode("rs:ResultSet");
IUriNode resultVariable = g.CreateUriNode("rs:resultVariable");
IUriNode solution = g.CreateUriNode("rs:solution");
IUriNode binding = g.CreateUriNode("rs:binding");
IUriNode value = g.CreateUriNode("rs:value");
IUriNode variable = g.CreateUriNode("rs:variable");
IUriNode boolean = g.CreateUriNode("rs:boolean");
// First we declare a Result Set
IBlankNode rset = g.CreateBlankNode();
g.Assert(new Triple(rset, rdfType, resultSetClass));
if (results.ResultsType == SparqlResultsType.VariableBindings)
{
// Assert a Triple for each Result Variable
foreach (String v in results.Variables)
{
g.Assert(new Triple(rset, resultVariable, g.CreateLiteralNode(v)));
}
// Then we're going to define a solution for each result
foreach (SparqlResult r in results)
{
IBlankNode sln = g.CreateBlankNode();
g.Assert(new Triple(rset, solution, sln));
foreach (String v in results.Variables)
{
// Only define Bindings if there is a value and it is non-null
if (r.HasValue(v) && r[v] != null)
{
IBlankNode bnd = g.CreateBlankNode();
g.Assert(new Triple(sln, binding, bnd));
g.Assert(new Triple(bnd, variable, g.CreateLiteralNode(v)));
switch (r[v].NodeType)
{
case NodeType.Blank:
IBlankNode b = (IBlankNode)r[v];
IBlankNode bMapped;
if (b.GraphUri == null)
{
bMapped = g.CreateBlankNode(b.InternalID + "def");
}
else
{
bMapped = g.CreateBlankNode(b.InternalID + b.GraphUri.GetEnhancedHashCode());
}
g.Assert(new Triple(bnd, value, bMapped));
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("SPARQL Results RDF Serialization"));
case NodeType.Literal:
case NodeType.Uri:
g.Assert(new Triple(bnd, value, r[v].CopyNode(g)));
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("SPARQL Results RDF Serialization"));
}
}
}
}
}
else
{
// A Boolean Result Set
g.Assert(new Triple(rset, boolean, g.CreateLiteralNode(results.Result.ToString(), UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeBoolean))));
}
return(g);
}
private void GenerateCollectionOutput(RdfXmlWriterContext context, INode key, XmlElement pred, ref int nextNamespaceID, List <String> tempNamespaces, XmlDocument doc)
{
OutputRdfCollection c = context.Collections[key];
c.HasBeenWritten = true;
if (!c.IsExplicit)
{
XmlAttribute parseType;
if (pred.ParentNode != doc.DocumentElement)
{
//Need to set the Predicate to have a rdf:parseType of Resource
parseType = doc.CreateAttribute("rdf:parseType", NamespaceMapper.RDF);
parseType.Value = "Resource";
pred.Attributes.Append(parseType);
}
XmlElement first, rest;
while (c.Triples.Count > 0)
{
//Get the Next Item and generate rdf:first and rdf:rest Nodes
INode next = c.Triples.First().Object;
c.Triples.RemoveAt(0);
first = doc.CreateElement("rdf:first", NamespaceMapper.RDF);
rest = doc.CreateElement("rdf:rest", NamespaceMapper.RDF);
pred.AppendChild(first);
pred.AppendChild(rest);
//Set the value of the rdf:first Item
switch (next.NodeType)
{
case NodeType.Blank:
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = ((IBlankNode)next).InternalID;
first.Attributes.Append(nodeID);
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
this.GenerateLiteralOutput(context, (ILiteralNode)next, first, doc);
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)next, "rdf:resource", tempNamespaces, first, doc);
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
if (c.Triples.Count >= 1)
{
//Set Parse Type to resource
parseType = doc.CreateAttribute("rdf:parseType", NamespaceMapper.RDF);
parseType.Value = "Resource";
rest.Attributes.Append(parseType);
pred = rest;
}
else
{
//Terminate list with an rdf:nil
XmlAttribute res = doc.CreateAttribute("rdf:resource");
res.InnerXml = "&rdf;nil";
rest.Attributes.Append(res);
}
}
}
else
{
if (c.Triples.Count == 0)
{
//Terminate the Blank Node triple by adding a rdf:nodeID attribute
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = ((IBlankNode)key).InternalID;
pred.Attributes.Append(nodeID);
}
else
{
//Need to set the Predicate to have a rdf:parseType of Resource
if (pred.Name != "rdf:Description" && pred.ParentNode != doc.DocumentElement)
{
XmlAttribute parseType = doc.CreateAttribute("rdf:parseType", NamespaceMapper.RDF);
parseType.Value = "Resource";
pred.Attributes.Append(parseType);
}
//Output the Predicate Object list
while (c.Triples.Count > 0)
{
INode nextPred = c.Triples.First().Predicate;
INode nextObj = c.Triples.First().Object;
c.Triples.RemoveAt(0);
XmlElement p;
//Generate the predicate
p = this.GeneratePredicateNode(context, nextPred, ref nextNamespaceID, tempNamespaces, doc, pred);
//Output the Object
switch (nextObj.NodeType)
{
case NodeType.Blank:
if (context.Collections.ContainsKey(nextObj))
{
//Output a Collection
this.GenerateCollectionOutput(context, nextObj, p, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = ((IBlankNode)nextObj).InternalID;
p.Attributes.Append(nodeID);
}
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
this.GenerateLiteralOutput(context, (ILiteralNode)nextObj, p, doc);
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)nextObj, "rdf:resource", tempNamespaces, p, doc);
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
}
}
}
}
/// <summary>
/// Internal method which generates the RDF/Json Output for a Graph
/// </summary>
/// <param name="context">Writer Context</param>
private void GenerateOutput(RdfXmlWriterContext context)
{
context.UseDtd = this._useDTD;
//Create required variables
int nextNamespaceID = 0;
List <String> tempNamespaces = new List <String>();
//Always force RDF Namespace to be correctly defined
context.Graph.NamespaceMap.AddNamespace("rdf", new Uri(NamespaceMapper.RDF));
//Create an XML Document
XmlDocument doc = new XmlDocument();
XmlDeclaration decl = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
doc.AppendChild(decl);
//Create the DOCTYPE declaration and the rdf:RDF element
StringBuilder entities = new StringBuilder();
XmlElement rdf = doc.CreateElement("rdf:RDF", NamespaceMapper.RDF);
if (context.Graph.BaseUri != null)
{
XmlAttribute baseUri = doc.CreateAttribute("xml:base");
baseUri.Value = Uri.EscapeUriString(context.Graph.BaseUri.ToString());
rdf.Attributes.Append(baseUri);
}
XmlAttribute ns;
String uri;
entities.Append('\n');
foreach (String prefix in context.Graph.NamespaceMap.Prefixes)
{
uri = context.Graph.NamespaceMap.GetNamespaceUri(prefix).ToString();
if (!prefix.Equals(String.Empty))
{
entities.AppendLine("\t<!ENTITY " + prefix + " '" + uri + "'>");
ns = doc.CreateAttribute("xmlns:" + prefix);
ns.Value = Uri.EscapeUriString(uri.Replace("'", "'"));
}
else
{
ns = doc.CreateAttribute("xmlns");
ns.Value = Uri.EscapeUriString(uri);
}
rdf.Attributes.Append(ns);
}
if (context.UseDtd)
{
XmlDocumentType doctype = doc.CreateDocumentType("rdf:RDF", null, null, entities.ToString());
doc.AppendChild(doctype);
}
doc.AppendChild(rdf);
//Find the Collections
if (this._compressionLevel >= WriterCompressionLevel.More)
{
WriterHelper.FindCollections(context);
}
//Find the Type References
Dictionary <INode, String> typerefs = this.FindTypeReferences(context, ref nextNamespaceID, tempNamespaces, doc);
//Get the Triples as a Sorted List
List <Triple> ts = context.Graph.Triples.Where(t => !context.TriplesDone.Contains(t)).ToList();
ts.Sort();
//Variables we need to track our writing
INode lastSubj, lastPred;
lastSubj = lastPred = null;
XmlElement subj, pred;
//Initialise stuff to keep the compiler happy
subj = doc.CreateElement("rdf:Description", NamespaceMapper.RDF);
pred = doc.CreateElement("temp");
for (int i = 0; i < ts.Count; i++)
{
Triple t = ts[i];
if (context.TriplesDone.Contains(t))
{
continue; //Skip if already done
}
if (lastSubj == null || !t.Subject.Equals(lastSubj))
{
//Start a new set of Triples
//Validate Subject
//Use a Type Reference if applicable
if (typerefs.ContainsKey(t.Subject))
{
String tref = typerefs[t.Subject];
String tprefix;
if (tref.StartsWith(":"))
{
tprefix = String.Empty;
}
else if (tref.Contains(":"))
{
tprefix = tref.Substring(0, tref.IndexOf(':'));
}
else
{
tprefix = String.Empty;
}
subj = doc.CreateElement(tref, context.Graph.NamespaceMap.GetNamespaceUri(tprefix).ToString());
}
else
{
subj = doc.CreateElement("rdf:Description", NamespaceMapper.RDF);
}
//Write out the Subject
doc.DocumentElement.AppendChild(subj);
lastSubj = t.Subject;
//Apply appropriate attributes
switch (t.Subject.NodeType)
{
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
throw new RdfOutputException(WriterErrorMessages.LiteralSubjectsUnserializable("RDF/XML"));
case NodeType.Blank:
if (context.Collections.ContainsKey(t.Subject))
{
this.GenerateCollectionOutput(context, t.Subject, subj, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = ((IBlankNode)t.Subject).InternalID;
subj.Attributes.Append(nodeID);
}
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Subject, "rdf:about", tempNamespaces, subj, doc);
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
//Write the Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
lastPred = t.Predicate;
}
else if (lastPred == null || !t.Predicate.Equals(lastPred))
{
//Write the Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
lastPred = t.Predicate;
}
//Write the Object
//Create an Object for the Object
switch (t.Object.NodeType)
{
case NodeType.Blank:
if (pred.HasChildNodes || pred.HasAttributes)
{
//Require a new Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
}
if (context.Collections.ContainsKey(t.Object))
{
//Output a Collection
this.GenerateCollectionOutput(context, t.Object, pred, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
//Terminate the Blank Node triple by adding a rdf:nodeID attribute
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID", NamespaceMapper.RDF);
nodeID.Value = ((IBlankNode)t.Object).InternalID;
pred.Attributes.Append(nodeID);
}
//Force a new Predicate after Blank Nodes
lastPred = null;
break;
case NodeType.GraphLiteral:
throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("RDF/XML"));
case NodeType.Literal:
ILiteralNode lit = (ILiteralNode)t.Object;
if (pred.HasChildNodes || pred.HasAttributes)
{
//Require a new Predicate
pred = this.GeneratePredicateNode(context, t.Predicate, ref nextNamespaceID, tempNamespaces, doc, subj);
subj.AppendChild(pred);
}
this.GenerateLiteralOutput(context, lit, pred, doc);
//Force a new Predicate Node after Literals
lastPred = null;
break;
case NodeType.Uri:
this.GenerateUriOutput(context, (IUriNode)t.Object, "rdf:resource", tempNamespaces, pred, doc);
//Force a new Predicate Node after URIs
lastPred = null;
break;
default:
throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("RDF/XML"));
}
context.TriplesDone.Add(t);
}
//Check we haven't failed to output any collections
foreach (KeyValuePair <INode, OutputRdfCollection> pair in context.Collections)
{
if (!pair.Value.HasBeenWritten)
{
if (typerefs.ContainsKey(pair.Key))
{
String tref = typerefs[pair.Key];
String tprefix;
if (tref.StartsWith(":"))
{
tref = tref.Substring(1);
tprefix = String.Empty;
}
else if (tref.Contains(":"))
{
tprefix = tref.Substring(0, tref.IndexOf(':'));
}
else
{
tprefix = String.Empty;
}
subj = doc.CreateElement(tref, context.Graph.NamespaceMap.GetNamespaceUri(tprefix).ToString());
doc.DocumentElement.AppendChild(subj);
this.GenerateCollectionOutput(context, pair.Key, subj, ref nextNamespaceID, tempNamespaces, doc);
}
else
{
//Generate an rdf:Description Node with a rdf:nodeID on it
XmlElement colNode = doc.CreateElement("rdf:Description");
XmlAttribute nodeID = doc.CreateAttribute("rdf:nodeID");
nodeID.Value = ((IBlankNode)pair.Key).InternalID;
colNode.Attributes.Append(nodeID);
doc.DocumentElement.AppendChild(colNode);
this.GenerateCollectionOutput(context, pair.Key, colNode, ref nextNamespaceID, tempNamespaces, doc);
//throw new RdfOutputException("Failed to output a Collection due to an unknown error");
}
}
}
//Save to the Output Stream
InternalXmlWriter writer = new InternalXmlWriter();
writer.Save(context.Output, doc);
//Get rid of the Temporary Namespace
foreach (String tempPrefix in tempNamespaces)
{
context.Graph.NamespaceMap.RemoveNamespace(tempPrefix);
}
}
