/// <summary>
/// Adds the specified statement.
/// </summary>
/// <param name="statement">The statement.</param>
public override void Add(Statement statement)
{
if (statement.Meta == Statement.DefaultMeta)
AddStatement(statement);
else
AddFormulaStatement(statement);
}
public static Literal SelectLiteral(this SelectableSource src, Statement tpl)
{
var st = SelectSingle(src, tpl);
if (st.HasValue && st.Value.Object is Literal)
return (Literal)st.Value.Object;
return null;
}
public bool Add(SemWeb.Statement stmt)
{
string predicate = stmt.Predicate.Uri;
string title = System.IO.Path.GetFileName(predicate);
string bg = InfoDisplay.Color(info.Style.Background(Gtk.StateType.Active));
string fg = InfoDisplay.Color(info.Style.Foreground(Gtk.StateType.Active));
//if (MetadataStore.Namespaces.GetPrefix (path) != null) {
if (stmt.Object is Literal)
{
stream.Write("<tr><td valign=top align=right bgcolor=\"" + bg + "\"><font color=\"" + fg + "\">");
stream.Write(title);
stream.Write("</font></td><td>");
string s = ((SemWeb.Literal)(stmt.Object)).Value;
/*
* else {
* MemoryStore store = source.Select (stmt.Invert (), new SelectPartialFilter (true, false, false, false));
* s = "";
* foreach (Statement sub in store) {
* s += sub.Object.ToString () + "/n";
* }
* }
*/
if (s != null && s != String.Empty)
{
stream.Write(s);
}
stream.Write("</td><tr>");
}
return(true);
}
public bool Matches(Statement statement) {
if (Subject != null && Subject != statement.Subject && statement.Subject != null) return false;
if (Predicate != null && Predicate != statement.Predicate && statement.Predicate != null) return false;
if (Object != null && Object != statement.Object && statement.Object != null) return false;
if (Meta != null && Meta != statement.Meta && statement.Meta != null) return false;
return true;
}
public override MetaQueryResult MetaQuery(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource source) {
SemWeb.Query.MetaQueryResult ret = new SemWeb.Query.MetaQueryResult();
ret.QuerySupported = true;
ret.NoData = new bool[graph.Length];
for (int i = 0; i < graph.Length; i++) {
// Take this statement and replace variables by nulls
// to make it a statement template.
Statement st = graph[i];
for (int j = 0; j < 4; j++) {
if (st.GetComponent(j) is Variable)
st.SetComponent(j, null);
}
// See if the store contains this template.
if (st != Statement.All && !source.Contains(st)) {
ret.NoData[i] = true;
continue;
}
// Process it further in case we have variables
// with known values, in which case if none of the
// known values is in the store, we also know this
// statement is unanswerable.
for (int j = 0; j < 4; j++) {
Resource r = graph[i].GetComponent(j);
// No need to check the following given the check above.
//if (r != null && !(r is Variable) && !source.Contains(r))
// ret.NoData[i] = true;
if (r != null && r is Variable && options.VariableKnownValues != null &&
#if !DOTNET2
options.VariableKnownValues.Contains((Variable)r)
#else
options.VariableKnownValues.ContainsKey((Variable)r)
#endif
) {
bool found = false;
#if !DOTNET2
foreach (Resource s in (ICollection)options.VariableKnownValues[(Variable)r]) {
#else
foreach (Resource s in (ICollection<Resource>)options.VariableKnownValues[(Variable)r]) {
#endif
if (source.Contains(s)) {
found = true;
break;
}
}
if (!found) {
ret.NoData[i] = true;
}
}
}
}
return ret;
}
public override SemWeb.Query.MetaQueryResult MetaQuery(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource targetModel)
{
QueryCheckArg(graph);
SemWeb.Query.MetaQueryResult ret = new SemWeb.Query.MetaQueryResult();
ret.QuerySupported = true;
// TODO: Best to check also whether variables in the query are even known to us.
return ret;
}
public bool Add(SemWeb.Statement stmt)
{
if (stmt.Predicate == MetadataStore.Namespaces.Resolve("tiff:ImageWidth"))
{
if (width == null)
{
width = ((SemWeb.Literal)stmt.Object).Value;
}
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("tiff:ImageLength"))
{
if (height == null)
{
height = ((SemWeb.Literal)stmt.Object).Value;
}
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:PixelXDimension"))
{
width = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:PixelYDimension"))
{
height = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ExposureTime"))
{
exposure = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ApertureValue"))
{
aperture = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:FNumber"))
{
fnumber = ((SemWeb.Literal)stmt.Object).Value;
}
else if (stmt.Predicate == MetadataStore.Namespaces.Resolve("exif:ISOSpeedRatings"))
{
iso_anon = stmt.Object;
}
else if (stmt.Subject == iso_anon && stmt.Predicate == MetadataStore.Namespaces.Resolve("rdf:li"))
{
iso_speed = ((SemWeb.Literal)stmt.Object).Value;
}
else if (add && stmt.Subject.Uri == null)
{
store.Add(stmt);
}
if (width == null || height == null || exposure == null || aperture == null || iso_speed == null)
{
return(true);
}
else
{
return(false);
}
}
private void QueryCheckArg(Statement[] graph) {
if (graph == null) throw new ArgumentNullException("graph");
foreach (Statement s in graph) {
if (s.Subject == null || s.Predicate == null || s.Object == null || s.Meta == null)
throw new ArgumentNullException("Graph statements cannot contain a null subject, predicate, or object. Use a Variable instance instead.");
if (s.Meta != Statement.DefaultMeta && !(s.Meta is Variable))
throw new NotSupportedException("Graph statements' meta fields must be Statement.DefaultMeta. Other values of meta are not currently supported.");
}
}
void Add(Statement schemastatement) {
if (schemastatement.Predicate == subClassOf && schemastatement.Object is Entity)
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, superclasses, subclasses, true);
if (schemastatement.Predicate == subPropertyOf && schemastatement.Object is Entity)
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, superprops, subprops, true);
if (schemastatement.Predicate == domain && schemastatement.Object is Entity)
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, domains, domainof, false);
if (schemastatement.Predicate == range && schemastatement.Object is Entity)
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, ranges, rangeof, false);
}
public bool Add(Statement st)
{
int s = indexes.ContainsKey(st.Subject) ? (int)indexes[st.Subject] : -1;
int p = indexes.ContainsKey(st.Predicate) ? (int)indexes[st.Predicate] : -1;
int o = indexes.ContainsKey(st.Object) ? (int)indexes[st.Object] : -1;
if (s != -1 && p != -1) { connectivity[s,p]=true; connectivity[p,s]=true; }
if (s != -1 && o != -1) { connectivity[s,o]=true; connectivity[o,s]=true; }
if (p != -1 && o != -1) { connectivity[p,o]=true; connectivity[o,p]=true; }
return true;
}
public override void Add(Statement statement) {
if (statement.AnyNull) throw new ArgumentNullException();
if (checkForDuplicates && Contains(statement)) return;
statements.Add(statement);
if (isIndexed) {
GetIndexArray(statementsAboutSubject, statement.Subject).Add(statement);
GetIndexArray(statementsAboutObject, statement.Object).Add(statement);
}
if (!checkForDuplicates) distinct = false;
}
bool Select(Statement template, StatementSink sink, bool ask) {
return Select(
template.Subject == null ? null : new Entity[] { template.Subject },
template.Predicate == null ? null : new Entity[] { template.Predicate },
template.Object == null ? null : new Resource[] { template.Object },
template.Meta == null ? null : new Entity[] { template.Meta },
null,
0,
sink,
ask
);
}
public override void Add (Statement stmt)
{
string predicate = stmt.Predicate.Uri;
string prefix;
string localname;
// Fill in the namespaces with nice prefixes
if (MetadataStore.Namespaces.Normalize (predicate, out prefix, out localname)) {
if (prefix != null)
Namespaces.AddNamespace (predicate.Remove (predicate.Length - localname.Length, localname.Length), prefix);
}
base.Add (stmt);
}
void AddAxiom(Statement schemastatement) {
if (schemastatement.Predicate == subClassOf && schemastatement.Object is Entity) {
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, superclasses, subclasses);
AddRelation(schemastatement.Subject, rdfsresource, superclasses, subclasses);
AddRelation((Entity)schemastatement.Object, rdfsresource, superclasses, subclasses);
}
if (schemastatement.Predicate == subPropertyOf && schemastatement.Object is Entity)
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, superprops, subprops);
if (schemastatement.Predicate == domain && schemastatement.Object is Entity) {
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, domains, domainof);
AddRelation((Entity)schemastatement.Object, rdfsresource, superclasses, subclasses);
}
if (schemastatement.Predicate == range && schemastatement.Object is Entity) {
AddRelation(schemastatement.Subject, (Entity)schemastatement.Object, ranges, rangeof);
AddRelation((Entity)schemastatement.Object, rdfsresource, superclasses, subclasses);
}
}
/// <summary>
/// Converts a dotNetRDF Triple to a SemWeb Statement
/// </summary>
/// <param name="t">Triple</param>
/// <param name="mapping">Mapping of Blank Nodes</param>
/// <returns></returns>
public static Statement ToSemWeb(Triple t, SemWebMapping mapping)
{
Entity s, p;
Resource o;
Statement stmt;
if (t.IsGroundTriple)
{
//Easy to map across without need for BNode mapping
stmt = new Statement(ToSemWebEntity(t.Subject), ToSemWebEntity(t.Predicate), ToSemWeb(t.Object));
}
else
{
s = ToSemWebEntity(t.Subject, mapping);
p = ToSemWebEntity(t.Predicate, mapping);
o = ToSemWeb(t.Object, mapping);
stmt = new Statement(s, p, o);
}
return stmt;
}
public void Extract(Assembly assembly, Store rdfStore)
{
var types = assembly.GetExportedTypes();
foreach (var t in types) {
// store class hierarchy
var typeEntity = GetEntity(t);
if (t.IsInterface) {
var stType = new Statement(typeEntity, NS.Rdf.typeEntity, NS.CSO.interfaceEntity);
if (!rdfStore.Contains(stType)) {
rdfStore.Add(stType);
rdfStore.AddLabel(typeEntity, t.FullName);
}
} else if (t.IsClass) {
var stType = new Statement(typeEntity, NS.Rdf.typeEntity, NS.CSO.classEntity);
if (!rdfStore.Contains(stType)) {
rdfStore.Add(stType);
rdfStore.AddLabel(typeEntity, t.FullName);
}
} else
continue;
if (t.BaseType != null)
rdfStore.Add(new Statement(typeEntity, NS.Rdfs.subClassOfEntity, GetEntity(t.BaseType) ));
// store info about interfaces
var ifaces = t.GetInterfaces();
foreach (var iType in ifaces) {
rdfStore.Add(new Statement(typeEntity, NS.CSO.Implements, GetEntity(iType)));
rdfStore.Add(new Statement(typeEntity, NS.Rdfs.subClassOfEntity, GetEntity(iType)));
}
// store info about properties
var props = t.GetProperties(BindingFlags.Public|BindingFlags.SetProperty|BindingFlags.DeclaredOnly|BindingFlags.Instance);
foreach (var p in props) {
var propEntity = NS.DotNet.GetPropertyEntity(p.Name);
rdfStore.Add(new Statement(propEntity, NS.Rdf.typeEntity, NS.Rdf.PropertyEntity));
rdfStore.AddLabel(propEntity, p.Name);
rdfStore.Add(new Statement(propEntity, NS.Rdfs.domainEntity, typeEntity));
}
}
}
public abstract void Query(Statement[] graph, QueryOptions options, SelectableSource targetModel, QueryResultSink result);
public abstract MetaQueryResult MetaQuery(Statement[] graph, QueryOptions options, SelectableSource targetModel);
public Proof(Statement[] proved, ProofStep[] steps) {
Proved = proved;
Steps = steps;
}
public abstract bool Distinct { get; } // assume targetModel.Distinct is true, *then* would Select be distinct?
public void Select(Statement template, SelectableSource targetModel, StatementSink sink) {
Select(new SelectFilter(template), targetModel, sink);
}
public Rule(Statement[] antecedent, Statement[] consequent) {
Antecedent = antecedent;
Consequent = consequent;
}
public override void Add(Statement statement) {
if (statement.AnyNull) throw new ArgumentNullException();
WriteStatement2(URI(statement.Subject), URI(statement.Predicate),
statement.Object is Literal ? ((Literal)statement.Object).ToString() : URI((Entity)statement.Object));
}
/// <summary>
/// Executes a Graph Pattern style query against the Source
/// </summary>
/// <param name="graph">Graph Pattern</param>
/// <param name="options">Query Options</param>
/// <param name="sink">Results Sink</param>
/// <remarks>
/// <para>
/// This is implemented by transforming the Graph Pattern which is a set of SemWeb Statement templates into a SPARQL Algebra BGP. The resulting algebra is then executed using the Leviathan engine and the results converted into VariableBindings for SemWeb
/// </para>
/// <para>
/// The only Query Option that is supported is the Limit option
/// </para>
/// </remarks>
public void Query(Statement[] graph, SW.Query.QueryOptions options, SW.Query.QueryResultSink sink)
{
ISparqlAlgebra algebra = this.ToAlgebra(graph);
SparqlEvaluationContext context = new SparqlEvaluationContext(null, new InMemoryDataset(this._store));
BaseMultiset results = context.Evaluate(algebra);//algebra.Evaluate(context);
sink.Init(results.Variables.Select(v => new Variable(v)).ToArray());
if (results.Count > 0)
{
int c = 0;
foreach (Set s in results.Sets)
{
//Apply Limit if applicable
if (options.Limit > 0 && c >= options.Limit)
{
sink.Finished();
return;
}
//Convert the Set to VariableBindings for SemWeb
Variable[] vars = s.Variables.Select(v => new Variable(v)).ToArray();
Resource[] resources = s.Variables.Select(v => SemWebConverter.ToSemWeb(s[v], this.GetMapping(s[v].Graph))).ToArray();
SW.Query.VariableBindings bindings = new SW.Query.VariableBindings(vars, resources);
//Keep adding results until the sink tells us to stop
if (!sink.Add(bindings))
{
sink.Finished();
return;
}
c++;
}
sink.Finished();
}
else
{
sink.Finished();
}
}
/// <summary>
/// Returns a Meta Result that says that the Query is supported
/// </summary>
/// <param name="graph">Graph Pattern</param>
/// <param name="options">Query Options</param>
/// <returns></returns>
/// <remarks>
/// <para>
/// The method does not actually do any analysis of the query, it assumes that all Graph Patterns expressible in SemWeb statement templates can be transformed to a SPARQL Algebra BGP (which generally they can)
/// </para>
/// </remarks>
public SW.Query.MetaQueryResult MetaQuery(Statement[] graph, SW.Query.QueryOptions options)
{
SW.Query.MetaQueryResult metaResult = new SW.Query.MetaQueryResult();
metaResult.QuerySupported = true;
return metaResult;
}
public abstract void Add(Statement statement);
/// <summary>
/// Writes the statement to the output stream.
/// </summary>
/// <param name="statement">The statement.</param>
protected virtual void WriteStatement(Statement statement)
{
WriteEntity(statement.Subject);
Write(' ');
WriteStatementBody(statement);
}
public override void Query(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource targetModel, QueryResultSink result) {
SemWeb.Query.GraphMatch q = new SemWeb.Query.GraphMatch();
foreach (Statement s in graph)
q.AddGraphStatement(s);
q.ReturnLimit = options.Limit;
if (options.VariableKnownValues != null) {
#if !DOTNET2
foreach (DictionaryEntry ent in options.VariableKnownValues)
q.SetVariableRange((Variable)ent.Key, (ICollection)ent.Value);
#else
foreach (KeyValuePair<Variable,ICollection<Resource>> ent in options.VariableKnownValues)
q.SetVariableRange(ent.Key, ent.Value);
#endif
}
if (options.VariableLiteralFilters != null) {
#if !DOTNET2
foreach (DictionaryEntry ent in options.VariableLiteralFilters)
foreach (LiteralFilter filter in (ICollection)ent.Value)
q.AddLiteralFilter((Variable)ent.Key, filter);
#else
foreach (KeyValuePair<Variable,ICollection<LiteralFilter>> ent in options.VariableLiteralFilters)
foreach (LiteralFilter filter in ent.Value)
q.AddLiteralFilter(ent.Key, filter);
#endif
}
if (options.DistinguishedVariables != null) {
foreach (Variable v in options.DistinguishedVariables)
q.SetDistinguishedVariable(v);
}
q.Run(targetModel, result);
}
/// <summary>
/// Removes Triples that match the template from the underlying Store
/// </summary>
/// <param name="template">Template</param>
public void Remove(Statement template)
{
//Get the Graphs over which the Remove will operate
IEnumerable<IGraph> gs;
if (template.Meta == null)
{
gs = this._store.Graphs;
}
else
{
Uri graphUri = new Uri(template.Meta.Uri);
if (this._store.HasGraph(graphUri))
{
gs = this._store.Graph(graphUri).AsEnumerable();
}
else
{
gs = Enumerable.Empty<IGraph>();
}
}
//Retract the Triples which match the Template in each affected Graph
foreach (IGraph g in gs)
{
IEnumerable<Triple> ts = this.TemplateToEnumerable(template, g);
g.Retract(ts);
}
}
/// <summary>
/// Adds the statement.
/// </summary>
/// <param name="statement">The statement (not a formula).</param>
protected virtual void AddStatement(Statement statement)
{
WriteStatement(statement);
FlushWriter();
}
/// <summary>
/// Removes Triples which match any of the templates from the underlying Store
/// </summary>
/// <param name="templates">Templates</param>
public void RemoveAll(Statement[] templates)
{
foreach (Statement template in templates)
{
this.Remove(template);
}
}
/// <summary>
/// Writes the statement body to the output writer.
/// </summary>
/// <param name="statement">The statement.</param>
protected virtual void WriteStatementBody(Statement statement)
{
WritePredicate(statement.Predicate);
Write(' ');
WriteResource(statement.Object);
Write('.');
WriteLine();
}
/// <summary>
/// Throws an error since the Replace operation is not valid in the dotNetRDF API model
/// </summary>
/// <param name="find">Find Template</param>
/// <param name="replacement">Replace Template</param>
public void Replace(Statement find, Statement replacement)
{
throw new RdfException("The SemWeb Replace operation is not valid for dotNetRDF Data Sources");
}
/// <summary>
/// Adds the statement of a formula.
/// </summary>
/// <param name="statement">The statement.</param>
protected virtual void AddFormulaStatement(Statement statement)
{
Entity formulaId = statement.Meta;
Entity statementId = new BNode();
if (m_LastFormulaId != formulaId)
{
m_LastFormulaId = formulaId;
AddStatement(new Statement(formulaId, Predicate.RdfType, Identifier.LogFormula));
}
AddStatement(new Statement(formulaId, Predicate.LogIncludes, statementId));
AddStatement(new Statement(statementId, Predicate.RdfType, Identifier.RdfStatement));
AddStatement(new Statement(statementId, Predicate.RdfSubject, statement.Subject));
AddStatement(new Statement(statementId, Predicate.RdfPredicate, statement.Predicate));
AddStatement(new Statement(statementId, Predicate.RdfObject, statement.Object));
}
bool StatementSink.Add(Statement statement)
{
Add(statement);
return(true);
}
