default <T extends ImmutableTerm> ImmutableList<T> updateSubject(ImmutableList<T> originalArguments, T newSubject) { return updateSPO(originalArguments, newSubject, getProperty(originalArguments), getObject(originalArguments)); }
private Optional<IRI> extractIRI(Function atom) { return Optional.of(atom.getFunctionSymbol()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .flatMap(p -> { ImmutableList<ImmutableTerm> arguments = atom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return p.getClassIRI(arguments) .map(Optional::of) .orElseGet(() -> p.getPropertyIRI(arguments)); }); }
default <T extends ImmutableTerm> ImmutableList<T> updateObject(ImmutableList<T> originalArguments, T newObject) { return updateSPO(originalArguments, getSubject(originalArguments), getProperty(originalArguments), newObject); } }
default <T extends ImmutableTerm> ImmutableList<T> updateSO(ImmutableList<T> originalArguments, T newSubject, T newObject) { return updateSPO(originalArguments, newSubject, getProperty(originalArguments), newObject); }
private static ImmutableSet<Constant> extractIRITemplates(RDFAtomPredicate predicate, IQ definition) { ImmutableList<Variable> projectedVariables = definition.getProjectionAtom().getArguments(); return Stream.of(predicate.getSubject(projectedVariables), predicate.getObject(projectedVariables)) .flatMap(v -> extractIRITemplates(v, definition.getTree())) .collect(ImmutableCollectors.toSet()); }
private Variable getVarFromRDFAtom(DistinctVariableOnlyDataAtom atom, Position position) { switch (position) { case SUBJECT: return getRDFAtomPredicate(atom).getSubject(atom.getArguments()); case OBJECT: return getRDFAtomPredicate(atom).getObject(atom.getArguments()); case PROPERTY: return getRDFAtomPredicate(atom).getProperty(atom.getArguments()); default: throw new UnexpectedPositionException(position); } }
RDFAtomPredicate predicate = (RDFAtomPredicate)projectionAtom.getPredicate(); boolean isClass = predicate.getClassIRI(a.getSubstitutedTerms()) .isPresent(); ? predicate.getObject(projectionAtom.getArguments()) : predicate.getProperty(projectionAtom.getArguments());
RDFAtomPredicate predicate = (RDFAtomPredicate) targetAtom.getProjectionAtom().getPredicate(); Optional<org.apache.commons.rdf.api.IRI> classIRI = predicate.getClassIRI(terms); Optional<org.apache.commons.rdf.api.IRI> propertyIRI = predicate.getPropertyIRI(terms); IRI iri = IRI.create(propertyIRI.get().getIRIString()); ImmutableTerm objectTerm = predicate.getObject(terms); if (objectTerm instanceof ImmutableFunctionalTerm) {
private IQ completeSameAsDefinition(IQ originalDefinition, RDFAtomPredicate rdfAtomPredicate) { ImmutableList<Variable> originalProjectedVariables = originalDefinition.getProjectionAtom().getArguments(); Variable originalSubject = rdfAtomPredicate.getSubject(originalProjectedVariables); Variable originalObject = rdfAtomPredicate.getObject(originalProjectedVariables); rdfAtomPredicate.updateSO(originalProjectedVariables, newSubject, newObject));
private Optional<IQ> getRDFClassDefinition(RDFAtomPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> arguments) { return predicate.getClassIRI(arguments) .map(i -> mapping.getRDFClassDefinition(predicate, i)) .orElseGet(() -> getStarClassDefinition(predicate)); }
private Optional<IRI> getPropertyIRI(DataAtom atom) { AtomPredicate atomPredicate = atom.getPredicate(); return Optional.of(atomPredicate) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .flatMap(p -> p.getPropertyIRI(atom.getArguments())); }
@Override public Optional<IRI> getPredicateIRI() { return Optional.of(atom.getPredicate()) .filter(p -> p instanceof RDFAtomPredicate) .map(p -> (RDFAtomPredicate) p) .flatMap(p -> p.getPredicateIRI(getSubstitutedTerms())); }
private static PredicateClassification classify(ImmutableSet<Constant> sameAsIriTemplates, IQ definition, RDFAtomPredicate rdfAtomPredicate, boolean isClass) { ImmutableList<Variable> variables = definition.getProjectionAtom().getArguments(); /* * Current limitation: is the object is concerned about SameAs rewriting, the subject is supposed also * concerned. * TODO: enrich the classification */ if (!isClass && extractIRITemplates(rdfAtomPredicate.getObject(variables), definition.getTree()) .anyMatch(sameAsIriTemplates::contains)) { return PredicateClassification.AT_LEAST_OBJECT; } return extractIRITemplates(rdfAtomPredicate.getSubject(variables), definition.getTree()) .filter(sameAsIriTemplates::contains) .findAny() .map(t -> PredicateClassification.SUBJECT_ONLY) .orElse(PredicateClassification.NONE); }
private Optional<IRI> extractClassIRI(Function rdfDataAtom) { if (rdfDataAtom.getFunctionSymbol() instanceof RDFAtomPredicate) { RDFAtomPredicate rdfAtomPredicate = (RDFAtomPredicate) rdfDataAtom.getFunctionSymbol(); ImmutableList<ImmutableTerm> arguments = rdfDataAtom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return rdfAtomPredicate.getClassIRI(arguments); } return Optional.empty(); } }
private Optional<IRI> extractPropertyIRI(Function rdfDataAtom) { if (rdfDataAtom.getFunctionSymbol() instanceof RDFAtomPredicate) { RDFAtomPredicate rdfAtomPredicate = (RDFAtomPredicate) rdfDataAtom.getFunctionSymbol(); ImmutableList<ImmutableTerm> arguments = rdfDataAtom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return rdfAtomPredicate.getPropertyIRI(arguments); } return Optional.empty(); }
RDFAtomPredicate atomPredicate = (RDFAtomPredicate) atom.getProjectionAtom().getPredicate(); ImmutableTerm term1 = atomPredicate.getSubject(substitutedTerms); ImmutableTerm term2 = atomPredicate.getObject(substitutedTerms);
private RDFPredicate extractRDFPredicate(CQIE mappingAssertion) { Function headAtom = mappingAssertion.getHead(); if (!(headAtom.getFunctionSymbol() instanceof RDFAtomPredicate)) throw new MinorOntopInternalBugException("Mapping assertion without an RDFAtomPredicate found"); RDFAtomPredicate predicate = (RDFAtomPredicate) headAtom.getFunctionSymbol(); ImmutableList<ImmutableTerm> arguments = headAtom.getTerms().stream() .map(immutabilityTools::convertIntoImmutableTerm) .collect(ImmutableCollectors.toList()); return predicate.getClassIRI(arguments) .map(iri -> new RDFPredicate(true, iri)) .orElseGet(() -> predicate.getPropertyIRI(arguments) .map(i -> new RDFPredicate(false, i)) .orElseThrow(() -> new MinorOntopInternalBugException("Could not extract a predicate IRI from " + headAtom))); }
private Optional<IQ> getDefinition(RDFAtomPredicate predicate, ImmutableList<? extends VariableOrGroundTerm> arguments) { return predicate.getPropertyIRI(arguments) .map(i -> i.equals(RDF.TYPE) ? getRDFClassDefinition(predicate, arguments) : mapping.getRDFPropertyDefinition(predicate, i)) .orElseGet(() -> getStarDefinition(predicate)); }