public PelletInfGraph bind(final KnowledgeBase kb) throws ReasonerException { return new PelletInfGraph(kb, this, new DefaultGraphLoader()); }
final Node s = getObject(stmt, OWL2.sourceIndividual.asNode()); if (s == null) addUnsupportedFeature("Negated property value is missing owl:sourceIndividual value"); return false; final Node p = getObject(stmt, OWL2.assertionProperty.asNode()); if (p == null) addUnsupportedFeature("Negated property value is missing owl:assertionProperty value"); return false; final Node oi = getObject(stmt, OWL2.targetIndividual.asNode()); final Node ov = getObject(stmt, OWL2.targetValue.asNode()); if (oi == null && ov == null) addUnsupportedFeature("Negated property value is missing owl:targetIndividual or owl:targetValue value"); return false; addUnsupportedFeature("Negated property value must not have owl:targetIndividual and owl:targetValue value"); return false; final ATermAppl st = node2term(s); final ATermAppl pt = node2term(p); ATermAppl ot; defineIndividual(st); if (oi != null)
public DefaultGraphLoader() { clear(); }
private void defineBuiltinProperties() { defineAnnotationProperty(node2term(RDFS.label.asNode())); defineAnnotationProperty(node2term(RDFS.comment.asNode())); defineAnnotationProperty(node2term(RDFS.seeAlso.asNode())); defineAnnotationProperty(node2term(RDFS.isDefinedBy.asNode())); defineAnnotationProperty(node2term(OWL.versionInfo.asNode())); defineAnnotationProperty(node2term(OWL.backwardCompatibleWith.asNode())); defineAnnotationProperty(node2term(OWL.priorVersion.asNode())); defineAnnotationProperty(node2term(OWL.incompatibleWith.asNode())); }
@Override public Node next() { final Node first = getFirst(_list); _monitor.incrementProgress(); final Node rest = getRest(_list); _monitor.incrementProgress(); if (first == null || rest == null) { addUnsupportedFeature("Invalid _list structure: List " + _list + " does not have a " + (first == null ? "rdf:first" : "rdf:rest") + " property. Ignoring rest of the _list."); return null; } _list = rest; return first; }
private AtomIObject createRuleIObject(final Node node) { if (hasObject(node, RDF.type.asNode(), SWRL.Variable.asNode())) return new AtomIVariable(node.getURI()); else { final ATermAppl term = node2term(node); if (defineIndividual(term)) return new AtomIConstant(node2term(node)); else { addUnsupportedFeature("Cannot create rule _individual object for _node " + node); return null; } } }
if (isLoadABox()) final ATermAppl ot = node2term(o); defineClass(ot); final ATermAppl st = node2term(s); defineIndividual(st); _kb.addType(st, ot); processType(triple); final ATermAppl st = node2term(s); final ATermAppl ot = node2term(o); final ATermAppl pt = node2term(p); final Role role = _kb.getProperty(pt); final PropertyType type = role == null ? PropertyType.UNTYPED : role.getType(); if (defineAnnotationProperty(pt)) _kb.addAnnotation(st, pt, ot); addUnsupportedFeature("Ignoring triple with unknown property from " + builtin + " namespace: " + triple); return; if (defineDatatypeProperty(pt)) if (defineIndividual(st))
final ATermAppl st = node2term(s); addUnsupportedFeature("Ignoring triple with unknown term from " + builtin + " namespace: " + triple); return; defineProperty(st); break; defineClass(st); break; case OWL_DataRange: if (s.isURI()) defineDatatype(st); else _anonDatatypes.add(s); defineClass(st); break; defineIndividual(st); break; defineIndividual(st); _kb.addType(st, ATermUtils.BOTTOM); break; if (s.isURI() && !defineObjectProperty(st)) addUnsupportedFeature("Property " + st + " is defined both as an ObjectProperty and a " + _kb.getPropertyType(st) + "Property");
final Node atomNode = getObject(atomList, RDF.first.asNode()); if (hasObject(atomNode, RDF.type.asNode(), SWRL.ClassAtom.asNode())) if ((obj = getObject(atomNode, SWRL.classPredicate.asNode())) != null) description = node2term(obj); if ((obj = getObject(atomNode, SWRL.argument1.asNode())) != null) argument = createRuleIObject(obj); addUnsupportedFeature("Error on " + SWRL.classPredicate); else if (argument == null) addUnsupportedFeature("Error on" + SWRL.argument1); else atom = new ClassAtom(description, argument); if (hasObject(atomNode, RDF.type.asNode(), SWRL.IndividualPropertyAtom.asNode())) if ((obj = getObject(atomNode, SWRL.propertyPredicate.asNode())) != null) pred = node2term(obj); if ((obj = getObject(atomNode, SWRL.argument1.asNode())) != null) argument1 = createRuleIObject(obj); if ((obj = getObject(atomNode, SWRL.argument2.asNode())) != null) argument2 = createRuleIObject(obj); if (pred == null || !defineObjectProperty(pred))
if (isRestriction(node)) aTerm = createRestriction(node); else if (node.isBlank()) final Triple expr = getExpression(node); if (expr != null) final ATermList list = createList(exprValue); aTerm = ATermUtils.makeAnd(list); final ATermList list = createList(exprValue); aTerm = ATermUtils.makeOr(list); final ATermAppl complement = node2term(exprValue); aTerm = ATermUtils.makeNot(complement); final ATermAppl inverse = node2term(exprValue); aTerm = ATermUtils.makeInv(inverse); final ATermList list = createList(exprValue); ATermList result = ATermUtils.EMPTY_LIST; if (list.isEmpty()) aTerm = parseDataRange(node, exprValue); else if (exprType.equals(OWL2.onDataRange.asNode())) aTerm = parseDataRangeLegacy(node, exprValue); else
addUnsupportedFeature("Skipping invalid restriction"); return aTerm; final ATermAppl pt = node2term(p); value = _kb.getDatatypeReasoner().getValue(node2term(filler)); defineObjectProperty(pt); addSimpleProperty(pt, SELF); addUnsupportedFeature("Invalid value for " + OWL2.hasSelf.getLocalName() + " restriction. Expecting \"true\"^^xsd:boolean but found: " + filler); final ATermAppl ot = node2term(filler); defineDatatypeProperty(pt); else defineObjectProperty(pt); defineIndividual(ot); final ATermAppl ot = node2term(filler); defineObjectProperty(pt); else if (_kb.isDatatype(ot)) defineDatatypeProperty(pt); final ATermAppl ot = node2term(filler);
addUnsupportedFeature(msg); r.removeSubRoleChains(); defineObjectProperty(r.getName()); break; case DATATYPE: defineDatatypeProperty(r.getName()); rangeToDatatype = true; break; defineObjectProperty(r.getName()); defineDatatype(range); defineClass(range);
private List<AtomDObject> parseArgumentList(final Node argumentListParam) { Node argumentList = argumentListParam; final List<AtomDObject> arguments = new ArrayList<>(); while (argumentList != null && !argumentList.equals(RDF.nil.asNode())) { final Node argumentNode = getObject(argumentList, RDF.first.asNode()); if (argumentNode == null) addUnsupportedFeature("Term in _list not found " + RDF.first); else { arguments.add(createRuleDObject(argumentNode)); argumentList = getObject(argumentList, RDF.rest.asNode()); } } return arguments; }
private void defineRule(final Node node) { final List<RuleAtom> head = parseAtomList(getObject(node, SWRL.head.asNode())); final List<RuleAtom> body = parseAtomList(getObject(node, SWRL.body.asNode())); if (head == null || body == null) { String whichPart = "head and body"; if (head != null) whichPart = "body"; else if (body != null) whichPart = "head"; addUnsupportedFeature("Ignoring SWRL rule (unsupported " + whichPart + "): " + node); return; } final ATermAppl name = JenaUtils.makeATerm(node); final Rule rule = new Rule(name, head, body); _kb.addRule(rule); }
private ATermAppl parseDataRangeLegacy(final Node s, final Node definition) { if (!definition.isURI()) { addUnsupportedFeature("Invalid datatype definition, _expected URI but found " + s); return ATermUtils.BOTTOM_LIT; } final ATermAppl baseDatatype = ATermUtils.makeTermAppl(definition.getURI()); final Property[] datatypeFacets = new Property[] { OWL2.minInclusive, OWL2.maxInclusive, OWL2.minExclusive, OWL2.maxExclusive, OWL2.totalDigits, OWL2.fractionDigits, OWL2.pattern }; final List<ATermAppl> restrictions = new ArrayList<>(); for (final Property datatypeFacet : datatypeFacets) { final Node facetValue = getObject(s, datatypeFacet.asNode()); if (facetValue != null) { final ATermAppl restriction = ATermUtils.makeFacetRestriction(ATermUtils.makeTermAppl(datatypeFacet.getURI()), JenaUtils.makeATerm(facetValue)); restrictions.add(restriction); } } if (restrictions.isEmpty()) { addUnsupportedFeature("A _data range is defined without XSD facet restrictions " + s); return ATermUtils.BOTTOM_LIT; } else return ATermUtils.makeRestrictedDatatype(baseDatatype, restrictions.toArray(new ATermAppl[restrictions.size()])); }
protected ATermList createList(final RDFListIterator i) { if (!i.hasNext()) return ATermUtils.EMPTY_LIST; final Node node = i.next(); if (node == null) return ATermUtils.EMPTY_LIST; final ATermAppl first = node2term(node); final ATermList rest = createList(i); final ATermList list = ATermUtils.makeList(first, rest); return list; }
private AtomDObject createRuleDObject(final Node node) { if (!node.isLiteral()) { final ATermAppl name = node2term(node); if (!ATermUtils.isPrimitive(name)) { addUnsupportedFeature("Cannot create rule _data variable out of " + node); return null; } return new AtomDVariable(name.toString()); } else return new AtomDConstant(node2term(node)); }
protected ATermList createList(final Node node) { if (_lists.containsKey(node)) return _lists.get(node); final ATermList list = createList(new RDFListIterator(node)); _lists.put(node, list); return list; }
return createRestriction(restrictionType, p, filler, qualification, isObjectRestriction);
if (isLoadABox()) final ATermAppl ot = node2term(o); defineClass(ot); final ATermAppl st = node2term(s); defineIndividual(st); _kb.addType(st, ot); processType(triple); final ATermAppl st = node2term(s); final ATermAppl ot = node2term(o); final ATermAppl pt = node2term(p); final Role role = _kb.getProperty(pt); final PropertyType type = role == null ? PropertyType.UNTYPED : role.getType(); if (defineAnnotationProperty(pt)) _kb.addAnnotation(st, pt, ot); addUnsupportedFeature("Ignoring triple with unknown property from " + builtin + " namespace: " + triple); return; if (defineDatatypeProperty(pt)) if (defineIndividual(st))