private bool nextIsMatchingVarPattern(ITriplePattern main, List <IElement> elements, int i) { if (main.getObject() is IVariable && i < elements.Count - 2 && elements[i + 1] is ITriplePattern && elements[i + 2] is ITriplePattern) { IVariable mainVar = (IVariable)main.getObject(); if (mainVar.isBlankNodeVar()) { ITriplePattern nextPattern = (ITriplePattern)elements[i + 1]; ITriplePattern lastPattern = (ITriplePattern)elements[i + 2]; IResource nextSubject = nextPattern.getSubject(); IResource lastSubject = lastPattern.getSubject(); if (nextSubject is IVariable && lastSubject is IVariable && RDFUtil.sameTerm(RDF.PropertyFirst, nextPattern.getPredicate()) && RDFUtil.sameTerm(RDF.PropertyRest, lastPattern.getPredicate())) { IVariable nextVar = (IVariable)nextSubject; if (mainVar.getName().Equals(nextVar.getName())) { IVariable lastVar = (IVariable)lastSubject; return(mainVar.getName().Equals(lastVar.getName())); } } } } return(false); }
override public void visit(IVariable variable) { if (RDFUtil.sameTerm(_var, variable)) { _checker.setResult(); } }
public List <Dictionary <String, IResource> > getBindings() { List <String> varNames = getVarNames(); List <Dictionary <String, IResource> > bindings = new List <Dictionary <String, IResource> >(); List <IResource> outerList = getResource(SP.PropertyBindings).AsList(); if (outerList != null) { foreach (IResource innerList in outerList) { Dictionary <String, IResource> binding = new Dictionary <String, IResource>(); bindings.Add(binding); IEnumerator <String> vars = varNames.GetEnumerator(); IEnumerator <IResource> values = innerList.AsList().GetEnumerator(); while (vars.MoveNext()) { String varName = vars.Current; IResource value = values.Current; if (!RDFUtil.sameTerm(SP.ClassPropertyUndef, value)) { binding.Add(varName, value); } } } } return(bindings); }
/// <summary> /// /// </summary> /// <param name="spinGraph"></param> /// <returns></returns> internal IGraph Initialise(IGraph spinGraph) { if (_spinConfiguration.GraphUris.Contains(spinGraph.BaseUri)) { _spinConfiguration.RemoveGraph(spinGraph.BaseUri); } String ontQuery = "CONSTRUCT { ?graphUri a <" + SPIN.ClassLibraryOntology + ">} WHERE { {?s (<" + SPIN.PropertyImports + ">|<" + OWL.PropertyImports + ">) ?graphUri} UNION {?graphUri a <" + SPIN.ClassLibraryOntology + ">} }"; IGraph imports = (Graph)spinGraph.ExecuteQuery(ontQuery); // Explore for subsequent imports foreach (Triple t in imports.GetTriplesWithPredicateObject(RDF.PropertyType, SPIN.ClassLibraryOntology)) { Uri importUri = ((IUriNode)t.Subject).Uri; if (!_spinConfiguration.GraphUris.Contains(importUri) && !RDFUtil.sameTerm(importUri, spinGraph.BaseUri)) { Initialise(importUri); } } _spinConfiguration.AddGraph(spinGraph); _reasoner.Initialise(spinGraph); IGraph inferenceGraph = ApplyInference(spinGraph); _spinConfiguration.AddGraph(inferenceGraph); _reasoner.Initialise(inferenceGraph); return(inferenceGraph); }
/** * * @param constaint is a statement whose subject is a class, and whose predicate is SPIN.constraint * @param results */ private void addArgumentFromConstraint(Triple constraint, List <IArgument> results) { if (constraint.Object is IBlankNode) { // Optimized case to avoid walking up class hierarchy IEnumerator <Triple> types = Resource.Get(constraint.Object, getModel()).listProperties(RDF.PropertyType).GetEnumerator(); while (types.MoveNext()) { Triple typeS = types.Current; if (typeS.Object is IUriNode) { if (RDFUtil.sameTerm(SPL.ClassArgument, typeS.Object)) { results.Add(SPINFactory.asArgument(Resource.Get(constraint.Object, getModel()))); } else if (!RDFUtil.sameTerm(SPL.ClassAttribute, typeS.Object)) { if (Resource.Get(typeS.Object, getModel()).hasProperty(RDFS.PropertySubClassOf, SPL.ClassArgument)) { results.Add(SPINFactory.asArgument(Resource.Get(constraint.Object, getModel()))); } } } } } else if (constraint.Object is IUriNode && Resource.Get(constraint.Object, getModel()).hasProperty(RDFS.PropertySubClassOf, SPL.ClassArgument)) { results.Add(SPINFactory.asArgument(Resource.Get(constraint.Object, getModel()))); } }
override public void visit(ITriplePath triplePath) { if (RDFUtil.sameTerm(_var, triplePath.getObject()) || RDFUtil.sameTerm(_var, triplePath.getSubject())) { _checker.setResult(); } }
// Special treatment of nested rdf:Lists private int printTriplePattern(List <IElement> elements, int i, ISparqlPrinter p) { ITriplePattern main = (ITriplePattern)elements[i]; // Print subject List <IResource> leftList = new List <IResource>(); i = addListMembers(elements, i, leftList); if (leftList.Count == 0) { TupleImpl.print(getModel(), main.getSubject(), p); } else { printRDFList(p, leftList); main = (ITriplePattern)elements[i]; } p.print(" "); // Print predicate if (RDFUtil.sameTerm(RDF.PropertyType, main.getPredicate())) { p.print("a"); } else { TupleImpl.print(getModel(), main.getPredicate(), p); } p.print(" "); // Print object if (nextIsMatchingVarPattern(main, elements, i)) { List <IResource> rightList = new List <IResource>(); i = addListMembers(elements, i + 1, rightList); if (rightList.Count == 0) { TupleImpl.print(getModel(), main.getObject(), p); if (leftList.Count != 0) { i--; } } else { printRDFList(p, rightList); i--; } } else { TupleImpl.print(getModel(), main.getObject(), p); } return(i); }
internal void SortClasses(List <Resource> classList) { classList.Sort(delegate(Resource x, Resource y) { if (RDFUtil.sameTerm(x, y)) { return(0); } if (ContainsTriple(x, RDFS.PropertySubClassOf, y)) { return(1); } return(-1); }); }
internal void SortProperties(List <Resource> propertyList) { propertyList.Sort(delegate(Resource x, Resource y) { if (RDFUtil.sameTerm(x, y)) { return(0); } if (ContainsTriple(x, RDFS.PropertySubPropertyOf, y)) { return(1); } return(-1); }); }
public Dictionary <IResource, IResource> getArgumentsMap() { /*sealed*/ Dictionary <IResource, IResource> values = new Dictionary <IResource, IResource>(); IEnumerator <Triple> it = listProperties().GetEnumerator(); while (it.MoveNext()) { Triple s = it.Current; if (!RDFUtil.sameTerm(RDF.PropertyType, s.Predicate)) { values[Resource.Get(s.Predicate, getModel())] = Resource.Get(s.Object, getModel()); } } return(values); }
/** * Checks if a given INode might represent a Function call, and if * yes returns the resource as Function. The condition here is fairly * general: a function call must be a blank node with an rdf:type triple * where the type triple's object is a URI resource. It is generally * assumed that this function is called after other options have been * exhausted. For example, in order to test whether a resource is a * variable or a function call, the variable test must be done first * as it is more specific than these test conditions * @param resource the INode to test * @return resource as a Function or null if resource cannot be cast */ public static IFunctionCall asFunctionCall(IResource resource) { if (resource == null) { return(null); } if (resource is IBlankNode) { IResource t = resource.getResource(RDF.PropertyType); if (t != null && !RDFUtil.sameTerm(SP.ClassVariable, t)) { return((IFunctionCall)resource.As(typeof(FunctionCallImpl))); } } return(null); }
private String getPrefix(Uri ns, ISparqlPrinter context) { String prefix = getSource().Graph.NamespaceMap.GetPrefix(ns); if (prefix == null && context.getUseExtraPrefixes()) { INamespaceMapper extras = ExtraPrefixes.getExtraPrefixes(); foreach (String extraPrefix in extras.Prefixes) { Uri extraNs = extras.GetNamespaceUri(extraPrefix); if (RDFUtil.sameTerm(ns, extraNs)) { return(extraPrefix); } } } return(prefix); }
/** * Gets an spl:Attribute defined for a given property on a given class. * The spl:Attribute must be a direct spin:constraint on the class. * @param cls the class * @param property the property * @return the Attribute or null if none is found */ public static IAttribute getAttribute(IResource cls, INode property) { IEnumerator <Triple> it = cls.listProperties(SPIN.PropertyConstraint).GetEnumerator(); while (it.MoveNext()) { IResource obj = Resource.Get(it.Current.Object, cls.getModel()); if (obj is INode && ((IResource)obj).hasProperty(RDF.PropertyType, SPL.ClassAttribute)) { IAttribute a = (IAttribute)obj.As(typeof(AttributeImpl)); if (RDFUtil.sameTerm(property, a.getPredicate())) { it.Dispose(); return(a); } } } return(null); }
private int addListMembers(List <IElement> elements, int i, List <IResource> members) { bool first = true; while (i < elements.Count - 1 && elements[i] is ITriplePattern && elements[i + 1] is ITriplePattern) { ITriplePattern firstPattern = (ITriplePattern)elements[i]; ITriplePattern secondPattern = (ITriplePattern)elements[i + 1]; if (RDFUtil.sameTerm(RDF.PropertyFirst, firstPattern.getPredicate()) && RDFUtil.sameTerm(RDF.PropertyRest, secondPattern.getPredicate())) { IResource firstSubject = firstPattern.getSubject(); IResource secondSubject = secondPattern.getSubject(); if (firstSubject is IVariable && secondSubject is IVariable) { IVariable firstVar = (IVariable)firstSubject; IVariable secondVar = (IVariable)secondSubject; if (firstVar.isBlankNodeVar() && firstVar.getName().Equals(secondVar.getName())) { members.Add(firstPattern.getObject()); IResource secondObject = secondPattern.getObject(); i++; if (RDFUtil.sameTerm(RDF.Nil, secondObject)) { return(i + 1); } } } } // We are not in a valid list if (first && members.Count == 0) { break; } first = false; i++; } return(i); }
public static void print(SpinProcessor model, IResource node, ISparqlPrinter p, bool abbrevRDFType) { // TODO find the good tests ????? if (!node.isLiteral()) { if (abbrevRDFType && RDFUtil.sameTerm(RDF.PropertyType, node)) { p.print("a"); } else { printVarOrResource(p, node); } } else { //TODO INamespaceMapper pm = p.getUsePrefixes() ? model.getGraph().getPrefixMapping() : SPINExpressions.emptyPrefixMapping; String str = node.getSource().ToString();// TODO is this correct ? // FmtUtils.stringForNode(node, null/*TODO pm*/); p.print(str); } }
override public void Print(ISparqlPrinter p) { IResource function = getFunction(); List <IResource> args = getArguments(); String symbol = getSymbol(function); //TODO implement isLetter if (symbol != null && (/*TODO !symbol[0].isLetter() ||*/ isSetOperator(symbol))) { printOperator(p, symbol, args); } else if (symbol != null && (RDFUtil.sameTerm(SP.PropertyExists, function) || RDFUtil.sameTerm(SP.PropertyNotExists, function))) { printExistsOrNotExists(p, symbol); } else { printFunction(p, function, args); } }
/** * Checks if a given INode can be cast into an ElementList. * It must be either rdf:nil or an rdf:List where the first * list item is an element using <code>asElement()</code>. * @param resource the resource to test * @return true if resource is an element list */ public static bool isElementList(IResource resource) { if (resource.isUri() && RDFUtil.sameTerm(RDF.Nil, resource)) { return(true); } else { return(resource.hasProperty(RDF.PropertyFirst)); /* * ITriple firstS = Model.getProperty(Model, resource, RDF.first); * if (firstS != null && !(firstS.Object is ILiteralNode)) * { * INode first = firstS.Object; * return asElement(first) != null; * } * else * { * return false; * } */ } }
private IResource[] getArgumentProperties(Dictionary <IResource, IResource> values) { IResource[] ps = new IResource[values.Count]; List <IResource> others = new List <IResource>(); foreach (IResource p in values.Keys) { if (p.Uri.ToString().StartsWith(SP_ARG) && !RDFUtil.sameTerm(p, SP.PropertyArg)) { int index = int.Parse(p.Uri.ToString().Substring(SP_ARG.Length)); ps[index - 1] = p; } else { others.Add(p); } } if (others.Count > 0) { others.Sort(delegate(IResource arg0, IResource arg1) { //TODO is that OK ? return(RDFUtil.uriComparer.Compare(arg0.Uri, arg1.Uri)); } ); IEnumerator <IResource> it = others.GetEnumerator(); for (int i = 0; i < ps.Length; i++) { if (ps[i] == null) { ps[i] = it.Current; } } } return(ps); }
private ISparqlPath createPath(IResource path) { if (path.isUri()) { return(new Property(path.getSource())); } else { IResource typeS = path.getResource(RDF.PropertyType); if (typeS != null && typeS.isUri()) { INode type = typeS; if (RDFUtil.sameTerm(SP.ClassAltPath, type)) { ISparqlPath leftPath = createPath(path, SP.PropertyPath1); ISparqlPath rightPath = createPath(path, SP.PropertyPath2); return(new AlternativePath(leftPath, rightPath)); } else if (RDFUtil.sameTerm(SP.ClassModPath, type)) { ISparqlPath subPath = createPath(path, SP.PropertySubPath); int? min = path.getInteger(SP.PropertyModMin); int? max = path.getInteger(SP.PropertyModMax); if (max == null || max < 0) { if (min == 1) { return(new OneOrMore(subPath)); // TODO: is this correct? } else if (min == null || min == -1) { return(new ZeroOrMore(subPath)); } else { // -2 return(new NOrMore(subPath, (int)min)); // TODO: is this correct? } } else { if (min == null || min == -1) { return(new ZeroToN(subPath, (int)max)); } else { return(new NToM(subPath, (int)min, (int)max)); } } } else if (RDFUtil.sameTerm(SP.ClassReversePath, type)) { ISparqlPath subPath = createPath(path, SP.PropertySubPath); return(new InversePath(subPath)); } else if (RDFUtil.sameTerm(SP.ClassSeqPath, type)) { ISparqlPath leftPath = createPath(path, SP.PropertyPath1); ISparqlPath rightPath = createPath(path, SP.PropertyPath2); return(new SequencePath(leftPath, rightPath)); } else if (RDFUtil.sameTerm(SP.ClassReverseLinkPath, type)) { IResource node = path.getObject(SP.PropertyNode); ISparqlPath subPath = createPath(node); // TODO: is this correct ? return(new InversePath(subPath)); } } return(null); } }
public static bool isRootClass(IResource cls) { return(RDFUtil.sameTerm(RDFS.ClassResource, cls) || RDFUtil.sameTerm(OWL.Thing, cls)); }
/** * Checks if a given INode is spin:query or a sub-property of it. * @param predicate the INode to test * @return true if predicate is a query property */ public static bool isQueryProperty(IResource predicate) { return(RDFUtil.sameTerm(SPIN.PropertyQuery, predicate) || predicate.hasProperty(RDFS.PropertySubPropertyOf, SPIN.PropertyQuery)); }
override protected void handleTriplePattern(ITriplePattern triplePattern, Dictionary <IResource, IResource> bindings) { bool valid = false; IResource subject = triplePattern.getSubject(); if (RDFUtil.sameTerm(SPIN.Property_this, subject)) { valid = true; } else if (bindings != null) { IVariable var = SPINFactory.asVariable(subject); if (var != null) { String varName = var.getName(); foreach (IResource argPredicate in bindings.Keys) { if (varName.Equals(argPredicate.Uri().ToString().Replace(SP.BASE_URI, "").Replace(SPIN.BASE_URI, ""))) { IResource b = bindings[argPredicate]; if (RDFUtil.sameTerm(SPIN.Property_this, b)) { valid = true; break; } } } } } if (valid) { IResource predicate = triplePattern.getPredicate(); if (predicate != null) { IVariable variable = SPINFactory.asVariable(predicate); if (variable == null) { Uri uri = predicate.Uri(); if (uri != null) { properties.Add(Resource.Get(predicate, _targetModel)); } } else if (bindings != null) { String varName = variable.getName(); foreach (IResource argPredicate in bindings.Keys) { if (varName.Equals(argPredicate.Uri().ToString().Replace(SP.BASE_URI, "").Replace(SPIN.BASE_URI, ""))) { IResource b = bindings[argPredicate]; if (b != null && b.isUri()) { properties.Add(Resource.Get(b, _targetModel)); } } } } } } }
private bool containsVar(ITriple triple) { return(RDFUtil.sameTerm(var, triple.getObject()) || RDFUtil.sameTerm(var, triple.getPredicate()) || RDFUtil.sameTerm(var, triple.getSubject())); }
// TODO Replace IEnumerable<IUpdate> with a SparqlUpdateCommandSet /// <summary> /// TODO find a way to compile the global changes so ExecutionContexts can be set globally for Rules processing or Constraints checking. /// </summary> /// <param name="spinUpdateCommandSet"></param> internal IGraph ExecuteUpdate(IEnumerable <IUpdate> spinUpdateCommandSet) { QueryMode currentQueryMode = QueryExecutionMode; Uri currentExecutionGraphUri = RDFRuntime.NewTempGraphUri(); IGraph remoteChanges = new ThreadSafeGraph(); remoteChanges.BaseUri = currentExecutionGraphUri; try { foreach (IUpdate update in spinUpdateCommandSet) { if (update != null) { UpdateInternal(update, currentExecutionGraphUri); } } Storage.LoadGraph(remoteChanges, currentExecutionGraphUri); List <Resource> newTypes = new List <Resource>(); foreach (Triple t in remoteChanges.Triples) { if (RDFUtil.sameTerm(RDF.PropertyType, t.Predicate)) { // if remoteChanges contains an already checked rdf:type triple that means we have a infinite loop case in the SPIN processing pipeline so we stop execution if (_loopPreventionChecks.Contains(t)) { // TODO document better the exception cause throw new SpinException("Infinite loop encountered. Execution is canceled"); } _loopPreventionChecks.Add(t); newTypes.Add(AsResource(t.Object)); } else if (RDFUtil.sameTerm(RDFRuntime.PropertyHasChanged, t.Predicate)) { // mark the resource as updated for the next global CheckConstraints or Apply rules _changedResources.Add(t.Object); } else if (RDFUtil.sameTerm(RDFRuntime.PropertyResets, t.Predicate)) { // TODO log the property resets for filtering pattern extensions in the subsequent SPARQL execution } } CurrentExecutionContext = currentExecutionGraphUri; // run the constructors remoteChanges.Assert(this.RunConstructors(newTypes).Triples); } catch (Exception any) { // for cleanliness sake on exception cases foreach (Uri graphUri in Configuration.GetTriplesRemovalsGraphs().Union(Configuration.GetTriplesAdditionsGraphs())) { Storage.DeleteGraph(graphUri); } throw new Exception("", any); } finally { Storage.DeleteGraph(currentExecutionGraphUri); _queryExecutionMode = currentQueryMode; ResetExecutionContext(); } return(remoteChanges); }