public void RunConvert(String[] args)
{
//Set the Options
if (!this.SetOptions(args))
{
//If SetOptions returns false then some options were invalid and errors have been output to the error stream
return;
}
//First grab the MIME Type Definitions for the conversion
List <MimeTypeDefinition> defs = MimeTypesHelper.GetDefinitions(this._outFormats).ToList();
//Process each input to determine the Conversion Handler to use
foreach (IConversionInput input in this._inputs)
{
String outFile;
String ext = this._outExt;
//First determine the writer we'll use
MimeTypeDefinition graphDef = defs.FirstOrDefault(d => d.CanWriteRdf);
if (graphDef != null)
{
//Then generate the output filename
if (ext.Equals(String.Empty))
{
ext = "." + graphDef.CanonicalFileExtension;
}
if (this._inputs.Count == 1 && !this._outputFilename.Equals(String.Empty))
{
outFile = this._outputFilename;
}
else
{
outFile = input.GetFilename(this._outputFilename, ext);
}
//Check it doesn't already exist or overwrite is enabled
if (File.Exists(outFile) && !this._overwrite)
{
Console.Error.WriteLine("rdfConvert: Warning: Skipping Conversion of Input " + input.ToString() + " as this would generate the Output File '" + outFile + "' which already exists and the -overwrite option was not specified");
continue;
}
//Get the Writer and apply Conversion Options
IRdfWriter writer = graphDef.GetRdfWriter();
foreach (IConversionOption option in this._options)
{
option.Apply(writer);
}
//If -best always use SaveOnCompletionHandler
if (this._best)
{
if (this._verbose)
{
Console.WriteLine("rdfConvert: Using Best Quality data conversion subject to user specified compression options");
}
input.ConversionHandler = new SaveOnCompletionHandler(writer, new StreamWriter(outFile, false, graphDef.Encoding));
}
else
{
//Use the fast WriteThroughHandler where possible
if (writer is IFormatterBasedWriter)
{
if (this._verbose)
{
Console.WriteLine("rdfConvert: Using Streaming Conversion with formatter " + ((IFormatterBasedWriter)writer).TripleFormatterType.Name);
}
input.ConversionHandler = new WriteToFileHandler(outFile, graphDef.Encoding, ((IFormatterBasedWriter)writer).TripleFormatterType);
}
else
{
//Can't use it in this case
if (this._verbose)
{
Console.WriteLine("rdfConvert: Warning: Target Format not suitable for streaming conversion, input data will be loaded into memory prior to conversion");
}
input.ConversionHandler = new SaveOnCompletionHandler(writer, new StreamWriter(outFile, false, graphDef.Encoding));
}
}
}
else
{
MimeTypeDefinition storeDef = defs.FirstOrDefault(d => d.CanWriteRdfDatasets);
if (storeDef != null)
{
//Then generate the output filename
if (ext.Equals(String.Empty))
{
ext = "." + storeDef.CanonicalFileExtension;
}
outFile = input.GetFilename(this._outputFilename, ext);
//Get the Writer and apply conversion options
IStoreWriter writer = storeDef.GetRdfDatasetWriter();
foreach (IConversionOption option in this._options)
{
option.Apply(writer);
}
//If -best always use SaveOnCompletionHandler
if (this._best)
{
if (this._verbose)
{
Console.WriteLine("rdfConvert: Using Best Quality data conversion subject to user specified compression options");
}
input.ConversionHandler = new SaveStoreOnCompletionHandler(writer, new StreamWriter(outFile, false, storeDef.Encoding));
}
else
{
//Use the fast WriteThroughHandler where possible
if (writer is IFormatterBasedWriter)
{
if (this._verbose)
{
Console.WriteLine("rdfConvert: Using Streaming Conversion with formatter " + ((IFormatterBasedWriter)writer).TripleFormatterType.Name);
}
input.ConversionHandler = new WriteToFileHandler(outFile, graphDef.Encoding, ((IFormatterBasedWriter)writer).TripleFormatterType);
}
else
{
if (this._verbose)
{
Console.WriteLine("rdfConvert: Warning: Target Format not suitable for streaming conversion, input data will be loaded into memory prior to conversion");
}
input.ConversionHandler = new SaveStoreOnCompletionHandler(writer, new StreamWriter(outFile, false, storeDef.Encoding));
}
}
}
else
{
Console.Error.WriteLine("rdfConvert: Warning: Skipping Conversion of Input " + input.ToString() + " as unable to determine how to convert it");
continue;
}
}
//Then do the Conversion
Console.WriteLine("rdfConvert: Converting Input " + input.ToString() + " to '" + outFile + "'...");
try
{
if (this._verbose)
{
input.ConversionHandler = new ConversionProgressHandler(input.ConversionHandler);
Console.WriteLine("rdfConvert: Debug: Conversion Handler is " + input.ConversionHandler.GetType().FullName);
}
input.Convert();
Console.WriteLine("rdfConvert: Converted Input " + input.ToString() + " to '" + outFile + "' OK");
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfConvert: Error: Error Converting Input " + input.ToString() + " due to a RDF Parse Exception");
Console.Error.WriteLine(parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
}
catch (RdfException rdfEx)
{
Console.Error.WriteLine("rdfConvert: Error: Error Converting Input " + input.ToString() + " due to a RDF Exception");
Console.Error.WriteLine(rdfEx.Message);
if (this._debug)
{
this.DebugErrors(rdfEx);
}
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfConvert: Error: Error Converting Input " + input.ToString() + " due to a Unexpected Exception");
Console.Error.WriteLine(ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
}
}
}
/// <summary>
/// Runs the task
/// </summary>
/// <returns></returns>
protected override TaskResult RunTaskInternal()
{
MimeTypeDefinition def = MimeTypesHelper.GetDefinitionsByFileExtension(MimeTypesHelper.GetTrueFileExtension(this._file)).FirstOrDefault(d => d.CanWriteRdfDatasets);
if (def == null)
{
throw new RdfOutputException("Cannot Export the Store to the selected File since dotNetRDF was unable to select a writer to use based on the File Extension");
}
IStoreWriter writer = def.GetRdfDatasetWriter();
if (writer is IMultiThreadedWriter)
{
((IMultiThreadedWriter)writer).UseMultiThreadedWriting = false;
}
TripleStore store = new TripleStore();
if (writer is TriXWriter)
{
//For TriX must load all into memory and then write out all at once
foreach (Uri u in this.ListGraphs())
{
Graph g = new Graph();
this._manager.LoadGraph(g, u);
g.BaseUri = u;
store.Add(g);
this.Information = "Loading into memory prior to export, loaded " + store.Graphs.Sum(x => x.Triples.Count) + " Triple(s) in " + store.Graphs.Count + " Graph(s) so far...";
if (this.HasBeenCancelled)
{
this.Information = "Export Cancelled";
return(new TaskResult(true));
}
}
this.Information = "Exporting Data all at once, have " + store.Graphs.Sum(x => x.Triples.Count) + " Triple(s) in " + store.Graphs.Count + " Graph(s) to export...";
writer.Save(store, new StreamWriter(this._file));
this.Information = "Exported " + store.Graphs.Sum(x => x.Triples.Count) + " Triple(s) in " + store.Graphs.Count + " Graph(s)";
}
else
{
if (File.Exists(this._file))
{
File.Delete(this._file);
}
//For non-TriX formats assume it is safe to append one Graph at a time to the file
int graphCount = 0, tripleCount = 0;
foreach (Uri u in this.ListGraphs())
{
using (FileStream stream = new FileStream(this._file, FileMode.Append))
{
if (writer is IFormatterBasedWriter)
{
//Stream via a WriteThroughHandler
this.Information = "Stream Exporting Graph " + (u != null ? u.AbsoluteUri : "Default");
WriteThroughHandler handler = new WriteThroughHandler(((IFormatterBasedWriter)writer).TripleFormatterType, new StreamWriter(stream), true);
ExportProgressHandler progHandler = new ExportProgressHandler(handler, this, tripleCount);
this._manager.LoadGraph(progHandler, u);
graphCount++;
tripleCount = progHandler.TripleCount;
this.Information = "Finished Stream Exporting Graph " + (u != null ? u.AbsoluteUri : "Default") + ", exported " + tripleCount + " Triple(s) in " + graphCount + " Graph(s) so far...";
}
else
{
//Load Graph into memory
Graph g = new Graph();
g.BaseUri = u;
this.Information = "Loading Graph " + (u != null ? u.AbsoluteUri : "Default");
this._manager.LoadGraph(g, u);
g.BaseUri = u;
if (this.HasBeenCancelled)
{
stream.Close();
this.Information = "Export Cancelled, exported " + tripleCount + " Triple(s) in " + graphCount + " Graph(s)";
return(new TaskResult(true));
}
graphCount++;
tripleCount += g.Triples.Count;
//Save it
store.Add(g);
writer.Save(store, new StreamWriter(stream, def.Encoding));
store.Remove(u);
this.Information = "Exporting Data graph by graph, exported " + tripleCount + " Triple(s) in " + graphCount + " Graph(s) so far...";
}
//Check for cancellation
if (this.HasBeenCancelled)
{
stream.Close();
this.Information = "Export Cancelled, exported " + tripleCount + " Triple(s) in " + graphCount + " Graph(s)";
return(new TaskResult(true));
}
}
}
this.Information = "Exported " + tripleCount + " Triple(s) in " + graphCount + " Graph(s)";
}
return(new TaskResult(true));
}
