public void ParsingRdfXmlAmpersands()
        {
            List<IRdfWriter> writers = new List<IRdfWriter>()
            {
                new RdfXmlWriter(),
                new FastRdfXmlWriter()
            };
            IRdfReader parser = new RdfXmlParser();

            Graph g = new Graph();
            g.BaseUri = new Uri("http://example.org/ampersandsInRdfXml");
            g.Assert(new Triple(g.CreateUriNode(), g.CreateUriNode(new Uri("http://example.org/property")), g.CreateUriNode(new Uri("http://example.org/a&b"))));
            g.Assert(new Triple(g.CreateUriNode(), g.CreateUriNode(new Uri("http://example.org/property")), g.CreateLiteralNode("A & B")));

            foreach (IRdfWriter writer in writers)
            {
                try
                {
                    Console.WriteLine(writer.GetType().ToString());
                    String temp = StringWriter.Write(g, writer);
                    Console.WriteLine(temp);
                    Graph h = new Graph();
                    StringParser.Parse(h, temp);
                    Assert.AreEqual(g, h, "Graphs should be equal");
                    Console.WriteLine();
                }
                catch (Exception ex)
                {
                    TestTools.ReportError("Error", ex, true);
                }
            }
        }
        public void ParsingRdfXmlEmptyStrings()
        {
            NTriplesFormatter formatter = new NTriplesFormatter();
            RdfXmlParser domParser = new RdfXmlParser(RdfXmlParserMode.DOM);
            Graph g = new Graph();
            domParser.Load(g, "empty-string-rdfxml.rdf");

            Console.WriteLine("DOM Parser parsed OK");

            foreach (Triple t in g.Triples)
            {
                Console.WriteLine(t.ToString(formatter));
            }
            Console.WriteLine();

            RdfXmlParser streamingParser = new RdfXmlParser(RdfXmlParserMode.Streaming);
            Graph h = new Graph();
            streamingParser.Load(h, "empty-string-rdfxml.rdf");

            Console.WriteLine("Streaming Parser parsed OK");

            foreach (Triple t in h.Triples)
            {
                Console.WriteLine(t.ToString(formatter));
            }

            Assert.AreEqual(g, h, "Graphs should be equal");
        }
        public IEnumerable<IDataObject> BindRdfDataObjects(XDocument rdfXmlDocument,
                                                           IList<OrderingDirection> orderingDirections)
        {
            var g = new Graph();
#if PORTABLE || WINDOWS_PHONE
			var parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
			// This is pretty nasty, having to deserialize only to go through parsing again
			parser.Load(g, new System.IO.StringReader(rdfXmlDocument.ToString()));
#else
			var parser = new RdfXmlParser(RdfXmlParserMode.DOM);
            parser.Load(g, rdfXmlDocument.AsXmlDocument());
#endif
            var p = new VDS.RDF.Query.LeviathanQueryProcessor(new InMemoryDataset(g));
            var queryString = MakeOrderedResourceQuery(orderingDirections);
            var sparqlParser = new SparqlQueryParser();
            var query = sparqlParser.ParseFromString(queryString);
            var queryResultSet = p.ProcessQuery(query) as VDS.RDF.Query.SparqlResultSet;
            foreach (var row in queryResultSet.Results)
            {
                INode uriNode;
                if (row.TryGetBoundValue("x", out uriNode) && uriNode is IUriNode)
                {
                    yield return BindRdfDataObject(uriNode as IUriNode, g);
                }
            }
        } 
        public static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress)
        {
            nuspec = NormalizeNuspecNamespace(nuspec);

            XslCompiledTransform transform = CreateTransform("xslt.nuspec.xslt");

            XsltArgumentList arguments = new XsltArgumentList();
            arguments.AddParam("base", "", baseAddress + "packages/");
            arguments.AddParam("extension", "", ".json");

            arguments.AddExtensionObject("urn:helper", new XsltHelper());

            XDocument rdfxml = new XDocument();
            using (XmlWriter writer = rdfxml.CreateWriter())
            {
                transform.Transform(nuspec.CreateReader(), arguments, writer);
            }

            RdfXmlParser rdfXmlParser = new RdfXmlParser();
            XmlDocument doc = new XmlDocument();
            doc.Load(rdfxml.CreateReader());
            IGraph graph = new Graph();
            rdfXmlParser.Load(graph, doc);

            return graph;
        }
        protected override void LoadGraph()
        {
            CreateGraph();

            using (Stream stream = InnerObject.GetStream())
            using (StreamReader reader = new StreamReader(stream, true))
            {
                RdfXmlParser rdfXmlParser = new RdfXmlParser();

                rdfXmlParser.Load(_graph, reader);
            }
        }
Beispiel #6
0
        public static void Main(String[] args)
        {
            try
            {
                Console.WriteLine("Reading a RDF/XML format Test Graph");
                RdfXmlParser parser = new RdfXmlParser();
                Graph g = new Graph();
                parser.Load(g, "JSONTest.rdf");

                Console.WriteLine("Serializing back to RDF/JSON");
                RdfJsonWriter writer = new RdfJsonWriter();
                writer.Save(g, "JSONTest.rdf.json");

                Console.WriteLine("Reading back from the RDF/JSON");
                RdfJsonParser jsonparser = new RdfJsonParser();
                Graph h = new Graph();
                jsonparser.Load(h, "JSONTest.rdf.json");

                Console.WriteLine("Outputting to NTriples");
                NTriplesWriter ntwriter = new NTriplesWriter();
                ntwriter.Save(h, "JSONTest.rdf.json.out");

                Console.WriteLine("Reading a RDF/JSON format Test Graph with tons of Comments in it");
                Graph i = new Graph();
                jsonparser.Load(i, "JSONTest.json");

                Console.WriteLine("Outputting to NTriples");
                ntwriter.Save(i, "JSONTest.json.out");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                Console.WriteLine(ex.StackTrace);
                if (ex.InnerException != null)
                {
                    Console.WriteLine(ex.InnerException.Message);
                    Console.WriteLine(ex.InnerException.StackTrace);
                }
            }
        }
        /// <summary>
        /// Updates the underlying store with this as the new representation of the identified resource
        /// </summary>
        /// <param name="resourceUri">The resource for whom this is the representation</param>
        /// <param name="resourceDescription">The rdf xml document that describes the resource</param>
        public override void ApplyFragment(string resourceUri, XDocument resourceDescription)
        {
            try
            {
                var g = new Graph();
                var rdfXmlParser = new RdfXmlParser();
                rdfXmlParser.Load(g, new StringReader(resourceDescription.ToString()));
                var ntWriter = new NTriplesWriter();
                var data = StringWriter.Write(g, ntWriter);

                var sparqlUpdate = "";
                sparqlUpdate += "DELETE { GRAPH <" + GraphUri + "> { <" + resourceUri + ">  ?x  ?y }}";
                sparqlUpdate += "USING <" + GraphUri + "> WHERE {<" + resourceUri + "> ?x ?y } ;";
                sparqlUpdate += "INSERT DATA { GRAPH <" + GraphUri + "> {  ";
                sparqlUpdate += data;
                sparqlUpdate += " }};";

                // execute update
                var wr = WebRequest.Create(SparqlEndpoint) as HttpWebRequest;
                wr.ContentType = "application/sparql-update";
                wr.Method = "POST";
                var ds = wr.GetRequestStream();
                var bytes = Encoding.ASCII.GetBytes(sparqlUpdate);
                ds.Write(bytes, 0, bytes.Length);
                var resp = wr.GetResponse() as HttpWebResponse;

                if (resp.StatusCode == HttpStatusCode.OK)
                {
                    Logging.LogDebug("Update successful");
                }
                else
                {
                    Logging.LogDebug("Not a 200");
                }
                resp.Close();
            } catch(Exception ex)
            {
                Logging.LogError(1, "Unable to apply fragment for resourceUri {0} {1}", ex.Message, ex.StackTrace);
            }
        }
        static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress, XslCompiledTransform xslt)
        {
            XsltArgumentList arguments = new XsltArgumentList();
            arguments.AddParam("base", "", baseAddress);
            arguments.AddParam("extension", "", ".json");

            arguments.AddExtensionObject("urn:helper", new XsltHelper());

            XDocument rdfxml = new XDocument();
            using (XmlWriter writer = rdfxml.CreateWriter())
            {
                xslt.Transform(nuspec.CreateReader(), arguments, writer);
            }

            XmlDocument doc = new XmlDocument();
            doc.Load(rdfxml.CreateReader());

            IGraph graph = new Graph();
            RdfXmlParser rdfXmlParser = new RdfXmlParser();
            rdfXmlParser.Load(graph, doc);

            return graph;
        }
        public static IGraph GraphFromXml(XDocument original, XslCompiledTransform transform, XsltArgumentList arguments)
        {
            XDocument rdfxml = new XDocument();
            using (XmlWriter writer = rdfxml.CreateWriter())
            {
                transform.Transform(original.CreateReader(), arguments, writer);
            }

            RdfXmlParser rdfXmlParser = new RdfXmlParser();
            XmlDocument doc = new XmlDocument();
            doc.Load(rdfxml.CreateReader());

            //DEBUG
            //using (var xmlWriter = XmlWriter.Create(Console.Out))
            //{
            //    doc.WriteTo(xmlWriter);
            //}

            IGraph graph = new Graph();
            rdfXmlParser.Load(graph, doc);

            return graph;
        }
        public void ParsingBaseUriAssignmentRdfXml()
        {
            Graph g = new Graph();
            g.BaseUri = new Uri("http://example.org/RdfXml");

            System.IO.StringWriter strWriter = new System.IO.StringWriter();
            RdfXmlWriter writer = new RdfXmlWriter();
            writer.Save(g, strWriter);

            Console.WriteLine("Original Base URI: " + ShowBaseUri(g.BaseUri));

            Console.WriteLine("Output using RdfXmlWriter:");
            Console.WriteLine(strWriter.ToString());
            Console.WriteLine();

            Graph h = new Graph();
            RdfXmlParser parser = new RdfXmlParser();
            parser.Load(h, new System.IO.StringReader(strWriter.ToString()));

            Console.WriteLine("Base URI after round-trip using RdfXmlWriter: " + ShowBaseUri(h.BaseUri));
            Assert.IsNotNull(h.BaseUri, "Base URI should not be null");

            strWriter = new System.IO.StringWriter();
            FastRdfXmlWriter fastWriter = new FastRdfXmlWriter();
            fastWriter.Save(g, strWriter);

            Console.WriteLine("Output using FastRdfXmlWriter:");
            Console.WriteLine(strWriter.ToString());
            Console.WriteLine();

            Graph i = new Graph();
            parser.Load(i, new System.IO.StringReader(strWriter.ToString()));

            Console.WriteLine("Base URI after round-trip to FastRdfXmlWriter: " + ShowBaseUri(h.BaseUri));
            Assert.IsNotNull(i.BaseUri, "Base URI should not be null");
        }
        public static void Main(string[] args)
        {
            StreamWriter output = new StreamWriter("RdfXmlTestSuite.txt");
            Console.SetOut(output);

            try
            {
                int testsPassed = 0;
                int testsFailed = 0;
                bool passed, passDesired;

                //RdfXmlParser parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
                RdfXmlParser parser = new RdfXmlParser(RdfXmlParserMode.DOM);
                NTriplesWriter ntwriter = new NTriplesWriter();
                parser.TraceParsing = true;
                Graph g = new Graph();

                output.WriteLine("## RDF/XML Test Suite");
                output.WriteLine();

                String[] dirs = Directory.GetDirectories("xmlrdf_tests");

                foreach (String dir in dirs)
                {
                    if (dir.Contains(".svn"))
                    {
                        continue;
                    }
                    String[] files = Directory.GetFiles(dir);

                    foreach (String file in files)
                    {
                        if (!Path.GetExtension(file).Equals(".rdf"))
                        {
                            continue;
                        }

                        passed = false;
                        passDesired = true;

                        output.WriteLine("## Testing " + file);
                        output.WriteLine("# Test Started at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat));

                        if (Path.GetFileNameWithoutExtension(file).StartsWith("error"))
                        {
                            passDesired = false;
                            output.WriteLine("# Desired Result = Parsing Failed");
                        }
                        else
                        {
                            output.WriteLine("# Desired Result = Parses OK");
                        }

                        try
                        {
                            Debug.WriteLine("Testing file " + file);
                            g = new Graph();
                            g.BaseUri = new Uri(XMLTestSuiteBaseURI);
                            parser.Load(g, file);

                            passed = true;
                        }
                        catch (IOException ioEx)
                        {
                            reportError(output, "IO Exception", ioEx);
                        }
                        catch (RdfParseException parseEx)
                        {
                            reportError(output, "Parsing Exception", parseEx);
                        }
                        catch (RdfException rdfEx)
                        {
                            reportError(output, "RDF Exception", rdfEx);
                        }
                        catch (Exception ex)
                        {
                            reportError(output, "Other Exception", ex);
                        }
                        finally
                        {
                            if (passed && passDesired)
                            {
                                //Passed and we wanted to Pass
                                testsPassed++;
                                output.WriteLine("# Result = Test Passed");

                                //Try to write output
                                ntwriter.Save(g, Path.ChangeExtension(file, "out"));
                            }
                            else if (!passed && passDesired)
                            {
                                //Failed when we should have Passed
                                testsFailed++;
                                output.WriteLine("# Result = Test Failed");

                                //Show output
                                output.WriteLine("Generated the following Triples before failing:");
                                foreach (Triple t in g.Triples)
                                {
                                    Console.WriteLine(t.ToString());
                                }
                            }
                            else if (passed && !passDesired)
                            {
                                //Passed when we should have Failed
                                testsFailed++;
                                output.WriteLine("# Result = Test Failed");
                            }
                            else
                            {
                                //Failed and we wanted to Fail
                                testsPassed++;
                                output.WriteLine("# Result = Test Passed");
                            }

                            output.WriteLine("# " + g.Triples.Count() + " Triples generated");
                            output.WriteLine("# Test Ended at " + DateTime.Now.ToString(TestSuite.TestSuiteTimeFormat));

                        }

                        output.WriteLine();
                    }
                }

                output.WriteLine(testsPassed + " Tests Passed");
                output.WriteLine(testsFailed + " Tests Failed");
            }
            catch (IOException ioEx)
            {
                reportError(output, "IO Exception", ioEx);
            }
            catch (RdfParseException parseEx)
            {
                reportError(output, "Parsing Exception", parseEx);
            }
            catch (RdfException rdfEx)
            {
                reportError(output, "RDF Exception", rdfEx);
            }
            catch (Exception ex)
            {
                reportError(output, "Other Exception", ex);
            }

            output.Close();
        }
Beispiel #12
0
        public static Object LoadFromReader(Reader r, string baseUri, org.openrdf.rio.RDFFormat rdff)
        {
            Object obj;

            if (rdff == dotSesameFormats.RDFFormat.N3)
            {
                obj = new Graph();
                if (baseUri != null) ((IGraph)obj).BaseUri = new Uri(baseUri);
                Notation3Parser parser = new Notation3Parser();
                parser.Load((IGraph)obj, r.ToDotNetReadableStream());
            }
            else if (rdff == dotSesameFormats.RDFFormat.NTRIPLES)
            {
                obj = new Graph();
                if (baseUri != null) ((IGraph)obj).BaseUri = new Uri(baseUri);
                NTriplesParser parser = new NTriplesParser();
                parser.Load((IGraph)obj, r.ToDotNetReadableStream());
            }
            else if (rdff == dotSesameFormats.RDFFormat.RDFXML)
            {
                obj = new Graph();
                if (baseUri != null) ((IGraph)obj).BaseUri = new Uri(baseUri);
                RdfXmlParser parser = new RdfXmlParser();
                parser.Load((IGraph)obj, r.ToDotNetReadableStream());
            }
            else if (rdff == dotSesameFormats.RDFFormat.TRIG)
            {
                obj = new TripleStore();
                TriGParser trig = new TriGParser();
                trig.Load((ITripleStore)obj, new StreamParams(r.ToDotNetReadableStream().BaseStream));
            }
            else if (rdff == dotSesameFormats.RDFFormat.TRIX)
            {
                obj = new TripleStore();
                TriXParser trix = new TriXParser();
                trix.Load((ITripleStore)obj, new StreamParams(r.ToDotNetReadableStream().BaseStream));
            }
            else if (rdff == dotSesameFormats.RDFFormat.TURTLE)
            {
                obj = new Graph();
                if (baseUri != null) ((IGraph)obj).BaseUri = new Uri(baseUri);
                TurtleParser parser = new TurtleParser();
                parser.Load((IGraph)obj, r.ToDotNetReadableStream());
            }
            else
            {
                throw new RdfParserSelectionException("The given Input Format is not supported by dotNetRDF");
            }

            return obj;
        }
Beispiel #13
0
        private Graph GetXmlDocumentAsGraph()
        {
            var g = new Graph();

            if (_xmlParser == null)
            {
                _xmlParser = new RdfXmlParser(RdfXmlParserMode.DOM);
                //This is not to store the URIs in a static list by dotNetRDF (uses up a lot of mem)
                Options.InternUris = false;
            }

            _xmlParser.Load(g, _output);

            //add namespaces from the XML doc to the graph
            foreach (var nsPrefix in _namespaces.Keys)
            {
                if (!g.NamespaceMap.HasNamespace(nsPrefix))
                    g.NamespaceMap.AddNamespace(nsPrefix, new Uri(_namespaces[nsPrefix]));
            }

            return g;
        }
Beispiel #14
0
        static void Main(string[] args)
        {
            var tf = new edu.stanford.nlp.trees.LabeledScoredTreeFactory(new CustomStringLabelFactory());

            var str   = "(x2 / score :null_edge(x1 / null_tag) :null_edge(x3 / null_tag)	:time(xap0 / before	:quant(x5 / temporal - quantity	:unit(y / year) :null_edge(x4 / null_tag))))";
            var input = new java.io.StringReader(str);

            var treeReader = new edu.stanford.nlp.trees.PennTreeReader(input, tf, new CustomTreeNormalizer(), new CustomTokenizerAdapter(input));

            var t = treeReader.readTree();


            TreePrint p = new TreePrint("penn");

            p.printTree(t);



            //READ RST INFORMATION
            RSTTree tree = new RSTTree("lincon");

            tree.Load(Path.Combine(Root, "rst.xml"));
            tree.EvaluateODonell();

            var sum = tree.Summarize();

            //READ AMR INFORMATION FOR EACH EDU AND ASSOCIATTE THE ODONELL SCORE
            IGraph g      = new Graph();
            var    parser = new VDS.RDF.Parsing.RdfXmlParser();

            //   NTriplesParser ntparser = new NTriplesParser();
            parser.Load(g, Path.Combine(Root, "output.xml"));
            var document = new AMRDocument();

            document.Load(g);

            foreach (var item in document.EDUSentences)
            {
                item.ApplyRSTWeight(sum.Where(c => c.edu == item.Id).Select(c => c.Weight).First());
            }

            //var rstdocument = new RSTDocumentRepository();
            //rstdocument.DeleteAllNodes();
            //rstdocument.Save(tree);

            AMRNEORepository repo = new AMRNEORepository();

            repo.DeleteAllNodes();
            repo.SaveDocument(document);



            //var ids = Helper.ReadIds(g);
            //foreach (var item in ids)
            //{

            //    item.sentence = Helper.GetSentence(g, item);
            //    item.AddNodes(g);


            //    if (item.id == 22)
            //    {
            //        Console.WriteLine(item.urlid);
            //        Console.WriteLine(item.sentence);
            //        Console.WriteLine(item.Root.uriid);
            //        Console.WriteLine(item.Root.Term.uriid);
            //        Console.WriteLine(item.Root.Term.type);
            //    }

            //}

            //SparqlQueryParser qparser = new SparqlQueryParser();
            ////Then we can parse a SPARQL string into a query

            //StringBuilder querystr = new StringBuilder();
            //querystr.AppendLine("PREFIX amr-core: <http://amr.isi.edu/rdf/core-amr#>");
            //querystr.AppendLine("PREFIX amr-data: <http://amr.isi.edu/amr_data#>");
            //querystr.AppendLine("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>");
            //querystr.AppendLine("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>");
            //querystr.AppendLine("PREFIX amr-terms: <http://amr.isi.edu/rdf/amr-terms#>");
            ////querystr.AppendLine("SELECT  ?p WHERE { ?s rdf:type ?p }");
            ////querystr.Append("SELECT ?s ?sentence ?id ?root ?rtype ?amrtype");
            //querystr.Append("SELECT ?root ?rtype  ?amrtypelbl ");
            //querystr.Append("WHERE {");
            //querystr.Append("?s amr-core:has-sentence ?sentence.");
            //querystr.Append("?s amr-core:has-id ?id.");
            //querystr.Append("?s amr-core:root ?root. ");
            //querystr.Append("?root rdf:type ?rtype. ");
            //querystr.Append("?rtype rdf:type ?amrtype. ");
            //querystr.Append("?amrtype rdfs:label ?amrtypelbl. ");
            //querystr.Append("}");

            //SparqlQuery q = qparser.ParseFromString(querystr.ToString());

            ////http://amr.isi.edu/rdf/core-amr#has-id
            //var rset = (SparqlResultSet)g.ExecuteQuery(q);

            //var SB = new StringBuilder();
            //if (rset.Result && rset.Results.Count > 0)
            //{
            //    foreach (var result in rset.Results)
            //    {
            //        foreach (var r in result)
            //        {
            //            Console.WriteLine(r.Key + " " + r.Value);
            //        }

            //        //Do what you want with each result
            //    }
            //}
            //File.WriteAllText("dic.txt", SB.ToString());
            //http://amr.isi.edu/amr_data/22#root01

            //foreach (var item in g.Triples)
            //{


            //    Console.WriteLine(item.Subject);

            //}



            //foreach (var node in g.Nodes)
            //{
            //    Console.WriteLine(node.ToString());
            //}

            //g.SaveToFile("output.rdf");
        }
Beispiel #15
0
        static void Main(string[] args)
        {
            IGraph g      = new Graph();
            IGraph h      = new Graph();
            var    parser = new VDS.RDF.Parsing.RdfXmlParser();

            //   NTriplesParser ntparser = new NTriplesParser();
            //Load using a Filename
            parser.Load(g, Path.Combine(Root, "edus.amr.xml"));

            var ids = Helper.ReadIds(g);

            foreach (var item in ids)
            {
                item.sentence = Helper.GetSentence(g, item);
                item.AddRoot(g);


                Console.WriteLine(item.id);
                Console.WriteLine(item.urlid);
                Console.WriteLine(item.sentence);
                Console.WriteLine(item.Root.uriid);
                Console.WriteLine(item.Root.Term.uriid);
                Console.WriteLine(item.Root.Term.type);
            }

            //SparqlQueryParser qparser = new SparqlQueryParser();
            ////Then we can parse a SPARQL string into a query
            //SparqlQuery q =
            //    qparser.ParseFromString("SELECT ?s ?x ?p WHERE { ?s ?x ?p }");

            ////http://amr.isi.edu/rdf/core-amr#has-id
            //var rset = (SparqlResultSet)g.ExecuteQuery(q);

            //var SB = new StringBuilder();
            //if (rset.Result && rset.Results.Count > 0 )
            //{
            //    foreach (var result in rset.Results)
            //    {
            //        foreach (var r in result)
            //        {
            //            SB.AppendLine(r.Key + " " + r.Value);
            //            Console.WriteLine(r.Key + " " + r.Value);
            //        }

            //        //Do what you want with each result
            //    }
            //}
            //File.WriteAllText("dic.txt", SB.ToString());
            //http://amr.isi.edu/amr_data/22#root01

            //foreach (var item in g.Triples)
            //{


            //    Console.WriteLine(item.Subject);

            //}



            //foreach (var node in g.Nodes)
            //{
            //    Console.WriteLine(node.ToString());
            //}

            //g.SaveToFile("output.rdf");
        }
        /// <summary>
        /// Выполнение Sparql-запроса
        /// </summary>
        /// <param name="sparqlCommandText">Текст Sparql-запроса</param>
        /// <returns>Результат запроса в виде текста</returns>
        public string ExecuteQuery(string sparqlCommandText)
        {
            using (Graph baseGraph = new Graph())
            {
                RdfXmlParser fileParser = new RdfXmlParser();
                foreach (string fileName in FilesToQuery)
                {
                    if (String.IsNullOrWhiteSpace(fileName))
                        continue;

                    using (Graph g = new Graph())
                    {
                        try
                        {
                            fileParser.Load(g, fileName);
                            baseGraph.Merge(g);
                        }
                        catch (Exception ex)
                        {
                            throw new Exception(String.Format("Ошибка при обработке файла {0}\r\n{1}",fileName, ex.Message), ex);
                        }
                    }
                }

                var resultSet = baseGraph.ExecuteQuery(sparqlCommandText);

                if (resultSet is SparqlResultSet)
                {
                    SparqlResultSet outputSet = resultSet as SparqlResultSet;

                    if (outputSet.IsEmpty)
                        QueryResult = "Пустой результат";
                    else
                    {
                        StringBuilder outputString = new StringBuilder();
                        foreach (SparqlResult result in outputSet.Results)
                            outputString.AppendLine(result.ToString());

                        QueryResult = outputString.ToString();
                    }
                }
                else if (resultSet is Graph)
                {
                    Graph resultGraph = resultSet as Graph;

                    if (resultGraph.IsEmpty)
                        QueryResult = "Пустой граф";
                    else
                        QueryResult = VDS.RDF.Writing.StringWriter.Write(resultGraph, new RdfXmlWriter());
                }
                else
                {
                    QueryResult = string.Format("Неизвестный результат: {0}", resultSet.GetType());
                }

                return QueryResult;
            }
        }
Beispiel #17
0
        public void ParsingRdfXmlStreaming()
        {
            try
            {
                RdfXmlParser parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
                parser.TraceParsing = true;
                Graph g = new Graph();
                parser.Load(g, "example.rdf");

                TestTools.ShowGraph(g);
            }
            catch (Exception ex)
            {
                TestTools.ReportError("Error", ex, true);
            }
        }
        /// <summary>
        /// Internal Method which performs multi-threaded reading of data
        /// </summary>
        private void LoadGraphs(FolderStoreParserContext context)
        {
            //Create the relevant Parser
            IRdfReader parser;
            switch (context.Format)
            {
                case FolderStoreFormat.Turtle:
                    parser = new TurtleParser();
                    break;
                case FolderStoreFormat.Notation3:
                    parser = new Notation3Parser();
                    break;
                case FolderStoreFormat.RdfXml:
                    parser = new RdfXmlParser();
                    break;
                default:
                    parser = new TurtleParser();
                    break;
            }

            try
            {
                String file = context.GetNextFilename();
                while (file != null)
                {
                    //Read from Disk
                    Graph g = new Graph();
                    String sourceFile = Path.Combine(context.Folder, file);
                    parser.Load(g, sourceFile);

                    //Add to Graph Collection
                    foreach (Triple t in g.Triples)
                    {
                        if (context.Terminated) break;
                        if (!context.Handler.HandleTriple(t)) ParserHelper.Stop();
                    }

                    if (context.Terminated) break;

                    //Get the Next Filename
                    file = context.GetNextFilename();
                }
            }
            catch (ThreadAbortException)
            {
                //We've been terminated, don't do anything
#if !SILVERLIGHT
                Thread.ResetAbort();
#endif
            }
            catch (RdfParsingTerminatedException)
            {
                context.Terminated = true;
                context.ClearFilenames();
            }
            catch (Exception ex)
            {
                throw new RdfStorageException("Error in Threaded Reader in Thread ID " + Thread.CurrentThread.ManagedThreadId, ex);
            }
        }
Beispiel #19
0
        public void ParsingRdfXmlEmptyElement()
        {
            String fragment = @"<?xml version='1.0'?><rdf:RDF xmlns:rdf='" + NamespaceMapper.RDF + @"' xmlns='http://example.org/'><rdf:Description rdf:about='http://example.org/subject'><predicate rdf:resource='http://example.org/object' /></rdf:Description></rdf:RDF>";

            Graph g = new Graph();
            RdfXmlParser parser = new RdfXmlParser(RdfXmlParserMode.Streaming);
            parser.TraceParsing = true;
            VDS.RDF.Parsing.StringParser.Parse(g, fragment, parser);
            foreach (Triple t in g.Triples)
            {
                Console.WriteLine(t.ToString());
            }
        }
Beispiel #20
0
        public void TestRdfXmlExport()
        {
            CopyTestDataToImportFolder("simple.txt");
            var storeName = "TestRdfXmlExport_" + DateTime.Now.Ticks;
            var client = GetClient();
            client.CreateStore(storeName);

            var importJob = client.StartImport(storeName, "simple.txt");
            importJob = WaitForJob(importJob, client, storeName);
            Assert.That(importJob.JobCompletedOk, "Import failed: {0} - {1}", importJob.StatusMessage, importJob.ExceptionInfo);
            var pathToExport = Path.Combine(Configuration.StoreLocation, "import", "simple.rdf");
            if (File.Exists(pathToExport)) File.Delete(pathToExport);

            var exportJob = client.StartExport(storeName, "simple.rdf", exportFormat: RdfFormat.RdfXml,
                                               graphUri: Constants.DefaultGraphUri);
            exportJob = WaitForJob(exportJob, client, storeName);
            Assert.That(exportJob.JobCompletedOk, "Export failed: {0} - {1}", exportJob.StatusMessage, exportJob.ExceptionInfo);
            Assert.That(File.Exists(pathToExport));

            var g = new Graph();
            var parser = new RdfXmlParser();
            parser.Load(g, pathToExport);

            // TODO: Validate expected content

        }
        //static void Model_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        //{
        //    if (e.PropertyName == "ConsoleOutput")
        //        Console.WriteLine((sender as ProcessViewModel).ConsoleOutput);
        //}
        /// <summary>
        /// https://bitbucket.org/dotnetrdf/dotnetrdf/wiki/User%20Guide
        /// </summary>
        static void TestRDF()
        {
            IGraph g = new Graph();
            RdfXmlParser fileParser = new RdfXmlParser();
            //fileParser.Load(g, "schema.xml");
            fileParser.Load(g, "TestRdf.xml");

            //SparqlQueryParser queryParser = new SparqlQueryParser();
            //queryParser.ParseFromString("SELECT * WHERE { ?s a ?type }");
            //VDS.RDF.Writing.StringWriter.Write(g, new RdfXmlWriter())

            StringBuilder div = new StringBuilder();

            XElement rdf = XElement.Parse(VDS.RDF.Writing.StringWriter.Write(g, new RdfXmlWriter()));
            foreach (XElement element in rdf.Elements())
            {
                div.AppendFormat("<div itemscope itemtype=\"{0}/{1}\">", element.Name.NamespaceName.TrimEnd('/'), element.Name.LocalName);
                div.AppendLine();
                foreach (XElement content in element.Elements())
                {
                    div.AppendFormat("<meta itemprop=\"{0}\" content=\"{1}\">", content.Name.LocalName, content.Value);
                    div.AppendLine();
                }
                div.AppendLine("</div>");
            }

            var output = g.ExecuteQuery("SELECT * WHERE { ?s a ?type }");

            SparqlParameterizedString query = new SparqlParameterizedString();
            query.Namespaces.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
            query.Namespaces.AddNamespace("owl", new Uri("http://www.w3.org/2002/07/owl#"));
            query.Namespaces.AddNamespace("xsd", new Uri("http://www.w3.org/2001/XMLSchema#"));
            query.Namespaces.AddNamespace("rdfs", new Uri("http://www.w3.org/2000/01/rdf-schema#"));
            query.Namespaces.AddNamespace("schema", new Uri("http://schema.org/"));
            query.Namespaces.AddNamespace("fact", new Uri("http://www.co-ode.org/ontologies/ont.owl#"));

            query.CommandText = "SELECT * WHERE { ?organization rdf:type fact:UniqueCompany }";

            var output2 = g.ExecuteQuery(query);

            //            var output2 = g.ExecuteQuery(@"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
            //										PREFIX owl: <http://www.w3.org/2002/07/owl#>
            //										PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
            //										PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
            //										PREFIX schema: <http://schema.org/>
            //										PREFIX fact:<http://www.co-ode.org/ontologies/ont.owl#>
            //										SELECT *
            //										WHERE { ?organization rdf:type fact:UniqueCompany }");
        }