Exemplo n.º 1
0
		public void Load (System.IO.Stream stream)
		{
			try {
				RdfXmlReader reader = new RdfXmlReader (stream);
				reader.BaseUri = MetadataStore.FSpotXMPBase;
				store.Import (reader);
				//Dump ();
			} catch (System.Exception e) {
				Beagle.Util.Log.Error (e, "Error loading TIFF file");
			}
		}
Exemplo n.º 2
0
		public void Load (System.IO.Stream stream)
		{
			try {
				RdfXmlReader reader = new RdfXmlReader (stream);
				reader.BaseUri = MetadataStore.FSpotXMPBase;
				store.Import (reader);
				//Dump ();
			} catch (System.Exception e) {
				Log.DebugFormat ("Caught an exception :{0}", e.ToString ());
			}
		}
Exemplo n.º 3
0
		public void Load (System.IO.Stream stream)
		{
			try {
				RdfXmlReader reader = new RdfXmlReader (stream);
				reader.BaseUri = MetadataStore.FSpotXMPBase;
				store.Import (reader);
				//Dump ();
			} catch (System.Exception e) {
				System.Console.WriteLine (e.ToString ());
			}
		}
Exemplo n.º 4
0
        public static RdfReader LoadFromUri(Uri webresource)
        {
            // TODO: Add Accept header for HTTP resources.

            System.Net.WebRequest  rq   = System.Net.WebRequest.Create(webresource);
            System.Net.WebResponse resp = rq.GetResponse();

            string mimetype = resp.ContentType;

            if (mimetype.IndexOf(';') > -1)
            {
                mimetype = mimetype.Substring(0, mimetype.IndexOf(';'));
            }

            mimetype = NormalizeMimeType(mimetype.Trim());

            RdfReader reader;

            if (mimetype == "xml" || mimetype == "application/rss+xml")
            {
                reader = new RdfXmlReader(resp.GetResponseStream());
            }

            else if (mimetype == "n3" || mimetype == "turtle")
            {
                reader = new N3Reader(new StreamReader(resp.GetResponseStream(), System.Text.Encoding.UTF8));
            }

            else if (webresource.LocalPath.EndsWith(".rdf") || webresource.LocalPath.EndsWith(".xml") || webresource.LocalPath.EndsWith(".rss"))
            {
                reader = new RdfXmlReader(resp.GetResponseStream());
            }

            else if (webresource.LocalPath.EndsWith(".n3") || webresource.LocalPath.EndsWith(".ttl") || webresource.LocalPath.EndsWith(".nt"))
            {
                reader = new N3Reader(new StreamReader(resp.GetResponseStream(), System.Text.Encoding.UTF8));
            }

            else
            {
                throw new InvalidOperationException("Could not determine the RDF format of the resource.");
            }

            reader.BaseUri = resp.ResponseUri.ToString();

            return(reader);
        }
 public void AddNewRDFData(string rdfData, bool removeExistingDataForSubjects)
 {
     MemoryStore store = new MemoryStore();
     RdfXmlReader reader = new RdfXmlReader(new System.IO.StringReader(rdfData));
     store.Import(reader);
     // its possible that we want to update info about some existing concept
     // if removeExistingDataForSubjects is true we first remove existing information before we start adding statements
     if (removeExistingDataForSubjects)
     {
         foreach (Entity subject in store.SelectSubjects(null, null))
             _conceptsStore.Remove(new Statement(subject, null, null));
     }
     foreach (Statement s in store.Select(new Statement(null, null, null)))
         AddNewStatement(s);
     foreach (Entity subject in store.SelectSubjects(null, null))
         UpdateSuggestionsForUri(subject.Uri);
 }
Exemplo n.º 6
0
    public static void Main(string[] args)
    {
        if (args.Length != 2) {
            Console.WriteLine("runtests.exe basepath manifestfile");
            return;
        }

        basepath = args[0];
        string manifestfile = Path.Combine(basepath, args[1]);

        RdfReader reader = new RdfXmlReader(manifestfile);
        if (!manifestfile.EndsWith(".rdf"))
            reader = new N3Reader(manifestfile);
        reader.BaseUri = "http://www.example.org/";

        MemoryStore testlist = new MemoryStore(reader);

        // RDF/XML TESTS

        foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#PositiveParserTest"))
            RunTest(testlist, test, true, 0);
        foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2000/10/rdf-tests/rdfcore/testSchema#NegativeParserTest"))
            RunTest(testlist, test, false, 0);

        // N3 TESTS

        foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2004/11/n3test#PositiveParserTest"))
            RunTest(testlist, test, true, 1);
        foreach (Entity test in testlist.GetEntitiesOfType("http://www.w3.org/2004/11/n3test#NegativeParserTest"))
            RunTest(testlist, test, false, 1);

        Console.WriteLine("Total Tests:\t{0}", total);
        Console.WriteLine("Total Failures:\t{0} ({1}%)", badfail+badpass, (int)(100*(float)(badpass+badfail)/total));
        Console.WriteLine("Positive Fails:\t{0}", badfail);
        Console.WriteLine("Negative Fails:\t{0}", badpass);
        Console.WriteLine("Test Errors:\t{0}", error);
    }
Exemplo n.º 7
0
		public static RdfReader LoadFromUri(Uri webresource) {
			// TODO: Add Accept header for HTTP resources.
			
			System.Net.WebRequest rq = System.Net.WebRequest.Create(webresource);
			System.Net.WebResponse resp = rq.GetResponse();
			
			string mimetype = resp.ContentType;
			if (mimetype.IndexOf(';') > -1)
				mimetype = mimetype.Substring(0, mimetype.IndexOf(';'));
				
			mimetype = NormalizeMimeType(mimetype.Trim());
			
			RdfReader reader;
			
			if (mimetype == "xml" || mimetype == "application/rss+xml")
				reader = new RdfXmlReader(resp.GetResponseStream());
					
			else if (mimetype == "n3")
				reader = new N3Reader(new StreamReader(resp.GetResponseStream(), System.Text.Encoding.UTF8));
			
			else if (webresource.LocalPath.EndsWith(".rdf") || webresource.LocalPath.EndsWith(".xml") || webresource.LocalPath.EndsWith(".rss"))
				reader = new RdfXmlReader(resp.GetResponseStream());
			
			else if (webresource.LocalPath.EndsWith(".n3") || webresource.LocalPath.EndsWith(".ttl") || webresource.LocalPath.EndsWith(".nt"))
				reader = new N3Reader(new StreamReader(resp.GetResponseStream(), System.Text.Encoding.UTF8));

			else
				throw new InvalidOperationException("Could not determine the RDF format of the resource.");
				
			reader.BaseUri = resp.ResponseUri.ToString();
			
			return reader;
		}
 public void LoadAnnotationOntologyFromString(string rdfData)
 {
     _conceptsStore = new MemoryStore();
     RdfXmlReader reader = new RdfXmlReader(new System.IO.StringReader(rdfData));
     _conceptsStore.Import(reader);
     UpdateDictionaries();
 }
Exemplo n.º 9
0
    static void RunTest(Entity test, Store manifest)
    {
        Entity rdf_type = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
        Entity mf_PositiveSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#PositiveSyntaxTest";
        Entity mf_NegativeSyntaxTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#NegativeSyntaxTest";
        Entity mf_QueryTest = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#QueryEvaluationTest";
        Entity mf_action = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#action";
        Entity mf_result = "http://www.w3.org/2001/sw/DataAccess/tests/test-manifest#result";
        Entity qt_data = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#data";
        Entity qt_query = "http://www.w3.org/2001/sw/DataAccess/tests/test-query#query";

        Entity test_type = (Entity)manifest.SelectObjects(test, rdf_type)[0];
        Entity action = (Entity)manifest.SelectObjects(test, mf_action)[0];

        if (test_type == mf_PositiveSyntaxTest || test_type == mf_NegativeSyntaxTest) {
            // The action is a query.

            // Load the action as a string.
            string q = ReadFile(action.Uri);

            // Run the action.
            try {
                new SparqlEngine(q);
            } catch (SemWeb.Query.QueryFormatException qfe) {
                // On a negative test: Good!
                if (test_type == mf_NegativeSyntaxTest) {
                    pass++;
                    return;
                }

                Console.WriteLine("Test Failed: " + action);
                Console.WriteLine(qfe.Message);
                Console.WriteLine(q);
                Console.WriteLine();
                fail++;
                return;
            }

            // On a positive test: Good!
            if (test_type == mf_PositiveSyntaxTest) {
                pass++;
                return;
            }

            Console.WriteLine("Test Failed: " + action);
            Console.WriteLine("Query is syntactically incorrect.");
            Console.WriteLine(q);
            Console.WriteLine();
            fail++;

        } else if (test_type == mf_QueryTest) {

            Entity data = (Entity)manifest.SelectObjects(action, qt_data)[0];
            Entity query = (Entity)manifest.SelectObjects(action, qt_query)[0];
            Entity result = (Entity)manifest.SelectObjects(test, mf_result)[0];

            MemoryStore data_store = new MemoryStore(new N3Reader(data.Uri));
            string q = ReadFile(query.Uri);

            if (q.IndexOf("ASK") >= 0) {
                Console.WriteLine("ASK Test Skipped: " + test);
                skip++;
                return;
            }

            string run_individual_test = "mono ../../bin/rdfquery.exe -type sparql n3:" + data.Uri + " < " + query.Uri;

            SparqlEngine sp;
            try {
                sp = new SparqlEngine(q);
            } catch (SemWeb.Query.QueryFormatException qfe) {
                Console.WriteLine("Test Failed: " + test);
                Console.WriteLine(run_individual_test);
                Console.WriteLine(q);
                Console.WriteLine(qfe.Message);
                Console.WriteLine();
                fail++;
                return;
            }

            QueryResultBuffer results = new QueryResultBuffer();
            bool results_bool = false;
            try {
                if (sp.Type != SparqlEngine.QueryType.Ask)
                    sp.Run(data_store, results);
                else
                    results_bool = sp.Ask(data_store);
            } catch (Exception e) {
                Console.WriteLine("Test Failed: " + test);
                Console.WriteLine(run_individual_test);
                Console.WriteLine(q);
                Console.WriteLine(e);
                Console.WriteLine();
                fail++;
                return;
            }

            bool failed = false;
            StringBuilder info = new StringBuilder();

            if (result.Uri.EndsWith(".ttl") || result.Uri.EndsWith(".srx") || result.Uri.EndsWith(".rdf")) {

                bool sorted = false;
                QueryResultBuffer results2 = new QueryResultBuffer();

                if (result.Uri.EndsWith(".srx")) {
                        using (FileStream fs = new FileStream(result.Uri, FileMode.Open))
                            SemWeb.Remote.SparqlHttpSource.ParseSparqlResponse(fs, results2);

                } else if (result.Uri.EndsWith(".rdf") || result.Uri.EndsWith(".ttl")) {
                    RdfReader reader = null;
                    if (result.Uri.EndsWith(".rdf"))
                        reader = new RdfXmlReader(result.Uri);
                    else if (result.Uri.EndsWith(".ttl"))
                        reader = new N3Reader(result.Uri);
                    MemoryStore result_store = new MemoryStore(reader);

                    string rs = "http://www.w3.org/2001/sw/DataAccess/tests/result-set#";
                    Entity rsResultSet = rs + "ResultSet";
                    Entity rsresultVariable = rs + "resultVariable";
                    Entity rssolution = rs + "solution";
                    Entity rsindex = rs + "index";
                    Entity rsbinding = rs + "binding";
                    Entity rsvariable = rs + "variable";
                    Entity rsvalue = rs + "value";

                    // get a list of variables in the query output
                    Entity resultset = result_store.GetEntitiesOfType(rsResultSet)[0];
                    ArrayList vars = new ArrayList();
                    foreach (Literal var in result_store.SelectObjects(resultset, rsresultVariable))
                        vars.Add(new Variable(var.Value));
                    Variable[] varsarray = (Variable[])vars.ToArray(typeof(Variable));

                    // try to order as best we can to our own output, so we sort the results the same way
                    for (int i = 0; i < results.Variables.Length; i++) {
                        if (i >= varsarray.Length) break;
                        for (int j = i; j < varsarray.Length; j++) {
                            if (varsarray[j].LocalName == results.Variables[i].LocalName) {
                                Variable temp = varsarray[i];
                                varsarray[i] = varsarray[j];
                                varsarray[j] = temp;
                                break;
                            }
                        }
                    }

                    Hashtable varmap = new Hashtable();
                    foreach (Variable v in varsarray)
                            varmap[v.LocalName] = varmap.Count;

                    results2.Init(varsarray);

                    Resource[] resultbindings = result_store.SelectObjects(resultset, rssolution);

                    // Try sorting by index
                    int[] indexes = new int[resultbindings.Length];
                    for (int i = 0; i < resultbindings.Length; i++) {
                        Entity binding = (Entity)resultbindings[i];
                        Literal index = (Literal)result_store.SelectObjects(binding, rsindex)[0];
                        indexes[i] = (int)(Decimal)index.ParseValue();
                        sorted = true;
                    }
                    Array.Sort(indexes, resultbindings);

                    // Add bindings into results2.
                    for (int i = 0; i < resultbindings.Length; i++) {
                        Resource[] row = new Resource[vars.Count];
                        Entity binding = (Entity)resultbindings[i];
                        foreach (Entity var in result_store.SelectObjects(binding, rsbinding)) {
                            string name = ((Literal)result_store.SelectObjects(var, rsvariable)[0]).Value;
                            Resource val = result_store.SelectObjects(var, rsvalue)[0];
                            row[(int)varmap[name]] = val;
                        }
                        results2.Add(new VariableBindings(varsarray, row));
                    }
                }

                // Check variable list
                ArrayList vars1 = new ArrayList();
                foreach (Variable v in results.Variables)
                    vars1.Add(v.LocalName);
                ArrayList vars2 = new ArrayList();
                foreach (Variable v in results2.Variables)
                    vars2.Add(v.LocalName);
                failed |= !SetsSame(vars1, vars2, "Result Set Variables", info);

                // Checking bindings
                if (results.Bindings.Count != results2.Bindings.Count) {
                    info.Append("Solutions have different number of bindings.\n");
                    failed = true;
                } else {
                    // Now actually run comparison.

                    if (!sorted) {
                        ((ArrayList)results.Bindings).Sort();
                        ((ArrayList)results2.Bindings).Sort();
                    }

                    for (int i = 0; i < results.Bindings.Count; i++) {
                            VariableBindings b1 = (VariableBindings)results.Bindings[i];
                            VariableBindings b2 = (VariableBindings)results2.Bindings[i];
                            foreach (Variable var in results.Variables) {
                                Resource val1 = b1[var.LocalName];
                                Resource val2 = b2[var.LocalName];
                                if (val1 != val2 && !(val1 is BNode) && !(val2 is BNode)) { // TODO: Test bnodes are returned correctly
                                    info.Append("Binding row " + i + " differ in value of " + var.LocalName + " variable: " + val2 + ", should be: " + val1 + "\n");
                                    failed = true;
                                }
                            }
                    }
                }

            } else {
                skip++;
                Console.WriteLine(test + ": Unknown result type " + result.Uri);
            }

            if (failed) {
                Console.WriteLine("Test Failed: " + test);
                Console.WriteLine(run_individual_test);
                Console.WriteLine(q);
                Console.WriteLine(info.ToString());
                Console.WriteLine();
                fail++;
            } else {
                pass++;
            }

        } else {
            skip++;
            Console.WriteLine(test + ": Unknown test type " + test_type);
            Console.WriteLine();
        }
    }
Exemplo n.º 10
0
    public Hashtable Validate()
    {
        string content = HttpContext.Current.Request.Form["content"];
        string format = HttpContext.Current.Request.Form["format"];
        if (content == null || content.Trim() == "" || format == null) {
            HttpContext.Current.Response.Redirect("index.xpd");
            throw new InvalidOperationException();
        }

        StringWriter output = new StringWriter();

        RdfReader reader;
        RdfWriter writer;

        Hashtable response = new Hashtable();

        response["InDocument"] = AddLineNumbers(content);

        if (format == "xml") {
            reader = new RdfXmlReader(new StringReader(content));
            writer = new N3Writer(output);
            response["InFormat"] = "RDF/XML";
            response["OutFormat"] = "Notation 3";
        } else if (format == "n3") {
            reader = new N3Reader(new StringReader(content));
            writer = new RdfXmlWriter(output);
            response["OutFormat"] = "RDF/XML";
            response["InFormat"] = "Notation 3";
        } else {
            throw new Exception("Invalid format.");
        }

        response["Validation"] = "Syntax validated OK.";

        response["OutDocument"] = "";
        response["Triples"] = "";

        MemoryStore data = new MemoryStore();
        try {
            data.Import(reader);
        } catch (Exception e) {
            response["Validation"] = "Validation failed: " + e.Message + ".";
            return response;
        } finally {
            if (reader.Warnings.Count > 0) {
                response["Validation"] += "  There were warnings: ";
                foreach (string warning in reader.Warnings)
                    response["Validation"] += " " + warning + ".";
            }
        }

        writer.Namespaces.AddFrom(reader.Namespaces);

        try {
            writer.Write(data);
            writer.Close();
            response["OutDocument"] = output.ToString();
        } catch (Exception e) {
            response["OutDocument"] = e.Message;
        }

        StringWriter triplesoutput = new StringWriter();
        using (NTriplesWriter tripleswriter = new NTriplesWriter(triplesoutput)) {
            tripleswriter.Write(data);
        }
        response["Triples"] = triplesoutput.ToString();

        return response;
    }