protected boolean isAnonymous(IRI node) { return consumer.isAnonymousNode(node); }
protected boolean isAnonymous(IRI node) { return consumer.isAnonymousNode(node); }
@Override public void handleResourceTriple(IRI subject, IRI predicate, IRI object) { remainingTriples.add(new RDFTriple(subject, isAnonymousNode(subject), predicate, isAnonymousNode(predicate), object, isAnonymousNode(object))); } });
@Override public void handleLiteralTriple(IRI subject, IRI predicate, OWLLiteral object) { remainingTriples.add(new RDFTriple(subject, isAnonymousNode(subject), predicate, isAnonymousNode(predicate), object)); } });
protected boolean isAnonymous(IRI IRI) { return getConsumer().isAnonymousNode(IRI); }
private RDFResource getRDFResource(IRI iri) { if(isAnonymousNode(iri)) { return new RDFResourceBlankNode(iri); } else { return new RDFResourceIRI(iri); } }
protected OWLIndividual getOWLIndividual(IRI iri) { if (isAnonymousNode(iri)) { return dataFactory.getOWLAnonymousIndividual(iri.toString()); } else { return dataFactory.getOWLNamedIndividual(iri); } }
protected OWLIndividual getOWLIndividual(IRI iri) { if (isAnonymousNode(iri)) { return getDataFactory().getOWLAnonymousIndividual(iri.toString()); } else { return getDataFactory().getOWLNamedIndividual(iri); } }
public OWLClassExpression translateClassExpression(IRI mainNode) { if (!isAnonymousNode(mainNode)) { return getDataFactory().getOWLClass(mainNode); } OWLClassExpression desc = translatedClassExpression.get(mainNode); if (desc == null) { ClassExpressionTranslator translator = classExpressionTranslatorSelector.getClassExpressionTranslator(mainNode); if (translator != null) { desc = translator.translate(mainNode); translatedClassExpression.put(mainNode, desc); restrictionIRIs.remove(mainNode); } else { return getDataFactory().getOWLClass(mainNode); } } return desc; }
@Override public boolean canHandle(IRI subject, IRI predicate, IRI object) { return super.canHandle(subject, predicate, object) && !getConsumer().isAnonymousNode(subject) && getConsumer().isClassExpression(subject); }
public boolean canHandleStreaming(IRI subject, IRI predicate, IRI object) { if (!getConsumer().isAnonymousNode(subject)) { if (getConsumer().isAnonymousNode(object)) { OWLClassExpression superClass = getConsumer().getClassExpressionIfTranslated(object); if (superClass != null) { potentiallyConsumedTiples++; return true; } } } getConsumer().addOWLClass(subject); getConsumer().addOWLClass(object); return !isSubjectOrObjectAnonymous(subject, object); }
private OWLClassExpression translateClassExpressionInternal(IRI mainNode) { // Some optimisations... // We either have a class or a restriction Mode mode = getConfiguration().isStrict() ? Mode.STRICT : Mode.LAX; for(ClassExpressionTranslator translator : classExpressionTranslators) { if(translator.matches(mainNode, mode)) { return translator.translate(mainNode); } } if(!isAnonymousNode(mainNode)) { return dataFactory.getOWLClass(mainNode); } else { return generateAndLogParseError(EntityType.CLASS, mainNode); } }
public OWLObjectPropertyExpression translateObjectPropertyExpression(IRI mainNode) { OWLObjectPropertyExpression prop = translatedProperties.get(mainNode); if (prop != null) { return prop; } // addOWLObjectProperty(mainNode); if (!isAnonymousNode(mainNode)) { // Simple object property prop = getDataFactory().getOWLObjectProperty(mainNode); translatedProperties.put(mainNode, prop); return prop; } else { // Inverse of a property expression IRI inverseOfObject = getResourceObject(mainNode, OWL_INVERSE_OF.getIRI(), true); if (inverseOfObject != null) { OWLObjectPropertyExpression otherProperty = translateObjectPropertyExpression(inverseOfObject); prop = getDataFactory().getOWLObjectInverseOf(otherProperty); } else { prop = getDataFactory().getOWLObjectInverseOf(getDataFactory().getOWLObjectProperty(mainNode)); } translatedProperties.put(mainNode, prop); return prop; } }
public void translateRule(IRI mainNode) { Set<SWRLAtom> consequent = Collections.emptySet(); IRI ruleHeadIRI = consumer.getResourceObject(mainNode, SWRLVocabulary.HEAD.getIRI(), true); if (ruleHeadIRI != null) { consequent = listTranslator.translateToSet(ruleHeadIRI); } Set<SWRLAtom> antecedent = Collections.emptySet(); IRI ruleBodyIRI = consumer.getResourceObject(mainNode, SWRLVocabulary.BODY.getIRI(), true); if (ruleBodyIRI != null) { antecedent = listTranslator.translateToSet(ruleBodyIRI); } SWRLRule rule = null; if (!consumer.isAnonymousNode(mainNode)) { rule = consumer.getDataFactory().getSWRLRule(mainNode, antecedent, consequent); } else { rule = consumer.getDataFactory().getSWRLRule(NodeID.getNodeID(mainNode.toString()), antecedent, consequent); } consumer.addAxiom(rule); } }
@Override public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException { if (!getConsumer().isAnonymousNode(subject)) { OWLClass cls = (OWLClass) translateClassExpression(subject); Set<OWLClassExpression> classExpressions = getConsumer().translateToClassExpressionSet(object); addAxiom(getDataFactory().getOWLDisjointUnionAxiom(cls, classExpressions, getPendingAnnotations())); consumeTriple(subject, predicate, object); } } }
public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException { if (!getConsumer().isAnonymousNode(subject)) { OWLDatatype dt = getDataFactory().getOWLDatatype(subject); if (!dt.isBuiltIn()) { addAxiom(getDataFactory().getOWLDeclarationAxiom(dt)); } } getConsumer().addOWLDatatype(subject); } }
@Override public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException { if (!getConsumer().isAnonymousNode(subject)) { OWLDatatype dt = getDataFactory().getOWLDatatype(subject); Set<OWLAnnotation> annos = getConsumer().getPendingAnnotations(); addAxiom(getDataFactory().getOWLDeclarationAxiom(dt, annos)); } getConsumer().addDataRange(subject, true); } }
public boolean canHandleStreaming(IRI subject, IRI predicate, IRI object) { OWLRDFConsumer consumer = getConsumer(); IRI propIRI = consumer.getResourceObject(subject, OWLRDFVocabulary.OWL_ON_PROPERTY.getIRI(), false); if(propIRI != null && (!consumer.isAnonymousNode(object) || consumer.getClassExpressionIfTranslated(object) != null)) { // The filler is either a datatype or named class if(consumer.isObjectPropertyOnly(propIRI)) { consumer.addOWLClass(object); consumer.addTriple(subject, predicate, object); consumer.translateClassExpression(subject); return true; } else if(consumer.isDataPropertyOnly(propIRI)) { } } return false; }
@Override public boolean canHandleStreaming(IRI subject, IRI predicate, IRI object) { OWLRDFConsumer consumer = getConsumer(); consumer.addOWLRestriction(subject, false); IRI propIRI = consumer.getResourceObject(subject, OWLRDFVocabulary.OWL_ON_PROPERTY.getIRI(), false); if (propIRI != null && (!consumer.isAnonymousNode(object) || consumer.getClassExpressionIfTranslated(object) != null)) { // The filler is either a datatype or named class if (consumer.isObjectPropertyOnly(propIRI)) { consumer.addClassExpression(object, false); consumer.addTriple(subject, predicate, object); consumer.translateClassExpression(subject); return true; } else if (consumer.isDataPropertyOnly(propIRI)) { } } return false; }
@Override public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException { if (getConsumer().isObjectProperty(subject) && getConsumer().isClassExpression(object)) { translateObjectPropertyDomain(subject, predicate, object); } else if (getConsumer().isDataPropertyOnly(subject) && getConsumer().isClassExpression(object)) { translateDataPropertyDomain(subject, predicate, object); } else if (getConsumer().isAnnotationProperty(subject) && getConsumer().isClassExpression(object) && !getConsumer().isAnonymousNode(object)) { translateAnnotationPropertyDomain(subject, predicate, object); } else if(!isStrict()) { translateAnnotationPropertyDomain(subject, predicate, object); } }