C# IGraph.Assert方法代码示例

        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()));
                    }
                }
            }
        }

 private void AddStats(IGraph g, IEnumerable<KeyValuePair<INode, long>> stats, INode statsProperty)
 {
     foreach (KeyValuePair<INode, long> kvp in stats)
     {
         g.Assert(kvp.Key.CopyNode(g), statsProperty, kvp.Value.ToLiteral(g));
     }
 }

 public void Apply(IGraph g)
 {
     g.BaseUri = this._baseUri;
     g.Assert(this._triples);
     foreach (KeyValuePair<String, String> ns in this._namespaces)
     {
         g.NamespaceMap.AddNamespace(ns.Key, UriFactory.Create(ns.Value));
     }
 }

 public static void FromJena(Model m, JenaMapping mapping, IGraph g)
 {
     StmtIterator iter = m.listStatements();
     while (iter.hasNext())
     {
         Statement stmt = iter.nextStatement();
         g.Assert(FromJena(stmt, mapping));
     }
 }

        public static void MaterializeInference(IGraph graph)
        {
            //  hard code some type inference

            //  nuget:ApiAppPackage rdfs:subClassOf nuget:PackageDetails

            foreach (Triple triple in graph.GetTriplesWithPredicateObject(graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.ApiAppPackage)))
            {
                graph.Assert(triple.Subject, triple.Predicate, graph.CreateUriNode(Schema.DataTypes.PackageDetails));
            }

            //  nuget:PowerShellPackage rdfs:subClassOf nuget:PackageDetails

            foreach (Triple triple in graph.GetTriplesWithPredicateObject(graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.PowerShellPackage)))
            {
                graph.Assert(triple.Subject, triple.Predicate, graph.CreateUriNode(Schema.DataTypes.PackageDetails));
            }
        }

        /// <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));
            //        }
            //    }
            //}
        }

        private static void FillGraph(IGraph graph)
        {
            graph.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
            graph.NamespaceMap.AddNamespace("ex", new Uri("http://example.org"));
            graph.NamespaceMap.AddNamespace("med", new Uri("http://med.org"));

            IUriNode rdfTypeNode = graph.CreateUriNode("rdf:type");
            IUriNode patienSubjectNode = graph.CreateUriNode(UriFactory.Create("http://ex-hospital-DB/patients/ID98765"));
            IUriNode patientTypeNode = graph.CreateUriNode(UriFactory.Create("http://ex-hospital#patient"));
            IUriNode hasVitalsPredicateNode = graph.CreateUriNode("ex:hasVitals");

            IUriNode odfElementSubjectNode = graph.CreateUriNode(new Uri("med:Sect1"));
            IUriNode odfElementTypeNode = graph.CreateUriNode(UriFactory.Create("http://docs.oasis-open.org/ns/office/1.2/meta/odf#Element"));
            IUriNode vitalDataTypeNode = graph.CreateUriNode("med:vitalData");

            graph.Assert(new Triple(odfElementSubjectNode, rdfTypeNode, vitalDataTypeNode));
            graph.Assert(new Triple(odfElementSubjectNode, rdfTypeNode, odfElementTypeNode));

            graph.Assert(new Triple(patienSubjectNode, rdfTypeNode, patientTypeNode));
            graph.Assert(new Triple(patienSubjectNode, hasVitalsPredicateNode, odfElementSubjectNode));
        }

        public static void Collect(IGraph source, INode subject, IGraph destination, ISet<string> exclude)
        {
            foreach (Triple triple in source.GetTriplesWithSubject(subject))
            {
                destination.Assert(triple.CopyTriple(destination));

                if (triple.Object is IUriNode && !exclude.Contains(((IUriNode)triple.Object).Uri.ToString()))
                {
                    Collect(source, triple.Object, destination, exclude);
                }
            }
        }

        public static void ReplaceIRI(IGraph graph, Uri oldIRI, Uri newIRI)
        {
            // replace the local IRI with the NuGet IRI
            string localUri = oldIRI.AbsoluteUri;

            var triples = graph.Triples.ToArray();

            string mainIRI = newIRI.AbsoluteUri;

            foreach (var triple in triples)
            {
                IUriNode subject = triple.Subject as IUriNode;
                IUriNode objNode = triple.Object as IUriNode;
                INode newSubject = triple.Subject;
                INode newObject = triple.Object;

                bool replace = false;

                if (subject != null && subject.Uri.AbsoluteUri.StartsWith(localUri))
                {
                    // TODO: store these mappings in a dictionary
                    Uri iri = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}{1}", mainIRI, subject.Uri.AbsoluteUri.Substring(localUri.Length)));
                    newSubject = graph.CreateUriNode(iri);
                    replace = true;
                }

                if (objNode != null && objNode.Uri.AbsoluteUri.StartsWith(localUri))
                {
                    // TODO: store these mappings in a dictionary
                    Uri iri = new Uri(String.Format(CultureInfo.InvariantCulture, "{0}{1}", mainIRI, objNode.Uri.AbsoluteUri.Substring(localUri.Length)));
                    newObject = graph.CreateUriNode(iri);
                    replace = true;
                }

                if (replace)
                {
                    graph.Assert(newSubject, triple.Predicate, newObject);
                    graph.Retract(triple);
                }
            }
        }

 /// <summary>
 /// Applies the reasoner to the given input Graph outputting inferences into the output Graph
 /// </summary>
 /// <param name="input">Input Graph</param>
 /// <param name="output">Output Graph</param>
 public virtual void Apply(IGraph input, IGraph output)
 {
     output.Assert(this._reasoner.Extract(OwlHelper.OwlExtractMode.AllStatements));
 }

        /// <summary>
        /// Loads a Graph from the Quad Store
        /// </summary>
        /// <param name="g">Graph to load into</param>
        /// <param name="graphUri">Uri of the Graph to Load</param>
        public void LoadGraph(IGraph g, Uri graphUri)
        {
            if (graphUri == null) throw new RdfStorageException("Cannot load an unnamed Graph from Virtuoso as this would require loading the entirety of the Virtuoso Quad Store into memory!");

            if (!g.IsEmpty)
            {
                //Do the load into a new Empty Graph and then do a merge
                Graph h = new Graph();
                this.LoadGraph(h, graphUri);
                g.Merge(h);
                return;
            }

            try
            {
                g.BaseUri = graphUri;

                //Need to keep Database Open as Literals require extra trips to the Database to get additional
                //information about Language and Type
                this.Open(false);

                DataTable data = this.LoadTriples(graphUri);

                foreach (DataRow row in data.Rows)
                {
                    Object s, p, o;
                    INode subj, pred, obj;

                    //Get Data
                    s = row["S"];
                    p = row["P"];
                    o = row["O"];

                    //Create Nodes
                    subj = this.LoadNode(g, s);
                    pred = this.LoadNode(g, p);
                    obj = this.LoadNode(g, o);

                    //Assert Triple
                    g.Assert(new Triple(subj, pred, obj));
                }
                this.Close(false);
            }
            catch
            {
                this.Close(true);
                throw;
            }
        }

        public static void Rebase(IGraph source, IGraph destination, Uri sourceUri, Uri destinationUri)
        {
            Uri modifiedDestinationUri = new Uri(destinationUri.ToString().Replace('#', '/'));

            foreach (Triple triple in source.Triples)
            {
                Uri subjectUri;
                if (triple.Subject.ToString() == destinationUri.ToString())
                {
                    subjectUri = modifiedDestinationUri;
                }
                else
                {
                    subjectUri = RebaseUri(((IUriNode)triple.Subject).Uri, sourceUri, modifiedDestinationUri);
                }

                INode subjectNode = destination.CreateUriNode(subjectUri);
                INode predicateNode = triple.Predicate.CopyNode(destination);

                INode objectNode;
                if (triple.Object is IUriNode)
                {
                    Uri objectUri = RebaseUri(((IUriNode)triple.Object).Uri, sourceUri, modifiedDestinationUri);
                    objectNode = destination.CreateUriNode(objectUri);
                }
                else
                {
                    objectNode = triple.Object.CopyNode(destination);
                }

                destination.Assert(subjectNode, predicateNode, objectNode);
            }
        }

        /// <summary>
        /// Applies inference to the Input Graph and outputs the inferred information to the Output Graph
        /// </summary>
        /// <param name="input">Graph to apply inference to</param>
        /// <param name="output">Graph inferred information is output to</param>
        public virtual void Apply(IGraph input, IGraph output)
        {
            //Infer information
            List<Triple> inferences = new List<Triple>();
            foreach (Triple t in input.Triples)
            {
                //Apply class/property hierarchy inferencing
                if (t.Predicate.Equals(this._rdfType))
                {
                    if (!t.Object.Equals(this._rdfsClass) && !t.Object.Equals(this._rdfProperty))
                    {
                        this.InferClasses(t, input, output, inferences);
                    }
                }
                else if (t.Predicate.Equals(this._rdfsSubClass))
                {
                    //Assert that this thing is a Class
                    inferences.Add(new Triple(t.Subject.CopyNode(output), this._rdfType.CopyNode(output), this._rdfsClass.CopyNode(output)));
                }
                else if (t.Predicate.Equals(this._rdfsSubProperty))
                {
                    //Assert that this thing is a Property
                    inferences.Add(new Triple(t.Subject.CopyNode(output), this._rdfType.CopyNode(output), this._rdfProperty.CopyNode(output)));
                }
                else if (this._propertyMappings.ContainsKey(t.Predicate))
                {
                    INode property = t.Predicate;

                    //Navigate up the property hierarchy asserting additional properties if able
                    while (this._propertyMappings.ContainsKey(property))
                    {
                        if (this._propertyMappings[property] != null)
                        {
                            //Assert additional properties
                            inferences.Add(new Triple(t.Subject.CopyNode(output), this._propertyMappings[property].CopyNode(output), t.Object.CopyNode(output)));
                            property = this._propertyMappings[property];
                        }
                        else
                        {
                            break;
                        }
                    }
                }

                //Apply Domain and Range inferencing on Predicates
                if (this._rangeMappings.ContainsKey(t.Predicate))
                {
                    //Assert additional type information
                    foreach (INode n in this._rangeMappings.GetValues(t.Predicate))
                    {
                        inferences.Add(new Triple(t.Object.CopyNode(output), this._rdfType.CopyNode(output), n.CopyNode(output)));
                    }

                    //Call InferClasses to get extra type information
                    this.InferClasses(inferences[inferences.Count - 1], input, output, inferences);
                }
                if (this._domainMappings.ContainsKey(t.Predicate))
                {
                    //Assert additional type information
                    foreach (INode n in this._domainMappings.GetValues(t.Predicate))
                    {
                        inferences.Add(new Triple(t.Subject.CopyNode(output), this._rdfType.CopyNode(output), n.CopyNode(output)));
                    }
                    
                    //Call InferClasses to get extra type information
                    this.InferClasses(inferences[inferences.Count - 1], input, output, inferences);
                }
            }

            //Assert the inferred information
            inferences.RemoveAll(t => t.Subject.NodeType == NodeType.Literal);
            if (inferences.Count > 0)
            {
                output.Assert(inferences);
            }
        }

        public static void Reverse(IGraph graph, Uri existingProperty, Uri reverseProperty)
        {
            var existingTriples = graph
                .GetTriplesWithPredicate(graph.CreateUriNode(existingProperty))
                .ToList();

            graph.Retract(existingTriples);

            INode predicate = graph.CreateUriNode(reverseProperty);
            foreach (var existingTriple in existingTriples)
            {
                graph.Assert(existingTriple.Object, predicate, existingTriple.Subject);
            }
        }

        /// <summary>
        /// Applies inference to the Input Graph and outputs the inferred information to the Output Graph
        /// </summary>
        /// <param name="input">Graph to apply inference to</param>
        /// <param name="output">Graph inferred information is output to</param>
        public virtual void Apply(IGraph input, IGraph output)
        {
            List<Triple> inferences = new List<Triple>();
            lock (this._conceptMappings)
            {
                foreach (Triple t in input.Triples)
                {
                    if (!(t.Predicate.Equals(this._skosBroader) || t.Predicate.Equals(this._skosNarrower)) && this._conceptMappings.ContainsKey(t.Object))
                    {
                        INode concept = t.Object;
                        while (this._conceptMappings.ContainsKey(concept))
                        {
                            if (this._conceptMappings[concept] != null)
                            {
                                //Assert additional information
                                inferences.Add(new Triple(t.Subject.CopyNode(output), t.Predicate.CopyNode(output), this._conceptMappings[concept].CopyNode(output)));
                                concept = this._conceptMappings[concept];
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }
            }

            if (inferences.Count > 0)
            {
                output.Assert(inferences);
            }
        }