/// <summary>
 /// Creates a new Union Triple Collection which is a union of any number of collections
 /// </summary>
 /// <param name="baseTriples">Base Triple Collection</param>
 /// <param name="additionalTriples">Additional Triple Collection(s)</param>
 public UnionTripleCollection(BaseTripleCollection baseTriples, IEnumerable<BaseTripleCollection> additionalTriples)
 {
     if (baseTriples == null) throw new ArgumentNullException("baseTriple");
     this._collections.Add(baseTriples);
     this._collections.AddRange(additionalTriples);
     this._baseCollection = baseTriples;
 }
Exemple #2
0
        private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced)
        {
            var actualTripleList   = new List <Triple>(actualTriples);
            var expectedTripleList = new List <Triple>(expectedTriples);
            var alreadySeen        = new HashSet <Triple>();
            var bnodeMap           = new Dictionary <string, string>();

            while (actualTripleList.Count > 0)
            {
                var at = actualTripleList[0];
                actualTripleList.Remove(at);
                if (alreadySeen.Contains(at))
                {
                    continue;
                }
                var match = expectedTripleList.Find(x => TripleMatch(x, at, bnodeMap));
                if (match == null)
                {
                    Assert.Fail("No match found for actual triple {0} in expected triples set", at);
                }

                expectedTripleList.Remove(match);
                alreadySeen.Add(at);
            }
            Assert.IsTrue(actualTripleList.Count == 0);
            Assert.IsTrue(expectedTripleList.Count == 0, "Left with some unmatched triples in the expected triples set: {0}",
                          String.Join(",", expectedTripleList.Select(t => t.ToString())));
        }
 /// <summary>
 /// Creates a new Union Triple Collection which is a union of two collections
 /// </summary>
 /// <param name="baseTriples">Base Triple Collection</param>
 /// <param name="additionalTriples">Additional Triple Collection</param>
 public UnionTripleCollection(BaseTripleCollection baseTriples, BaseTripleCollection additionalTriples)
 {
     if (baseTriples == null) throw new ArgumentNullException("baseTriple");
     if (additionalTriples == null) throw new ArgumentNullException("additionalTriples");
     this._collections.Add(baseTriples);
     this._collections.Add(additionalTriples);
     this._baseCollection = baseTriples;
 }
        private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced)
        {
            var actualGraph   = new Graph(actualTriples);
            var expectedGraph = new Graph(expectedTriples);

            Assert.IsTrue(expectedGraph.Equals(actualGraph), "Result graphs do not match.r\nExpected:\r\n{0}\r\nActual:\r\n{1}",
                          String.Join(",", expectedTriples.Select(t => t.ToString())),
                          String.Join(",", actualTriples.Select(t => t.ToString())));
        }
Exemple #5
0
 public void AssertTriplesRetracted(BaseTripleCollection tripleCollection, Uri graphIri)
 {
     foreach (var t in tripleCollection)
     {
         Retracted.Should().Contain(x =>
                                    x.Item1.Equals(t.Subject) && x.Item2.Equals(t.Predicate) && x.Item3.Equals(t.Object) &&
                                    x.Item4.Equals(graphIri),
                                    "Expected a quad ({0}, {1}, {2}, {3}) to have been retracted but no matching quad was found.",
                                    t.Subject, t.Predicate, t.Object, graphIri);
     }
 }
Exemple #6
0
        public void ConfigurationLoadObjectTripleCollection1()
        {
            String graph = ConfigLookupTests.Prefixes + @"
_:a a dnr:TripleCollection ;
  dnr:type ""VDS.RDF.TreeIndexedTripleCollection"" .";

            Graph g = new Graph();

            g.LoadFromString(graph);

            BaseTripleCollection collection = ConfigurationLoader.LoadObject(g, g.GetBlankNode("a")) as BaseTripleCollection;

            Assert.IsNotNull(collection);
            Assert.AreEqual(typeof(TreeIndexedTripleCollection), collection.GetType());
        }
Exemple #7
0
        private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced)
        {
            var alreadySeen = new HashSet <Triple>();

            foreach (var expectedTriple in expectedTriples)
            {
                if (reduced && alreadySeen.Contains(expectedTriple))
                {
                    continue;
                }
                Assert.IsTrue(actualTriples.Contains(expectedTriple),
                              "Could not find expected triple '{0}' in results set.", expectedTriple);
            }
            foreach (var actualTriple in actualTriples)
            {
                Assert.IsTrue(expectedTriples.Contains(actualTriple),
                              "Unexpected result set triple '{0}'", actualTriple);
            }
        }
Exemple #8
0
 /// <summary>
 /// Creates a new instance of a Graph using the given Triple Collection
 /// </summary>
 /// <param name="tripleCollection">Triple Collection</param>
 public Graph(BaseTripleCollection tripleCollection)
     : base(tripleCollection) { }
Exemple #9
0
 public static Dictionary <INode, OutputRdfCollection> FindCollections(IGraph g, BaseTripleCollection triplesDone)
 {
     throw new NotSupportedException("No longer supported");
 }
Exemple #10
0
 /// <summary>
 /// Helper method for detaching the necessary event Handlers from a Triple Collection
 /// </summary>
 /// <param name="tripleCollection">Triple Collection</param>
 /// <remarks>
 /// May be useful if you replace the Triple Collection after instantiation e.g. as done in <see cref="Query.SparqlView">SparqlView</see>'s
 /// </remarks>
 protected void DetachEventHandlers(BaseTripleCollection tripleCollection)
 {
     tripleCollection.TripleAdded -= this.TripleAddedHandler;
     tripleCollection.TripleRemoved -= this.TripleRemovedHandler;
 }
        private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced) 
		{
            var alreadySeen = new HashSet<Triple>();
            foreach (var expectedTriple in expectedTriples)
            {
                if (reduced && alreadySeen.Contains(expectedTriple)) continue;
                Assert.IsTrue(actualTriples.Contains(expectedTriple),
                              "Could not find expected triple '{0}' in results set.", expectedTriple);
            }
            foreach(var actualTriple in actualTriples)
            {
                Assert.IsTrue(expectedTriples.Contains(actualTriple),
                    "Unexpected result set triple '{0}'", actualTriple);
            }
		}
Exemple #12
0
        protected BaseGraph(BaseTripleCollection tripleCollection, BaseNodeCollection nodeCollection)
        {
            this._triples = tripleCollection;
            this._nodes = nodeCollection;
            this._bnodemapper = new BlankNodeMapper();
            this._nsmapper = new NamespaceMapper();

            //Create Event Handlers and attach to the Triple Collection
            this.TripleAddedHandler = new TripleEventHandler(this.OnTripleAsserted);
            this.TripleRemovedHandler = new TripleEventHandler(this.OnTripleRetracted);
            this.AttachEventHandlers(this._triples);
        }
Exemple #13
0
 /// <summary>
 /// Creates a new Base Graph which uses the given Triple Collection and the default <see cref="HashedNodeCollection">HashedNodeCollection</see> as the Node Collection
 /// </summary>
 /// <param name="tripleCollection">Triple Collection to use</param>
 protected BaseGraph(BaseTripleCollection tripleCollection)
     : this(tripleCollection, new HashedNodeCollection()) { }
Exemple #14
0
 /// <summary>
 /// Creates a new instance of a Graph using the given Triple and Node Collections
 /// </summary>
 /// <param name="tripleCollection">Triple Collection</param>
 /// <param name="nodeCollection">Node Collection</param>
 public Graph(BaseTripleCollection tripleCollection, BaseNodeCollection nodeCollection)
     : base(tripleCollection, nodeCollection) { }
Exemple #15
0
        /// <summary>
        /// Tries to load a Graph based on information from the Configuration Graph.
        /// </summary>
        /// <param name="g">Configuration Graph.</param>
        /// <param name="objNode">Object Node.</param>
        /// <param name="targetType">Target Type.</param>
        /// <param name="obj">Output Object.</param>
        /// <returns></returns>
        public bool TryLoadObject(IGraph g, INode objNode, Type targetType, out object obj)
        {
            obj = null;
            IGraph output;

            // Check whether to use a specific Triple Collection
            INode collectionNode = ConfigurationLoader.GetConfigurationNode(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyUsingTripleCollection)));

            try
            {
                if (collectionNode == null)
                {
                    // Simple Graph creation
                    output = (IGraph)Activator.CreateInstance(targetType);
                }
                else
                {
                    // Graph with custom triple collection
                    BaseTripleCollection tripleCollection = ConfigurationLoader.LoadObject(g, collectionNode) as BaseTripleCollection;
                    if (tripleCollection == null)
                    {
                        throw new DotNetRdfConfigurationException("Unable to load the Graph identified by the Node '" + objNode.ToString() + "' as the dnr:usingTripleCollection points to an object which cannot be loaded as an instance of the required type BaseTripleCollection");
                    }
                    output = (IGraph)Activator.CreateInstance(targetType, new Object[] { tripleCollection });
                }
            }
            catch
            {
                // Any error means this loader can't load this type
                return(false);
            }

            // Now we want to find out where the data for the Graph is coming from
            // Data Source loading order is Graphs, Files, Strings, Databases, Stores, URIs
            IEnumerable <INode> sources;

            // Load from Graphs
            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromGraph)));
            foreach (INode source in sources)
            {
                ConfigurationLoader.CheckCircularReference(objNode, source, "dnr:fromGraph");

                Object graph = ConfigurationLoader.LoadObject(g, source);
                if (graph is IGraph)
                {
                    output.Merge((IGraph)graph);
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from another Graph for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromGraph property points to an Object that cannot be loaded as an object which implements the IGraph interface");
                }
            }

            // Load from Embedded Resources
            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromEmbedded)));
            foreach (INode source in sources)
            {
                if (source.NodeType == NodeType.Literal)
                {
                    EmbeddedResourceLoader.Load(output, ((ILiteralNode)source).Value);
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from an Embedded Resource for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromEmbedded property is not a Literal Node as required");
                }
            }

            // Load from Files
            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromFile)));
            foreach (INode source in sources)
            {
                if (source.NodeType == NodeType.Literal)
                {
                    FileLoader.Load(output, ConfigurationLoader.ResolvePath(((ILiteralNode)source).Value));
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from a file for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromFile property is not a Literal Node as required");
                }
            }

            // Load from Strings
            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromString)));
            foreach (INode source in sources)
            {
                if (source.NodeType == NodeType.Literal)
                {
                    StringParser.Parse(output, ((ILiteralNode)source).Value);
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from a string for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromString property is not a Literal Node as required");
                }
            }

            IEnumerable <Object> connections;

            // Load from Stores
            IEnumerable <INode> stores = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromStore)));

            stores.All(s => !ConfigurationLoader.CheckCircularReference(objNode, s, "dnr:fromStore"));
            connections = stores.Select(s => ConfigurationLoader.LoadObject(g, s));
            sources     = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyWithUri)));
            foreach (Object store in connections)
            {
                if (store is IStorageProvider)
                {
                    foreach (INode source in sources)
                    {
                        if (source.NodeType == NodeType.Uri || source.NodeType == NodeType.Literal)
                        {
                            ((IStorageProvider)store).LoadGraph(output, source.ToString());
                        }
                        else
                        {
                            throw new DotNetRdfConfigurationException("Unable to load data from a Generic Store for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:withUri property is not a URI/Literal Node as required");
                        }
                    }
                }
                else if (store is ITripleStore)
                {
                    foreach (INode source in sources)
                    {
                        if (source.NodeType == NodeType.Uri)
                        {
                            output.Merge(((ITripleStore)store)[((IUriNode)source).Uri]);
                        }
                        else if (source.NodeType == NodeType.Literal)
                        {
                            output.Merge(((ITripleStore)store)[UriFactory.Create(((ILiteralNode)source).Value)]);
                        }
                        else
                        {
                            throw new DotNetRdfConfigurationException("Unable to load data from a Store for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:withUri property is not a URI/Literal Node as required");
                        }
                    }
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from a Store for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values of the dnr:fromStore property points to an Object which cannot be loaded as an object which implements either the IStorageProvider/ITripleStore interface");
                }
            }

            // Load from Datasets
            IEnumerable <INode> ds = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromDataset)));

            ds.All(d => !ConfigurationLoader.CheckCircularReference(objNode, d, ConfigurationLoader.PropertyFromDataset));
            IEnumerable <Object> datasets = ds.Select(d => ConfigurationLoader.LoadObject(g, d));

            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyWithUri)));
            foreach (Object dataset in datasets)
            {
                if (dataset is ISparqlDataset)
                {
                    foreach (INode source in sources)
                    {
                        if (source.NodeType == NodeType.Uri)
                        {
                            output.Merge(((ISparqlDataset)dataset)[((IUriNode)sources).Uri]);
                        }
                        else if (source.NodeType == NodeType.Literal)
                        {
                            output.Merge(((ISparqlDataset)dataset)[UriFactory.Create(((ILiteralNode)source).Value)]);
                        }
                        else
                        {
                            throw new DotNetRdfConfigurationException("Unable to load data from a Dataset for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:withUri property is not a URI/Literal Node as required");
                        }
                    }
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from a Dataset for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values of the dnr:fromDataset property points to an Object which cannot be loaded as an object which implements the required ISparqlDataset interface");
                }
            }


            // Finally load from Remote URIs
            sources = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyFromUri)));
            foreach (INode source in sources)
            {
                if (source.NodeType == NodeType.Uri)
                {
                    UriLoader.Load(output, ((IUriNode)source).Uri);
                }
                else if (source.NodeType == NodeType.Literal)
                {
                    UriLoader.Load(output, UriFactory.Create(((ILiteralNode)source).Value));
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to load data from a URI for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:fromUri property is not a URI/Literal Node as required");
                }
            }

            // Then are we assigning a Base URI to this Graph which overrides any existing Base URI?
            INode baseUri = ConfigurationLoader.GetConfigurationNode(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyAssignUri)));

            if (baseUri != null)
            {
                if (baseUri.NodeType == NodeType.Uri)
                {
                    output.BaseUri = ((IUriNode)baseUri).Uri;
                }
                else if (baseUri.NodeType == NodeType.Literal)
                {
                    output.BaseUri = UriFactory.Create(((ILiteralNode)baseUri).Value);
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to assign a new Base URI for the Graph identified by the Node '" + objNode.ToString() + "' as the value for the dnr:assignUri property is not a URI/Literal Node as required");
                }
            }

            // Finally we'll apply any reasoners
            IEnumerable <INode> reasoners = ConfigurationLoader.GetConfigurationData(g, objNode, g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyReasoner)));

            foreach (INode reasoner in reasoners)
            {
                Object temp = ConfigurationLoader.LoadObject(g, reasoner);
                if (temp is IInferenceEngine)
                {
                    ((IInferenceEngine)temp).Apply(output);
                }
                else
                {
                    throw new DotNetRdfConfigurationException("Unable to apply a reasoner for the Graph identified by the Node '" + objNode.ToString() + "' as one of the values for the dnr:reasoner property points to an Object which cannot be loaded as an object which implements the IInferenceEngine interface");
                }
            }

            obj = output;
            return(true);
        }
Exemple #16
0
        private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced)
        {
            var actualTripleList = new List<Triple>(actualTriples);
            var expectedTripleList = new List<Triple>(expectedTriples);
            var alreadySeen = new HashSet<Triple>();
            var bnodeMap = new Dictionary<string, string>();

            while (actualTripleList.Count > 0)
            {
                var at = actualTripleList[0];
                actualTripleList.Remove(at);
                if (alreadySeen.Contains(at)) continue;
                var match = expectedTripleList.Find(x => TripleMatch(x, at, bnodeMap));
                if (match == null)
                {
                    Assert.Fail("No match found for actual triple {0} in expected triples set", at);
                }

                expectedTripleList.Remove(match);
                alreadySeen.Add(at);
            }
            Assert.IsTrue(actualTripleList.Count == 0);
            Assert.IsTrue(expectedTripleList.Count == 0, "Left with some unmatched triples in the expected triples set: {0}",
                String.Join(",", expectedTripleList.Select(t => t.ToString())));
        }
Exemple #17
0
        public List <Tuple <string, string, string> > GetTriplesStringList(BaseTripleCollection triples)
        {
            List <Tuple <string, string, string> > temp = new List <Tuple <string, string, string> >();

            foreach (var triple in triples)
            {
                Tuple <string, string, string> tempTuple;
                string item1 = "";
                string item2 = "";
                string item3 = "";
                if (triple.Subject.ToString().StartsWith("urn:myClasses:"))
                {
                    item1 = "Class:" + triple.Subject.ToString().Remove(0, 14);
                }
                if (triple.Subject.ToString().StartsWith("urn:myObjects:"))
                {
                    item1 = "Object:" + triple.Subject.ToString().Remove(0, 14);
                }
                if (triple.Object.ToString().StartsWith("urn:myObjects:"))
                {
                    item3 = "Object:" + triple.Object.ToString().Remove(0, 14);
                }
                if (triple.Object.ToString().StartsWith("urn:myClasses:"))
                {
                    item3 = "Class:" + triple.Object.ToString().Remove(0, 14);
                }
                if (triple.Object.ToString().StartsWith("http://www.w3.org/2000/01/rdf-schema#Class"))
                {
                    item3 = "rdfs:Class" + triple.Object.ToString().Remove(0, 42);
                }
                if (triple.Predicate.ToString().StartsWith(@"http://www.w3.org/1999/02/22-rdf-syntax-ns#type"))
                {
                    item2 = "type";
                }
                if (triple.Predicate.ToString().StartsWith(@"http://www.w3.org/2000/01/rdf-schema#subClassOf"))
                {
                    item2 = "subClassOf";
                }
                if (triple.Predicate.ToString().StartsWith(@"http://www.wikidata.org/wiki/Property:P1542"))
                {
                    item2 = "whatFor";
                }
                if (triple.Predicate.ToString().StartsWith(@"http://www.wikidata.org/wiki/Property:P2868"))
                {
                    item2 = "causesWhy";
                }
                if (triple.Subject.ToString().StartsWith("urn:myProperties:"))
                {
                    item1 = "Property:" + triple.Subject.ToString().Remove(0, 17);
                }
                if (triple.Object.ToString().StartsWith(@"http://www.w3.org/1999/02/22-rdf-syntax-ns#Property"))
                {
                    item3 = "Property";
                }


                temp.Add(new Tuple <string, string, string>(item1, item2, item3));
            }

            return(temp);
        }
Exemple #18
0
 public static Dictionary<INode, OutputRdfCollection> FindCollections(IGraph g, BaseTripleCollection triplesDone)
 {
     throw new NotSupportedException("No longer supported");
 }
Exemple #19
0
 /// <summary>
 /// Creates a new instance of a Graph using the given Triple Collection and an optionally empty Namespace Map
 /// </summary>
 /// <param name="tripleCollection">Triple Collection</param>
 /// <param name="emptyNamespaceMap">Whether the Namespace Map should be empty</param>
 public Graph(BaseTripleCollection tripleCollection, bool emptyNamespaceMap)
     : base(tripleCollection)
 {
     if (emptyNamespaceMap) this._nsmapper.Clear();
 }
Exemple #20
0
 private static void CompareTripleCollections(BaseTripleCollection actualTriples, BaseTripleCollection expectedTriples, bool reduced)
 {
     var actualGraph = new Graph(actualTriples);
     var expectedGraph = new Graph(expectedTriples);
     Assert.IsTrue(expectedGraph.Equals(actualGraph), "Result graphs do not match.r\nExpected:\r\n{0}\r\nActual:\r\n{1}",
         String.Join(",", expectedTriples.Select(t => t.ToString())),
         String.Join(",", actualTriples.Select(t => t.ToString())));
 }