public void ParsingRdfXmlEmptyStrings()
{
NTriplesFormatter formatter = new NTriplesFormatter();
RdfXmlParser domParser = new RdfXmlParser(RdfXmlParserMode.DOM);
Graph g = new Graph();
domParser.Load(g, "resources\\empty-string-rdfxml.rdf");
Console.WriteLine("DOM Parser parsed OK");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
RdfXmlParser streamingParser = new RdfXmlParser(RdfXmlParserMode.Streaming);
Graph h = new Graph();
streamingParser.Load(h, "resources\\empty-string-rdfxml.rdf");
Console.WriteLine("Streaming Parser parsed OK");
foreach (Triple t in h.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Assert.AreEqual(g, h, "Graphs should be equal");
}
public void ParsingRdfXmlWithUrlEscapedNodes2()
{
//Originally submitted by Rob Styles as part of CORE-251, modified somewhat during debugging process
NTriplesFormatter formatter = new NTriplesFormatter();
RdfXmlParser domParser = new RdfXmlParser(RdfXmlParserMode.DOM);
Graph g = new Graph();
domParser.Load(g, "resources\\urlencodes-in-rdfxml.rdf");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Uri encoded = new Uri("http://example.com/some%20encoded%2FUri");
Uri unencoded = new Uri("http://example.com/some encoded/Uri");
Assert.IsTrue(EqualityHelper.AreUrisEqual(encoded, unencoded), "URIs should be equivalent");
IUriNode encodedNode = g.GetUriNode(encoded);
Assert.IsNotNull(encodedNode, "The encoded node should be returned by its encoded URI");
IUriNode unencodedNode = g.GetUriNode(unencoded);
Assert.IsNotNull(unencodedNode, "The unencoded node should be returned by its unencoded URI");
IUriNode pred = g.CreateUriNode(new Uri("http://example.org/schema/encoded"));
Assert.IsTrue(g.ContainsTriple(new Triple(encodedNode, pred, g.CreateLiteralNode("true"))), "The encoded node should have the property 'true' from the file");
Assert.IsTrue(g.ContainsTriple(new Triple(unencodedNode, pred, g.CreateLiteralNode("false"))), "The unencoded node should have the property 'false' from the file");
}
public void ParsingRdfXmlPropertyInDefaultNamespaceBad()
{
Graph g = new Graph();
RdfXmlParser parser = new RdfXmlParser();
g.LoadFromFile("resources\\rdfxml-bad-property.rdf", parser);
}
public static IGraph GetDocument(string transformName, IDictionary <string, string> transformArgs, XDocument data, string baseAddress)
{
XslCompiledTransform transform = CreateTransform(transformName);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("base", "", baseAddress);
foreach (KeyValuePair <string, string> arg in transformArgs)
{
arguments.AddParam(arg.Key, "", arg.Value);
}
XDocument rdfxml = new XDocument();
using (XmlWriter writer = rdfxml.CreateWriter())
{
transform.Transform(data.CreateReader(), arguments, writer);
}
RdfXmlParser rdfXmlParser = new RdfXmlParser();
XmlDocument doc = new XmlDocument();
doc.Load(rdfxml.CreateReader());
IGraph graph = new Graph();
rdfXmlParser.Load(graph, doc);
return(graph);
}
private void LoadButton_Click(object sender, RoutedEventArgs e)
{
try
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.InitialDirectory = Environment.CurrentDirectory;
ofd.Filter = "RDF Files (*.rdf)|*.rdf|Turtle Files (*.ttl)|*.ttl|All Files (*.*)|*.*";
if (ofd.ShowDialog().Value)
{
string filePath = ofd.FileName;
switch (ModeComboBox.SelectedIndex)
{
case 0: // RDF/XML
RdfXmlParser rdfXmlParser = new RdfXmlParser(RdfXmlParserMode.Streaming);
myGraph = new Graph();
rdfXmlParser.Load(myGraph, filePath);
break;
case 1: // NTriples
NTriplesParser ntp = new NTriplesParser();
myGraph = new Graph();
ntp.Load(myGraph, filePath);
break;
}
MessageBox.Show("Graph Loaded From File Successfully", "Connected", MessageBoxButton.OK,
MessageBoxImage.Information);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n" + ex.StackTrace, "ERROR", MessageBoxButton.OK);
}
}
public IEnumerable <IDataObject> BindRdfDataObjects(XDocument rdfXmlDocument,
IList <OrderingDirection> orderingDirections)
{
var g = new Graph();
#if PORTABLE || WINDOWS_PHONE
var parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
// This is pretty nasty, having to deserialize only to go through parsing again
parser.Load(g, new System.IO.StringReader(rdfXmlDocument.ToString()));
#else
var parser = new RdfXmlParser(RdfXmlParserMode.DOM);
parser.Load(g, rdfXmlDocument.AsXmlDocument());
#endif
var p = new VDS.RDF.Query.LeviathanQueryProcessor(new InMemoryDataset(g));
var queryString = MakeOrderedResourceQuery(orderingDirections);
var sparqlParser = new SparqlQueryParser();
var query = sparqlParser.ParseFromString(queryString);
var queryResultSet = p.ProcessQuery(query) as VDS.RDF.Query.SparqlResultSet;
foreach (var row in queryResultSet.Results)
{
INode uriNode;
if (row.TryGetBoundValue("x", out uriNode) && uriNode is IUriNode)
{
yield return(BindRdfDataObject(uriNode as IUriNode, g));
}
}
}
private static IRdfReader CreateReader(string mediaType)
{
IRdfReader result = null;
switch (mediaType)
{
case TextTurtle:
result = new TurtleParser();
break;
case ApplicationRdfXml:
case ApplicationOwlXml:
result = new RdfXmlParser();
break;
case ApplicationLdJson:
result = new JsonLdParser();
break;
default:
throw new InvalidOperationException(String.Format("Media type '{0}' is not supported.", mediaType));
}
return(result);
}
public static IGraph Load(XDocument nuspec, string baseAddress)
{
string path = @"..\..\..\..\..\src\MakeMetadata\MakeMetadata\nuspec2package.xslt";
XslCompiledTransform transform = CreateTransform(path);
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("base", "", baseAddress);
XDocument rdfxml = new XDocument();
using (XmlWriter writer = rdfxml.CreateWriter())
{
transform.Transform(nuspec.CreateReader(), arguments, writer);
}
RdfXmlParser rdfXmlParser = new RdfXmlParser();
XmlDocument doc = new XmlDocument();
doc.Load(rdfxml.CreateReader());
IGraph graph = new Graph();
rdfXmlParser.Load(graph, doc);
return(graph);
}
public void ItHandlesRdfDescriptionRegardessOfNamespacePrefix()
{
var rdfXml1 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:ex='http://example.org/'><rdf:Description rdf:about='http://example.org/#us'><ex:property rdf:Resource='http://example.org/object'/></rdf:Description></rdf:RDF>";
var rdfXml2 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:ex='http://example.org/'><foo:Description rdf:about='http://example.org/#us' xmlns:foo='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><ex:property rdf:Resource='http://example.org/object' xmlns:ex='http://example.org/'/></foo:Description></rdf:RDF>";
var rdfXml3 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:ex='http://example.org/'><Description rdf:about='http://example.org/#us' xmlns='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><ex:property rdf:Resource='http://example.org/object'/></Description></rdf:RDF>";
var parser = new RdfXmlParser();
var graph1 = new Graph();
graph1.LoadFromString(rdfXml1, parser);
var graph2 = new Graph();
graph2.LoadFromString(rdfXml2, parser);
var graph3 = new Graph();
graph3.LoadFromString(rdfXml3, parser);
var diff12 = graph1.Difference(graph2);
var diff13 = graph1.Difference(graph3);
Assert.True(diff12.AreEqual);
Assert.True(diff13.AreEqual);
}
public static IGraph GraphFromXml(XDocument original, XslCompiledTransform transform, XsltArgumentList arguments)
{
XDocument rdfxml = new XDocument();
using (XmlWriter writer = rdfxml.CreateWriter())
{
transform.Transform(original.CreateReader(), arguments, writer);
}
RdfXmlParser rdfXmlParser = new RdfXmlParser();
XmlDocument doc = new XmlDocument();
doc.Load(rdfxml.CreateReader());
//DEBUG
//using (var xmlWriter = XmlWriter.Create(Console.Out))
//{
// doc.WriteTo(xmlWriter);
//}
IGraph graph = new Graph();
rdfXmlParser.Load(graph, doc);
return(graph);
}
private void LoadInGraph(String path)
{
RdfXmlParser ttlparser = new RdfXmlParser();
try
{
ttlparser.Load(situation, path);
}
catch (RdfParseException parseEx)
{
//This indicates a parser error e.g unexpected character, premature end of input, invalid syntax etc.
logger.LogFunction("Parser Error");
logger.LogFunction(parseEx.Message);
}
catch (RdfException rdfEx)
{
//This represents a RDF error e.g. illegal triple for the given syntax, undefined namespace
logger.LogFunction("RDF Error");
logger.LogFunction(rdfEx.Message);
}
catch (Exception ex)
{
logger.LogFunction("Unknown Error");
logger.LogFunction(ex.Message);
}
}
public void ParsingRdfXmlAmpersands()
{
List <IRdfWriter> writers = new List <IRdfWriter>()
{
new RdfXmlWriter(),
new PrettyRdfXmlWriter()
};
IRdfReader parser = new RdfXmlParser();
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/ampersandsInRdfXml");
g.Assert(new Triple(g.CreateUriNode(), g.CreateUriNode(new Uri("http://example.org/property")), g.CreateUriNode(new Uri("http://example.org/a&b"))));
g.Assert(new Triple(g.CreateUriNode(), g.CreateUriNode(new Uri("http://example.org/property")), g.CreateLiteralNode("A & B")));
foreach (IRdfWriter writer in writers)
{
Console.WriteLine(writer.GetType().ToString());
String temp = StringWriter.Write(g, writer);
Console.WriteLine(temp);
Graph h = new Graph();
StringParser.Parse(h, temp);
Assert.Equal(g, h);
Console.WriteLine();
}
}
public void ItExpandsRdfListElementsRegardlessOfNamespacePrefix()
{
const string rdfXml1 = "<RDF xmlns='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><Seq><li>bar</li></Seq></RDF>";
const string rdfXml2 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><rdf:Seq><rdf:li>bar</rdf:li></rdf:Seq></rdf:RDF>";
const string rdfXml3 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'><rdf:Seq><foo:li xmlns:foo='http://www.w3.org/1999/02/22-rdf-syntax-ns#'>bar</foo:li></rdf:Seq></rdf:RDF>";
var parser = new RdfXmlParser();
var graph1 = new Graph();
graph1.LoadFromString(rdfXml1, parser);
var graph2 = new Graph();
graph2.LoadFromString(rdfXml2, parser);
var graph3 = new Graph();
graph3.LoadFromString(rdfXml3, parser);
var diff12 = graph1.Difference(graph2);
var diff13 = graph1.Difference(graph3);
Assert.True(diff12.AreEqual);
Assert.True(diff13.AreEqual);
}
public void ItHandlesRdfTypeAttributesRegardlessOfNamespacePrefix(RdfXmlParserMode parserMode)
{
const string rdfXml1 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:eg='http://example.org/'><eg:Example rdf:about='http://example.org/#us'><rdf:type rdf:Resource='http://example.org/SomeType'/></eg:Example></rdf:RDF>";
const string rdfXml2 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:eg='http://example.org/'><eg:Example rdf:about='http://example.org/#us'><eg:type rdf:Resource='http://example.org/SomeType' xmlns:eg='http://www.w3.org/1999/02/22-rdf-syntax-ns#'/></eg:Example></rdf:RDF>";
const string rdfXml3 = "<rdf:RDF xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#' xmlns:eg='http://example.org/'><eg:Example rdf:about='http://example.org/#us'><type rdf:Resource='http://example.org/SomeType' xmlns='http://www.w3.org/1999/02/22-rdf-syntax-ns#' /></eg:Example></rdf:RDF>";
var parser = new RdfXmlParser(parserMode);
var graph1 = new Graph();
graph1.LoadFromString(rdfXml1, parser);
var graph2 = new Graph();
graph2.LoadFromString(rdfXml2, parser);
var graph3 = new Graph();
graph3.LoadFromString(rdfXml3, parser);
var diff12 = graph1.Difference(graph2);
var diff13 = graph1.Difference(graph3);
Assert.True(diff12.AreEqual);
Assert.True(diff13.AreEqual);
}
private void ProcessRootServices()
{
try {
OslcClient rootServicesClient = new OslcClient();
HttpResponseMessage response = rootServicesClient.GetResource(rootServicesUrl, OSLCConstants.CT_RDF);
Stream stream = response.Content.ReadAsStreamAsync().Result;
IGraph rdfGraph = new Graph();
IRdfReader parser = new RdfXmlParser();
StreamReader streamReader = new StreamReader(stream);
using (streamReader)
{
parser.Load(rdfGraph, streamReader);
//get the catalog URL
catalogUrl = GetRootServicesProperty(rdfGraph, catalogNamespace, catalogProperty);
//get the OAuth URLs
requestTokenUrl = GetRootServicesProperty(rdfGraph, JFS_NAMESPACE, JazzRootServicesConstants.OAUTH_REQUEST_TOKEN_URL);
authorizationTokenUrl = GetRootServicesProperty(rdfGraph, JFS_NAMESPACE, JazzRootServicesConstants.OAUTH_USER_AUTH_URL);
accessTokenUrl = GetRootServicesProperty(rdfGraph, JFS_NAMESPACE, JazzRootServicesConstants.OAUTH_ACCESS_TOKEN_URL);
try { // Following field is optional, try to get it, if not found ignore exception because it will use the default
authorizationRealm = GetRootServicesProperty(rdfGraph, JFS_NAMESPACE, JazzRootServicesConstants.OAUTH_REALM_NAME);
} catch (ResourceNotFoundException e) {
// Ignore
}
}
} catch (Exception e) {
throw new RootServicesException(baseUrl, e);
}
}
public void LoadFromFile(string filePath, DatasourceFileType fileType)
{
try
{
switch (fileType)
{
case DatasourceFileType.Rdfxml: // RDF/XML
RdfXmlParser rdfXmlParser = new RdfXmlParser(RdfXmlParserMode.Streaming);
myGraph = new Graph();
rdfXmlParser.Load(myGraph, filePath);
break;
case DatasourceFileType.NTriples: // NTriples
NTriplesParser ntp = new NTriplesParser();
myGraph = new Graph();
ntp.Load(myGraph, filePath);
break;
}
}
catch (Exception ex)
{
MySoapFault fault = new MySoapFault();
fault.Operation = "LoadFromFile";
fault.Reason = "Error in loading datasource file into graph .";
fault.Details = ex.Message;
fault.MoreDetails = ex.StackTrace;
throw new FaultException <MySoapFault>(fault);
}
}
public void ParsingRelativeUriAppBaseRdfXml2()
{
//This invocation succeeds because when invoking because
//we manually set the Base URI prior to invoking the parser
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org");
RdfXmlParser parser = new RdfXmlParser();
parser.Load(g, "resources\\rdfxml-relative-uri.rdf");
//Expect a non-empty grpah with a single triple
Assert.IsFalse(g.IsEmpty);
Assert.AreEqual(1, g.Triples.Count);
Triple t = g.Triples.First();
//Object should get it's relative URI resolved into
//the correct HTTP URI
Uri obj = ((IUriNode)t.Object).Uri;
Assert.AreEqual("http", obj.Scheme);
Assert.AreEqual("example.org", obj.Host);
Assert.AreEqual("relative", obj.Segments[1]);
}
public void ParsingBaseUriAssignmentRdfXml()
{
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/RdfXml");
System.IO.StringWriter strWriter = new System.IO.StringWriter();
RdfXmlWriter writer = new RdfXmlWriter();
writer.Save(g, strWriter);
Console.WriteLine("Original Base URI: " + ShowBaseUri(g.BaseUri));
Console.WriteLine("Output using RdfXmlWriter:");
Console.WriteLine(strWriter.ToString());
Console.WriteLine();
Graph h = new Graph();
RdfXmlParser parser = new RdfXmlParser();
parser.Load(h, new System.IO.StringReader(strWriter.ToString()));
Console.WriteLine("Base URI after round-trip using RdfXmlWriter: " + ShowBaseUri(h.BaseUri));
Assert.IsNotNull(h.BaseUri, "Base URI should not be null");
}
public void ReadRDL(string fileName)
{
IGraph g = new Graph();
//IUriNode dotNetRDF = g.CreateUriNode(UriFactory.Create("http://www.dotnetrdf.org"));
//IUriNode says = g.CreateUriNode(UriFactory.Create("http://example.org/says"));
//ILiteralNode helloWorld = g.CreateLiteralNode("Hello World");
//ILiteralNode bonjourMonde = g.CreateLiteralNode("Bonjour tout le Monde", "fr");
//g.Assert(new Triple(dotNetRDF, says, helloWorld));
//g.Assert(new Triple(dotNetRDF, says, bonjourMonde));
//foreach (Triple t in g.Triples)
//{
// Console.WriteLine(t.ToString());
//}
//NTriplesWriter ntwriter = new NTriplesWriter();
//ntwriter.Save(g, "HelloWorld.nt");
//RdfXmlWriter rdfxmlwriter = new RdfXmlWriter();
//rdfxmlwriter.Save(g, "HelloWorld.rdf");
RdfXmlParser fileParser = new RdfXmlParser();
fileParser.Load(g, fileName);
//VDS.RDF.Nam
}
public static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress, bool normalizeXml = false)
{
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("base", "", baseAddress);
arguments.AddParam("extension", "", ".json");
arguments.AddExtensionObject("urn:helper", new XsltHelper());
nuspec = SafeXmlTransform(nuspec.CreateReader(), XslTransformNormalizeNuSpecNamespaceCache.Value);
var rdfxml = SafeXmlTransform(nuspec.CreateReader(), XslTransformNuSpecCache.Value, arguments);
var doc = SafeCreateXmlDocument(rdfxml.CreateReader());
if (normalizeXml)
{
NormalizeXml(doc);
}
RdfXmlParser rdfXmlParser = new RdfXmlParser();
IGraph graph = new Graph();
rdfXmlParser.Load(graph, doc);
return(graph);
}
static IGraph CreateNuspecGraph(XDocument nuspec, Uri baseAddress, XslCompiledTransform xslt)
{
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("base", "", baseAddress.ToString());
arguments.AddParam("extension", "", ".json");
arguments.AddExtensionObject("urn:helper", new XsltHelper());
XDocument rdfxml = new XDocument();
using (XmlWriter writer = rdfxml.CreateWriter())
{
xslt.Transform(nuspec.CreateReader(), arguments, writer);
}
XmlDocument doc = new XmlDocument();
doc.Load(rdfxml.CreateReader());
IGraph graph = new Graph();
RdfXmlParser rdfXmlParser = new RdfXmlParser();
rdfXmlParser.Load(graph, doc);
return(graph);
}
public void ParsingRdfXmlPropertyInDefaultNamespaceBad()
{
Graph g = new Graph();
RdfXmlParser parser = new RdfXmlParser();
Assert.Throws <RdfParseException>(() => g.LoadFromFile("resources\\rdfxml-bad-property.rdf", parser));
}
public static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress)
{
nuspec = NormalizeNuspecNamespace(nuspec);
XslCompiledTransform transform = CreateTransform("xslt.nuspec.xslt");
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("base", "", baseAddress + "packages/");
arguments.AddParam("extension", "", ".json");
arguments.AddExtensionObject("urn:helper", new XsltHelper());
XDocument rdfxml = new XDocument();
using (XmlWriter writer = rdfxml.CreateWriter())
{
transform.Transform(nuspec.CreateReader(), arguments, writer);
}
RdfXmlParser rdfXmlParser = new RdfXmlParser();
XmlDocument doc = new XmlDocument();
doc.Load(rdfxml.CreateReader());
IGraph graph = new Graph();
rdfXmlParser.Load(graph, doc);
return(graph);
}
// Load RDF content from xml file
public static Graph LoadFromFileXml(String fileName)
{
Graph g = new Graph();
RdfXmlParser xmlParser = new RdfXmlParser();
xmlParser.Load(g, fileName);
return(g);
}
public static Pubmed LoadFromXML(string filename)
{
RdfXmlParser xmlParser = new RdfXmlParser();
IGraph g = new Graph();
xmlParser.Load(g, filename);
return(new Pubmed(g));
}
public Response Refresh(string graphName, XDocument xDocument)
{
Response response = new Response();
response.StatusList = new List <Status>();
Status status = new Status();
status.Messages = new Messages();
try
{
status.Identifier = graphName;
DateTime startTime = DateTime.Now;
_graphMap = _mapping.FindGraphMap(graphName);
// create xdoc from rdf xelement
Uri graphUri = new Uri(_graphNs.NamespaceName + graphName);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(xDocument.ToString());
xDocument.Root.RemoveAll();
// load xdoc to graph
RdfXmlParser parser = new RdfXmlParser();
_graph.Clear();
_graph.BaseUri = graphUri;
parser.Load(_graph, xmlDocument);
xmlDocument.RemoveAll();
// delete old graph and save new one
DeleteGraph(graphUri);
_tripleStore.SaveGraph(_graph);
DateTime endTime = DateTime.Now;
TimeSpan duration = endTime.Subtract(startTime);
status.Messages.Add("Graph [" + graphName + "] has been refreshed in triple store successfully.");
status.Messages.Add(
String.Format("Execution time [{0}:{1}.{2}] minutes.",
duration.Minutes,
duration.Seconds,
duration.Milliseconds
)
);
}
catch (Exception ex)
{
_logger.Error(string.Format("Error refreshing graph [{0}]. {1}", graphName, ex));
status.Level = StatusLevel.Error;
status.Messages.Add(String.Format("Error refreshing graph [{0}]. {1}", graphName, ex));
}
response.Append(status);
return(response);
}
public void ParsingRdfXmlStackOverflow1()
{
IGraph g = new Graph();
RdfXmlParser parser = new RdfXmlParser();
parser.Load(g, @"resources\cogapp.rdf");
Assert.False(g.IsEmpty);
Assert.Equal(9358, g.Triples.Count);
}
public void ParsingRelativeUriNoBaseRdfXml()
{
//This invocation fails because when invoking the parser directly
//the Base URI is not set to the file URI
Graph g = new Graph();
RdfXmlParser parser = new RdfXmlParser();
parser.Load(g, "resources\\rdfxml-relative-uri.rdf");
}
//static void Model_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
//{
// if (e.PropertyName == "ConsoleOutput")
// Console.WriteLine((sender as ProcessViewModel).ConsoleOutput);
//}
/// <summary>
/// https://bitbucket.org/dotnetrdf/dotnetrdf/wiki/User%20Guide
/// </summary>
static void TestRDF()
{
IGraph g = new Graph();
RdfXmlParser fileParser = new RdfXmlParser();
//fileParser.Load(g, "schema.xml");
fileParser.Load(g, "TestRdf.xml");
//SparqlQueryParser queryParser = new SparqlQueryParser();
//queryParser.ParseFromString("SELECT * WHERE { ?s a ?type }");
//VDS.RDF.Writing.StringWriter.Write(g, new RdfXmlWriter())
StringBuilder div = new StringBuilder();
XElement rdf = XElement.Parse(VDS.RDF.Writing.StringWriter.Write(g, new RdfXmlWriter()));
foreach (XElement element in rdf.Elements())
{
div.AppendFormat("<div itemscope itemtype=\"{0}/{1}\">", element.Name.NamespaceName.TrimEnd('/'), element.Name.LocalName);
div.AppendLine();
foreach (XElement content in element.Elements())
{
div.AppendFormat("<meta itemprop=\"{0}\" content=\"{1}\">", content.Name.LocalName, content.Value);
div.AppendLine();
}
div.AppendLine("</div>");
}
var output = g.ExecuteQuery("SELECT * WHERE { ?s a ?type }");
SparqlParameterizedString query = new SparqlParameterizedString();
query.Namespaces.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
query.Namespaces.AddNamespace("owl", new Uri("http://www.w3.org/2002/07/owl#"));
query.Namespaces.AddNamespace("xsd", new Uri("http://www.w3.org/2001/XMLSchema#"));
query.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
query.Namespaces.AddNamespace("schema", new Uri("http://schema.org/"));
query.Namespaces.AddNamespace("fact", new Uri("http://www.co-ode.org/ontologies/ont.owl#"));
query.CommandText = "SELECT * WHERE { ?organization rdf:type fact:UniqueCompany }";
var output2 = g.ExecuteQuery(query);
// var output2 = g.ExecuteQuery(@"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
// PREFIX owl: <http://www.w3.org/2002/07/owl#>
// PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
// PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
// PREFIX schema: <http://schema.org/>
// PREFIX fact:<http://www.co-ode.org/ontologies/ont.owl#>
// SELECT *
// WHERE { ?organization rdf:type fact:UniqueCompany }");
}
public void ParsingRdfXmlStreaming()
{
RdfXmlParser parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
parser.TraceParsing = true;
Graph g = new Graph();
parser.Load(g, "resources\\example.rdf");
TestTools.ShowGraph(g);
}
