public org.openrdf.repository.RepositoryResult getStatements(org.openrdf.model.Resource r, org.openrdf.model.URI uri, org.openrdf.model.Value v, bool b, params org.openrdf.model.Resource[] rarr)
{
SparqlParameterizedString queryString = new SparqlParameterizedString();
IEnumerable <Uri> contexts = rarr.ToContexts(this._mapping);
if (contexts.Any())
{
queryString.CommandText = "SELECT (?s AS ?subj) (?p AS ?pred) (?o AS ?obj)\n";
foreach (Uri u in contexts)
{
queryString.CommandText += "FROM <" + this._formatter.FormatUri(u) + ">\n";
}
queryString.CommandText += "WHERE { ?s ?p ?o }";
}
else
{
queryString.CommandText = "SELECT (?s AS ?subj) (?p AS ?pred) (?o AS ?obj) WHERE { ?s ?p ?o }";
}
if (r != null)
{
queryString.SetVariable("s", SesameConverter.FromSesameResource(r, this._mapping));
}
if (uri != null)
{
queryString.SetVariable("p", SesameConverter.FromSesameUri(uri, this._mapping));
}
if (v != null)
{
queryString.SetVariable("o", SesameConverter.FromSesameValue(v, this._mapping));
}
return(this.GetStatementsInternal(queryString.ToString(), this._mapping));
}
public void evaluate(org.openrdf.query.TupleQueryResultHandler tqrh)
{
SparqlResultSet rset = this.EvaluateQuery();
java.util.ArrayList vars = new java.util.ArrayList();
foreach (String var in rset.Variables)
{
vars.add(var);
}
tqrh.startQueryResult(vars);
SesameMapping mapping = new SesameMapping(new Graph(), new dotSesame.impl.GraphImpl());
foreach (SparqlResult r in rset)
{
dotSesameQuery.impl.MapBindingSet binding = new org.openrdf.query.impl.MapBindingSet();
foreach (String var in r.Variables)
{
binding.addBinding(var, SesameConverter.ToSesameValue(r[var], mapping));
}
tqrh.handleSolution(binding);
}
tqrh.endQueryResult();
}
internal static IEnumerable <Triple> ToTriples(this info.aduna.iteration.Iteration iter, SesameMapping mapping)
{
while (iter.hasNext())
{
yield return(SesameConverter.FromSesame((dotSesame.Statement)iter.next(), mapping));
}
}
public bool add(object obj)
{
if (obj is dotSesame.Statement)
{
dotSesame.Statement stmt = (dotSesame.Statement)obj;
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (this._g.ContainsTriple(t))
{
return(false);
}
else
{
this._g.Assert(t);
return(true);
}
}
else if (obj is Triple)
{
Triple t = (Triple)obj;
if (this._g.ContainsTriple(t))
{
return(false);
}
else
{
this._g.Assert(t);
return(true);
}
}
else
{
return(false);
}
}
public override IEnumerable <Triple> WithObject(INode obj)
{
dotSesame.Value v = SesameConverter.ToSesameValue(obj, this._mapping);
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(this._g.match(null, null, v, null));
return(stmtIter.Select(s => SesameConverter.FromSesame(s, this._mapping)));
}
public bool hasStatement(org.openrdf.model.Resource r, org.openrdf.model.URI uri, org.openrdf.model.Value v, bool b, params org.openrdf.model.Resource[] rarr)
{
SparqlParameterizedString queryString = new SparqlParameterizedString();
queryString.CommandText = "ASK";
foreach (Uri u in rarr.ToContexts(this._mapping))
{
queryString.CommandText += "\nFROM <" + this._formatter.FormatUri(u) + ">";
}
queryString.CommandText += "\nWHERE { ?subject ?predicate ?object}";
if (r != null)
{
queryString.SetVariable("subject", SesameConverter.FromSesameResource(r, this._mapping));
}
if (uri != null)
{
queryString.SetVariable("predicate", SesameConverter.FromSesameUri(uri, this._mapping));
}
if (v != null)
{
queryString.SetVariable("object", SesameConverter.FromSesameValue(v, this._mapping));
}
return(this.HasTriplesInternal(queryString.ToString()));
}
public override IEnumerable <Triple> WithPredicate(INode pred)
{
dotSesame.URI u = SesameConverter.ToSesameUri(pred, this._mapping);
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(this._g.match(null, u, null, null));
return(stmtIter.Select(s => SesameConverter.FromSesame(s, this._mapping)));
}
public virtual void add(org.openrdf.model.Resource r, org.openrdf.model.URI uri, org.openrdf.model.Value v, params org.openrdf.model.Resource[] rarr)
{
IEnumerable <Uri> contexts = rarr.ToContexts(this._mapping);
Graph g = new Graph();
g.Assert(SesameConverter.FromSesameResource(r, this._mapping), SesameConverter.FromSesameUri(uri, this._mapping), SesameConverter.FromSesameValue(v, this._mapping));
this.AddInternal(g, contexts);
}
public virtual void add(org.openrdf.model.Statement s, params org.openrdf.model.Resource[] rarr)
{
IEnumerable <Uri> contexts = rarr.ToContexts(this._mapping);
Graph g = new Graph();
g.Assert(SesameConverter.FromSesame(s, this._mapping));
this.AddInternal(g, contexts);
}
public org.openrdf.query.BindingSet getBindings()
{
dotSesameQuery.impl.MapBindingSet s = new org.openrdf.query.impl.MapBindingSet();
foreach (KeyValuePair <String, INode> kvp in this._queryString.Variables)
{
s.addBinding(kvp.Key, SesameConverter.ToSesameValue(kvp.Value, this._mapping));
}
return(s);
}
public bool contains(object obj)
{
if (obj is dotSesame.Statement)
{
Triple t = SesameConverter.FromSesame((dotSesame.Statement)obj, this._mapping);
return(this._g.ContainsTriple(t));
}
else
{
return(false);
}
}
public bool equals(object obj)
{
if (obj is dotSesame.Graph)
{
Graph h = new Graph();
SesameConverter.FromSesame((dotSesame.Graph)obj, h);
return(this._g.Equals(h));
}
else
{
return(this._g.Equals(obj));
}
}
public bool add(dotSesame.Resource r, dotSesame.URI uri, dotSesame.Value v, params dotSesame.Resource[] rarr)
{
Triple t = new Triple(SesameConverter.FromSesameResource(r, this._mapping), SesameConverter.FromSesameUri(uri, this._mapping), SesameConverter.FromSesameValue(v, this._mapping));
if (this._g.ContainsTriple(t))
{
return(false);
}
else
{
this._g.Assert(t);
return(true);
}
}
public bool addAll(java.util.Collection c)
{
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <dotSesame.Statement>(c.iterator());
bool added = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (!this._g.ContainsTriple(t))
{
this._g.Assert(t);
added = added || true;
}
}
return(added);
}
public void evaluate(org.openrdf.rio.RDFHandler rdfh)
{
IGraph g = this.EvaluateQuery();
SesameMapping mapping = new SesameMapping(g, new dotSesame.impl.GraphImpl());
rdfh.startRDF();
foreach (String prefix in g.NamespaceMap.Prefixes)
{
rdfh.handleNamespace(prefix, g.NamespaceMap.GetNamespaceUri(prefix).ToString());
}
foreach (Triple t in g.Triples)
{
rdfh.handleStatement(SesameConverter.ToSesame(t, mapping));
}
rdfh.endRDF();
}
public bool containsAll(java.util.Collection c)
{
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(c.iterator());
bool contains = true;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (!this._g.ContainsTriple(t))
{
contains = false;
break;
}
}
return(contains);
}
public bool removeAll(java.util.Collection c)
{
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(c.iterator());
bool removed = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
Triple t = SesameConverter.FromSesame(stmt, this._mapping);
if (this._g.ContainsTriple(t))
{
this._g.Retract(t);
removed = removed || true;
}
}
return(removed);
}
public org.openrdf.query.GraphQueryResult evaluate()
{
IGraph g = this.EvaluateQuery();
SesameMapping mapping = new SesameMapping(g, new dotSesame.impl.GraphImpl());
IEnumerable <dotSesame.Statement> stmts = from t in g.Triples
select SesameConverter.ToSesame(t, mapping);
DotNetEnumerableWrapper wrapper = new DotNetEnumerableWrapper(stmts);
java.util.HashMap map = new java.util.HashMap();
foreach (String prefix in g.NamespaceMap.Prefixes)
{
map.put(prefix, g.NamespaceMap.GetNamespaceUri(prefix).ToString());
}
dotSesameQuery.impl.GraphQueryResultImpl results = new org.openrdf.query.impl.GraphQueryResultImpl(map, wrapper);
return(results);
}
public bool remove(object obj)
{
if (obj is dotSesame.Statement)
{
Triple t = SesameConverter.FromSesame((dotSesame.Statement)obj, this._mapping);
if (this._g.ContainsTriple(t))
{
this._g.Retract(t);
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public bool retainAll(java.util.Collection c)
{
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(c.iterator());
HashSet <Triple> retained = new HashSet <Triple>();
bool changed = false;
foreach (dotSesame.Statement stmt in stmtIter)
{
retained.Add(SesameConverter.FromSesame(stmt, this._mapping));
}
foreach (Triple t in this._g.Triples.ToList())
{
if (!retained.Contains(t))
{
changed = true;
this._g.Retract(t);
}
}
return(changed);
}
public object[] toArray(object[] objarr)
{
if (objarr.Length < this._g.Triples.Count)
{
objarr = new object[this._g.Triples.Count];
}
int i = 0;
foreach (Triple t in this._g.Triples)
{
objarr[i] = SesameConverter.ToSesame(t, this._mapping);
i++;
}
if (i < objarr.Length)
{
objarr[i] = null;
}
return(objarr);
}
internal static IEnumerable <Uri> ToContexts(this dotSesame.Resource[] contexts, SesameMapping mapping)
{
if (contexts == null)
{
return(Enumerable.Empty <Uri>());
}
else if (contexts.Length == 0)
{
return(Enumerable.Empty <Uri>());
}
else
{
List <Uri> results = new List <Uri>();
foreach (dotSesame.Resource r in contexts)
{
if (r != null && r is dotSesame.URI)
{
results.Add(((IUriNode)SesameConverter.FromSesameResource(r, mapping)).Uri);
}
}
return(results);
}
}
public override org.openrdf.repository.RepositoryResult getContextIDs()
{
try
{
Object results = this._store.ExecuteQuery("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o }}");
if (results is SparqlResultSet)
{
IEnumerable <dotSesame.Resource> resIter = from result in (SparqlResultSet)results
where result.HasValue("g") && result["g"] != null
select SesameConverter.ToSesameResource(result["g"], this._mapping);
return(new org.openrdf.repository.RepositoryResult(new DotNetAdunaIterationWrapper(resIter)));
}
else
{
throw new dotSesameRepo.RepositoryException("Unable to return the Context IDs from this repository as the repository returned an unexpected result");
}
}
catch (Exception ex)
{
throw new dotSesameRepo.RepositoryException("Unable to return the Context IDs from this repository due to the following error: " + ex.Message);
}
}
public override org.openrdf.repository.RepositoryResult getContextIDs()
{
if (this._manager.ListGraphsSupported)
{
IEnumerable <dotSesame.Resource> resIter = from u in this._manager.ListGraphs()
select(dotSesame.Resource) this._mapping.ValueFactory.createURI(u.ToString());
return(new org.openrdf.repository.RepositoryResult(new DotNetAdunaIterationWrapper(resIter)));
}
else if (this._manager is IQueryableGenericIOManager)
{
try
{
Object results = ((IQueryableGenericIOManager)this._manager).Query("SELECT DISTINCT ?g WHERE { GRAPH ?g { ?s ?p ?o }}");
if (results is SparqlResultSet)
{
IEnumerable <dotSesame.Resource> resIter = from result in (SparqlResultSet)results
where result.HasValue("g") && result["g"] != null
select SesameConverter.ToSesameResource(result["g"], this._mapping);
return(new org.openrdf.repository.RepositoryResult(new DotNetAdunaIterationWrapper(resIter)));
}
else
{
throw new dotSesameRepo.RepositoryException("Unable to return the Context IDs from this repository as the repository returned an unexpected result");
}
}
catch (Exception ex)
{
throw new dotSesameRepo.RepositoryException("Unable to return the Context IDs from this repository due to the following error: " + ex.Message);
}
}
else
{
throw new dotSesameRepo.RepositoryException("This dotNetRDF Generic Repository does not support returning the Context IDs");
}
}
public void parse(org.openrdf.model.Graph g, org.openrdf.model.Resource r)
{
Graph config = new Graph();
SesameMapping mapping = new SesameMapping(config, g);
SesameConverter.FromSesame(g, config);
this._name = r.stringValue().Substring(r.stringValue().LastIndexOf(":") + 1);
Object temp = ConfigurationLoader.LoadObject(config, SesameConverter.FromSesameResource(r, mapping));
if (temp is IInMemoryQueryableStore)
{
this._repo = new DotNetRdfInMemoryRepository((IInMemoryQueryableStore)temp);
}
else if (temp is IGenericIOManager)
{
this._repo = new DotNetRdfGenericRepository((IGenericIOManager)temp);
}
else
{
throw new dotSesameRepo.config.RepositoryConfigException("Unable to load Configuration for the Repository as the loaded Object was not an IInMemoryQueryableStore or an IGenericIOManager implementation");
}
}
public void setBinding(string str, org.openrdf.model.Value v)
{
this._queryString.SetVariable(str, SesameConverter.FromSesameValue(v, this._mapping));
}
public override bool Contains(Triple t)
{
return(this._g.contains(SesameConverter.ToSesame(t, this._mapping)));
}
public override IEnumerator <Triple> GetEnumerator()
{
JavaIteratorWrapper <dotSesame.Statement> stmtIter = new JavaIteratorWrapper <org.openrdf.model.Statement>(this._g.iterator());
return(stmtIter.Select(s => SesameConverter.FromSesame(s, this._mapping)).GetEnumerator());
}
protected override void Delete(Triple t)
{
this._g.remove(SesameConverter.ToSesame(t, this._mapping));
}
protected override org.openrdf.repository.RepositoryResult GetStatementsInternal(string sparqlQuery, SesameMapping mapping)
{
if (this._manager is IQueryableGenericIOManager)
{
try
{
Object results = ((IQueryableGenericIOManager)this._manager).Query(sparqlQuery);
if (results is SparqlResultSet)
{
IEnumerable <dotSesame.Statement> stmts = from result in (SparqlResultSet)results
select this._factory.createStatement(SesameConverter.ToSesameResource(result["subj"], mapping), SesameConverter.ToSesameUri(result["pred"], mapping), SesameConverter.ToSesameValue(result["obj"], mapping));
return(new dotSesameRepo.RepositoryResult(new DotNetAdunaIterationWrapper(stmts)));
}
else
{
throw new dotSesameRepo.RepositoryException("Unable to return Statements from this repository as the repository returned an unexpected result");
}
}
catch (Exception ex)
{
throw new dotSesameRepo.RepositoryException("Unable to return Statements from this repository due to the following error: " + ex.Message);
}
}
else
{
throw new dotSesameRepo.RepositoryException("This dotNetRDF Generic Repository does not support returning specific Statements");
}
}