public void RunVocab(String[] args)
{
if (args.Length < 2)
{
Console.Error.WriteLine("rdfWebDeploy: Error: 2 Arguments are required in order to use the -vocab mode");
return;
}
if (File.Exists(args[1]))
{
Console.Error.WriteLine("rdfWebDeploy: Error: Cannot output the configuration vocabulary to " + args[1] + " as a file already exists at that location");
return;
}
TurtleParser ttlparser = new TurtleParser();
StreamReader reader = new StreamReader(Assembly.GetAssembly(typeof(IGraph)).GetManifestResourceStream("VDS.RDF.Configuration.configuration.ttl"));
Graph g = new Graph();
ttlparser.Load(g, reader);
IRdfWriter writer;
try
{
writer = MimeTypesHelper.GetWriterByFileExtension(MimeTypesHelper.GetTrueFileExtension(args[1]));
}
catch (RdfWriterSelectionException)
{
writer = new CompressingTurtleWriter(WriterCompressionLevel.High);
}
writer.Save(g, args[1]);
Console.WriteLine("rdfWebDeploy: Configuration Vocabulary output to " + args[1]);
}
public void Run()
{
if (this._args.Length == 0)
{
this.ShowUsage();
}
else
{
if (!this.ParseOptions())
{
Console.Error.WriteLine("rdfOptStats: Error: One/More options were invalid");
return;
}
if (this._inputs.Count == 0)
{
Console.Error.WriteLine("rdfOptStats: Error: No Inputs Specified");
return;
}
List <BaseStatsHandler> handlers = new List <BaseStatsHandler>();
if (this._subjects && this._predicates && this._objects)
{
handlers.Add(new SPOStatsHandler(this._literals));
}
else if (this._subjects && this._predicates)
{
handlers.Add(new SPStatsHandler(this._literals));
}
else
{
if (this._subjects)
{
handlers.Add(new SubjectStatsHandler(this._literals));
}
if (this._predicates)
{
handlers.Add(new PredicateStatsHandler(this._literals));
}
if (this._objects)
{
handlers.Add(new ObjectStatsHandler(this._literals));
}
}
if (this._nodes)
{
handlers.Add(new NodeStatsHandler());
}
bool ok = true;
IRdfHandler handler;
if (handlers.Count == 1)
{
handler = handlers[0];
}
else
{
handler = new MultiHandler(handlers.OfType <IRdfHandler>());
}
Stopwatch timer = new Stopwatch();
timer.Start();
for (int i = 0; i < this._inputs.Count; i++)
{
Console.WriteLine("rdfOptStats: Processing Input " + (i + 1) + " of " + this._inputs.Count + " - '" + this._inputs[i] + "'");
try
{
FileLoader.Load(handler, this._inputs[i]);
}
catch (RdfParserSelectionException selEx)
{
ok = false;
Console.Error.WriteLine("rdfOptStats: Error: Unable to select a Parser to read input");
break;
}
catch (RdfParseException parseEx)
{
ok = false;
Console.Error.WriteLine("rdfOptStats: Error: Parsing Error while reading input");
break;
}
catch (RdfException parseEx)
{
ok = false;
Console.Error.WriteLine("rdfOptStats: Error: RDF Error while reading input");
break;
}
catch (Exception ex)
{
ok = false;
Console.Error.WriteLine("rdfOptStats: Error: Unexpected Error while reading input");
break;
}
}
Console.WriteLine("rdfOptStats: Finished Processing Inputs");
timer.Stop();
Console.WriteLine("rdfOptStats: Took " + timer.Elapsed + " to process inputs");
timer.Reset();
if (ok)
{
//Output the Stats
timer.Start();
Graph g = new Graph();
g.NamespaceMap.Import(handlers.First().Namespaces);
try
{
foreach (BaseStatsHandler h in handlers)
{
h.GetStats(g);
}
IRdfWriter writer = MimeTypesHelper.GetWriterByFileExtension(MimeTypesHelper.GetTrueFileExtension(this._file));
if (writer is ICompressingWriter)
{
((ICompressingWriter)writer).CompressionLevel = WriterCompressionLevel.High;
}
if (writer is IHighSpeedWriter)
{
((IHighSpeedWriter)writer).HighSpeedModePermitted = false;
}
writer.Save(g, this._file);
Console.WriteLine("rdfOptStats: Statistics output to " + this._file);
timer.Stop();
Console.WriteLine("rdfOptStats: Took " + timer.Elapsed + " to output statistics");
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfOptStats: Error: Unexpected error outputting statistics to " + this._file);
Console.Error.WriteLine(ex.Message);
Console.Error.WriteLine(ex.StackTrace);
}
}
else
{
Console.Error.WriteLine("rdfOptStats: Error: Unable to output statistics due to errors during input processing");
}
}
}
private void mnuSaveConnection_Click(object sender, EventArgs e)
{
if (this.ActiveMdiChild != null)
{
if (this.ActiveMdiChild is StoreManagerForm)
{
Object manager;
if (this.ActiveMdiChild is StoreManagerForm)
{
manager = ((StoreManagerForm)this.ActiveMdiChild).Manager;
}
else
{
return;
}
if (manager is IConfigurationSerializable)
{
this.sfdConnection.Filter = MimeTypesHelper.GetFilenameFilter(true, false, false, false, false, false);
if (this.sfdConnection.ShowDialog() == DialogResult.OK)
{
//Append to existing configuration file or overwrite?
ConfigurationSerializationContext context;
if (File.Exists(this.sfdConnection.FileName))
{
DialogResult result = MessageBox.Show("The selected connection file already exists - would you like to append this connection to that file? Click Yes to append to this file, No to overwrite and Cancel to abort", "Append Connection?", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
switch (result)
{
case DialogResult.Yes:
Graph g = new Graph();
FileLoader.Load(g, this.sfdConnection.FileName);
context = new ConfigurationSerializationContext(g);
break;
case DialogResult.No:
context = new ConfigurationSerializationContext();
break;
default:
return;
}
}
else
{
//Create new configuration file
context = new ConfigurationSerializationContext();
}
//Save the Connection
((IConfigurationSerializable)manager).SerializeConfiguration(context);
try
{
IRdfWriter writer = MimeTypesHelper.GetWriterByFileExtension(MimeTypesHelper.GetTrueFileExtension(this.sfdConnection.FileName));
writer.Save(context.Graph, this.sfdConnection.FileName);
}
catch (RdfWriterSelectionException)
{
CompressingTurtleWriter ttlwriter = new CompressingTurtleWriter(WriterCompressionLevel.High);
ttlwriter.Save(context.Graph, this.sfdConnection.FileName);
}
}
}
else
{
MessageBox.Show("Unable to save the current connection as it does not support this feature", "Save Unavailable", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
private bool SetOptions(String[] args)
{
if (args.Length == 0 || args.Length == 1 && args[0].Equals("-help"))
{
this.ShowUsage();
return(false);
}
String arg;
int i = 0;
while (i < args.Length)
{
arg = args[i];
if (arg.StartsWith("-uri:"))
{
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify input URIs as well as specifying a remote endpoint to query");
return(false);
}
String uri = arg.Substring(5);
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given URI
if (!this._print)
{
Uri u = new Uri(uri);
Graph g = new Graph();
UriLoader.Load(g, u);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' since this is not a valid URI");
if (this._debug)
{
this.DebugErrors(uriEx);
}
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the input URI '" + uri + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
}
}
else if (arg.StartsWith("-endpoint:"))
{
if (this._mode == RdfQueryMode.Local)
{
Console.Error.WriteLine("rdfQuery: Cannot specify a remote endpoint to query as well as specifying local files and/or input URIs");
return(false);
}
else if (this._mode == RdfQueryMode.Remote)
{
if (!(this._endpoint is FederatedSparqlRemoteEndpoint))
{
this._endpoint = new FederatedSparqlRemoteEndpoint(this._endpoint);
}
}
try
{
this._mode = RdfQueryMode.Remote;
if (this._endpoint is FederatedSparqlRemoteEndpoint)
{
((FederatedSparqlRemoteEndpoint)this._endpoint).AddEndpoint(new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1))));
}
else
{
this._endpoint = new SparqlRemoteEndpoint(new Uri(arg.Substring(arg.IndexOf(':') + 1)));
}
}
catch (UriFormatException uriEx)
{
Console.Error.WriteLine("rdfQuery: Unable to use remote endpoint with URI '" + arg.Substring(arg.IndexOf(':') + 1) + "' since this is not a valid URI");
if (this._debug)
{
this.DebugErrors(uriEx);
}
return(false);
}
}
else if (arg.StartsWith("-output:") || arg.StartsWith("-out:"))
{
this._output = arg.Substring(arg.IndexOf(':') + 1);
}
else if (arg.StartsWith("-outformat:"))
{
String format = arg.Substring(arg.IndexOf(':') + 1);
try
{
if (format.Contains("/"))
{
//MIME Type
this._graphWriter = MimeTypesHelper.GetWriter(format);
this._resultsWriter = MimeTypesHelper.GetSparqlWriter(format);
}
else
{
//File Extension
this._graphWriter = MimeTypesHelper.GetWriterByFileExtension(format);
this._resultsWriter = MimeTypesHelper.GetSparqlWriterByFileExtension(format);
}
}
catch (RdfException)
{
Console.Error.WriteLine("rdfQuery: The file extension '" + format + "' could not be used to determine a MIME Type and select a writer - default writers will be used");
}
}
else if (arg.StartsWith("-syntax"))
{
if (arg.Contains(':'))
{
String syntax = arg.Substring(arg.IndexOf(':') + 1);
switch (syntax)
{
case "1":
case "1.0":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_0;
break;
case "1.1":
this._parser.SyntaxMode = SparqlQuerySyntax.Sparql_1_1;
break;
case "E":
case "e":
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + syntax + "' is not a valid query syntax specifier - assuming SPARQL 1.1 with Extensions");
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
break;
}
}
else
{
this._parser.SyntaxMode = SparqlQuerySyntax.Extended;
}
}
else if (arg.StartsWith("-timeout:"))
{
long timeout;
if (Int64.TryParse(arg.Substring(arg.IndexOf(':') + 1), out timeout))
{
this._timeout = timeout;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid timeout in milliseconds - default timeouts will be used");
}
}
else if (arg.StartsWith("-r:"))
{
arg = arg.Substring(arg.IndexOf(':') + 1);
switch (arg)
{
case "rdfs":
((IInferencingTripleStore)this._store).AddInferenceEngine(new RdfsReasoner());
break;
case "skos":
((IInferencingTripleStore)this._store).AddInferenceEngine(new SkosReasoner());
break;
default:
Console.Error.WriteLine("rdfQuery: The value '" + arg + "' is not a valid Reasoner - ignoring this option");
break;
}
}
else if (arg.StartsWith("-partialResults"))
{
if (arg.Contains(':'))
{
bool partial;
if (Boolean.TryParse(arg.Substring(arg.IndexOf(':') + 1), out partial))
{
this._partialResults = partial;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + arg.Substring(arg.IndexOf(':') + 1) + "' is not a valid boolean - partial results mode is disabled");
}
}
else
{
this._partialResults = true;
}
}
else if (arg.StartsWith("-noopt"))
{
if (arg.Equals("-noopt"))
{
Options.QueryOptimisation = false;
Options.AlgebraOptimisation = false;
}
else if (arg.Length >= 7)
{
String opts = arg.Substring(7);
foreach (char c in opts.ToCharArray())
{
if (c == 'a' || c == 'A')
{
Options.AlgebraOptimisation = false;
}
else if (c == 'q' || c == 'Q')
{
Options.QueryOptimisation = false;
}
else
{
Console.Error.WriteLine("rdfQuery: The value '" + c + "' as part of the -noopt argument is not supported - it has been ignored");
}
}
}
}
else if (arg.Equals("-nocache"))
{
Options.UriLoaderCaching = false;
}
else if (arg.Equals("-nobom"))
{
Options.UseBomForUtf8 = false;
}
else if (arg.Equals("-print"))
{
this._print = true;
}
else if (arg.Equals("-debug"))
{
this._debug = true;
}
else if (arg.StartsWith("-explain"))
{
this._explain = true;
if (arg.Length > 9)
{
try
{
this._level = (ExplanationLevel)Enum.Parse(typeof(ExplanationLevel), arg.Substring(9));
this._level = (this._level | ExplanationLevel.OutputToConsoleStdErr | ExplanationLevel.Simulate) ^ ExplanationLevel.OutputToConsoleStdOut;
}
catch
{
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' does not specify a valid Explanation Level");
return(false);
}
}
}
else if (arg.Equals("-help"))
{
//Ignore Help Argument if other arguments present
}
else if (arg.StartsWith("-"))
{
//Report Invalid Argument
Console.Error.WriteLine("rdfQuery: The argument '" + arg + "' is not a supported argument - it has been ignored");
}
else if (i == args.Length - 1)
{
//Last Argument must be the Query
this._query = arg;
}
else
{
//Treat as an input file
if (this._mode == RdfQueryMode.Remote)
{
Console.Error.WriteLine("rdfQuery: Cannot specify local files as well as specifying a remote endpoint to query");
return(false);
}
try
{
this._mode = RdfQueryMode.Local;
//Try and parse RDF from the given file
if (!this._print)
{
Graph g = new Graph();
FileLoader.Load(g, arg);
this._store.Add(g);
}
else
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' since -print has been specified so the query will not be executed so no need to load the data");
}
}
catch (RdfParseException parseEx)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Parser Error: " + parseEx.Message);
if (this._debug)
{
this.DebugErrors(parseEx);
}
}
catch (Exception ex)
{
Console.Error.WriteLine("rdfQuery: Ignoring the local file '" + arg + "' due to the following error:");
Console.Error.WriteLine("rdfQuery: Error: " + ex.Message);
if (this._debug)
{
this.DebugErrors(ex);
}
}
}
i++;
}
return(true);
}
/// <summary>
/// Launch the RDF export wizard and save resulting RDF file to disk.
/// </summary>
public void ExportRDF()
{
// Generate candidate list of namespaces to map, for the export dialog to consume
candidateNamespacesToMap = new HashSet <Uri>();
foreach (Worksheet worksheet in Globals.ThisAddIn.Application.Worksheets)
{
int lastUsedColumnIndex = worksheet.UsedRange.Columns.Count;
string lastUsedColumnName = Helper.GetExcelColumnName(lastUsedColumnIndex);
Range headerRange = worksheet.get_Range(String.Format("A1:{0}1", lastUsedColumnName));
candidateNamespacesToMap.UnionWith(Helper.getNamespaceUrisFromComments(headerRange));
}
ExportOptionsForm exportOptionsForm = new ExportOptionsForm();
if (exportOptionsForm.ShowDialog() == DialogResult.OK)
{
// Set up save file UI
SaveFileDialog saveRdfFileDialog = new SaveFileDialog();
saveRdfFileDialog.Filter = "RDF/XML (*.rdf)|*.rdf|Turtle (*.ttl)|*.ttl|NTriples (*.nt)|*.nt";
saveRdfFileDialog.Title = "Save RDF file";
if (saveRdfFileDialog.ShowDialog() == DialogResult.OK)
{
// Initiate DotNetRdf Graph and shared IRI:s
IGraph g = new Graph();
IUriNode rdfType = g.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
// Assign namespace mappings from export dialog
foreach (KeyValuePair <string, Uri> entry in exportPrefixMappings)
{
g.NamespaceMap.AddNamespace(entry.Key, entry.Value);
}
// Used to trim URI:s
Char[] trimUrisChars = new Char[] { '<', '>' };
// Iterate over all worksheets
foreach (Worksheet worksheet in Globals.ThisAddIn.Application.Worksheets)
{
// Which bits of the sheet are being used
Range usedRange = worksheet.UsedRange;
int lastUsedRow = usedRange.Row + usedRange.Rows.Count - 1;
int lastUsedColumn = usedRange.Column + usedRange.Columns.Count - 1;
// Identifier column metadata
int identifierColumn = 0;
// Class name is tentatively in the data namespace until the identifier column is found
Uri className = new Uri(exportNamespace.ToString() + worksheet.Name);
// Set up lookup table. Note that we use 1-indexing to simplify mapping to/from Excel
// ranges. The 0:th column will thus be empty and should not be adressed, as will the
// identifier column.
HeaderFields[] headerLookupTable = new HeaderFields[lastUsedColumn + 1];
// Parse the header row.
string lastUsedColumnName = Helper.GetExcelColumnName(lastUsedColumn);
Range headerRange = worksheet.get_Range(String.Format("A1:{0}1", lastUsedColumnName));
foreach (Range headerCell in headerRange.Cells)
{
int column = headerCell.Column;
// If there is an embedded note, proceed
if (headerCell.Comment != null)
{
string noteText = headerCell.Comment.Text(Type.Missing, Type.Missing, Type.Missing);
string[] noteTextComponents = noteText.Split('\n');
string iriComponent = noteTextComponents[0];
if (iriComponent.Equals("<IRI>") && noteTextComponents.Count() == 2)
{
// This is the identifier column; update worksheet metadata accordingly
identifierColumn = headerCell.Column;
string classComponent = noteTextComponents[1];
string classComponentTrimmed = classComponent.Trim(trimUrisChars);
className = new Uri(classComponentTrimmed);
}
else if (noteTextComponents.Count() == 3)
{
HeaderFields hf = new HeaderFields();
hf.propertyIri = g.CreateUriNode(UriFactory.Create(iriComponent.Trim(trimUrisChars)));
string propertyTypeComponent = noteTextComponents[1];
hf.propertyType = new Uri(propertyTypeComponent.Trim(trimUrisChars));
string propertyRangeComponent = noteTextComponents[2];
hf.propertyRange = new Uri(propertyRangeComponent.Trim(trimUrisChars));
headerLookupTable[column] = hf;
}
else if (noteTextComponents.Count() == 6)
{
HeaderFields hf = new HeaderFields();
hf.propertyIri = g.CreateUriNode(UriFactory.Create(iriComponent.Trim(trimUrisChars)));
string propertyTypeComponent = noteTextComponents[1];
hf.propertyType = new Uri(propertyTypeComponent.Trim(trimUrisChars));
string propertyRangeComponent = noteTextComponents[2];
hf.propertyRange = new Uri(propertyRangeComponent.Trim(trimUrisChars));
string nestedIriComponent = noteTextComponents[3];
hf.nestedIri = g.CreateUriNode(UriFactory.Create(nestedIriComponent.Trim(trimUrisChars)));
string nestedTypeComponent = noteTextComponents[4];
hf.nestedType = new Uri(nestedTypeComponent.Trim(trimUrisChars));
string nestedRangeComponent = noteTextComponents[5].Trim(trimUrisChars);
if (nestedRangeComponent.Length > 0)
{
hf.nestedRange = new Uri(nestedRangeComponent);
}
headerLookupTable[column] = hf;
}
}
}
// Now, assuming an identifier column has been found, we can finally start parsing the rows
if (identifierColumn != 0)
{
// All entities will have the same class
IUriNode worksheetClass = g.CreateUriNode(className);
// For every row in the spreadsheet..
for (int rowIndex = 2; rowIndex <= lastUsedRow; rowIndex++)
{
string rowRangeIdentifier = String.Format("{0}{1}:{2}{3}", Helper.GetExcelColumnName(1), rowIndex, Helper.GetExcelColumnName(lastUsedColumn), rowIndex);
Range row = worksheet.get_Range(rowRangeIdentifier);
// Set subject node ID.
string identifierCellIdentifier = String.Format("{0}{1}", Helper.GetExcelColumnName(identifierColumn), rowIndex);
Range identifierCell = worksheet.get_Range(identifierCellIdentifier);
// Used to store the references to any intermediate (nested) blank nodes for the row
Dictionary <IUriNode, IBlankNode> intermediateNodes = new Dictionary <IUriNode, IBlankNode>();
// Only parse rows that have an identifier
if (identifierCell.Text != "")
{
Uri subjectUri = new Uri(exportNamespace.ToString() + identifierCell.Text);
IUriNode subjectNode = g.CreateUriNode(subjectUri);
g.Assert(new Triple(subjectNode, rdfType, worksheetClass));
// Iterate over remaining columns, i.e., property instances, skipping the identifier column if it reappears
foreach (Range dataCell in row.Cells)
{
if (dataCell.Column == identifierColumn)
{
continue;
}
// Get header fields
HeaderFields hf = headerLookupTable[dataCell.Column];
// Check that there actually are header fields for the cell under consideration; otherwise, ignore cell
// This is not a simple null check since HeaderFields is a struct, e.g., value type, which cannot be null
if (hf.Equals(default(HeaderFields)))
{
continue;
}
if (hf.nestedIri != null)
{
// This is a nested anonymous individual
// Assert the intermediate (nested) individual
IUriNode predicateNode = hf.propertyIri;
IBlankNode intermediateBlank;
if (intermediateNodes.ContainsKey(predicateNode))
{
intermediateBlank = intermediateNodes[predicateNode];
}
else
{
intermediateBlank = g.CreateBlankNode();
intermediateNodes.Add(predicateNode, intermediateBlank);
}
IUriNode intermediateType = g.CreateUriNode(hf.propertyRange);
g.Assert(new Triple(subjectNode, predicateNode, intermediateBlank));
g.Assert(new Triple(intermediateBlank, rdfType, intermediateType));
IUriNode nestedPredicateNode = hf.nestedIri;
// Get out and parse object.
// "Raw" cell value, will need treatment (TODO!)
INode objectNode;
string cellValue = dataCell.Text;
// Check so cell isn't empty
if (!cellValue.Equals(""))
{
switch (hf.nestedType.ToString())
{
case OntologyHelper.OwlDatatypeProperty:
objectNode = g.CreateLiteralNode(cellValue, hf.nestedRange);
break;
case OntologyHelper.OwlObjectProperty:
// If there is a valid URI in the cell, use that as-is, otherwise generate one frame the export namespace
if (Uri.TryCreate(cellValue, UriKind.Absolute, out Uri tempObjectPropertyValue) == true)
{
objectNode = g.CreateUriNode(tempObjectPropertyValue);
}
else
{
objectNode = g.CreateUriNode(new Uri(exportNamespace.ToString() + cellValue));
}
break;
case OntologyHelper.OwlAnnotationProperty:
// For annotation properties we use literal object nodes if property range is in XSD namespace
// and uri nodes otherwise.
if (hf.nestedRange.ToString().Contains(XmlSpecsHelper.NamespaceXmlSchema))
{
objectNode = g.CreateLiteralNode(cellValue, hf.nestedRange);
}
else
{
// If there is a valid URI in the cell, use that as-is, otherwise generate one frame the export namespace
if (Uri.TryCreate(cellValue, UriKind.Absolute, out Uri tempAnnotationPropertyValue) == true)
{
objectNode = g.CreateUriNode(tempAnnotationPropertyValue);
}
else
{
objectNode = g.CreateUriNode(new Uri(exportNamespace.ToString() + cellValue));
}
}
break;
default:
continue;
}
g.Assert(new Triple(intermediateBlank, nestedPredicateNode, objectNode));
}
}
else
{
IUriNode predicateNode = hf.propertyIri;
// Get out and parse object.
// "Raw" cell value, will need treatment (TODO!)
INode objectNode;
string cellValue = dataCell.Text;
// Check so cell isn't empty
if (!cellValue.Equals(""))
{
switch (hf.propertyType.ToString())
{
case OntologyHelper.OwlDatatypeProperty:
objectNode = g.CreateLiteralNode(cellValue, hf.propertyRange);
break;
case OntologyHelper.OwlObjectProperty:
// If there is a valid URI in the cell, use that as-is, otherwise generate one frame the export namespace
if (Uri.TryCreate(cellValue, UriKind.Absolute, out Uri tempObjectPropertyValue) == true)
{
objectNode = g.CreateUriNode(tempObjectPropertyValue);
}
else
{
objectNode = g.CreateUriNode(new Uri(exportNamespace.ToString() + cellValue));
}
break;
case OntologyHelper.OwlAnnotationProperty:
// For annotation properties we use literal object nodes if property range is in XSD namespace
// and uri nodes otherwise.
if (hf.propertyRange.ToString().Contains(XmlSpecsHelper.NamespaceXmlSchema))
{
objectNode = g.CreateLiteralNode(cellValue, hf.propertyRange);
}
else
{
// If there is a valid URI in the cell, use that as-is, otherwise generate one frame the export namespace
if (Uri.TryCreate(cellValue, UriKind.Absolute, out Uri tempAnnotationPropertyValue) == true)
{
objectNode = g.CreateUriNode(tempAnnotationPropertyValue);
}
else
{
objectNode = g.CreateUriNode(new Uri(exportNamespace.ToString() + cellValue));
}
}
break;
default:
continue;
}
g.Assert(new Triple(subjectNode, predicateNode, objectNode));
}
}
}
}
}
String saveFileExtension = Path.GetExtension(saveRdfFileDialog.FileName);
IRdfWriter writer = MimeTypesHelper.GetWriterByFileExtension(saveFileExtension);
writer.Save(g, saveRdfFileDialog.FileName);
}
}
}
}
}