public void WritingCollectionCompressionNamedListNodes3()
{
Graph g = new Graph();
INode data1 = g.CreateBlankNode();
g.Assert(data1, g.CreateUriNode(new Uri("http://property")), g.CreateLiteralNode("test1"));
INode data2 = g.CreateBlankNode();
g.Assert(data2, g.CreateUriNode(new Uri("http://property")), g.CreateLiteralNode("test2"));
INode listEntry1 = g.CreateUriNode(new Uri("http://test/1"));
INode rdfFirst = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListFirst));
INode rdfRest = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListRest));
INode rdfNil = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil));
g.Assert(listEntry1, rdfFirst, data1);
g.Assert(listEntry1, rdfRest, rdfNil);
INode listEntry2 = g.CreateUriNode(new Uri("http://test/2"));
g.Assert(listEntry2, rdfFirst, data2);
g.Assert(listEntry2, rdfRest, listEntry1);
INode root = g.CreateUriNode(new Uri("http://root"));
g.Assert(root, g.CreateUriNode(new Uri("http://list")), listEntry2);
NTriplesFormatter formatter = new NTriplesFormatter();
_output.WriteLine("Original Graph");
foreach (Triple t in g.Triples)
{
_output.WriteLine(t.ToString(formatter));
}
_output.WriteLine("");
var sw = new System.IO.StringWriter();
CompressingTurtleWriterContext context = new CompressingTurtleWriterContext(g, sw);
WriterHelper.FindCollections(context);
_output.WriteLine(sw.ToString());
_output.WriteLine(context.Collections.Count + " Collections Found");
_output.WriteLine("");
System.IO.StringWriter strWriter = new System.IO.StringWriter();
CompressingTurtleWriter writer = new CompressingTurtleWriter();
writer.CompressionLevel = WriterCompressionLevel.High;
writer.Save(g, strWriter);
_output.WriteLine("Compressed Turtle");
_output.WriteLine(strWriter.ToString());
_output.WriteLine("");
Graph h = new Graph();
TurtleParser parser = new TurtleParser();
StringParser.Parse(h, strWriter.ToString());
_output.WriteLine("Graph after Round Trip to Compressed Turtle");
foreach (Triple t in h.Triples)
{
_output.WriteLine(t.ToString(formatter));
}
Assert.Equal(g, h);
}
/// <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>
/// Internal Helper method which converts a Collection into Notation 3 Syntax.
/// </summary>
/// <param name="context">Writer Context.</param>
/// <param name="c">Collection to convert.</param>
/// <param name="indent">Indent to use for pretty printing.</param>
/// <returns></returns>
private String GenerateCollectionOutput(CompressingTurtleWriterContext context, OutputRdfCollection c, int indent)
{
StringBuilder output = new StringBuilder();
bool first = true;
if (!c.IsExplicit)
{
output.Append('(');
while (c.Triples.Count > 0)
{
if (context.PrettyPrint && !first)
{
output.Append(new String(' ', indent));
}
first = false;
output.Append(GenerateNodeOutput(context, c.Triples.First().Object, TripleSegment.Object, indent));
c.Triples.RemoveAt(0);
if (c.Triples.Count > 0)
{
output.Append(' ');
}
}
output.Append(')');
}
else
{
if (c.Triples.Count == 0)
{
// Empty Collection
// Can represent as a single Blank Node []
output.Append("[]");
}
else
{
output.Append('[');
while (c.Triples.Count > 0)
{
if (context.PrettyPrint && !first)
{
output.Append(new String(' ', indent));
}
first = false;
String temp = GenerateNodeOutput(context, c.Triples.First().Predicate, TripleSegment.Predicate, indent);
output.Append(temp);
output.Append(' ');
int addIndent;
if (temp.Contains('\n'))
{
addIndent = temp.Split('\n').Last().Length;
}
else
{
addIndent = temp.Length;
}
output.Append(GenerateNodeOutput(context, c.Triples.First().Object, TripleSegment.Object, indent + 2 + addIndent));
c.Triples.RemoveAt(0);
if (c.Triples.Count > 0)
{
output.AppendLine(" ; ");
output.Append(' ');
}
}
output.Append(']');
}
}
return(output.ToString());
}
/// <summary>
/// Generates the Notation 3 Syntax for the Graph.
/// </summary>
private void GenerateOutput(CompressingTurtleWriterContext context)
{
// Create the Header
// Base Directive
if (context.Graph.BaseUri != null)
{
context.Output.WriteLine("@base <" + context.UriFormatter.FormatUri(context.Graph.BaseUri) + ">.");
context.Output.WriteLine();
}
// Prefix Directives
foreach (String prefix in context.Graph.NamespaceMap.Prefixes)
{
if (TurtleSpecsHelper.IsValidQName(prefix + ":"))
{
if (!prefix.Equals(String.Empty))
{
context.Output.WriteLine("@prefix " + prefix + ": <" + context.UriFormatter.FormatUri(context.Graph.NamespaceMap.GetNamespaceUri(prefix)) + ">.");
}
else
{
context.Output.WriteLine("@prefix : <" + context.UriFormatter.FormatUri(context.Graph.NamespaceMap.GetNamespaceUri(String.Empty)) + ">.");
}
}
}
context.Output.WriteLine();
// Decide on the Write Mode to use
bool hiSpeed = false;
bool contextWritten = false;
double subjNodes = context.Graph.Triples.SubjectNodes.Count();
double triples = context.Graph.Triples.Count;
if ((subjNodes / triples) > 0.75)
{
hiSpeed = true;
}
if (context.CompressionLevel == WriterCompressionLevel.None || (hiSpeed && context.HighSpeedModePermitted))
{
RaiseWarning("High Speed Write Mode in use - minimal syntax compression will be used");
context.CompressionLevel = WriterCompressionLevel.Minimal;
context.NodeFormatter = new UncompressedNotation3Formatter();
foreach (Triple t in context.Graph.Triples)
{
if (!contextWritten && t.Context != null && t.Context is VariableContext)
{
VariableContext varContext = (VariableContext)t.Context;
contextWritten = GenerateVariableQuantificationOutput(context, varContext);
}
context.Output.WriteLine(GenerateTripleOutput(context, t));
}
}
else
{
if (context.CompressionLevel >= WriterCompressionLevel.More)
{
WriterHelper.FindCollections(context);
}
// Get the Triples as a Sorted List
List <Triple> ts = context.Graph.Triples.Where(t => !context.TriplesDone.Contains(t)).ToList();
ts.Sort(new FullTripleComparer(new FastNodeComparer()));
// Variables we need to track our writing
INode lastSubj, lastPred;
lastSubj = lastPred = null;
int subjIndent = 0, predIndent = 0;
String temp;
for (int i = 0; i < ts.Count; i++)
{
Triple t = ts[i];
if (lastSubj == null || !t.Subject.Equals(lastSubj) || (t.Context != null && t.Context is VariableContext))
{
// Terminate previous Triples
if (lastSubj != null)
{
context.Output.WriteLine(".");
}
// If there's a Variable Context insert the @forAll and @forSome
if (!contextWritten && t.Context != null && t.Context is VariableContext)
{
VariableContext varContext = (VariableContext)t.Context;
contextWritten = GenerateVariableQuantificationOutput(context, varContext);
}
// Start a new set of Triples
temp = GenerateNodeOutput(context, t.Subject, TripleSegment.Subject, 0);
context.Output.Write(temp);
context.Output.Write(" ");
if (temp.Contains('\n'))
{
subjIndent = temp.Split('\n').Last().Length + 1;
}
else
{
subjIndent = temp.Length + 1;
}
lastSubj = t.Subject;
// Write the first Predicate
temp = GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate, subjIndent);
context.Output.Write(temp);
context.Output.Write(" ");
predIndent = temp.Length + 1;
lastPred = t.Predicate;
}
else if (lastPred == null || !t.Predicate.Equals(lastPred))
{
// Terminate previous Predicate Object list
context.Output.WriteLine(";");
if (context.PrettyPrint)
{
context.Output.Write(new String(' ', subjIndent));
}
// Write the next Predicate
temp = GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate, subjIndent);
context.Output.Write(temp);
context.Output.Write(" ");
predIndent = temp.Length + 1;
lastPred = t.Predicate;
}
else
{
// Continue Object List
context.Output.WriteLine(",");
if (context.PrettyPrint)
{
context.Output.Write(new String(' ', subjIndent + predIndent));
}
}
// Write the Object
context.Output.Write(GenerateNodeOutput(context, t.Object, TripleSegment.Object, subjIndent + predIndent));
}
// Terminate Triples
if (ts.Count > 0)
{
context.Output.WriteLine(".");
}
return;
}
}
