/// <summary>
/// Saves a Triple Store to TSV format
/// </summary>
/// <param name="store">Triple Store to save</param>
/// <param name="writer">Writer to save to</param>
public void Save(ITripleStore store, TextWriter writer)
{
if (store == null)
{
throw new RdfOutputException("Cannot output a null Triple Store");
}
if (writer == null)
{
throw new RdfOutputException("Cannot output to a null writer");
}
ThreadedStoreWriterContext context = new ThreadedStoreWriterContext(store, writer);
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
/// <summary>
/// Saves a Store in TriG (Turtle with Named Graphs) format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating a Stream to write to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
//Try and determine the TextWriter to output to
TriGWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
((StreamParams)parameters).Encoding = new UTF8Encoding(Options.UseBomForUtf8);
context = new TriGWriterContext(store, ((StreamParams)parameters).StreamWriter, this._prettyprint, this._allowHiSpeed, this._compressionLevel, this._n3compat);
}
else if (parameters is TextWriterParams)
{
context = new TriGWriterContext(store, ((TextWriterParams)parameters).TextWriter, this._prettyprint, this._allowHiSpeed, this._compressionLevel, this._n3compat);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
//Write the Header of the File
foreach (IGraph g in context.Store.Graphs)
{
context.NamespaceMap.Import(g.NamespaceMap);
}
if (context.CompressionLevel > WriterCompressionLevel.None)
{
//Only add @prefix declarations if compression is enabled
context.QNameMapper = new ThreadSafeQNameOutputMapper(context.NamespaceMap);
foreach (String prefix in context.NamespaceMap.Prefixes)
{
if (TurtleSpecsHelper.IsValidQName(prefix + ":"))
{
context.Output.WriteLine("@prefix " + prefix + ": <" + context.FormatUri(context.NamespaceMap.GetNamespaceUri(prefix)) + ">.");
}
}
context.Output.WriteLine();
}
else
{
context.QNameMapper = new ThreadSafeQNameOutputMapper(new NamespaceMapper(true));
}
if (this._useMultiThreading)
{
//Standard Multi-Threaded Writing
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
if (g.BaseUri == null)
{
context.Add(new Uri(GraphCollection.DefaultGraphUri));
}
else
{
context.Add(g.BaseUri);
}
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TriG"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
//Make sure to close the output
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
try
{
//Optional Single Threaded Writing
foreach (IGraph g in store.Graphs)
{
TurtleWriterContext graphContext = new TurtleWriterContext(g, new System.IO.StringWriter(), context.PrettyPrint, context.HighSpeedModePermitted);
if (context.CompressionLevel > WriterCompressionLevel.None)
{
graphContext.NodeFormatter = new TurtleFormatter(context.QNameMapper);
}
else
{
graphContext.NodeFormatter = new UncompressedTurtleFormatter();
}
context.Output.WriteLine(this.GenerateGraphOutput(context, graphContext));
}
//Make sure to close the output
context.Output.Close();
}
catch
{
try
{
//Close the output
context.Output.Close();
}
catch
{
//No catch actions, just cleaning up the output stream
}
throw;
}
}
}
else
{
throw new RdfStorageException("Parameters for the TriGWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves a Store in NQuads format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating a Stream to write to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
ThreadedStoreWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
#if !SILVERLIGHT
((StreamParams)parameters).Encoding = Encoding.ASCII;
#endif
context = new ThreadedStoreWriterContext(store, ((StreamParams)parameters).StreamWriter, this._prettyPrint, false);
}
else if (parameters is TextWriterParams)
{
context = new ThreadedStoreWriterContext(store, ((TextWriterParams)parameters).TextWriter, this._prettyPrint, false);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
try
{
if (this._multiThreaded)
{
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
if (g.BaseUri == null)
{
context.Add(UriFactory.Create(GraphCollection.DefaultGraphUri));
}
else
{
context.Add(g.BaseUri);
}
}
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any()) throw outputEx;
}
else
{
foreach (IGraph g in context.Store.Graphs)
{
NTriplesWriterContext graphContext = new NTriplesWriterContext(g, context.Output);
foreach (Triple t in g.Triples)
{
context.Output.WriteLine(this.TripleToNQuads(graphContext, t));
}
}
context.Output.Close();
}
}
catch
{
try
{
context.Output.Close();
}
catch
{
//Just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the NQuadsWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves the given Store to Disk using the settings the Writer was instantiated with
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating where to save to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is FolderStoreParams)
{
//Get the Parameters
FolderStoreWriterContext context = new FolderStoreWriterContext(store, (FolderStoreParams)parameters);
//Create the Folder
if (!Directory.Exists(context.Folder))
{
Directory.CreateDirectory(context.Folder);
}
//Write list of Graphs and Queue URIs of Graphs for writing by the async calls
StreamWriter graphlist = new StreamWriter(Path.Combine(context.Folder,"graphs.fstore"));
String ext;
switch (context.Format)
{
case FolderStoreFormat.Turtle:
ext = ".ttl";
break;
case FolderStoreFormat.Notation3:
ext = ".n3";
break;
case FolderStoreFormat.RdfXml:
ext = ".rdf";
break;
default:
ext = ".ttl";
break;
}
graphlist.WriteLine(ext);
foreach (Uri u in context.Store.Graphs.GraphUris)
{
context.Add(u);
graphlist.WriteLine(u.GetSha256Hash() + ext);
}
graphlist.Close();
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < context.Threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("Folder Store"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any()) throw outputEx;
}
else
{
throw new RdfStorageException("Parameters for the FolderStoreWriter must be of type FolderStoreParams");
}
}
/// <summary>
/// Saves a Store in TriG (Turtle with Named Graphs) format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating a Stream to write to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
//Try and determine the TextWriter to output to
TriGWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
((StreamParams)parameters).Encoding = new UTF8Encoding(Options.UseBomForUtf8);
context = new TriGWriterContext(store, ((StreamParams)parameters).StreamWriter, this._prettyprint, this._allowHiSpeed, this._compressionLevel, this._n3compat);
}
else if (parameters is TextWriterParams)
{
context = new TriGWriterContext(store, ((TextWriterParams)parameters).TextWriter, this._prettyprint, this._allowHiSpeed, this._compressionLevel, this._n3compat);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
//Write the Header of the File
foreach (IGraph g in context.Store.Graphs)
{
context.NamespaceMap.Import(g.NamespaceMap);
}
if (context.CompressionLevel > WriterCompressionLevel.None)
{
//Only add @prefix declarations if compression is enabled
context.QNameMapper = new ThreadSafeQNameOutputMapper(context.NamespaceMap);
foreach (String prefix in context.NamespaceMap.Prefixes)
{
if (TurtleSpecsHelper.IsValidQName(prefix + ":"))
{
context.Output.WriteLine("@prefix " + prefix + ": <" + context.FormatUri(context.NamespaceMap.GetNamespaceUri(prefix)) + ">.");
}
}
context.Output.WriteLine();
}
else
{
context.QNameMapper = new ThreadSafeQNameOutputMapper(new NamespaceMapper(true));
}
if (this._useMultiThreading)
{
//Standard Multi-Threaded Writing
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
if (g.BaseUri == null)
{
context.Add(new Uri(GraphCollection.DefaultGraphUri));
}
else
{
context.Add(g.BaseUri);
}
}
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TriG"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
//Make sure to close the output
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any()) throw outputEx;
}
else
{
try
{
//Optional Single Threaded Writing
foreach (IGraph g in store.Graphs)
{
TurtleWriterContext graphContext = new TurtleWriterContext(g, new System.IO.StringWriter(), context.PrettyPrint, context.HighSpeedModePermitted);
if (context.CompressionLevel > WriterCompressionLevel.None)
{
graphContext.NodeFormatter = new TurtleFormatter(context.QNameMapper);
}
else
{
graphContext.NodeFormatter = new UncompressedTurtleFormatter();
}
context.Output.WriteLine(this.GenerateGraphOutput(context, graphContext));
}
//Make sure to close the output
context.Output.Close();
}
catch
{
try
{
//Close the output
context.Output.Close();
}
catch
{
//No catch actions, just cleaning up the output stream
}
throw;
}
}
}
else
{
throw new RdfStorageException("Parameters for the TriGWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves a Store in NQuads format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating a Stream to write to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
ThreadedStoreWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
#if !SILVERLIGHT
((StreamParams)parameters).Encoding = Encoding.ASCII;
#endif
context = new ThreadedStoreWriterContext(store, ((StreamParams)parameters).StreamWriter, this._prettyPrint, false);
}
else if (parameters is TextWriterParams)
{
context = new ThreadedStoreWriterContext(store, ((TextWriterParams)parameters).TextWriter, this._prettyPrint, false);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
try
{
if (this._multiThreaded)
{
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
if (g.BaseUri == null)
{
context.Add(UriFactory.Create(GraphCollection.DefaultGraphUri));
}
else
{
context.Add(g.BaseUri);
}
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
foreach (IGraph g in context.Store.Graphs)
{
NTriplesWriterContext graphContext = new NTriplesWriterContext(g, context.Output);
foreach (Triple t in g.Triples)
{
context.Output.WriteLine(this.TripleToNQuads(graphContext, t));
}
}
context.Output.Close();
}
}
catch
{
try
{
context.Output.Close();
}
catch
{
//Just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the NQuadsWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves the given Store to Disk using the settings the Writer was instantiated with
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Parameters indicating where to save to</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is FolderStoreParams)
{
//Get the Parameters
FolderStoreWriterContext context = new FolderStoreWriterContext(store, (FolderStoreParams)parameters);
//Create the Folder
if (!Directory.Exists(context.Folder))
{
Directory.CreateDirectory(context.Folder);
}
//Write list of Graphs and Queue URIs of Graphs for writing by the async calls
StreamWriter graphlist = new StreamWriter(Path.Combine(context.Folder, "graphs.fstore"));
String ext;
switch (context.Format)
{
case FolderStoreFormat.Turtle:
ext = ".ttl";
break;
case FolderStoreFormat.Notation3:
ext = ".n3";
break;
case FolderStoreFormat.RdfXml:
ext = ".rdf";
break;
default:
ext = ".ttl";
break;
}
graphlist.WriteLine(ext);
foreach (Uri u in context.Store.Graphs.GraphUris)
{
context.Add(u);
graphlist.WriteLine(u.GetSha256Hash() + ext);
}
graphlist.Close();
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < context.Threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("Folder Store"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
throw new RdfStorageException("Parameters for the FolderStoreWriter must be of type FolderStoreParams");
}
}
/// <summary>
/// Saves a Store in NQuads format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="writer">Writer to save to</param>
/// <param name="leaveOpen">Boolean flag indicating if <paramref name="writer"/> should be left open after the store is written</param>
public void Save(ITripleStore store, TextWriter writer, bool leaveOpen)
{
if (store == null)
{
throw new RdfOutputException("Cannot output a null Triple Store");
}
if (writer == null)
{
throw new RdfOutputException("Cannot output to a null writer");
}
var context = new ThreadedStoreWriterContext(store, writer, PrettyPrintMode, false);
// Check there's something to do
if (context.Store.Graphs.Count == 0)
{
if (!leaveOpen)
{
context.Output.Close();
}
return;
}
try
{
if (UseMultiThreadedWriting)
{
// Queue the Graphs to be written
foreach (var g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
// Start making the async calls
var results = new List <IAsyncResult>();
var d = new SaveGraphsDelegate(SaveGraphs);
for (var i = 0; i < _threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
// Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
var outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (var result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
if (!leaveOpen)
{
context.Output.Close();
}
// If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
foreach (var g in context.Store.Graphs)
{
var graphContext = new NTriplesWriterContext(g, context.Output, NQuadsParser.AsNTriplesSyntax(Syntax));
foreach (var t in g.Triples)
{
context.Output.WriteLine(TripleToNQuads(graphContext, t, g.BaseUri));
}
}
if (!leaveOpen)
{
context.Output.Close();
}
}
}
catch
{
try
{
if (!leaveOpen)
{
context.Output.Close();
}
}
catch
{
// Just cleaning up
}
throw;
}
}
/// <summary>
/// Saves a Triple Store to TSV format
/// </summary>
/// <param name="store">Triple Store to save</param>
/// <param name="parameters">A set of <see cref="StreamParams">StreamParams</see></param>
public void Save(ITripleStore store, IStoreParams parameters)
{
ThreadedStoreWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
context = new ThreadedStoreWriterContext(store, ((StreamParams)parameters).StreamWriter);
}
else if (parameters is TextWriterParams)
{
context = new ThreadedStoreWriterContext(store, ((TextWriterParams)parameters).TextWriter);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any()) throw outputEx;
}
else
{
throw new RdfStorageException("Parameters for the TsvStoreWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves a Triple Store to TSV format
/// </summary>
/// <param name="store">Triple Store to save</param>
/// <param name="parameters">A set of <see cref="StreamParams">StreamParams</see></param>
public void Save(ITripleStore store, IStoreParams parameters)
{
ThreadedStoreWriterContext context = null;
if (parameters is StreamParams)
{
//Create a new Writer Context
context = new ThreadedStoreWriterContext(store, ((StreamParams)parameters).StreamWriter);
}
else if (parameters is TextWriterParams)
{
context = new ThreadedStoreWriterContext(store, ((TextWriterParams)parameters).TextWriter);
}
if (context != null)
{
//Check there's something to do
if (context.Store.Graphs.Count == 0)
{
context.Output.Close();
return;
}
//Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(this.SaveGraphs);
for (int i = 0; i < this._threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
//Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
context.Output.Close();
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
throw new RdfStorageException("Parameters for the TsvStoreWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves a Store in TriG (Turtle with Named Graphs) format
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="writer">Writer to save to</param>
/// <param name="leaveOpen">Boolean flag indicating if <paramref name="writer"/> should be left open after the store is saved</param>
public void Save(ITripleStore store, TextWriter writer, bool leaveOpen)
{
if (store == null)
{
throw new RdfOutputException("Cannot output a null Triple Store");
}
if (writer == null)
{
throw new RdfOutputException("Cannot output to a null writer");
}
TriGWriterContext context = new TriGWriterContext(store, writer, _prettyprint, _allowHiSpeed, _compressionLevel, _n3compat);
// Check there's something to do
if (context.Store.Graphs.Count == 0)
{
if (!leaveOpen)
{
context.Output.Close();
}
return;
}
// Write the Header of the File
foreach (var g in context.Store.Graphs)
{
context.NamespaceMap.Import(g.NamespaceMap);
}
if (context.CompressionLevel > WriterCompressionLevel.None)
{
// Only add @prefix declarations if compression is enabled
context.QNameMapper = new ThreadSafeQNameOutputMapper(context.NamespaceMap);
foreach (string prefix in context.NamespaceMap.Prefixes)
{
if (TurtleSpecsHelper.IsValidQName(prefix + ":"))
{
context.Output.WriteLine("@prefix " + prefix + ": <" + context.FormatUri(context.NamespaceMap.GetNamespaceUri(prefix)) + ">.");
}
}
context.Output.WriteLine();
}
else
{
context.QNameMapper = new ThreadSafeQNameOutputMapper(new NamespaceMapper(true));
}
if (_useMultiThreading)
{
// Standard Multi-Threaded Writing
// Queue the Graphs to be written
foreach (IGraph g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
// Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
SaveGraphsDelegate d = new SaveGraphsDelegate(SaveGraphs);
for (int i = 0; i < _threads; i++)
{
results.Add(d.BeginInvoke(context, null, null));
}
// Wait for all the async calls to complete
WaitHandle.WaitAll(results.Select(r => r.AsyncWaitHandle).ToArray());
RdfThreadedOutputException outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TriG"));
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
outputEx.AddException(ex);
}
}
// Make sure to close the output
if (!leaveOpen)
{
context.Output.Close();
}
// If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
try
{
// Optional Single Threaded Writing
foreach (IGraph g in store.Graphs)
{
TurtleWriterContext graphContext = new TurtleWriterContext(g, new System.IO.StringWriter(), context.PrettyPrint, context.HighSpeedModePermitted);
if (context.CompressionLevel > WriterCompressionLevel.None)
{
graphContext.NodeFormatter = new TurtleFormatter(context.QNameMapper);
}
else
{
graphContext.NodeFormatter = new UncompressedTurtleFormatter();
}
context.Output.WriteLine(GenerateGraphOutput(context, graphContext));
}
// Make sure to close the output
if (!leaveOpen)
{
context.Output.Close();
}
}
catch
{
try
{
// Close the output
if (!leaveOpen)
{
context.Output.Close();
}
}
catch
{
// No catch actions, just cleaning up the output stream
}
throw;
}
}
}
