/// <summary>
/// Thread Worker method which writes Graphs to the output.
/// </summary>
/// <param name="globalContext">Context for writing the Store.</param>
private void SaveGraphs(ThreadedStoreWriterContext globalContext)
{
try
{
Uri u = null;
while (globalContext.TryGetNextUri(out u))
{
// Get the Graph from the Store
IGraph g = globalContext.Store.Graphs[u];
// Generate the Graph Output and add to Stream
BaseWriterContext context = new BaseWriterContext(g, new System.IO.StringWriter());
String graphContent = GenerateGraphOutput(globalContext, context);
try
{
Monitor.Enter(globalContext.Output);
globalContext.Output.WriteLine(graphContent);
globalContext.Output.Flush();
}
finally
{
Monitor.Exit(globalContext.Output);
}
}
}
catch (ThreadAbortException)
{
// We've been terminated, don't do anything
}
catch (Exception ex)
{
throw new RdfStorageException("Error in Threaded Writer in Thread ID " + Thread.CurrentThread.ManagedThreadId, ex);
}
}
/// <summary>
/// Generates the Output for a Graph as a String in CSV syntax.
/// </summary>
/// <param name="globalContext">Context for writing the Store.</param>
/// <param name="context">Context for writing the Graph.</param>
/// <returns></returns>
private String GenerateGraphOutput(ThreadedStoreWriterContext globalContext, BaseWriterContext context)
{
if (context.Graph.BaseUri != null)
{
// Named Graphs have a fourth context field added
foreach (Triple t in context.Graph.Triples)
{
GenerateNodeOutput(context, t.Subject, TripleSegment.Subject);
context.Output.Write(',');
GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate);
context.Output.Write(',');
GenerateNodeOutput(context, t.Object, TripleSegment.Object);
context.Output.Write(',');
context.Output.Write(_formatter.FormatUri(context.Graph.BaseUri));
context.Output.Write("\r\n");
}
}
else
{
// Default Graph has an empty field added
foreach (Triple t in context.Graph.Triples)
{
GenerateNodeOutput(context, t.Subject, TripleSegment.Subject);
context.Output.Write(',');
GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate);
context.Output.Write(',');
GenerateNodeOutput(context, t.Object, TripleSegment.Object);
context.Output.Write(',');
context.Output.Write("\r\n");
}
}
return(context.Output.ToString());
}
/// <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>
/// Thread Worker method which writes Graphs to the output
/// </summary>
/// <param name="globalContext">Context for writing the Store</param>
private void SaveGraphs(ThreadedStoreWriterContext globalContext)
{
try
{
Uri u = globalContext.GetNextUri();
while (u != null)
{
//Get the Graph from the Store
if (WriterHelper.IsDefaultGraph(u) && !globalContext.Store.HasGraph(u))
{
u = null;
}
IGraph g = globalContext.Store.Graphs[u];
//Generate the Graph Output and add to Stream
NTriplesWriterContext context = new NTriplesWriterContext(g, new System.IO.StringWriter(), globalContext.PrettyPrint, globalContext.HighSpeedModePermitted);
String graphContent = this.GraphToNQuads(globalContext, context);
if (!graphContent.Equals(String.Empty))
{
try
{
Monitor.Enter(globalContext.Output);
globalContext.Output.WriteLine(graphContent);
globalContext.Output.Flush();
}
catch
{
throw;
}
finally
{
Monitor.Exit(globalContext.Output);
}
}
//Get the Next Uri
u = globalContext.GetNextUri();
}
}
catch (ThreadAbortException)
{
//We've been terminated, don't do anything
#if !SILVERLIGHT
Thread.ResetAbort();
#endif
}
catch (Exception ex)
{
throw new RdfStorageException("Error in Threaded Writer in Thread ID " + Thread.CurrentThread.ManagedThreadId, ex);
}
}
/// <summary>
/// Thread Worker method which writes Graphs to the output
/// </summary>
/// <param name="globalContext">Context for writing the Store</param>
private void SaveGraphs(ThreadedStoreWriterContext globalContext)
{
try
{
Uri u = null;
while (globalContext.TryGetNextUri(out u))
{
//Get the Graph from the Store
IGraph g = globalContext.Store.Graphs[u];
//Generate the Graph Output and add to Stream
NTriplesWriterContext context = new NTriplesWriterContext(g, new System.IO.StringWriter(), NQuadsParser.AsNTriplesSyntax(this.Syntax), globalContext.PrettyPrint, globalContext.HighSpeedModePermitted);
String graphContent = this.GraphToNQuads(globalContext, context);
if (!graphContent.Equals(String.Empty))
{
try
{
Monitor.Enter(globalContext.Output);
globalContext.Output.WriteLine(graphContent);
globalContext.Output.Flush();
}
catch
{
throw;
}
finally
{
Monitor.Exit(globalContext.Output);
}
}
}
}
#if !PORTABLE // PCL doesn't provide Thread.Abort() or ThreadAbortException
catch (ThreadAbortException)
{
//We've been terminated, don't do anything
#if !SILVERLIGHT
Thread.ResetAbort();
#endif
}
#endif
catch (Exception ex)
{
throw new RdfStorageException("Error in Threaded Writer in Thread ID " + Thread.CurrentThread.ManagedThreadId, ex);
}
}
private String GraphToNQuads(ThreadedStoreWriterContext globalContext, NTriplesWriterContext context)
{
if (context.Graph.IsEmpty)
{
return(String.Empty);
}
if (context.PrettyPrint && !WriterHelper.IsDefaultGraph(context.Graph.BaseUri))
{
context.Output.WriteLine("# Graph: " + context.Graph.BaseUri.ToString());
}
foreach (Triple t in context.Graph.Triples)
{
context.Output.WriteLine(this.TripleToNQuads(context, t));
}
context.Output.WriteLine();
return(context.Output.ToString());
}
private string GraphToNQuads(ThreadedStoreWriterContext globalContext, NTriplesWriterContext context)
{
if (context.Graph.IsEmpty)
{
return(string.Empty);
}
if (context.PrettyPrint && context.Graph.BaseUri != null)
{
context.Output.WriteLine("# Graph: " + context.Graph.BaseUri.AbsoluteUri);
}
foreach (var t in context.Graph.Triples)
{
context.Output.WriteLine(TripleToNQuads(context, t, context.Graph.BaseUri));
}
context.Output.WriteLine();
return(context.Output.ToString());
}
/// <summary>
/// Thread Worker method which writes Graphs to the output.
/// </summary>
/// <param name="globalContext">Context for writing the Store.</param>
private void SaveGraphs(ThreadedStoreWriterContext globalContext)
{
try
{
while (globalContext.TryGetNextUri(out var u))
{
// Get the Graph from the Store
var g = globalContext.Store.Graphs[u];
// Generate the Graph Output and add to Stream
var context = new NTriplesWriterContext(g, new System.IO.StringWriter(), NQuadsParser.AsNTriplesSyntax(Syntax), globalContext.PrettyPrint, globalContext.HighSpeedModePermitted);
var graphContent = GraphToNQuads(globalContext, context);
if (!graphContent.Equals(String.Empty))
{
try
{
Monitor.Enter(globalContext.Output);
globalContext.Output.WriteLine(graphContent);
globalContext.Output.Flush();
}
catch
{
throw;
}
finally
{
Monitor.Exit(globalContext.Output);
}
}
}
}
catch (ThreadAbortException)
{
// We've been terminated, don't do anything
Thread.ResetAbort();
}
catch (Exception ex)
{
throw new RdfStorageException("Error in Threaded Writer in Thread ID " + Thread.CurrentThread.ManagedThreadId, ex);
}
}
/// <summary>
/// Generates the Output for a Graph as a String in TSV syntax
/// </summary>
/// <param name="globalContext">Context for writing the Store</param>
/// <param name="context">Context for writing the Graph</param>
/// <returns></returns>
private String GenerateGraphOutput(ThreadedStoreWriterContext globalContext, BaseWriterContext context)
{
if (!WriterHelper.IsDefaultGraph(context.Graph.BaseUri))
{
//Named Graphs have a fourth context field added
foreach (Triple t in context.Graph.Triples)
{
this.GenerateNodeOutput(context, t.Subject, TripleSegment.Subject);
context.Output.Write('\t');
this.GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate);
context.Output.Write('\t');
this.GenerateNodeOutput(context, t.Object, TripleSegment.Object);
context.Output.Write('\t');
context.Output.Write('<');
context.Output.Write(this._formatter.FormatUri(context.Graph.BaseUri));
context.Output.Write('>');
context.Output.Write('\n');
}
}
else
{
//Default Graph has an empty field added
foreach (Triple t in context.Graph.Triples)
{
this.GenerateNodeOutput(context, t.Subject, TripleSegment.Subject);
context.Output.Write('\t');
this.GenerateNodeOutput(context, t.Predicate, TripleSegment.Predicate);
context.Output.Write('\t');
this.GenerateNodeOutput(context, t.Object, TripleSegment.Object);
context.Output.Write('\t');
context.Output.Write('\n');
}
}
return(context.Output.ToString());
}
/// <summary>
/// Saves a Triple Store to CSV Format.
/// </summary>
/// <param name="store">Triple 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 writer completes.</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);
// Check there's something to do
if (context.Store.Graphs.Count == 0)
{
if (!leaveOpen)
{
context.Output.Close();
}
return;
}
// Queue the Graphs to be written
foreach (var g in context.Store.Graphs)
{
context.Add(g.BaseUri);
}
// Start making the async calls
var tasks = new List <Task>();
for (var i = 0; i < _threads; i++)
{
tasks.Add(Task.Factory.StartNew(() => SaveGraphs(context)));
}
// Wait for all the async calls to complete
var outputEx = new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("CSV"));
try
{
Task.WaitAll(tasks.ToArray());
}
catch (AggregateException ex)
{
foreach (var innerEx in ex.InnerExceptions)
{
outputEx.AddException(innerEx);
}
}
if (!leaveOpen)
{
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 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 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 workers = new Task[_threads];
for (var i = 0; i < _threads; i++)
{
workers[i] = Task.Factory.StartNew(() => SaveGraphs(context));
}
try
{
Task.WaitAll(workers);
}
catch (AggregateException ex)
{
var outputException =
new RdfThreadedOutputException(WriterErrorMessages.ThreadedOutputFailure("TSV"));
foreach (var innerException in ex.InnerExceptions)
{
outputException.AddException(innerException);
}
}
finally
{
if (!leaveOpen)
{
context.Output.Close();
}
}
}
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 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");
}
}