private void Replace(IGraph graph, IUriNode parent, Uri predicate, string jsonField) { JToken token = null; if (_galleryPage.TryGetValue(jsonField, out token)) { JArray array = token as JArray; JValue val = token as JValue; if (array != null || val != null) { var pred = graph.CreateUriNode(predicate); var old = graph.GetTriplesWithSubjectPredicate(parent, pred).ToArray(); // remove the old values foreach (var triple in old) { graph.Retract(triple); } if (array != null) { foreach (var child in array) { graph.Assert(parent, pred, graph.CreateLiteralNode(child.ToString())); } } else { graph.Assert(parent, pred, graph.CreateLiteralNode(val.ToString())); } } } }
public UriNodeControl(IUriNode u, INodeFormatter formatter) { InitializeComponent(); this.lnkUri.Text = formatter.Format(u); this._u = u.Uri; }
protected override void Initialise(IGraph g) { if (g.BaseUri != null) this._node = g.CreateUriNode(); //First ensure all the correct namespace prefixes are set to the correct URIs g.NamespaceMap.AddNamespace("rdf", new Uri(NamespaceMapper.RDF)); g.NamespaceMap.AddNamespace("void", new Uri(VoIDNamespace)); g.NamespaceMap.AddNamespace("foaf", new Uri(FoafNamespace)); g.NamespaceMap.AddNamespace("dcterms", new Uri(DublinCoreTermsNamespace)); g.NamespaceMap.AddNamespace("aat", new Uri(AATNamespace)); //First look for an Expansion Profile description Triple profileDescriptor = new Triple(g.CreateUriNode(), g.CreateUriNode("rdf:type"), g.CreateUriNode("aat:ExpansionProfile")); if (g.ContainsTriple(profileDescriptor)) { //Does it specify a Max Expansion Depth? Triple maxDepthSpecifier = g.GetTriplesWithSubjectPredicate(g.CreateUriNode(), g.CreateUriNode("aat:maxExpansionDepth")).FirstOrDefault(); if (maxDepthSpecifier != null) { if (maxDepthSpecifier.Object.NodeType == NodeType.Literal) { ILiteralNode l = (ILiteralNode)maxDepthSpecifier.Object; if (l.DataType != null && l.DataType.ToString().Equals(XmlSpecsHelper.XmlSchemaDataTypeInteger)) { this._maxDepth = Int32.Parse(l.Value); } } } } //Find Datasets foreach (Triple t in g.GetTriplesWithPredicateObject(g.CreateUriNode("rdf:type"), g.CreateUriNode("void:Dataset"))) { ExpansionDataset dataset = new ExpansionDataset(g, t.Subject); if (this._datasets.ContainsKey(t.Subject)) { throw new NotImplementedException("Merging Expansion Datasets is not yet implemented"); } else { this._datasets.Add(t.Subject, dataset); } } //Find Linksets foreach (Triple t in g.GetTriplesWithPredicateObject(g.CreateUriNode("rdf:type"), g.CreateUriNode("void:Linkset"))) { ExpansionLinkset linkset = new ExpansionLinkset(g, t.Subject); if (this._linksets.ContainsKey(t.Subject)) { throw new NotImplementedException("Merging Expansion Linksets is not yet implemented"); } else { this._linksets.Add(t.Subject, linkset); } } }
private IDataObject BindRdfDataObject(IUriNode dataObjectResource, IGraph graph) { var triples = graph.GetTriplesWithSubject(dataObjectResource) .Where(t => t.Subject is IUriNode && t.Predicate is IUriNode) .Select(t => MakeTriple(t.Subject, t.Predicate, t.Object)); return MakeDataObject(dataObjectResource.Uri.ToString(), triples); }
/// <summary> /// Formats a URI Node /// </summary> /// <param name="u">URI Node</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected override string FormatUriNode(IUriNode u, TripleSegment? segment) { StringBuilder output = new StringBuilder(); output.Append('<'); output.Append(this.FormatUri(u.Uri)); output.Append('>'); return output.ToString(); }
/// <summary> /// Creates a new instance of the SKOS Reasoner /// </summary> public StaticSkosReasoner() { Graph g = new Graph(); g.NamespaceMap.AddNamespace("skos", new Uri(SKOSNamespace)); this._rdfType = g.CreateUriNode("rdf:type"); this._skosBroader = g.CreateUriNode("skos:broader"); this._skosConcept = g.CreateUriNode("skos:Concept"); this._skosNarrower = g.CreateUriNode("skos:narrower"); }
public ExpansionContext(ExpansionProfile profile) { this._profile = profile; this._linkTree.BaseUri = new Uri(VDS.RDF.Writing.WriterHelper.StoreDefaultGraphURIs.First()); this._linkTree.NamespaceMap.AddNamespace("owl", new Uri(NamespaceMapper.OWL)); this._sameAs = this._linkTree.CreateUriNode("owl:sameAs"); this._seeAlso = this._linkTree.CreateUriNode("rdfs:seeAlso"); this._store.Add(this._linkTree); }
/// <summary> /// Add data from nuget.packed.json /// </summary> public override void ApplyToGraph(IGraph graph, IUriNode mainNode) { Uri mainUri = mainNode.Uri; IUriNode typeNode = graph.CreateUriNode(Schema.Predicates.Type); // supported frameworks if (SupportedFrameworks != null) { foreach (string framework in SupportedFrameworks) { graph.Assert(new Triple(mainNode, graph.CreateUriNode(Schema.Predicates.SupportedFramework), graph.CreateLiteralNode(framework))); } } // assets //if (AssetGroups != null) //{ // int groupId = 0; // foreach (var group in AssetGroups) // { // // group type and id // var groupNode = GetSubNode(graph, mainUri, "assetGroup", "" + groupId); // graph.Assert(groupNode, typeNode, graph.CreateUriNode(PackageAssetGroupType)); // graph.Assert(mainNode, graph.CreateUriNode(AssetGroupPredicate), groupNode); // groupId++; // int propId = 0; // // group properties // foreach (var prop in group.Properties) // { // var propNode = GetSubNode(graph, groupNode, "property", "" + propId); // propId++; // graph.Assert(propNode, typeNode, graph.CreateUriNode(PackageAssetGroupPropertyType)); // graph.Assert(groupNode, graph.CreateUriNode(AssetGroupPropertyPredicate), propNode); // graph.Assert(propNode, graph.CreateUriNode(AssetKeyPredicate), graph.CreateLiteralNode(prop.Key)); // graph.Assert(propNode, graph.CreateUriNode(AssetValuePredicate), graph.CreateLiteralNode(prop.Value)); // } // int assetId = 0; // // group items // foreach (var item in group.Items) // { // var itemNode = GetSubNode(graph, groupNode, "asset", "" + assetId); // assetId++; // graph.Assert(itemNode, typeNode, graph.CreateUriNode(PackageAssetType)); // graph.Assert(groupNode, graph.CreateUriNode(AssetPredicate), itemNode); // graph.Assert(itemNode, graph.CreateUriNode(AssetTypePredicate), graph.CreateLiteralNode(item.ArtifactType)); // graph.Assert(itemNode, graph.CreateUriNode(AssetPathPredicate), graph.CreateLiteralNode(item.Path)); // } // } //} }
/// <summary> /// Creates a new instance of the Static RdfsReasoner /// </summary> public StaticRdfsReasoner() { Graph g = new Graph(); this._rdfType = g.CreateUriNode("rdf:type"); this._rdfsClass = g.CreateUriNode("rdfs:Class"); this._rdfsSubClass = g.CreateUriNode("rdfs:subClassOf"); this._rdfProperty = g.CreateUriNode("rdf:Property"); this._rdfsSubProperty = g.CreateUriNode("rdfs:subPropertyOf"); this._rdfsDomain = g.CreateUriNode("rdfs:domain"); this._rdfsRange = g.CreateUriNode("rdfs:range"); }
public override void ApplyToGraph(IGraph graph, IUriNode parent) { Replace(graph, parent, Schema.Predicates.ProjectUrl, "projectUrl"); Replace(graph, parent, Schema.Predicates.Title, "title"); Replace(graph, parent, Schema.Predicates.IconUrl, "iconUrl"); //Replace(graph, parent, Schema.Predicates.Summary, "summary"); //Replace(graph, parent, Schema.Predicates.Author, "authors"); //Replace(graph, parent, Schema.Predicates.Tag, "tag"); //Replace(graph, parent, Schema.Predicates.ReleaseNotes, "releaseNotes"); }
private static void CompareNodes(IUriNode a, IUriNode b) { Console.WriteLine("URI Node A has String form: " + a.ToString()); Console.WriteLine("URI Node B has String form: " + b.ToString()); Console.WriteLine(); Console.WriteLine("URI Node A has Hash Code: " + a.GetHashCode()); Console.WriteLine("URI Node B has Hash Code: " + b.GetHashCode()); Console.WriteLine(); Console.WriteLine("Nodes are Equal? " + a.Equals(b)); Console.WriteLine("Hash Codes are Equal? " + a.GetHashCode().Equals(b.GetHashCode())); Console.WriteLine(); }
public MetadataManifest(IPackageDocument document, string name) : base(document, name) { Graph.NamespaceMap.AddNamespace("pkg", new Uri("http://docs.oasis-open.org/ns/office/1.2/meta/pkg#")); Graph.NamespaceMap.AddNamespace("odf", new Uri("http://docs.oasis-open.org/ns/office/1.2/meta/odf#")); Graph.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#")); _documentNode = Graph.CreateUriNode(); _rdfTypeNode = Graph.CreateUriNode("rdf:type"); _hasPartPredicateNode = Graph.CreateUriNode("pkg:hasPart"); _metadataFileTypeNode = Graph.CreateUriNode("pkg:MetadataFile"); Graph.Assert(_documentNode, _rdfTypeNode, _hasPartPredicateNode); }
public static bool AreUrisEqual(IUriNode a, IUriNode b) { if (ReferenceEquals(a, b)) return true; if (a == null) { if (b == null) return true; return false; } else if (b == null) { return false; } return EqualityHelper.AreUrisEqual(a.Uri, b.Uri); }
private IDataObject BindRdfDataObject(IUriNode dataObjectResource, IGraph graph) { var triples = new List<Triple>(); foreach (var t in graph.GetTriplesWithSubject(dataObjectResource)) { if (t.Subject is IUriNode && t.Predicate is IUriNode) { // Only handling triples that have a URI predicate // subject will always be a UriNode, because that is what we used in the lookup var subject = (t.Subject as IUriNode).Uri.ToString(); var predicate = (t.Predicate as IUriNode).Uri.ToString(); if (t.Object is ILiteralNode) { var lit = t.Object as ILiteralNode; triples.Add(new Triple { Subject = subject, Predicate = predicate, IsLiteral = true, Object = lit.Value, DataType = lit.DataType == null ? Constants.DefaultDatatypeUri : lit.DataType.ToString(), LangCode = lit.Language }); } else if (t.Object is IUriNode) { var uriNode = t.Object as IUriNode; triples.Add(new Triple { Subject = subject, Predicate = predicate, IsLiteral = false, Object = uriNode.Uri.ToString() }); } } } var dataObject = _storeContext.MakeDataObject(dataObjectResource.Uri.ToString()) as DataObject; dataObject.BindTriples(triples); return dataObject; }
public ManifestGraph(IMetadataManifest metadataManifest) { if (metadataManifest == null) { throw new ArgumentNullException("metadataManifest"); } NamespaceMap.AddNamespace("pkg", new Uri("http://docs.oasis-open.org/ns/office/1.2/meta/pkg#")); NamespaceMap.AddNamespace("odf", new Uri("http://docs.oasis-open.org/ns/office/1.2/meta/odf#")); NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#")); //TODO Use a document URI. BaseUri = metadataManifest.Document.Uri; //_documentNode = CreateUriNode(new Uri("http://www.example.com")); _documentNode = CreateUriNode(); _rdfTypeNode = CreateUriNode("rdf:type"); _hasPartPredicateNode = CreateUriNode("pkg:hasPart"); _metadataFileTypeNode = CreateUriNode("pkg:MetadataFile"); IUriNode documentTypeNode = CreateUriNode("pkg:Document"); Assert(new Triple(_documentNode, _rdfTypeNode, documentTypeNode)); }
public static void CompareNodes(IUriNode a, IUriNode b, bool expectEquality) { Console.WriteLine("URI Node A has String form: " + a.ToString()); Console.WriteLine("URI Node B has String form: " + b.ToString()); Console.WriteLine(); Console.WriteLine("URI Node A has Hash Code: " + a.GetHashCode()); Console.WriteLine("URI Node B has Hash Code: " + b.GetHashCode()); Console.WriteLine(); Console.WriteLine("Nodes are Equal? " + a.Equals(b)); Console.WriteLine("Hash Codes are Equal? " + a.GetHashCode().Equals(b.GetHashCode())); Console.WriteLine(); if (expectEquality) { Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); Assert.AreEqual(a, b); } else { Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); Assert.AreNotEqual(a, b); } }
/// <summary> /// Nodes must implement a CompareTo method to allow them to be Sorted /// </summary> /// <param name="other">Node to compare self to</param> /// <returns></returns> /// <remarks> /// Implementations should use the SPARQL Term Sort Order for ordering nodes (as opposed to value sort order). Standard implementations of Node type specific comparisons can be found in <see cref="ComparisonHelper">ComparisonHelper</see> /// </remarks> public abstract int CompareTo(IUriNode other);
/// <summary> /// Formats a URI Node as a String for the given Format. /// </summary> /// <param name="u">URI Node.</param> /// <param name="segment">Triple Segment.</param> /// <returns></returns> protected abstract String FormatUriNode(IUriNode u, TripleSegment?segment);
private void GenerateUriOutput(RdfXmlWriterContext context, IUriNode u, String attribute, List<String> tempNamespaceIDs, XmlElement node, XmlDocument doc) { //Create an attribute XmlAttribute attr = doc.CreateAttribute(attribute, NamespaceMapper.RDF); //Get a Uri Reference if the Uri can be reduced UriRefType rtype; String uriref = this.GenerateUriRef(context, u, UriRefType.UriRef, tempNamespaceIDs, out rtype); attr.InnerXml = WriterHelper.EncodeForXml(uriref); //Append the attribute node.Attributes.Append(attr); }
public bool Equals(IUriNode other) { return(_source.Equals(other)); }
public override bool Equals(IUriNode other) { return Uri.Equals(other.Uri); }
/// <summary> /// Creates a new SubClassSelector for the given Graph with the given Target Class /// </summary> /// <param name="g"></param> /// <param name="targetClass"></param> public SubClassSelector(IGraph g, IUriNode targetClass) { this._targetclass = targetClass; this._subclassof = g.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "subClassOf")); }
public void StorageVirtuosoBlankNodePersistence() { //Create our Test Graph Graph g = new Graph(); g.BaseUri = new Uri("http://example.org/bnodes/"); g.NamespaceMap.AddNamespace(String.Empty, g.BaseUri); IBlankNode b = g.CreateBlankNode("blank"); IUriNode rdfType = g.CreateUriNode("rdf:type"); IUriNode bnode = g.CreateUriNode(":BlankNode"); g.Assert(new Triple(b, rdfType, bnode)); Assert.AreEqual(1, g.Triples.Count, "Should only be 1 Triple in the Test Graph"); //Connect to Virtuoso VirtuosoManager manager = VirtuosoTest.GetConnection(); try { //Save Graph manager.SaveGraph(g); //Retrieve Graph h = new Graph(); Graph i = new Graph(); manager.LoadGraph(h, g.BaseUri); manager.LoadGraph(i, g.BaseUri); Assert.AreEqual(1, h.Triples.Count, "Retrieved Graph should only contain 1 Triple"); Assert.AreEqual(1, i.Triples.Count, "Retrieved Graph should only contain 1 Triple"); Console.WriteLine("Contents of Retrieved Graph:"); foreach (Triple t in h.Triples) { Console.WriteLine(t.ToString()); } Console.WriteLine(); TestTools.CompareGraphs(h, i, true); //Save back again manager.SaveGraph(h); //Retrieve again Graph j = new Graph(); manager.LoadGraph(j, g.BaseUri); Console.WriteLine("Contents of Retrieved Graph (Retrieved after saving original Retrieval):"); foreach (Triple t in j.Triples) { Console.WriteLine(t.ToString()); } Console.WriteLine(); TestTools.CompareGraphs(h, j, false); TestTools.CompareGraphs(i, j, false); //Save back yet again manager.SaveGraph(j); //Retrieve yet again Graph k = new Graph(); manager.LoadGraph(k, g.BaseUri); Console.WriteLine("Contents of Retrieved Graph (Retrieved after saving second Retrieval):"); foreach (Triple t in k.Triples) { Console.WriteLine(t.ToString()); } Console.WriteLine(); TestTools.CompareGraphs(j, k, false); } finally { if (manager != null) { manager.Dispose(); } } }
/// <summary> /// Internal method which actually parses the Result Set by traversing the RDF Graph appropriately /// </summary> /// <param name="context">Parser Context</param> private void Parse(SparqlRdfParserContext context) { try { context.Handler.StartResults(); // Create relevant Nodes context.Graph.NamespaceMap.AddNamespace("rdf", UriFactory.Create(NamespaceMapper.RDF)); context.Graph.NamespaceMap.AddNamespace("rs", UriFactory.Create(SparqlSpecsHelper.SparqlRdfResultsNamespace)); IUriNode rdfType = context.Graph.CreateUriNode("rdf:type"); IUriNode resultSetClass = context.Graph.CreateUriNode("rs:ResultSet"); IUriNode resultVariable = context.Graph.CreateUriNode("rs:resultVariable"); IUriNode solution = context.Graph.CreateUriNode("rs:solution"); IUriNode binding = context.Graph.CreateUriNode("rs:binding"); IUriNode value = context.Graph.CreateUriNode("rs:value"); IUriNode variable = context.Graph.CreateUriNode("rs:variable"); IUriNode boolean = context.Graph.CreateUriNode("rs:boolean"); // Try to get a ResultSet object Triple rset = context.Graph.Triples.WithPredicateObject(rdfType, resultSetClass).FirstOrDefault(); if (rset != null) { INode rsetID = rset.Subject; // Find the Variables the Result Set contains or the Boolean Value List <Triple> temp = context.Graph.Triples.WithSubjectPredicate(rsetID, boolean).ToList(); if (temp.Count > 0) { if (temp.Count > 1) { throw new RdfParseException("Result Set has more than one boolean result defined for it"); } Triple booleanResult = temp.First(); INode result = booleanResult.Object; if (result.NodeType == NodeType.Literal) { ILiteralNode lit = (ILiteralNode)result; if (lit.DataType != null) { if (lit.DataType.AbsoluteUri.Equals(XmlSpecsHelper.XmlSchemaDataTypeBoolean)) { bool b; if (Boolean.TryParse(lit.Value, out b)) { context.Handler.HandleBooleanResult(b); return; } else { throw new RdfParseException("Result Set has a boolean result which is a Literal typed as boolean but which does not contain a valid boolean value"); } } else { throw new RdfParseException("Result Set has a boolean result which is a Literal which is not boolean typed"); } } else { throw new RdfParseException("Result Set has a boolean result which is a Literal which is not typed as a boolean"); } } else { throw new RdfParseException("Result Set has a boolean result which is not a Literal Node"); } } else { // We're expected one/more variables temp = context.Graph.Triples.WithSubjectPredicate(rsetID, resultVariable).ToList(); if (temp.Count > 0) { foreach (Triple t in temp) { if (t.Object.NodeType == NodeType.Literal) { if (!context.Handler.HandleVariable(((ILiteralNode)t.Object).Value)) { ParserHelper.Stop(); } context.Variables.Add(((ILiteralNode)t.Object).Value); } else { throw new RdfParseException("Result Set has a result variable definition which is not a Literal Node"); } } } else { throw new RdfParseException("Result Set does not define any result variables or a boolean result"); } // Then we're expecting some Solutions temp = context.Graph.Triples.WithSubjectPredicate(rsetID, solution).ToList(); foreach (Triple slnTriple in temp) { // Each Solution has some Bindings INode slnID = slnTriple.Object; bool ok = false; SparqlResult r = new SparqlResult(); foreach (Triple bindingTriple in context.Graph.Triples.WithSubjectPredicate(slnID, binding)) { // Each Binding has a Variable and a Value ok = true; INode bindingID = bindingTriple.Object; String var = String.Empty; INode val = null; // Retrieve the Variable and the Bound Value foreach (Triple valueTriple in context.Graph.Triples.WithSubject(bindingID)) { if (valueTriple.Predicate.Equals(variable)) { if (!var.Equals(String.Empty)) { throw new RdfParseException("Result Set contains a Binding which refers to more than one Variable"); } if (valueTriple.Object.NodeType != NodeType.Literal) { throw new RdfParseException("Result Set contains a Binding which refers to a Variable but not by a Literal Node as required"); } var = ((ILiteralNode)valueTriple.Object).Value; } else if (valueTriple.Predicate.Equals(value)) { if (val != null) { throw new RdfParseException("Result Set contains a Binding which has more than one Value"); } val = valueTriple.Object; } } if (var.Equals(String.Empty) || val == null) { throw new RdfParseException("Result Set contains a Binding which doesn't contain both a Variable and a Value"); } // Check that the Variable was defined in the Header if (!context.Variables.Contains(var)) { throw new RdfParseException("Unable to Parse a SPARQL Result Set since a <binding> element attempts to bind a value to the variable '" + var + "' which is not defined in the <head> by a <variable> element!"); } r.SetValue(var, val); } if (!ok) { throw new RdfParseException("Result Set contains a Solution which has no Bindings"); } // Check that all Variables are bound for a given result binding nulls where appropriate foreach (String v in context.Variables) { if (!r.HasValue(v)) { r.SetValue(v, null); } } if (!context.Handler.HandleResult(r)) { ParserHelper.Stop(); } } } } else { throw new RdfParseException("No Result Set object is defined in the Graph"); } context.Handler.EndResults(true); } catch (RdfParsingTerminatedException) { context.Handler.EndResults(true); } catch { context.Handler.EndResults(false); throw; } }
/// <summary> /// Compares two URI Nodes /// </summary> /// <param name="a">First URI Node</param> /// <param name="b">Second URI Node</param> /// <returns></returns> public static int CompareUris(IUriNode a, IUriNode b) { if (ReferenceEquals(a, b)) return 0; if (a == null) { if (b == null) return 0; return -1; } else if (b == null) { return 1; } return ComparisonHelper.CompareUris(a.Uri, b.Uri); }
public static bool HasVersionUri(this Ontology ontology) { IUriNode versionIri = ontology.Graph.CreateUriNode(VocabularyHelper.OWL.versionIRI); return(ontology.GetNodesViaPredicate(versionIri).UriNodes().Any()); }
public void NodesHashCodes() { Console.WriteLine("Tests that Literal and URI Nodes produce different Hashes"); Console.WriteLine(); //Create the Nodes Graph g = new Graph(); IUriNode u = g.CreateUriNode(new Uri("http://www.google.com")); ILiteralNode l = g.CreateLiteralNode("http://www.google.com/"); Console.WriteLine("Created a URI and Literal Node both referring to 'http://www.google.com'"); Console.WriteLine("String form of URI Node is:"); Console.WriteLine(u.ToString()); Console.WriteLine("String form of Literal Node is:"); Console.WriteLine(l.ToString()); Console.WriteLine("Hash Code of URI Node is " + u.GetHashCode()); Console.WriteLine("Hash Code of Literal Node is " + l.GetHashCode()); Console.WriteLine("Hash Codes are Equal? " + u.GetHashCode().Equals(l.GetHashCode())); Console.WriteLine("Nodes are equal? " + u.Equals(l)); Assert.NotEqual(u.GetHashCode(), l.GetHashCode()); Assert.NotSame(u, l); //Assert.NotEqual(u, l); //Create some plain and typed literals which may have colliding Hash Codes ILiteralNode plain = g.CreateLiteralNode("test^^http://example.org/type"); ILiteralNode typed = g.CreateLiteralNode("test", new Uri("http://example.org/type")); Console.WriteLine(); Console.WriteLine("Created a Plain and Typed Literal where the String representations are identical"); Console.WriteLine("Plain Literal String form is:"); Console.WriteLine(plain.ToString()); Console.WriteLine("Typed Literal String from is:"); Console.WriteLine(typed.ToString()); Console.WriteLine("Hash Code of Plain Literal is " + plain.GetHashCode()); Console.WriteLine("Hash Code of Typed Literal is " + typed.GetHashCode()); Console.WriteLine("Hash Codes are Equal? " + plain.GetHashCode().Equals(typed.GetHashCode())); Console.WriteLine("Nodes are equal? " + plain.Equals(typed)); Assert.NotEqual(plain.GetHashCode(), typed.GetHashCode()); Assert.NotEqual(plain, typed); //Create Triples IBlankNode b = g.CreateBlankNode(); IUriNode type = g.CreateUriNode("rdf:type"); Triple t1, t2; t1 = new Triple(b, type, u); t2 = new Triple(b, type, l); Console.WriteLine(); Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the URI Nodes created earlier"); Console.WriteLine("String form of Triple 1 (using URI Node) is:"); Console.WriteLine(t1.ToString()); Console.WriteLine("String form of Triple 2 (using Literal Node) is:"); Console.WriteLine(t2.ToString()); Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode()); Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode()); Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode())); Console.WriteLine("Triples are Equal? " + t1.Equals(t2)); Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode()); Assert.NotEqual(t1, t2); //Create Triples from the earlier Literal Nodes t1 = new Triple(b, type, plain); t2 = new Triple(b, type, typed); Console.WriteLine(); Console.WriteLine("Created two Triples stating a Blank Node has rdf:type of the Literal Nodes created earlier"); Console.WriteLine("String form of Triple 1 (using Plain Literal) is:"); Console.WriteLine(t1.ToString()); Console.WriteLine("String form of Triple 2 (using Typed Literal) is:"); Console.WriteLine(t2.ToString()); Console.WriteLine("Hash Code of Triple 1 is " + t1.GetHashCode()); Console.WriteLine("Hash Code of Triple 2 is " + t2.GetHashCode()); Console.WriteLine("Hash Codes are Equal? " + t1.GetHashCode().Equals(t2.GetHashCode())); Console.WriteLine("Triples are Equal? " + t1.Equals(t2)); Assert.NotEqual(t1.GetHashCode(), t2.GetHashCode()); Assert.NotEqual(t1, t2); }
public static bool IsDeprecated(this OntologyResource resource) { IUriNode deprecated = resource.Graph.CreateUriNode(OWL.deprecated); return(resource.GetNodesViaPredicate(deprecated).LiteralNodes().Any(node => node.Value == "true")); }
private void GenerateTemporaryNamespace(RdfXmlWriterContext context, IUriNode u, ref int nextNamespaceID, List<String> tempNamespaceIDs, XmlDocument doc) { String uri = u.Uri.ToString(); String nsUri; if (uri.Contains("#")) { //Create a Hash Namespace Uri nsUri = uri.Substring(0, uri.LastIndexOf("#") + 1); } else { //Create a Slash Namespace Uri nsUri = uri.Substring(0, uri.LastIndexOf("/") + 1); } //Create a Temporary Namespace ID while (context.Graph.NamespaceMap.HasNamespace("ns" + nextNamespaceID)) { nextNamespaceID++; } String prefix = "ns" + nextNamespaceID; nextNamespaceID++; context.Graph.NamespaceMap.AddNamespace(prefix, new Uri(nsUri)); tempNamespaceIDs.Add(prefix); //Add to XML Document Element XmlAttribute ns = doc.CreateAttribute("xmlns:" + prefix, "http://www.w3.org/2000/xmlns/"); ns.Value = nsUri; doc.DocumentElement.Attributes.Append(ns); this.RaiseWarning("Created a Temporary Namespace '" + prefix + "' with URI '" + nsUri + "'"); }
private String GenerateUriRef(RdfXmlWriterContext context, IUriNode u, UriRefType type, List<String> tempNamespaceIDs, out UriRefType outType) { String uriref, qname; if (context.Graph.NamespaceMap.ReduceToQName(u.Uri.ToString(), out qname)) { //Reduced to QName OK uriref = qname; outType = UriRefType.QName; } else { //Just use the Uri uriref = u.Uri.ToString(); outType = UriRefType.Uri; } //Convert to a Uri Ref from a QName if required if (outType == UriRefType.QName && type == UriRefType.UriRef) { if (uriref.Contains(':') && !uriref.StartsWith(":")) { String prefix = uriref.Substring(0, uriref.IndexOf(':')); if (context.UseDtd && !tempNamespaceIDs.Contains(prefix)) { //Must be using a DTD to use references of this form //Can only use entities for non-temporary Namespaces as Temporary Namespaces won't have Entities defined uriref = "&" + uriref.Replace(':', ';'); } else { uriref = context.Graph.NamespaceMap.GetNamespaceUri(prefix).ToString() + uriref.Substring(uriref.IndexOf(':') + 1); } } else { if (context.Graph.NamespaceMap.HasNamespace(String.Empty)) { uriref = context.Graph.NamespaceMap.GetNamespaceUri(String.Empty).ToString() + uriref.Substring(1); } else { String baseUri = context.Graph.BaseUri.ToString(); if (!baseUri.EndsWith("#")) baseUri += "#"; uriref = baseUri + uriref; } } outType = UriRefType.UriRef; } return uriref; }
/// <summary> /// Takes a <see cref="INode">INode</see> and converts it to a <see cref="IValuedNode">IValuedNode</see> if it is not already an instance that implements the interface. /// </summary> /// <param name="n">Node.</param> /// <returns>Valued Node.</returns> public static IValuedNode AsValuedNode(this INode n) { if (n == null) { return(null); } if (n is IValuedNode) { return((IValuedNode)n); } switch (n.NodeType) { case NodeType.Blank: IBlankNode b = (IBlankNode)n; return(new BlankNode(n.Graph, b.InternalID)); case NodeType.GraphLiteral: IGraphLiteralNode glit = (IGraphLiteralNode)n; return(new GraphLiteralNode(n.Graph, glit.SubGraph)); case NodeType.Literal: ILiteralNode lit = (ILiteralNode)n; // Decide what kind of valued node to produce based on node datatype if (lit.DataType != null) { String dt = lit.DataType.AbsoluteUri; switch (dt) { case XmlSpecsHelper.XmlSchemaDataTypeBoolean: bool bVal; if (Boolean.TryParse(lit.Value, out bVal)) { return(new BooleanNode(n.Graph, bVal)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeByte: // xsd:byte actually maps to SignedByte in .Net sbyte sbVal; if (sbyte.TryParse(lit.Value, out sbVal)) { return(new SignedByteNode(n.Graph, sbVal, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeDate: DateTime date; if (DateTime.TryParse(lit.Value, null, DateTimeStyles.AdjustToUniversal, out date)) { return(new DateNode(n.Graph, date, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeDateTime: DateTime dateTime; if (DateTime.TryParse(lit.Value, null, DateTimeStyles.AdjustToUniversal, out dateTime)) { return(new DateTimeNode(n.Graph, dateTime, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeDayTimeDuration: case XmlSpecsHelper.XmlSchemaDataTypeDuration: TimeSpan timeSpan; try { timeSpan = XmlConvert.ToTimeSpan(lit.Value); return(new TimeSpanNode(n.Graph, timeSpan, lit.Value, lit.DataType)); } catch { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeDecimal: Decimal dec; if (Decimal.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out dec)) { return(new DecimalNode(n.Graph, dec, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeDouble: Double dbl; if (Double.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out dbl)) { return(new DoubleNode(n.Graph, dbl, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeFloat: Single flt; if (Single.TryParse(lit.Value, NumberStyles.Any, CultureInfo.InvariantCulture, out flt)) { return(new FloatNode(n.Graph, flt, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeInt: case XmlSpecsHelper.XmlSchemaDataTypeInteger: case XmlSpecsHelper.XmlSchemaDataTypeLong: case XmlSpecsHelper.XmlSchemaDataTypeShort: long lng; if (Int64.TryParse(lit.Value, out lng)) { return(new LongNode(n.Graph, lng, lit.Value, lit.DataType)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeNegativeInteger: case XmlSpecsHelper.XmlSchemaDataTypeNonPositiveInteger: // Must be below zero long neglng; if (Int64.TryParse(lit.Value, out neglng) && neglng < 0) { return(new LongNode(n.Graph, neglng, lit.Value, lit.DataType)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeNonNegativeInteger: case XmlSpecsHelper.XmlSchemaDataTypePositiveInteger: // Must be above zero long poslng; if (Int64.TryParse(lit.Value, out poslng) && poslng >= 0) { return(new LongNode(n.Graph, poslng, lit.Value, lit.DataType)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeUnsignedByte: // xsd:unsignedByte actually maps to Byte in .Net byte byVal; if (byte.TryParse(lit.Value, out byVal)) { return(new ByteNode(n.Graph, byVal, lit.Value)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } case XmlSpecsHelper.XmlSchemaDataTypeUnsignedInt: case XmlSpecsHelper.XmlSchemaDataTypeUnsignedLong: case XmlSpecsHelper.XmlSchemaDataTypeUnsignedShort: // Must be unsigned ulong ulng; if (UInt64.TryParse(lit.Value, out ulng)) { return(new UnsignedLongNode(n.Graph, ulng, lit.Value, lit.DataType)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } default: if (SparqlSpecsHelper.IntegerDataTypes.Contains(dt)) { long l; if (Int64.TryParse(lit.Value, out l)) { return(new LongNode(n.Graph, l, lit.Value, lit.DataType)); } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } } else { return(new StringNode(n.Graph, lit.Value, lit.DataType)); } } } else if (!lit.Language.Equals(String.Empty)) { return(new StringNode(n.Graph, lit.Value, lit.Language)); } else { return(new StringNode(n.Graph, lit.Value)); } case NodeType.Uri: IUriNode u = (IUriNode)n; return(new UriNode(n.Graph, u.Uri)); case NodeType.Variable: IVariableNode v = (IVariableNode)n; return(new VariableNode(n.Graph, v.VariableName)); default: throw new RdfQueryException("Cannot create a valued node for an unknown node type"); } }
/// <summary> /// Formats URIs for CSV output /// </summary> /// <param name="u">URI</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected override string FormatUriNode(IUriNode u, TripleSegment?segment) { return(this.FormatUri(u.Uri)); }
/// <summary> /// Reifies a Triple /// </summary> /// <param name="context">Parser Context</param> /// <param name="uriref">Uri Reference for the Reified Triple</param> /// <param name="subj">Subject of the Triple</param> /// <param name="pred">Predicate of the Triple</param> /// <param name="obj">Object of the Triple</param> private void Reify(RdfXmlParserContext context, IUriNode uriref, INode subj, INode pred, INode obj) { if (!context.Handler.HandleTriple(new Triple(uriref, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfSubject)), subj))) ParserHelper.Stop(); if (!context.Handler.HandleTriple(new Triple(uriref, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfPredicate)), pred))) ParserHelper.Stop(); if (!context.Handler.HandleTriple(new Triple(uriref, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfObject)), obj))) ParserHelper.Stop(); if (!context.Handler.HandleTriple(new Triple(uriref, context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType)), context.Handler.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfStatement))))) ParserHelper.Stop(); }
public void SparqlMultisetLeftJoin() { //Create a load of Nodes to use in the tests Graph g = new Graph(); g.NamespaceMap.AddNamespace(String.Empty, new Uri("http://example.org")); IUriNode s1 = g.CreateUriNode(":s1"); IUriNode s2 = g.CreateUriNode(":s2"); IUriNode p1 = g.CreateUriNode(":p1"); IUriNode p2 = g.CreateUriNode(":p2"); IUriNode rdfsLabel = g.CreateUriNode("rdfs:label"); ILiteralNode o1 = g.CreateLiteralNode("Some Text"); ILiteralNode o2 = g.CreateLiteralNode("1", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)); //Create an ID and Null Multiset IdentityMultiset id = new IdentityMultiset(); NullMultiset nullset = new NullMultiset(); //Create and Populate a Multiset Multiset m = new Multiset(); Set s = new Set(); s.Add("s", s1); s.Add("p", p1); s.Add("o", o1); m.Add(s); s = new Set(); s.Add("s", s2); s.Add("p", p2); s.Add("o", o2); m.Add(s); //Create and Populate another Multiset Multiset n = new Multiset(); s = new Set(); s.Add("s", s1); s.Add("label", o1); n.Add(s); //Create and Populate another Multiset Multiset d = new Multiset(); s = new Set(); s.Add("s1", s1); s.Add("p1", p1); s.Add("o1", o1); d.Add(s); s = new Set(); s.Add("s1", s2); s.Add("p1", p2); s.Add("o1", o2); d.Add(s); //Show the Sets Console.WriteLine("LHS"); foreach (ISet set in m.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); Console.WriteLine("RHS"); foreach (ISet set in n.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); Console.WriteLine("D"); foreach (ISet set in d.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join to Identity Console.WriteLine("Join ID-LHS"); BaseMultiset join = id.Join(m); foreach (ISet set in join.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join to Identity Console.WriteLine("Join LHS-ID"); join = m.Join(id); foreach (ISet set in join.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join to Null Console.WriteLine("Join NULL-LHS"); join = nullset.Join(m); foreach (ISet set in join.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join to Null Console.WriteLine("Join LHS-NULL"); join = m.Join(nullset); foreach (ISet set in join.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a LeftJoin Console.WriteLine("LeftJoin NULL-LHS"); BaseMultiset leftjoin = nullset.LeftJoin(m, new ConstantTerm(new BooleanNode(null, true))); foreach (ISet set in leftjoin.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a LeftJoin Console.WriteLine("LeftJoin LHS-NULL"); leftjoin = m.LeftJoin(nullset, new ConstantTerm(new BooleanNode(null, true))); foreach (ISet set in leftjoin.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join Console.WriteLine("Join LHS-RHS"); join = m.Join(n); foreach (ISet set in join.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a LeftOuterJoin Console.WriteLine("LeftJoin LHS-RHS"); leftjoin = m.LeftJoin(n, new ConstantTerm(new BooleanNode(null, true))); foreach (ISet set in leftjoin.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Produce Console.WriteLine("Product LHS-RHS"); BaseMultiset product = m.Product(n); foreach (ISet set in product.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Join to Self Console.WriteLine("Product LHS-D"); product = m.Product(d); foreach (ISet set in product.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); //Try a Union Console.WriteLine("Union LHS-RHS"); BaseMultiset union = m.Union(n); foreach (ISet set in union.Sets) { Console.WriteLine(set.ToString()); } Console.WriteLine(); }
public void SparqlStreamingBgpSelectEvaluation() { //Get the Data we want to query TripleStore store = new TripleStore(); Graph g = new Graph(); FileLoader.Load(g, "resources\\InferenceTest.ttl"); store.Add(g); //g = new Graph(); //g.LoadFromFile("noise.ttl"); //store.Add(g); Console.WriteLine(store.Triples.Count() + " Triples in Store"); //Create the Triple Pattern we want to query with IUriNode fordFiesta = g.CreateUriNode(new Uri("http://example.org/vehicles/FordFiesta")); IUriNode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); IUriNode rdfsLabel = g.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label")); IUriNode speed = g.CreateUriNode(new Uri("http://example.org/vehicles/Speed")); IUriNode carClass = g.CreateUriNode(new Uri("http://example.org/vehicles/Car")); TriplePattern allTriples = new TriplePattern(new VariablePattern("?s"), new VariablePattern("?p"), new VariablePattern("?o")); TriplePattern allTriples2 = new TriplePattern(new VariablePattern("?x"), new VariablePattern("?y"), new VariablePattern("?z")); TriplePattern tp1 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(rdfType), new NodeMatchPattern(carClass)); TriplePattern tp2 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(speed), new VariablePattern("?speed")); TriplePattern tp3 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(rdfsLabel), new VariablePattern("?label")); TriplePattern novars = new TriplePattern(new NodeMatchPattern(fordFiesta), new NodeMatchPattern(rdfType), new NodeMatchPattern(carClass)); TriplePattern novars2 = new TriplePattern(new NodeMatchPattern(fordFiesta), new NodeMatchPattern(rdfsLabel), new NodeMatchPattern(carClass)); FilterPattern blankSubject = new FilterPattern(new UnaryExpressionFilter(new IsBlankFunction(new VariableTerm("?s")))); List <List <ITriplePattern> > tests = new List <List <ITriplePattern> >() { new List <ITriplePattern>() { }, new List <ITriplePattern>() { allTriples }, new List <ITriplePattern>() { allTriples, allTriples2 }, new List <ITriplePattern>() { tp1 }, new List <ITriplePattern>() { tp1, tp2 }, new List <ITriplePattern>() { tp1, tp3 }, new List <ITriplePattern>() { novars }, new List <ITriplePattern>() { novars, tp1 }, new List <ITriplePattern>() { novars, tp1, tp2 }, new List <ITriplePattern>() { novars2 }, new List <ITriplePattern>() { tp1, blankSubject } }; foreach (List <ITriplePattern> tps in tests) { Console.WriteLine(tps.Count + " Triple Patterns in the Query"); foreach (ITriplePattern tp in tps) { Console.WriteLine(tp.ToString()); } Console.WriteLine(); ISparqlAlgebra select = new Bgp(tps); ISparqlAlgebra selectOptimised = new LazyBgp(tps, 10); //Evaluate with timings Stopwatch timer = new Stopwatch(); TimeSpan unopt, opt; timer.Start(); BaseMultiset results1 = select.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store))); timer.Stop(); unopt = timer.Elapsed; timer.Reset(); timer.Start(); BaseMultiset results2 = selectOptimised.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store))); timer.Stop(); opt = timer.Elapsed; Console.WriteLine("SELECT = " + results1.GetType().ToString() + " (" + results1.Count + " Results) in " + unopt.ToString()); Console.WriteLine("SELECT Optimised = " + results2.GetType().ToString() + " (" + results2.Count + " Results) in " + opt.ToString()); Console.WriteLine(); Console.WriteLine("Optimised Results"); foreach (ISet s in results2.Sets) { Console.WriteLine(s.ToString()); } Assert.IsTrue(results1.Count >= results2.Count, "Optimised Select should have produced as many/fewer results than Unoptimised Select"); Console.WriteLine(); } }
public int CompareTo(IUriNode other) { return(_source.CompareTo(other)); }
/// <summary> /// Internal method which generates the HTML Output for the Graph /// </summary> /// <param name="context">Writer Context</param> private void GenerateOutput(HtmlWriterContext context) { Object results; //Add the Namespaces we want to use later on context.QNameMapper.AddNamespace("owl", UriFactory.Create(NamespaceMapper.OWL)); context.QNameMapper.AddNamespace("rdf", UriFactory.Create(NamespaceMapper.RDF)); context.QNameMapper.AddNamespace("rdfs", UriFactory.Create(NamespaceMapper.RDFS)); context.QNameMapper.AddNamespace("dc", UriFactory.Create("http://purl.org/dc/elements/1.1/")); context.QNameMapper.AddNamespace("dct", UriFactory.Create("http://purl.org/dc/terms/")); context.QNameMapper.AddNamespace("vann", UriFactory.Create("http://purl.org/vocab/vann/")); context.QNameMapper.AddNamespace("vs", UriFactory.Create("http://www.w3.org/2003/06/sw-vocab-status/ns#")); //Find the Node that represents the Schema Ontology //Assumes there is exactly one thing given rdf:type owl:Ontology IUriNode ontology = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.OWL + "Ontology")); IUriNode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType)); IUriNode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label")); INode ontoNode = context.Graph.GetTriplesWithPredicateObject(rdfType, ontology).Select(t => t.Subject).FirstOrDefault(); INode ontoLabel = (ontoNode != null) ? context.Graph.GetTriplesWithSubjectPredicate(ontoNode, rdfsLabel).Select(t => t.Object).FirstOrDefault() : null; //Stuff for formatting //We'll use the Turtle Formatter to get nice QNames wherever possible context.NodeFormatter = new TurtleFormatter(context.QNameMapper); context.UriFormatter = (IUriFormatter)context.NodeFormatter; //Page Header context.HtmlWriter.Write("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML+RDFa 1.0//EN\" \"http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd\">"); context.HtmlWriter.WriteLine(); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Html); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Head); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Title); context.HtmlWriter.WriteEncodedText("Schema"); if (ontoNode != null && ontoLabel != null) { context.HtmlWriter.WriteEncodedText(" - " + ontoLabel.ToSafeString()); } else if (context.Graph.BaseUri != null) { context.HtmlWriter.WriteEncodedText(" - " + context.Graph.BaseUri.AbsoluteUri); } context.HtmlWriter.RenderEndTag(); if (!this.Stylesheet.Equals(String.Empty)) { context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Href, this.Stylesheet); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Type, "text/css"); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Rel, "stylesheet"); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Link); context.HtmlWriter.RenderEndTag(); } context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Start Body context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Body); //Title context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H2); context.HtmlWriter.WriteEncodedText("Schema"); if (ontoNode != null && ontoLabel != null) { context.HtmlWriter.WriteEncodedText(" - " + ontoLabel.ToSafeString()); } else if (context.Graph.BaseUri != null) { context.HtmlWriter.WriteEncodedText(" - " + context.Graph.BaseUri.AbsoluteUri); } context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Show the Description of the Schema (if any) if (ontoNode != null) { SparqlParameterizedString getOntoDescrip = new SparqlParameterizedString(); getOntoDescrip.Namespaces = context.QNameMapper; getOntoDescrip.CommandText = "SELECT * WHERE { @onto a owl:Ontology . OPTIONAL { @onto rdfs:comment ?description } . OPTIONAL { @onto vann:preferredNamespacePrefix ?nsPrefix ; vann:preferredNamespaceUri ?nsUri } . OPTIONAL { @onto dc:creator ?creator . ?creator (foaf:name | rdfs:label) ?creatorName } }"; getOntoDescrip.SetParameter("onto", ontoNode); try { results = context.Graph.ExecuteQuery(getOntoDescrip); if (results is SparqlResultSet) { if (!((SparqlResultSet)results).IsEmpty) { SparqlResult ontoInfo = ((SparqlResultSet)results)[0]; //Show rdfs:comment on the Ontology if (ontoInfo.HasValue("description")) { INode descrip = ontoInfo["description"]; if (descrip.NodeType == NodeType.Literal) { context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.Write(((ILiteralNode)descrip).Value); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif } } //Show Author Information if (ontoInfo.HasValue("creator")) { INode author = ontoInfo["creator"]; INode authorName = ontoInfo["creatorName"]; context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Em); context.HtmlWriter.WriteEncodedText("Schema created by "); if (author.NodeType == NodeType.Uri) { context.HtmlWriter.AddAttribute("href", ((IUriNode)author).Uri.AbsoluteUri); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassUri); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); } switch (authorName.NodeType) { case NodeType.Uri: context.HtmlWriter.WriteEncodedText(((IUriNode)authorName).Uri.AbsoluteUri); break; case NodeType.Literal: context.HtmlWriter.WriteEncodedText(((ILiteralNode)authorName).Value); break; default: context.HtmlWriter.WriteEncodedText(authorName.ToString()); break; } if (author.NodeType == NodeType.Uri) { context.HtmlWriter.RenderEndTag(); } context.HtmlWriter.RenderEndTag(); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif } //Show the Namespace information for the Schema if (ontoInfo.HasValue("nsPrefix")) { if (ontoInfo["nsPrefix"].NodeType == NodeType.Literal && ontoInfo["nsUri"].NodeType == NodeType.Uri) { //Add this QName to the QName Mapper so we can get nice QNames later on String prefix = ((ILiteralNode)ontoInfo["nsPrefix"]).Value; context.QNameMapper.AddNamespace(prefix, ((IUriNode)ontoInfo["nsUri"]).Uri); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H4); context.HtmlWriter.WriteEncodedText("Preferred Namespace Definition"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Show human readable description of preferred Namespace Settings context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.WriteEncodedText("Preferred Namespace Prefix is "); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Strong); context.HtmlWriter.WriteEncodedText(prefix); context.HtmlWriter.RenderEndTag(); context.HtmlWriter.WriteEncodedText(" and preferred Namespace URI is "); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Href, context.QNameMapper.GetNamespaceUri(prefix).AbsoluteUri); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassUri); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); context.HtmlWriter.WriteEncodedText(context.QNameMapper.GetNamespaceUri(prefix).AbsoluteUri); context.HtmlWriter.RenderEndTag(); context.HtmlWriter.RenderEndTag(); //RDF/XML Syntax context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H5); context.HtmlWriter.WriteEncodedText("RDF/XML Syntax"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.AddStyleAttribute(HtmlTextWriterStyle.Width, "90%"); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Pre); int currIndent = context.HtmlWriter.Indent; context.HtmlWriter.Indent = 0; context.HtmlWriter.WriteEncodedText("<?xml version=\"1.0\" charset=\"utf-8\"?>"); context.HtmlWriter.WriteLine(); context.HtmlWriter.WriteEncodedText("<rdf:RDF xmlns:rdf=\"" + NamespaceMapper.RDF + "\" xmlns:" + prefix + "=\"" + context.UriFormatter.FormatUri(context.QNameMapper.GetNamespaceUri(prefix)) + "\">"); context.HtmlWriter.WriteLine(); context.HtmlWriter.WriteEncodedText(" <!-- Your RDF here... -->"); context.HtmlWriter.WriteLine(); context.HtmlWriter.WriteEncodedText("</rdf:RDF>"); context.HtmlWriter.Indent = currIndent; context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Turtle/N3 Syntax context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H5); context.HtmlWriter.WriteEncodedText("Turtle/N3 Syntax"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.AddStyleAttribute(HtmlTextWriterStyle.Width, "90%"); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Pre); currIndent = context.HtmlWriter.Indent; context.HtmlWriter.Indent = 0; context.HtmlWriter.WriteEncodedText("@prefix " + prefix + ": <" + context.UriFormatter.FormatUri(context.QNameMapper.GetNamespaceUri(prefix)) + "> ."); context.HtmlWriter.Indent = currIndent; context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //SPARQL Syntax context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H5); context.HtmlWriter.WriteEncodedText("SPARQL Syntax"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.AddStyleAttribute(HtmlTextWriterStyle.Width, "90%"); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Pre); currIndent = context.HtmlWriter.Indent; context.HtmlWriter.Indent = 0; context.HtmlWriter.WriteEncodedText("PREFIX " + prefix + ": <" + context.UriFormatter.FormatUri(context.QNameMapper.GetNamespaceUri(prefix)) + ">"); context.HtmlWriter.Indent = currIndent; context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif } } } } else { throw new RdfOutputException("Tried to make a SPARQL Query to determine Schema Information but an unexpected Query Result was returned"); } } catch (RdfQueryException queryEx) { throw new RdfOutputException("Tried to make a SPARQL Query to determine Schema Information but a Query Error occurred", queryEx); } } SparqlParameterizedString getPropertyRanges = new SparqlParameterizedString(); getPropertyRanges.Namespaces = new NamespaceMapper(); getPropertyRanges.Namespaces.AddNamespace("owl", UriFactory.Create(NamespaceMapper.OWL)); getPropertyRanges.CommandText = "SELECT ?range WHERE { { @property rdfs:range ?range . FILTER(ISURI(?range)) } UNION { @property rdfs:range ?union . ?union owl:unionOf ?ranges . { ?ranges rdf:first ?range } UNION { ?ranges rdf:rest+/rdf:first ?range } } }"; SparqlParameterizedString getPropertyDomains = new SparqlParameterizedString(); getPropertyDomains.Namespaces = getPropertyRanges.Namespaces; getPropertyDomains.CommandText = "SELECT ?domain WHERE { { @property rdfs:domain ?domain . FILTER(ISURI(?domain)) } UNION { @property rdfs:domain ?union . ?union owl:unionOf ?domains . { ?domains rdf:first ?domain } UNION { ?domains rdf:rest+/rdf:first ?domain } } }"; //Show lists of all Classes and Properties in the Schema context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H4); context.HtmlWriter.WriteEncodedText("Class and Property Summary"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.WriteEncodedText("This Schema defines the following classes:"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.AddStyleAttribute("width", "90%"); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassBox); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); //Get the Classes and Display SparqlParameterizedString getClasses = new SparqlParameterizedString(); getClasses.Namespaces = context.QNameMapper; getClasses.CommandText = "SELECT DISTINCT ?class WHERE { { ?class a rdfs:Class } UNION { ?class a owl:Class } FILTER(ISURI(?class)) } ORDER BY ?class"; try { results = context.Graph.ExecuteQuery(getClasses); if (results is SparqlResultSet) { SparqlResultSet rs = (SparqlResultSet)results; for (int i = 0; i < rs.Count; i++) { SparqlResult r = rs[i]; //Get the QName and output a Link to an anchor that we'll generate later to let //users jump to a Class/Property definition String qname = context.NodeFormatter.Format(r["class"]); context.HtmlWriter.AddAttribute("href", "#" + qname); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassUri); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); context.HtmlWriter.WriteEncodedText(qname); context.HtmlWriter.RenderEndTag(); if (i < rs.Count - 1) { context.HtmlWriter.WriteEncodedText(" , "); } } } else { throw new RdfOutputException("Tried to make a SPARQL Query to find Classes in the Schema but an unexpected Query Result was returned"); } } catch (RdfQueryException queryEx) { throw new RdfOutputException("Tried to make a SPARQL Query to find Classes in the Schema but a Query Error occurred", queryEx); } context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.WriteEncodedText("This Schema defines the following properties:"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif context.HtmlWriter.AddStyleAttribute("width", "90%"); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassBox); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); //Get the Properties and Display SparqlParameterizedString getProperties = new SparqlParameterizedString(); getProperties.Namespaces = context.QNameMapper; getProperties.CommandText = "SELECT DISTINCT ?property WHERE { { ?property a rdf:Property } UNION { ?property a owl:DatatypeProperty } UNION { ?property a owl:ObjectProperty } FILTER(ISURI(?property)) } ORDER BY ?property"; try { results = context.Graph.ExecuteQuery(getProperties); if (results is SparqlResultSet) { SparqlResultSet rs = (SparqlResultSet)results; for (int i = 0; i < rs.Count; i++) { SparqlResult r = rs[i]; //Get the QName and output a Link to an anchor that we'll generate later to let //users jump to a Class/Property definition String qname = context.NodeFormatter.Format(r["property"]); context.HtmlWriter.AddAttribute("href", "#" + qname); context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassUri); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); context.HtmlWriter.WriteEncodedText(qname); context.HtmlWriter.RenderEndTag(); if (i < rs.Count - 1) { context.HtmlWriter.WriteEncodedText(" , "); } } } else { throw new RdfOutputException("Tried to make a SPARQL Query to find Properties in the Schema but an unexpected Query Result was returned"); } } catch (RdfQueryException queryEx) { throw new RdfOutputException("Tried to make a SPARQL Query to find Properties in the Schema but a Query Error occurred", queryEx); } context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Show details for each class context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H3); context.HtmlWriter.WriteEncodedText("Classes"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Now create the URI Nodes we need for the next stage of Output IUriNode rdfsDomain = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "domain")); IUriNode rdfsRange = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "range")); IUriNode rdfsSubClassOf = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "subClassOf")); IUriNode rdfsSubPropertyOf = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "subPropertyOf")); IUriNode owlDisjointClass = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.OWL + "disjointWith")); IUriNode owlEquivalentClass = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.OWL + "equivalentClass")); IUriNode owlEquivalentProperty = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.OWL + "equivalentProperty")); IUriNode owlInverseProperty = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.OWL + "inverseOf")); //Alter our previous getClasses query to get additional details getClasses.CommandText = "SELECT ?class (SAMPLE(?label) AS ?classLabel) (SAMPLE(?description) AS ?classDescription) WHERE { { ?class a rdfs:Class } UNION { ?class a owl:Class } FILTER(ISURI(?class)) OPTIONAL { ?class rdfs:label ?label } OPTIONAL { ?class rdfs:comment ?description } } GROUP BY ?class ORDER BY ?class"; try { results = context.Graph.ExecuteQuery(getClasses); if (results is SparqlResultSet) { foreach (SparqlResult r in (SparqlResultSet)results) { if (!r.HasValue("class")) { continue; } String qname = context.NodeFormatter.Format(r["class"]); //Use a <div> for each Class context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassBox); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Div); //Add the Anchor to which earlier Class summary links to context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Name, qname); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); context.HtmlWriter.RenderEndTag(); //Show Basic Class Information context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H4); context.HtmlWriter.WriteEncodedText("Class: " + qname); context.HtmlWriter.RenderEndTag(); //Show "Local Name - Label" context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Em); if (TurtleSpecsHelper.IsValidQName(qname)) { context.HtmlWriter.WriteEncodedText(qname); } else { Uri temp = new Uri(qname, UriKind.RelativeOrAbsolute); if (!temp.Fragment.Equals(String.Empty)) { context.HtmlWriter.WriteEncodedText(temp.Fragment); } else { #if !SILVERLIGHT context.HtmlWriter.WriteEncodedText(temp.Segments.Last()); #else context.HtmlWriter.WriteEncodedText(temp.Segments().Last()); #endif } } context.HtmlWriter.RenderEndTag(); if (r.HasValue("classLabel")) { if (r["classLabel"] != null && r["classLabel"].NodeType == NodeType.Literal) { context.HtmlWriter.WriteEncodedText(" - "); context.HtmlWriter.WriteEncodedText(((ILiteralNode)r["classLabel"]).Value); } } context.HtmlWriter.WriteLine(); context.HtmlWriter.WriteBreak(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Output further information about the class IEnumerable <Triple> ts; //Output any Subclasses ts = context.Graph.GetTriplesWithSubjectPredicate(rdfsSubClassOf, r["class"]); this.GenerateCaptionedInformation(context, "Has Sub Classes", ts, t => t.Object); //Output Properties which have this as domain/range ts = context.Graph.GetTriplesWithPredicateObject(rdfsDomain, r["class"]); this.GenerateCaptionedInformation(context, "Properties Include", ts, t => t.Subject); ts = context.Graph.GetTriplesWithPredicateObject(rdfsRange, r["class"]); this.GenerateCaptionedInformation(context, "Used With", ts, t => t.Subject); //Output any Equivalent Classes ts = context.Graph.GetTriplesWithSubjectPredicate(r["class"], owlEquivalentClass).Concat(context.Graph.GetTriplesWithPredicateObject(owlEquivalentClass, r["class"])); this.GenerateCaptionedInformation(context, "Equivalent Classes", ts, t => t.Subject.Equals(r["class"]) ? t.Object : t.Subject); //Output any Disjoint Classes ts = context.Graph.GetTriplesWithSubjectPredicate(r["class"], owlDisjointClass).Concat(context.Graph.GetTriplesWithPredicateObject(owlDisjointClass, r["class"])); this.GenerateCaptionedInformation(context, "Disjoint Classes", ts, t => t.Subject.Equals(r["class"]) ? t.Object : t.Subject); //Show the Class Description if (r.HasValue("classDescription")) { if (r["classDescription"] != null && r["classDescription"].NodeType == NodeType.Literal) { context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.Write(((ILiteralNode)r["classDescription"]).Value); context.HtmlWriter.RenderEndTag(); } } //End the </div> for the Class context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif } } else { throw new RdfOutputException("Tried to make a SPARQL Query to get Class Information from the Schema but an unexpected Query Result was returned"); } } catch (RdfQueryException queryEx) { throw new RdfOutputException("Tried to make a SPARQL Query to get Class Information from the Schema but a Query Error occurred", queryEx); } //Show details for each property context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H3); context.HtmlWriter.WriteEncodedText("Properties"); context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Alter our previous getProperties query to get additional details getProperties.CommandText = "SELECT ?property (SAMPLE(?label) AS ?propertyLabel) (SAMPLE(?description) AS ?propertyDescription) WHERE { { ?property a rdf:Property } UNION { ?property a owl:ObjectProperty } UNION { ?property a owl:DatatypeProperty } FILTER(ISURI(?property)) OPTIONAL { ?property rdfs:label ?label } OPTIONAL { ?property rdfs:comment ?description } } GROUP BY ?property ORDER BY ?property"; try { results = context.Graph.ExecuteQuery(getProperties); if (results is SparqlResultSet) { foreach (SparqlResult r in (SparqlResultSet)results) { if (!r.HasValue("property")) { continue; } String qname = context.NodeFormatter.Format(r["property"]); //Use a <div> for each Property context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Class, this.CssClassBox); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Div); //Add the Anchor to which earlier Property summary links to context.HtmlWriter.AddAttribute(HtmlTextWriterAttribute.Name, qname); context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.A); context.HtmlWriter.RenderEndTag(); //Show Basic Property Information context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.H4); context.HtmlWriter.WriteEncodedText("Property: " + qname); context.HtmlWriter.RenderEndTag(); //Show "Local Name - Label" context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.Em); if (TurtleSpecsHelper.IsValidQName(qname)) { context.HtmlWriter.WriteEncodedText(qname); } else { Uri temp = new Uri(qname, UriKind.RelativeOrAbsolute); if (!temp.Fragment.Equals(String.Empty)) { context.HtmlWriter.WriteEncodedText(temp.Fragment); } else { #if !SILVERLIGHT context.HtmlWriter.WriteEncodedText(temp.Segments.Last()); #else context.HtmlWriter.WriteEncodedText(temp.Segments().Last()); #endif } } context.HtmlWriter.RenderEndTag(); if (r.HasValue("propertyLabel")) { if (r["propertyLabel"] != null && r["propertyLabel"].NodeType == NodeType.Literal) { context.HtmlWriter.WriteEncodedText(" - "); context.HtmlWriter.WriteEncodedText(((ILiteralNode)r["propertyLabel"]).Value); } } context.HtmlWriter.WriteLine(); context.HtmlWriter.WriteBreak(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif //Output further information about the property IEnumerable <Triple> ts; //Output any Subproperties ts = context.Graph.GetTriplesWithSubjectPredicate(rdfsSubPropertyOf, r["property"]); this.GenerateCaptionedInformation(context, "Has Sub Properties", ts, t => t.Object); //Output Domain and Range //ts = context.Graph.GetTriplesWithSubjectPredicate(r["property"], rdfsDomain); //this.GenerateCaptionedInformation(context, "Has Domain", ts, t => t.Object); //ts = context.Graph.GetTriplesWithSubjectPredicate(r["property"], rdfsRange); //this.GenerateCaptionedInformation(context, "Has Range", ts, t => t.Object); getPropertyDomains.SetParameter("property", r["property"]); this.GenerateCaptionedInformation(context, "Has Domain", context.Graph.ExecuteQuery(getPropertyDomains) as SparqlResultSet, "domain"); getPropertyRanges.SetParameter("property", r["property"]); this.GenerateCaptionedInformation(context, "Has Range", context.Graph.ExecuteQuery(getPropertyRanges) as SparqlResultSet, "range"); //Output any Equivalent Properties ts = context.Graph.GetTriplesWithSubjectPredicate(r["property"], owlEquivalentProperty).Concat(context.Graph.GetTriplesWithPredicateObject(owlEquivalentProperty, r["property"])); this.GenerateCaptionedInformation(context, "Equivalent Properties", ts, t => t.Subject.Equals(r["property"]) ? t.Object : t.Subject); //Output any Disjoint Classes ts = context.Graph.GetTriplesWithSubjectPredicate(r["property"], owlInverseProperty).Concat(context.Graph.GetTriplesWithPredicateObject(owlInverseProperty, r["property"])); this.GenerateCaptionedInformation(context, "Inverse Property", ts, t => t.Subject.Equals(r["property"]) ? t.Object : t.Subject); //Show the Property Description if (r.HasValue("propertyDescription")) { if (r["propertyDescription"] != null && r["propertyDescription"].NodeType == NodeType.Literal) { context.HtmlWriter.RenderBeginTag(HtmlTextWriterTag.P); context.HtmlWriter.Write(((ILiteralNode)r["propertyDescription"]).Value); context.HtmlWriter.RenderEndTag(); } } //End the </div> for the Property context.HtmlWriter.RenderEndTag(); #if !NO_WEB context.HtmlWriter.WriteLine(); #endif } } else { throw new RdfOutputException("Tried to make a SPARQL Query to get Property Information from the Schema but an unexpected Query Result was returned"); } } catch (RdfQueryException queryEx) { throw new RdfOutputException("Tried to make a SPARQL Query to get Property Information from the Schema but a Query Error occurred", queryEx); } //End of Page context.HtmlWriter.RenderEndTag(); //End Body context.HtmlWriter.RenderEndTag(); //End Html }
public override int CompareTo(IUriNode other) { return Uri.ToString().CompareTo(other.Uri.ToString()); }
/// <summary> /// Method which generates the RDF Graph of a SPARQL Result Set /// </summary> /// <param name="results">Result Set</param> /// <returns></returns> public IGraph GenerateOutput(SparqlResultSet results) { // Create the Graph for the Output IGraph g = new Graph(); // Add the relevant namespaces g.NamespaceMap.AddNamespace("rs", UriFactory.Create(SparqlSpecsHelper.SparqlRdfResultsNamespace)); // Create relevant Nodes IUriNode rdfType = g.CreateUriNode("rdf:type"); IUriNode resultSetClass = g.CreateUriNode("rs:ResultSet"); IUriNode resultVariable = g.CreateUriNode("rs:resultVariable"); IUriNode solution = g.CreateUriNode("rs:solution"); IUriNode binding = g.CreateUriNode("rs:binding"); IUriNode value = g.CreateUriNode("rs:value"); IUriNode variable = g.CreateUriNode("rs:variable"); IUriNode boolean = g.CreateUriNode("rs:boolean"); // First we declare a Result Set IBlankNode rset = g.CreateBlankNode(); g.Assert(new Triple(rset, rdfType, resultSetClass)); if (results.ResultsType == SparqlResultsType.VariableBindings) { // Assert a Triple for each Result Variable foreach (String v in results.Variables) { g.Assert(new Triple(rset, resultVariable, g.CreateLiteralNode(v))); } // Then we're going to define a solution for each result foreach (SparqlResult r in results) { IBlankNode sln = g.CreateBlankNode(); g.Assert(new Triple(rset, solution, sln)); foreach (String v in results.Variables) { // Only define Bindings if there is a value and it is non-null if (r.HasValue(v) && r[v] != null) { IBlankNode bnd = g.CreateBlankNode(); g.Assert(new Triple(sln, binding, bnd)); g.Assert(new Triple(bnd, variable, g.CreateLiteralNode(v))); switch (r[v].NodeType) { case NodeType.Blank: IBlankNode b = (IBlankNode)r[v]; IBlankNode bMapped; if (b.GraphUri == null) { bMapped = g.CreateBlankNode(b.InternalID + "def"); } else { bMapped = g.CreateBlankNode(b.InternalID + b.GraphUri.GetEnhancedHashCode()); } g.Assert(new Triple(bnd, value, bMapped)); break; case NodeType.GraphLiteral: throw new RdfOutputException(WriterErrorMessages.GraphLiteralsUnserializable("SPARQL Results RDF Serialization")); case NodeType.Literal: case NodeType.Uri: g.Assert(new Triple(bnd, value, r[v].CopyNode(g))); break; default: throw new RdfOutputException(WriterErrorMessages.UnknownNodeTypeUnserializable("SPARQL Results RDF Serialization")); } } } } } else { // A Boolean Result Set g.Assert(new Triple(rset, boolean, g.CreateLiteralNode(results.Result.ToString(), UriFactory.Create(XmlSpecsHelper.XmlSchemaDataTypeBoolean)))); } return(g); }
/// <summary> /// Creates a new Virtual URI Node /// </summary> /// <param name="g">Graph the Node belongs to</param> /// <param name="id">Virtual ID</param> /// <param name="provider">Virtual RDF Provider</param> /// <param name="value">Materialised Value</param> public SimpleVirtualUriNode(IGraph g, int id, IVirtualRdfProvider <int, int> provider, IUriNode value) : base(g, id, provider, value) { }
/// <summary> /// Used to extract the patterns that make up property functions. /// </summary> /// <param name="patterns">Triple Patterns.</param> /// <param name="localFactories">Locally scoped factories.</param> /// <returns></returns> public static List <IPropertyFunctionPattern> ExtractPatterns(IEnumerable <ITriplePattern> patterns, IEnumerable <IPropertyFunctionFactory> localFactories) { // Do a first pass which simply looks to find any 'magic' properties Dictionary <PatternItem, PropertyFunctionInfo> funcInfo = new Dictionary <PatternItem, PropertyFunctionInfo>(); List <IMatchTriplePattern> ps = patterns.OfType <IMatchTriplePattern>().ToList(); if (ps.Count == 0) { return(new List <IPropertyFunctionPattern>()); } foreach (IMatchTriplePattern tp in ps) { NodeMatchPattern predItem = tp.Predicate as NodeMatchPattern; if (predItem == null) { continue; } IUriNode predNode = predItem.Node as IUriNode; if (predNode == null) { continue; } if (PropertyFunctionFactory.IsPropertyFunction(predNode.Uri, localFactories)) { PropertyFunctionInfo info = new PropertyFunctionInfo(predNode.Uri); info.Patterns.Add(tp); funcInfo.Add(tp.Subject, info); } } // Remove any Patterns we found from the original patterns foreach (PropertyFunctionInfo info in funcInfo.Values) { info.Patterns.ForEach(tp => ps.Remove(tp)); } if (funcInfo.Count == 0) { return(new List <IPropertyFunctionPattern>()); } // Now for each 'magic' property we found do a further search to see if we are using // the collection forms to provide extended arguments foreach (PatternItem key in funcInfo.Keys) { if (key.VariableName != null && key.VariableName.StartsWith("_:")) { // If LHS is a blank node may be collection form int count = funcInfo[key].Patterns.Count; ExtractRelatedPatterns(key, key, ps, funcInfo, funcInfo[key].SubjectArgs); if (funcInfo[key].Patterns.Count == count) { // If no further patterns found just single LHS argument funcInfo[key].SubjectArgs.Add(key); } } else { // Otherwise key is the only LHS argument funcInfo[key].SubjectArgs.Add(key); } PatternItem searchKey = funcInfo[key].Patterns.First().Object; if (searchKey.VariableName != null && searchKey.VariableName.StartsWith("_:")) { // If RHS is a blank node may be collection form int count = funcInfo[key].Patterns.Count; ExtractRelatedPatterns(key, searchKey, ps, funcInfo, funcInfo[key].ObjectArgs); if (funcInfo[key].Patterns.Count == count) { // If no further patterns found just single RHS argument funcInfo[key].ObjectArgs.Add(searchKey); } } else { // Otherwise single RHS argument funcInfo[key].ObjectArgs.Add(searchKey); } } // Now try to create actual property functions List <IPropertyFunctionPattern> propFunctions = new List <IPropertyFunctionPattern>(); foreach (PatternItem key in funcInfo.Keys) { IPropertyFunctionPattern propFunc; if (PropertyFunctionFactory.TryCreatePropertyFunction(funcInfo[key], localFactories, out propFunc)) { propFunctions.Add(propFunc); } } return(propFunctions); }
/// <summary> /// Copies a Node so it can be used in another Graph since by default Triples cannot contain Nodes from more than one Graph. /// </summary> /// <param name="original">Node to Copy.</param> /// <param name="target">Graph to Copy into.</param> /// <returns></returns> /// <remarks> /// <para> /// <strong>Warning:</strong> Copying Blank Nodes may lead to unforseen circumstances since no remapping of IDs between Graphs is done. /// </para> /// </remarks> public static INode CopyNode(INode original, IGraph target) { // No need to copy if it's already in the relevant Graph if (ReferenceEquals(original.Graph, target)) { return(original); } // if a node can copy itself then let it do it var selfcopyable_original = original as Storage.Virtualisation.ICanCopy; if (selfcopyable_original != null) { return(selfcopyable_original.CopyNode(target)); } // if it doesn't, copy it's values: if (original.NodeType == NodeType.Uri) { IUriNode u = (IUriNode)original; IUriNode u2 = new UriNode(target, u.Uri); return(u2); } else if (original.NodeType == NodeType.Literal) { ILiteralNode l = (ILiteralNode)original; ILiteralNode l2; if (l.Language.Equals(String.Empty)) { if (!(l.DataType == null)) { l2 = new LiteralNode(target, l.Value, l.DataType); } else { l2 = new LiteralNode(target, l.Value); } } else { l2 = new LiteralNode(target, l.Value, l.Language); } return(l2); } else if (original.NodeType == NodeType.Blank) { IBlankNode b = (IBlankNode)original; IBlankNode b2; b2 = new BlankNode(target, b.InternalID); return(b2); } else if (original.NodeType == NodeType.Variable) { IVariableNode v = (IVariableNode)original; return(new VariableNode(target, v.VariableName)); } else { throw new RdfException("Unable to Copy '" + original.GetType().ToString() + "' Nodes between Graphs"); } }
/// <summary> /// Nodes must implement an Equals method so we can do type specific equality /// </summary> /// <param name="other">Node to check for equality</param> /// <returns></returns> /// <remarks> /// Nodes implementations are also required to implement an override of the non-generic Equals method. Standard implementations of some equality comparisons can be found in <see cref="EqualityHelper">EqualityHelper</see> /// </remarks> public abstract bool Equals(IUriNode other);
public MyHandler(IGraph g) : base(g) { _rdfsSubClassOf = g.CreateUriNode(UriFactory.Create("http://www.w3.org/2000/01/rdf-schema#subClassOf")); _rdfsLabel = g.CreateUriNode(UriFactory.Create("http://www.w3.org/2000/01/rdf-schema#label")); }
/// <summary> /// Formats a URI Node using QName compression if possible /// </summary> /// <param name="u">URI</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected override string FormatUriNode(IUriNode u, TripleSegment? segment) { StringBuilder output = new StringBuilder(); String qname; if (this._allowAKeyword && segment == TripleSegment.Predicate && u.Uri.ToString().Equals(RdfSpecsHelper.RdfType)) { output.Append('a'); } else if (this._qnameMapper.ReduceToQName(u.Uri.ToString(), out qname)) { if (this.IsValidQName(qname)) { output.Append(qname); } else { output.Append('<'); output.Append(this.FormatUri(u.Uri)); output.Append('>'); } } else { output.Append('<'); output.Append(this.FormatUri(u.Uri)); output.Append('>'); } return output.ToString(); }
private void GenerateTemporaryNamespace(RdfXmlWriterContext context, IUriNode u, out String tempPrefix, out String tempUri) { String uri = u.Uri.ToString(); String nsUri; if (uri.Contains("#")) { //Create a Hash Namespace Uri nsUri = uri.Substring(0, uri.LastIndexOf("#") + 1); } else { //Create a Slash Namespace Uri nsUri = uri.Substring(0, uri.LastIndexOf("/") + 1); } //Create a Temporary Namespace ID //Can't use an ID if already in the Namespace Map either at top level (nesting == 0) or at the current nesting while (context.NamespaceMap.HasNamespace("ns" + context.NextNamespaceID) && (context.NamespaceMap.GetNestingLevel("ns" + context.NextNamespaceID) == 0 || context.NamespaceMap.GetNestingLevel("ns" + context.NextNamespaceID) == context.NamespaceMap.NestingLevel)) { context.NextNamespaceID++; } String prefix = "ns" + context.NextNamespaceID; context.NextNamespaceID++; context.NamespaceMap.AddNamespace(prefix, new Uri(nsUri)); tempPrefix = prefix; tempUri = nsUri; this.RaiseWarning("Created a Temporary Namespace '" + prefix + "' with URI '" + nsUri + "'"); }
public override void ApplyToGraph(IGraph graph, IUriNode parent) { graph.Assert(parent, graph.CreateUriNode(new Uri(CantonConstants.CantonSchema + "origin")), graph.CreateLiteralNode(_origin)); graph.Assert(parent, graph.CreateUriNode(new Uri(CantonConstants.CantonSchema + "commitId")), graph.CreateLiteralNode("" + _commitId)); }
/// <summary> /// Populates the settings from an existing serialized configuration /// </summary> /// <param name="g">Graph</param> /// <param name="objNode">Object Node</param> public virtual void PopulateFrom(IGraph g, INode objNode) { foreach (PropertyInfo property in this._properties.Keys) { ConnectionAttribute attr = this._properties[property]; if (!String.IsNullOrEmpty(attr.PopulateFrom)) { INode n = objNode; if (!String.IsNullOrEmpty(attr.PopulateVia)) { n = ConfigurationLoader.GetConfigurationNode(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateVia))); if (n == null) { continue; } } switch (attr.Type) { case ConnectionSettingType.Boolean: bool b = ConfigurationLoader.GetConfigurationBoolean(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateFrom)), (bool)property.GetValue(this, null)); property.SetValue(this, b, null); break; case ConnectionSettingType.File: case ConnectionSettingType.Password: case ConnectionSettingType.String: String s = ConfigurationLoader.GetConfigurationString(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateFrom))); if (!String.IsNullOrEmpty(s)) { property.SetValue(this, s, null); } else { //May be a URI as the object IUriNode u = ConfigurationLoader.GetConfigurationNode(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateFrom))) as IUriNode; if (u != null) { property.SetValue(this, u.Uri.AbsoluteUri, null); } } break; case ConnectionSettingType.Integer: int i = ConfigurationLoader.GetConfigurationInt32(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateFrom)), (int)property.GetValue(this, null)); property.SetValue(this, i, null); break; case ConnectionSettingType.Enum: String enumStr = ConfigurationLoader.GetConfigurationString(g, n, g.CreateUriNode(UriFactory.Create(attr.PopulateFrom))); if (!String.IsNullOrEmpty(enumStr)) { try { Object val = Enum.Parse(property.GetValue(this, null).GetType(), enumStr, false); property.SetValue(this, val, null); } catch { //Ignore errors } } break; } } } }
/// <summary> /// Creates a new SubPropertySelector for the given Graph with the given Target Property /// </summary> /// <param name="g">Graph selection will occur in</param> /// <param name="targetProperty">Property you wish to select upon</param> public SubPropertySelector(IGraph g, IUriNode targetProperty) { this._targetproperty = targetProperty; this._subpropof = g.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "subPropertyOf")); }
/// <summary> /// Creates a new ExactClassSelector for the given Graph with the given Target Class /// </summary> /// <param name="g"></param> /// <param name="targetClass"></param> public ExactClassSelector(IGraph g, IUriNode targetClass) { this._targetclass = targetClass; this._type = g.CreateUriNode(UriFactory.Create(NamespaceMapper.RDF + "type")); }
public void WritingFormattingTriples() { try { //Create the Graph and define an additional namespace Graph g = new Graph(); g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org/")); //Create URIs used for datatypes Uri dtInt = new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger); Uri dtFloat = new Uri(XmlSpecsHelper.XmlSchemaDataTypeFloat); Uri dtDouble = new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble); Uri dtDecimal = new Uri(XmlSpecsHelper.XmlSchemaDataTypeDecimal); Uri dtBoolean = new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean); Uri dtUnknown = new Uri("http://example.org/unknownType"); Uri dtXmlLiteral = new Uri(RdfSpecsHelper.RdfXmlLiteral); //Create Nodes used for our test Triples IBlankNode subjBnode = g.CreateBlankNode(); IUriNode subjUri = g.CreateUriNode(new Uri("http://example.org/subject")); IUriNode subjUri2 = g.CreateUriNode(new Uri("http://example.org/123")); IUriNode predUri = g.CreateUriNode(new Uri("http://example.org/vocab#predicate")); IUriNode predType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); IBlankNode objBnode = g.CreateBlankNode(); IUriNode objUri = g.CreateUriNode(new Uri("http://example.org/object")); ILiteralNode objString = g.CreateLiteralNode("This is a literal"); ILiteralNode objStringLang = g.CreateLiteralNode("This is a literal with a language specifier", "en"); ILiteralNode objInt = g.CreateLiteralNode("123", dtInt); ILiteralNode objFloat = g.CreateLiteralNode("12.3e4", dtFloat); ILiteralNode objDouble = g.CreateLiteralNode("12.3e4", dtDouble); ILiteralNode objDecimal = g.CreateLiteralNode("12.3", dtDecimal); ILiteralNode objTrue = g.CreateLiteralNode("true", dtBoolean); ILiteralNode objFalse = g.CreateLiteralNode("false", dtBoolean); ILiteralNode objUnknown = g.CreateLiteralNode("This is a literal with an unknown type", dtUnknown); ILiteralNode objXmlLiteral = g.CreateLiteralNode("<strong>XML Literal</strong>", dtXmlLiteral); List <ITripleFormatter> formatters = new List <ITripleFormatter>() { new NTriplesFormatter(NTriplesSyntax.Original), new NTriplesFormatter(NTriplesSyntax.Rdf11), new UncompressedTurtleFormatter(), new UncompressedNotation3Formatter(), new TurtleFormatter(g), new TurtleW3CFormatter(g), new Notation3Formatter(g), new CsvFormatter(), new TsvFormatter(), new RdfXmlFormatter() }; List <INode> subjects = new List <INode>() { subjBnode, subjUri, subjUri2 }; List <INode> predicates = new List <INode>() { predUri, predType }; List <INode> objects = new List <INode>() { objBnode, objUri, objString, objStringLang, objInt, objFloat, objDouble, objDecimal, objTrue, objFalse, objUnknown, objXmlLiteral }; List <Triple> testTriples = (from s in subjects from p in predicates from o in objects select new Triple(s, p, o)).ToList(); foreach (Triple t in testTriples) { Console.WriteLine("Raw Triple:"); Console.WriteLine(t.ToString()); Console.WriteLine(); foreach (ITripleFormatter f in formatters) { Console.WriteLine(f.GetType().ToString()); Console.WriteLine(f.Format(t)); Console.WriteLine(); } Console.WriteLine(); } } catch (Exception ex) { throw; } }
/// <summary> /// Formats URIs for CSV output /// </summary> /// <param name="u">URI</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected override string FormatUriNode(IUriNode u, TripleSegment? segment) { return this.FormatUri(u.Uri); }
/// <summary> /// Creates a new Ontology Property for the given resource in the given Graph /// </summary> /// <param name="resource">Resource</param> /// <param name="graph">Graph</param> public OntologyProperty(INode resource, IGraph graph) : base(resource, graph) { //Q: Assert that this resource is a property? //UriNode rdfType = graph.CreateUriNode(new Uri(OntologyHelper.PropertyType)); //graph.Assert(new Triple(resource, rdfType, graph.CreateUriNode(new Uri(OntologyHelper.RdfsProperty)))); this.IntialiseProperty(OntologyHelper.PropertyDomain, false); this.IntialiseProperty(OntologyHelper.PropertyRange, false); this.IntialiseProperty(OntologyHelper.PropertyEquivalentProperty, false); this.IntialiseProperty(OntologyHelper.PropertySubPropertyOf, false); this.IntialiseProperty(OntologyHelper.PropertyInverseOf, false); //Find derived properties IUriNode subPropertyOf = this._graph.CreateUriNode(UriFactory.Create(OntologyHelper.PropertySubPropertyOf)); this._resourceProperties.Add(PropertyDerivedProperty, new List <INode>()); this._resourceProperties.Add(PropertyDirectSubProperty, new List <INode>()); foreach (Triple t in this._graph.GetTriplesWithPredicateObject(subPropertyOf, this._resource)) { if (!this._resourceProperties[PropertyDerivedProperty].Contains(t.Subject)) { this._resourceProperties[PropertyDerivedProperty].Add(t.Subject); } if (!this._resourceProperties[PropertyDirectSubProperty].Contains(t.Subject)) { this._resourceProperties[PropertyDirectSubProperty].Add(t.Subject); } } int c = 0; do { c = this._resourceProperties[PropertyDerivedProperty].Count; foreach (INode n in this._resourceProperties[PropertyDerivedProperty].ToList()) { foreach (Triple t in this._graph.GetTriplesWithPredicateObject(subPropertyOf, n)) { if (!this._resourceProperties[PropertyDerivedProperty].Contains(t.Subject)) { this._resourceProperties[PropertyDerivedProperty].Add(t.Subject); } } } } while (c < this._resourceProperties[PropertyDerivedProperty].Count); //Find additional super properties this._resourceProperties.Add(PropertyDirectSuperProperty, new List <INode>()); if (this._resourceProperties.ContainsKey(OntologyHelper.PropertySubPropertyOf)) { this._resourceProperties[PropertyDirectSuperProperty].AddRange(this._resourceProperties[OntologyHelper.PropertySubPropertyOf]); do { c = this._resourceProperties[OntologyHelper.PropertySubPropertyOf].Count; foreach (INode n in this._resourceProperties[OntologyHelper.PropertySubPropertyOf].ToList()) { foreach (Triple t in this._graph.GetTriplesWithSubjectPredicate(n, subPropertyOf)) { if (!this._resourceProperties[OntologyHelper.PropertySubPropertyOf].Contains(t.Object)) { this._resourceProperties[OntologyHelper.PropertySubPropertyOf].Add(t.Object); } } } } while (c < this._resourceProperties[OntologyHelper.PropertySubPropertyOf].Count); } //Find additional inverses if (!this._resourceProperties.ContainsKey(OntologyHelper.PropertyInverseOf)) { this._resourceProperties.Add(OntologyHelper.PropertyInverseOf, new List <INode>()); } foreach (Triple t in this._graph.GetTriplesWithPredicateObject(graph.CreateUriNode(UriFactory.Create(OntologyHelper.PropertyInverseOf)), this._resource)) { if (!this._resourceProperties[OntologyHelper.PropertyInverseOf].Contains(t.Subject)) { this._resourceProperties[OntologyHelper.PropertyInverseOf].Add(t.Subject); } } }
/// <summary> /// Creates a new HasExactPropertySelector which will select Triples with the given Property as the Predicate /// </summary> /// <param name="targetProperty">The Property Triples to be selected must contain as their Predicate</param> public HasExactPropertySelector(IUriNode targetProperty) { this._targetproperty = targetProperty; }
/// <summary> /// Generates a SPARQL Service Description Graph for the given Query Handler Configuration or uses the configuration supplied Description Graph /// </summary> /// <param name="context">HTTP Context</param> /// <param name="config">Query Handler Configuration</param> /// <param name="descripUri">Base URI of the Description</param> /// <returns></returns> public static IGraph GetServiceDescription(HttpContext context, BaseQueryHandlerConfiguration config, Uri descripUri) { //Use user specified Service Description if present if (config.ServiceDescription != null) { return(config.ServiceDescription); } IGraph g = SparqlServiceDescriber.GetNewGraph(); //Add the Top Level Node representing the Service IUriNode descrip = g.CreateUriNode(descripUri); IUriNode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); IUriNode service = g.CreateUriNode("sd:" + ClassService); g.Assert(descrip, rdfType, service); //Add its sd:url IUriNode url = g.CreateUriNode("sd:" + PropertyUrl); g.Assert(descrip, url, descrip); //Add the sd:supportedLanguage - Requires Query Language to be configurable through the Configuration API IUriNode supportedLang = g.CreateUriNode("sd:" + PropertySupportedLanguage); IUriNode lang; switch (config.Syntax) { case SparqlQuerySyntax.Extended: case SparqlQuerySyntax.Sparql_1_1: lang = g.CreateUriNode("sd:" + InstanceSparql11Query); break; default: lang = g.CreateUriNode("sd:" + InstanceSparql10Query); break; } g.Assert(descrip, supportedLang, lang); //Add the Result Formats IUriNode resultFormat = g.CreateUriNode("sd:" + PropertyResultFormat); foreach (MimeTypeDefinition definition in MimeTypesHelper.Definitions) { if (definition.CanWriteRdf || definition.CanWriteSparqlResults) { if (definition.FormatUri != null) { g.Assert(descrip, resultFormat, g.CreateUriNode(new Uri(definition.FormatUri))); } } } //Add Features and Dataset Description //First add descriptions for Global Expression Factories IUriNode extensionFunction = g.CreateUriNode("sd:" + PropertyExtensionFunction); IUriNode extensionAggregate = g.CreateUriNode("sd:" + PropertyExtensionAggregate); foreach (ISparqlCustomExpressionFactory factory in SparqlExpressionFactory.Factories) { foreach (Uri u in factory.AvailableExtensionFunctions) { g.Assert(descrip, extensionFunction, g.CreateUriNode(u)); } foreach (Uri u in factory.AvailableExtensionAggregates) { g.Assert(descrip, extensionAggregate, g.CreateUriNode(u)); } } //Then get the Configuration Object to add any other Feature Descriptions it wishes to config.AddFeatureDescription(g, descrip); return(g); }
/// <summary> /// Formats a URI Node /// </summary> /// <param name="u">URI Node</param> /// <param name="segment">Triple Segment</param> /// <returns></returns> protected override string FormatUriNode(IUriNode u, TripleSegment? segment) { StringBuilder output = new StringBuilder(); if (this._uriStartChar != null) output.Append(this._uriStartChar); if (this._uriEndChar != null) { output.Append(this.FormatUri(u.Uri)); output.Append(this._uriEndChar); } else { output.Append(this.FormatUri(u.Uri)); } return output.ToString(); }
/// <summary> /// Generates a SPARQL Service Description Graph for the specified portion of the SPARQL Server Handler Configuration or uses the configuration supplied Description Graph /// </summary> /// <param name="context">HTTP Context</param> /// <param name="config">SPARQL Server Configuration</param> /// <param name="descripUri">Base URI of the Description</param> /// <param name="type">Portion of the SPARQL Server to describe</param> /// <returns></returns> public static IGraph GetServiceDescription(HttpContext context, BaseSparqlServerConfiguration config, Uri descripUri, ServiceDescriptionType type) { //Use user specified Service Description if present if (config.ServiceDescription != null) { return(config.ServiceDescription); } IGraph g = SparqlServiceDescriber.GetNewGraph(); IUriNode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); IUriNode service = g.CreateUriNode("sd:" + ClassService); INode queryNode, updateNode, protocolNode; //Query Service Description if (config.QueryProcessor != null && (type == ServiceDescriptionType.Query || type == ServiceDescriptionType.All)) { //Add the Top Level Node representing the Query Service queryNode = g.CreateUriNode(new Uri(descripUri, "query")); g.Assert(queryNode, rdfType, service); //Add its sd:url IUriNode url = g.CreateUriNode("sd:" + PropertyUrl); g.Assert(queryNode, url, queryNode); //Add the sd:supportedLanguage IUriNode supportedLang = g.CreateUriNode("sd:" + PropertySupportedLanguage); IUriNode lang; switch (config.QuerySyntax) { case SparqlQuerySyntax.Extended: case SparqlQuerySyntax.Sparql_1_1: lang = g.CreateUriNode("sd:" + InstanceSparql11Query); break; default: lang = g.CreateUriNode("sd:" + InstanceSparql10Query); break; } g.Assert(queryNode, supportedLang, lang); //Add the Result Formats IUriNode resultFormat = g.CreateUriNode("sd:" + PropertyResultFormat); foreach (MimeTypeDefinition definition in MimeTypesHelper.Definitions) { if (definition.CanWriteRdf || definition.CanWriteSparqlResults) { if (definition.FormatUri != null) { g.Assert(queryNode, resultFormat, g.CreateUriNode(new Uri(definition.FormatUri))); } } } //Add Features and Dataset Description //First add descriptions for Global Expression Factories IUriNode extensionFunction = g.CreateUriNode("sd:" + PropertyExtensionFunction); IUriNode extensionAggregate = g.CreateUriNode("sd:" + PropertyExtensionAggregate); foreach (ISparqlCustomExpressionFactory factory in SparqlExpressionFactory.Factories) { foreach (Uri u in factory.AvailableExtensionFunctions) { g.Assert(queryNode, extensionFunction, g.CreateUriNode(u)); } foreach (Uri u in factory.AvailableExtensionAggregates) { g.Assert(queryNode, extensionAggregate, g.CreateUriNode(u)); } } } else { queryNode = null; } //Update Service Description if (config.UpdateProcessor != null && (type == ServiceDescriptionType.Update || type == ServiceDescriptionType.All)) { //Add the Top Level Node representing the Update Service updateNode = g.CreateUriNode(new Uri(descripUri, "update")); g.Assert(updateNode, rdfType, service); //Add its sd:url IUriNode url = g.CreateUriNode("sd:" + PropertyUrl); g.Assert(updateNode, url, updateNode); //Add the sd:supportedLanguage IUriNode supportedLang = g.CreateUriNode("sd:" + PropertySupportedLanguage); g.Assert(updateNode, supportedLang, g.CreateUriNode("sd:" + InstanceSparql11Update)); //Add Features and Dataset Description //First add descriptions for Global Expression Factories IUriNode extensionFunction = g.CreateUriNode("sd:" + PropertyExtensionFunction); IUriNode extensionAggregate = g.CreateUriNode("sd:" + PropertyExtensionAggregate); foreach (ISparqlCustomExpressionFactory factory in SparqlExpressionFactory.Factories) { foreach (Uri u in factory.AvailableExtensionFunctions) { g.Assert(updateNode, extensionFunction, g.CreateUriNode(u)); } foreach (Uri u in factory.AvailableExtensionAggregates) { g.Assert(updateNode, extensionAggregate, g.CreateUriNode(u)); } } } else { updateNode = null; } //Graph Store HTTP Protocol Description if (config.ProtocolProcessor != null && (type == ServiceDescriptionType.Protocol || type == ServiceDescriptionType.All)) { //Add the Top Level Node representing the Service if (descripUri.ToString().EndsWith("/description")) { String actualUri = descripUri.ToString(); actualUri = actualUri.Substring(0, actualUri.LastIndexOf("/description") + 1); protocolNode = g.CreateUriNode(new Uri(actualUri)); } else { protocolNode = g.CreateUriNode(descripUri); } g.Assert(protocolNode, rdfType, service); //Add its sd:url IUriNode url = g.CreateUriNode("sd:" + PropertyUrl); g.Assert(protocolNode, url, protocolNode); //Add the Input Formats IUriNode inputFormat = g.CreateUriNode("sd:" + PropertyInputFormat); foreach (MimeTypeDefinition definition in MimeTypesHelper.Definitions) { if (definition.CanParseRdf) { if (definition.FormatUri != null) { g.Assert(protocolNode, inputFormat, g.CreateUriNode(new Uri(definition.FormatUri))); } } } //Add the Result Formats IUriNode resultFormat = g.CreateUriNode("sd:" + PropertyResultFormat); foreach (MimeTypeDefinition definition in MimeTypesHelper.Definitions) { if (definition.CanWriteRdf) { if (definition.FormatUri != null) { g.Assert(protocolNode, resultFormat, g.CreateUriNode(new Uri(definition.FormatUri))); } } } } else { protocolNode = null; } //Finally get the Configuration Node to add additional feature and dataset descriptions config.AddFeatureDescription(g, queryNode, updateNode, protocolNode); return(g); }