/// <summary>
/// Loads a RDF dataset from GZipped input
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Store Parameters</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new RdfParseException("Cannot parse RDF Dataset using a null Handler");
}
if (parameters == null)
{
throw new RdfParseException("Cannot parse RDF Dataset from null parameters");
}
if (parameters is StreamParams)
{
StreamParams sp = (StreamParams)parameters;
StreamReader input = sp.StreamReader;
if (input.BaseStream is GZipStream)
{
this._parser.Load(handler, sp);
}
else
{
//Force the inner stream to be GZipped
this._parser.Load(handler, new StreamParams(new GZipStream(input.BaseStream, CompressionMode.Decompress)));
}
}
else
{
throw new RdfParseException("GZip Dataset Parsers can only read from StreamParams instances");
}
}
/// <summary>
/// Saves a RDF Dataset as GZipped output
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Storage Parameters</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (store == null)
{
throw new RdfOutputException("Cannot output a new Triple Store");
}
if (parameters == null)
{
throw new RdfOutputException("Cannot output using null parameters");
}
if (parameters is StreamParams)
{
StreamParams sp = (StreamParams)parameters;
StreamWriter output = sp.StreamWriter;
if (output.BaseStream is GZipStream)
{
this._writer.Save(store, sp);
}
else
{
this._writer.Save(store, new StreamParams(new GZipStream(output.BaseStream, CompressionMode.Compress)));
}
}
else
{
throw new RdfOutputException("GZip Dataset Writers can only write to StreamParams instances");
}
}
/// <summary>
/// Loads Graphs into the store using the settings the Reader was instantiated with
/// </summary>
/// <param name="store">Store to load into</param>
/// <param name="parameters">Parameters indicating where to read from</param>
public void Load(ITripleStore store, IStoreParams parameters)
{
if (store == null)
{
throw new RdfParseException("Cannot read RDF from a Folder Store into a null Triple Store");
}
this.Load(new StoreHandler(store), parameters);
}
/// <summary>
/// Loads a RDF dataset from GZipped input
/// </summary>
/// <param name="store">Triple Store to load into</param>
/// <param name="parameters">Store Parameters</param>
public void Load(ITripleStore store, IStoreParams parameters)
{
if (store == null)
{
throw new RdfParseException("Cannot parse an RDF Dataset into a null store");
}
this.Load(new StoreHandler(store), parameters);
}
/// <summary>
/// Saves a Store in TriX 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 get the TextWriter to output to
TextWriter output = null;
if (parameters is StreamParams)
{
output = ((StreamParams)parameters).StreamWriter;
}
else if (parameters is TextWriterParams)
{
output = ((TextWriterParams)parameters).TextWriter;
}
if (output != null)
{
try
{
//Setup the XML document
XmlWriter writer = XmlWriter.Create(output, this.GetSettings());
writer.WriteStartDocument();
writer.WriteStartElement("TriX", TriXParser.TriXNamespaceURI);
writer.WriteStartAttribute("xmlns");
writer.WriteRaw(TriXParser.TriXNamespaceURI);
writer.WriteEndAttribute();
//Output Graphs as XML <graph> elements
foreach (IGraph g in store.Graphs)
{
this.GraphToTriX(g, writer);
}
//Save the XML to disk
writer.WriteEndDocument();
writer.Close();
output.Close();
}
catch
{
try
{
output.Close();
}
catch
{
//Just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves a Store in TriX 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 get the TextWriter to output to
TextWriter output = null;
if (parameters is StreamParams)
{
output = ((StreamParams)parameters).StreamWriter;
}
else if (parameters is TextWriterParams)
{
output = ((TextWriterParams)parameters).TextWriter;
}
if (output != null)
{
try
{
//Setup the XML document
XmlWriter writer = XmlWriter.Create(output, this.GetSettings());
writer.WriteStartDocument();
writer.WriteStartElement("TriX", TriXParser.TriXNamespaceURI);
writer.WriteStartAttribute("xmlns");
writer.WriteRaw(TriXParser.TriXNamespaceURI);
writer.WriteEndAttribute();
//Output Graphs as XML <graph> elements
foreach (IGraph g in store.Graphs)
{
this.GraphToTriX(g, writer);
}
//Save the XML to disk
writer.WriteEndDocument();
writer.Close();
output.Close();
}
catch
{
try
{
output.Close();
}
catch
{
//Just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Saves the given Triple Store to the Target Store that this class was instantiated with
/// </summary>
/// <param name="store">Store to Save</param>
/// <param name="parameters">Parameters for the Store</param>
public override void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is ThreadedSqlIOParams)
{
//Setup context
ThreadedSqlStoreWriterContext context = new ThreadedSqlStoreWriterContext(store, (ThreadedSqlIOParams)parameters);
bool transSetting = context.Manager.DisableTransactions;
context.Manager.DisableTransactions = true;
//Queue Graphs for Writing
foreach (IGraph g in store.Graphs)
{
context.Add(g);
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
WriteGraphsDelegate d = new WriteGraphsDelegate(this.WriteGraphs);
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);
}
}
//Reset Transactions setting
context.Manager.DisableTransactions = transSetting;
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any())
{
throw outputEx;
}
}
else
{
throw new RdfStorageException("Parameters for the ThreadedSQLStoreWriter must be of type ThreadedSQLIOParams");
}
}
/// <summary>
/// Saves the given Triple Store to an arbitrary store
/// </summary>
/// <param name="store">Store to Save</param>
/// <param name="parameters">Parameters for the Store</param>
/// <remarks>
/// Parameters must be of type <see cref="GenericIOParams">GenericIOParams</see>
/// </remarks>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is GenericIOParams)
{
//Create the Writer Context
GenericStoreWriterContext context = new GenericStoreWriterContext(store, (GenericIOParams)parameters);
//Queue Graphs for Writing
foreach (IGraph g in store.Graphs)
{
context.Add(g.BaseUri);
}
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
WriteGraphsDelegate d = new WriteGraphsDelegate(this.WriteGraphs);
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("TSV"));
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 GenericStoreWriter must be of type GenericIOParams");
}
}
/// <summary>
/// Saves the given Triple Store to the SQL Store that this class was instantiated with
/// </summary>
/// <param name="store">Store you wish to Save</param>
/// <param name="parameters">Parameters for the Store</param>
public virtual void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is ISQLIOParams)
{
SqlIOParams writeParams = (SqlIOParams)parameters;
writeParams.Manager.PreserveState = true;
SqlWriter writer = new SqlWriter(writeParams.Manager);
foreach (IGraph g in store.Graphs)
{
writer.Save(g, writeParams.ClearIfExists);
}
}
else
{
throw new RdfStorageException("Parameters for the SQLStoreWriter must implement the interface ISQLIOParams");
}
}
/// <summary>
/// Saves the given Triple Store to the SQL Store that this class was instantiated with
/// </summary>
/// <param name="store">Store you wish to Save</param>
/// <param name="parameters">Parameters for the Store</param>
public virtual void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is ISQLIOParams)
{
SqlIOParams writeParams = (SqlIOParams)parameters;
writeParams.Manager.PreserveState = true;
SqlWriter writer = new SqlWriter(writeParams.Manager);
foreach (IGraph g in store.Graphs)
{
writer.Save(g, writeParams.ClearIfExists);
}
}
else
{
throw new RdfStorageException("Parameters for the SQLStoreWriter must implement the interface ISQLIOParams");
}
}
/// <summary>
/// Saves the given Triple Store to an arbitrary store
/// </summary>
/// <param name="store">Store to Save</param>
/// <param name="parameters">Parameters for the Store</param>
/// <remarks>
/// Parameters must be of type <see cref="GenericIOParams">GenericIOParams</see>
/// </remarks>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is GenericIOParams)
{
//Create the Writer Context
GenericStoreWriterContext context = new GenericStoreWriterContext(store, (GenericIOParams)parameters);
//Queue Graphs for Writing
foreach (IGraph g in store.Graphs)
{
context.Add(g.BaseUri);
}
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
WriteGraphsDelegate d = new WriteGraphsDelegate(this.WriteGraphs);
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("TSV"));
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 GenericStoreWriter must be of type GenericIOParams");
}
}
/// <summary>
/// Loads the named Graphs from the TriG input using the given RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the input to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null) throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
if (parameters == null) throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
//Issue a Warning if the Encoding of the Stream is not UTF-8
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.UTF8))
{
#if !SILVERLIGHT
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
#else
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.GetType().Name + " - Please be aware that parsing errors may occur as a result");
#endif
}
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
try
{
//Create the Parser Context and Invoke the Parser
TriGParserContext context = new TriGParserContext(handler, new TriGTokeniser(input), TokenQueueMode.SynchronousBufferDuringParsing, false, this._tracetokeniser);
this.Parse(context);
}
catch
{
throw;
}
finally
{
try
{
input.Close();
}
catch
{
//No catch actions just cleaning up
}
}
}
else
{
throw new RdfStorageException("Parameters for the TriGParser must be of the type StreamParams/TextReaderParams");
}
}
/// <summary>
/// Loads the RDF Dataset from the TriX input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the input to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null) throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
if (parameters == null) throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
//Issue a Warning if the Encoding of the Stream is not UTF-8
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.UTF8))
{
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
}
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
//First try and load as XML and apply any stylesheets
try
{
XmlDocument doc = new XmlDocument();
doc.Load(input);
input.Close();
XmlDocument inputDoc = new XmlDocument();
bool inputReady = false;
//If XSL isn't supported we can't apply it
#if !NO_XSL
//Try and apply any stylesheets (which are used to extend TriX) to get basic TriX syntax
foreach (XmlNode child in doc.ChildNodes)
{
if (child.NodeType == XmlNodeType.ProcessingInstruction)
{
if (child.Name == "xml-stylesheet")
{
//Load in the XML a 2nd time so we can transform it properly if needed
if (!inputReady)
{
inputDoc.LoadXml(doc.OuterXml);
inputReady = true;
}
Regex getStylesheetURI = new Regex("href=\"([^\"]+)\"");
String stylesheetUri = getStylesheetURI.Match(child.Value).Groups[1].Value;
//Load the Transform
XslCompiledTransform transform = new XslCompiledTransform();
XsltSettings settings = new XsltSettings();
transform.Load(stylesheetUri, settings, null);
//Apply the Transform
MemoryStream temp = new MemoryStream();
transform.Transform(inputDoc, XmlWriter.Create(temp));
temp.Flush();
temp.Seek(0, SeekOrigin.Begin);
inputDoc.Load(temp);
}
}
}
#endif
//Start parsing
if (!inputReady) inputDoc = doc;
this.TryParseGraphset(inputDoc, handler);
input.Close();
}
catch (XmlException xmlEx)
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
//Wrap in a RDF Parse Exception
throw new RdfParseException("Unable to Parse this TriX since System.Xml was unable to parse the document into a DOM Tree, see the inner exception for details", xmlEx);
}
catch
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXParser must be of the type StreamParams/TextReaderParams");
}
}
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null) throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
if (parameters == null) throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
//First try and load as XML and apply any stylesheets
try
{
//Get the reader and start parsing
XmlReader reader = XmlReader.Create(input, this.GetSettings());
this.RaiseWarning("The TriX Parser is operating without XSL support, if your TriX file requires XSL then it will not be parsed successfully");
this.TryParseGraphset(reader, handler);
input.Close();
}
catch (XmlException xmlEx)
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
//Wrap in a RDF Parse Exception
throw new RdfParseException("Unable to Parse this TriX since the XmlReader encountered an error, see the inner exception for details", xmlEx);
}
catch
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXParser must be of the type StreamParams/TextReaderParams");
}
}
/// <summary>
/// Loads RDF using the RDF Handler using the settings the Reader was instantiated with
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating where to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (parameters is FolderStoreParams)
{
//Create the Parser Context
FolderStoreParserContext context = new FolderStoreParserContext(handler, (FolderStoreParams)parameters);
//Create the Folder
if (!Directory.Exists(context.Folder))
{
throw new RdfStorageException("Cannot read a Folder Store from a Folder that doesn't exist");
}
//Read list of Graphs and Queue Filenames of Graphs for reading by the Threads
StreamReader graphlist = new StreamReader(Path.Combine(context.Folder, "graphs.fstore"));
//First line contains format information
String ext = graphlist.ReadLine();
if (context.Format == FolderStoreFormat.AutoDetect)
{
if (ext.Equals(".ttl"))
{
context.Format = FolderStoreFormat.Turtle;
}
else if (ext.Equals(".n3"))
{
context.Format = FolderStoreFormat.Notation3;
}
else if (ext.Equals(".rdf"))
{
context.Format = FolderStoreFormat.RdfXml;
}
else
{
throw new RdfStorageException("Folder Store Format auto-detection failed");
}
}
String file;
while (!graphlist.EndOfStream)
{
file = graphlist.ReadLine();
if (!file.Equals(String.Empty))
{
context.Add(file);
}
}
graphlist.Close();
//Start making the async calls
List <IAsyncResult> results = new List <IAsyncResult>();
LoadGraphsDelegate d = new LoadGraphsDelegate(this.LoadGraphs);
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());
RdfThreadedParsingException parsingEx = new RdfThreadedParsingException("One/more errors occurred while parsing RDF from a Folder Store using a multi-threaded parsing process");
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
parsingEx.AddException(ex);
}
}
//If there were any errors we'll throw an RdfThreadedOutputException now
if (parsingEx.InnerExceptions.Any())
{
throw parsingEx;
}
}
else
{
throw new RdfStorageException("Parameters for the FolderStoreReader must be of type FolderStoreParams");
}
}
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
}
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
//First try and load as XML and apply any stylesheets
try
{
//Get the reader and start parsing
XmlReader reader = XmlReader.Create(input, this.GetSettings());
this.RaiseWarning("The TriX Parser is operating without XSL support, if your TriX file requires XSL then it will not be parsed successfully");
this.TryParseGraphset(reader, handler);
input.Close();
}
catch (XmlException xmlEx)
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
//Wrap in a RDF Parse Exception
throw new RdfParseException("Unable to Parse this TriX since the XmlReader encountered an error, see the inner exception for details", xmlEx);
}
catch
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXParser must be of the type StreamParams/TextReaderParams");
}
}
/// <summary>
/// Loads RDF using the RDF Handler using the settings the Reader was instantiated with
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating where to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (parameters is FolderStoreParams)
{
//Create the Parser Context
FolderStoreParserContext context = new FolderStoreParserContext(handler, (FolderStoreParams)parameters);
//Create the Folder
if (!Directory.Exists(context.Folder))
{
throw new RdfStorageException("Cannot read a Folder Store from a Folder that doesn't exist");
}
//Read list of Graphs and Queue Filenames of Graphs for reading by the Threads
StreamReader graphlist = new StreamReader(Path.Combine(context.Folder, "graphs.fstore"));
//First line contains format information
String ext = graphlist.ReadLine();
if (context.Format == FolderStoreFormat.AutoDetect)
{
if (ext.Equals(".ttl"))
{
context.Format = FolderStoreFormat.Turtle;
}
else if (ext.Equals(".n3"))
{
context.Format = FolderStoreFormat.Notation3;
}
else if (ext.Equals(".rdf"))
{
context.Format = FolderStoreFormat.RdfXml;
}
else
{
throw new RdfStorageException("Folder Store Format auto-detection failed");
}
}
String file;
while (!graphlist.EndOfStream)
{
file = graphlist.ReadLine();
if (!file.Equals(String.Empty))
{
context.Add(file);
}
}
graphlist.Close();
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
LoadGraphsDelegate d = new LoadGraphsDelegate(this.LoadGraphs);
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());
RdfThreadedParsingException parsingEx = new RdfThreadedParsingException("One/more errors occurred while parsing RDF from a Folder Store using a multi-threaded parsing process");
foreach (IAsyncResult result in results)
{
try
{
d.EndInvoke(result);
}
catch (Exception ex)
{
parsingEx.AddException(ex);
}
}
//If there were any errors we'll throw an RdfThreadedOutputException now
if (parsingEx.InnerExceptions.Any()) throw parsingEx;
}
else
{
throw new RdfStorageException("Parameters for the FolderStoreReader must be of type FolderStoreParams");
}
}
/// <summary>
/// Loads the RDF Dataset from the TriX input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the input to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
}
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
//Issue a Warning if the Encoding of the Stream is not UTF-8
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.UTF8))
{
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
}
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
//First try and load as XML and apply any stylesheets
try
{
XmlDocument doc = new XmlDocument();
doc.Load(input);
input.Close();
XmlDocument inputDoc = new XmlDocument();
bool inputReady = false;
//If XSL isn't supported we can't apply it
#if !NO_XSL
//Try and apply any stylesheets (which are used to extend TriX) to get basic TriX syntax
foreach (XmlNode child in doc.ChildNodes)
{
if (child.NodeType == XmlNodeType.ProcessingInstruction)
{
if (child.Name == "xml-stylesheet")
{
//Load in the XML a 2nd time so we can transform it properly if needed
if (!inputReady)
{
inputDoc.LoadXml(doc.OuterXml);
inputReady = true;
}
Regex getStylesheetURI = new Regex("href=\"([^\"]+)\"");
String stylesheetUri = getStylesheetURI.Match(child.Value).Groups[1].Value;
//Load the Transform
XslCompiledTransform transform = new XslCompiledTransform();
XsltSettings settings = new XsltSettings();
transform.Load(stylesheetUri, settings, null);
//Apply the Transform
MemoryStream temp = new MemoryStream();
transform.Transform(inputDoc, XmlWriter.Create(temp));
temp.Flush();
temp.Seek(0, SeekOrigin.Begin);
inputDoc.Load(temp);
}
}
}
#endif
//Start parsing
if (!inputReady)
{
inputDoc = doc;
}
this.TryParseGraphset(inputDoc, handler);
input.Close();
}
catch (XmlException xmlEx)
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
//Wrap in a RDF Parse Exception
throw new RdfParseException("Unable to Parse this TriX since System.Xml was unable to parse the document into a DOM Tree, see the inner exception for details", xmlEx);
}
catch
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXParser must be of the type StreamParams/TextReaderParams");
}
}
/// <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>
/// Loads a RDF Dataset from the NQuads input into the given Triple Store
/// </summary>
/// <param name="store">Triple Store to load into</param>
/// <param name="parameters">Parameters indicating the Stream to read from</param>
public void Load(ITripleStore store, IStoreParams parameters)
{
if (store == null) throw new RdfParseException("Cannot read a RDF dataset into a null Store");
this.Load(new StoreHandler(store), parameters);
}
/// <summary>
/// Saves a Triple Store to CSV 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>();
SaveGraphsDeletegate d = new SaveGraphsDeletegate(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("CSV"));
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 CsvStoreWriter must be of the type StreamParams/TextWriterParams");
}
}
/// <summary>
/// Loads a RDF Dataset from the NQuads input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the Stream to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
}
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
#if !SILVERLIGHT
//Issue a Warning if the Encoding of the Stream is not ASCII
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.ASCII))
{
this.RaiseWarning("Expected Input Stream to be encoded as ASCII but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
}
#endif
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
try
{
//Setup Token Queue and Tokeniser
NTriplesTokeniser tokeniser = new NTriplesTokeniser(input);
tokeniser.NQuadsMode = true;
TokenQueue tokens = new TokenQueue();
tokens.Tokeniser = tokeniser;
tokens.Tracing = this._tracetokeniser;
tokens.InitialiseBuffer();
//Invoke the Parser
this.Parse(handler, tokens);
}
catch
{
throw;
}
finally
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
}
}
else
{
throw new RdfStorageException("Parameters for the NQuadsParser must be of the type StreamParams/TextReaderParams");
}
}
/// <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>
/// Loads a RDF dataset from GZipped input
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Store Parameters</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null) throw new RdfParseException("Cannot parse RDF Dataset using a null Handler");
if (parameters == null) throw new RdfParseException("Cannot parse RDF Dataset from null parameters");
if (parameters is StreamParams)
{
StreamParams sp = (StreamParams)parameters;
StreamReader input = sp.StreamReader;
if (input.BaseStream is GZipStream)
{
this._parser.Load(handler, sp);
}
else
{
//Force the inner stream to be GZipped
this._parser.Load(handler, new StreamParams(new GZipStream(input.BaseStream, CompressionMode.Decompress)));
}
}
else
{
throw new RdfParseException("GZip Dataset Parsers can only read from StreamParams instances");
}
}
/// <summary>
/// Saves a RDF Dataset as GZipped output
/// </summary>
/// <param name="store">Store to save</param>
/// <param name="parameters">Storage Parameters</param>
public void Save(ITripleStore store, IStoreParams parameters)
{
if (store == null) throw new RdfOutputException("Cannot output a new Triple Store");
if (parameters == null) throw new RdfOutputException("Cannot output using null parameters");
if (parameters is StreamParams)
{
StreamParams sp = (StreamParams)parameters;
StreamWriter output = sp.StreamWriter;
if (output.BaseStream is GZipStream)
{
this._writer.Save(store, sp);
}
else
{
this._writer.Save(store, new StreamParams(new GZipStream(output.BaseStream, CompressionMode.Compress)));
}
}
else
{
throw new RdfOutputException("GZip Dataset Writers can only write to StreamParams instances");
}
}
/// <summary>
/// Saves the given Triple Store to the Target Store that this class was instantiated with
/// </summary>
/// <param name="store">Store to Save</param>
/// <param name="parameters">Parameters for the Store</param>
public override void Save(ITripleStore store, IStoreParams parameters)
{
if (parameters is ThreadedSqlIOParams)
{
//Setup context
ThreadedSqlStoreWriterContext context = new ThreadedSqlStoreWriterContext(store, (ThreadedSqlIOParams)parameters);
bool transSetting = context.Manager.DisableTransactions;
context.Manager.DisableTransactions = true;
//Queue Graphs for Writing
foreach (IGraph g in store.Graphs)
{
context.Add(g);
}
//Start making the async calls
List<IAsyncResult> results = new List<IAsyncResult>();
WriteGraphsDelegate d = new WriteGraphsDelegate(this.WriteGraphs);
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);
}
}
//Reset Transactions setting
context.Manager.DisableTransactions = transSetting;
//If there were any errors we'll throw an RdfThreadedOutputException now
if (outputEx.InnerExceptions.Any()) throw outputEx;
}
else
{
throw new RdfStorageException("Parameters for the ThreadedSQLStoreWriter must be of type ThreadedSQLIOParams");
}
}
/// <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 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>
/// Loads a RDF Dataset from the NQuads input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the Stream to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null) throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
if (parameters == null) throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
#if !SILVERLIGHT
//Issue a Warning if the Encoding of the Stream is not ASCII
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.ASCII))
{
this.RaiseWarning("Expected Input Stream to be encoded as ASCII but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
}
#endif
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
try
{
//Setup Token Queue and Tokeniser
NTriplesTokeniser tokeniser = new NTriplesTokeniser(input);
tokeniser.NQuadsMode = true;
TokenQueue tokens = new TokenQueue();
tokens.Tokeniser = tokeniser;
tokens.Tracing = this._tracetokeniser;
tokens.InitialiseBuffer();
//Invoke the Parser
this.Parse(handler, tokens);
}
catch
{
throw;
}
finally
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
}
}
else
{
throw new RdfStorageException("Parameters for the NQuadsParser must be of the type StreamParams/TextReaderParams");
}
}
/// <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>
/// Loads the named Graphs from the TriG input using the given RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the input to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
}
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
//Issue a Warning if the Encoding of the Stream is not UTF-8
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.UTF8))
{
#if !SILVERLIGHT
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
#else
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.GetType().Name + " - Please be aware that parsing errors may occur as a result");
#endif
}
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
try
{
//Create the Parser Context and Invoke the Parser
TriGParserContext context = new TriGParserContext(handler, new TriGTokeniser(input), TokenQueueMode.SynchronousBufferDuringParsing, false, this._tracetokeniser);
this.Parse(context);
}
catch
{
throw;
}
finally
{
try
{
input.Close();
}
catch
{
//No catch actions just cleaning up
}
}
}
else
{
throw new RdfStorageException("Parameters for the TriGParser must be of the type StreamParams/TextReaderParams");
}
}
/// <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>
/// Loads Graphs into the store using the settings the Reader was instantiated with
/// </summary>
/// <param name="store">Store to load into</param>
/// <param name="parameters">Parameters indicating where to read from</param>
public void Load(ITripleStore store, IStoreParams parameters)
{
if (store == null) throw new RdfParseException("Cannot read RDF from a Folder Store into a null Triple Store");
this.Load(new StoreHandler(store), parameters);
}
