ont-api: add OWLSameIndividualAxiom implementation + fix and add tests (issue #2)

Author: sszuev

src/main/java/com/github/owlcs/ontapi/internal/axioms/AbstractNaryTranslator.java

@@ -26,6 +26,7 @@
 import org.apache.jena.rdf.model.Statement;
 import org.apache.jena.util.iterator.ExtendedIterator;
 import org.semanticweb.owlapi.model.*;
+import org.semanticweb.owlapi.util.OWLAPIStreamUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -120,6 +121,9 @@ protected NaryAxiomImpl(Object subject, String predicate, Object object, Supplie
 
         /**
          * Returns the number of components.
+         * For single-triple axioms (i.e. a with predicate such as {@code owl:sameAs}, {@code owl:equivalentClass})
+         * the method returns {@code 2}.
+         * Only n-ary axioms which are based on {@link OntDisjoint} resource can different members count.
          *
          * @return long
          */
@@ -228,6 +232,19 @@ boolean testSameContent(ONTStatementImpl other) {
             }
             return false;
         }
+
+        /**
+         * Lists {@link T}s retrieved from the axiom internals.
+         *
+         * @param visitor {@link OWLPairwiseVisitor}, a visitor to apply to all pairwise elements in this axiom;
+         *                pairs are ordered,  i.e., (i, j) and (j, i) will be considered. (i,i) is skipped, not {@code null}
+         * @param <T>     the type returned by the {@code visitor}
+         * @return a {@code Stream} of {@link T}s
+         * @see OWLNaryAxiom#walkAllPairwise(OWLPairwiseVisitor)
+         */
+        protected <T> Stream<T> fromPairs(OWLPairwiseVisitor<T, M> visitor) {
+            return OWLAPIStreamUtils.allPairs(operands()).map(v -> visitor.visit(v.i, v.j)).filter(Objects::nonNull);
+        }
     }
 
     /**
@@ -308,7 +325,7 @@ public final boolean canContainNamedClasses() {
 
         @Override
         public final boolean canContainClassExpressions() {
-            return true;
+            return false;
         }
 
         @Override
@@ -358,13 +375,14 @@ abstract static class ClassOrIndividualNaryAxiomImpl<A extends OWLNaryAxiom<M>,
          * @param a - {@link M}, the first operand, not {@code null}
          * @param b - {@link M}, the second operand, not {@code null}
          * @return {@link OWLSubClassOfAxiom}
+         * @see NaryAxiomImpl#fromPairs(OWLPairwiseVisitor)
          */
         @FactoryAccessor
         protected abstract OWLSubClassOfAxiom createSubClassOf(M a, M b);
 
         @FactoryAccessor
         @Override
-        public final Collection<OWLSubClassOfAxiom> asOWLSubClassOfAxioms() {
+        public Collection<OWLSubClassOfAxiom> asOWLSubClassOfAxioms() {
             return walkAllPairwise((a, b) -> createSubClassOf(eraseModel(a), eraseModel(b)));
         }
     }

src/main/java/com/github/owlcs/ontapi/internal/axioms/EquivalentClassesTranslator.java

@@ -36,16 +36,14 @@
 
 /**
  * A translator that provides {@link OWLEquivalentClassesAxiom} implementations.
- * Base class {@link AbstractNaryTranslator}
+ * Base class {@link AbstractNaryTranslator}.
  * Example of ttl:
  * <pre>{@code
  *  pizza:SpicyTopping owl:equivalentClass [ a owl:Class; owl:intersectionOf ( pizza:PizzaTopping [a owl:Restriction; owl:onProperty pizza:hasSpiciness; owl:someValuesFrom pizza:Hot] )] ;
  * }
  * </pre>
  * <p>
  * Created by @szuev on 29.09.2016.
- *
- * @see OWLEquivalentClassesAxiom
  */
 public class EquivalentClassesTranslator extends AbstractNaryTranslator<OWLEquivalentClassesAxiom, OWLClassExpression, OntCE> {
 
@@ -168,6 +166,10 @@ protected SimpleImpl(Object s, String p, Object o, Supplier<OntGraphModel> m) {
                 super(s, p, o, m);
             }
 
+            private static boolean isNonBuiltin(String uri) {
+                return !uri.equals(OWL.Thing.getURI()) && !uri.equals(OWL.Nothing.getURI());
+            }
+
             @Override
             protected boolean sameContent(ONTStatementImpl other) {
                 return other instanceof SimpleImpl && isReverseTriple((SimpleImpl) other);
@@ -193,6 +195,21 @@ public Stream<Triple> triples() {
                 };
             }
 
+            @Override
+            public boolean containsNamedEquivalentClass() {
+                return isNonBuiltin((String) subject) || isNonBuiltin((String) object);
+            }
+
+            @Override
+            public boolean containsOWLNothing() {
+                return hasURIResource(OWL.Nothing);
+            }
+
+            @Override
+            public boolean containsOWLThing() {
+                return hasURIResource(OWL.Thing);
+            }
+
             @SuppressWarnings("unchecked")
             @Override
             public Set<OWLClass> getNamedClassSet() {
@@ -213,8 +230,7 @@ public Set<OWLEntity> getSignatureSet() {
 
             @Override
             public boolean containsNamedClass(OWLClass clazz) {
-                String uri = ONTEntityImpl.getURI(clazz);
-                return subject.equals(uri) || object.equals(uri);
+                return hasURIResource(ONTEntityImpl.getURI(clazz));
             }
 
             @Override

src/main/java/com/github/owlcs/ontapi/internal/axioms/SameIndividualTranslator.java

@@ -14,23 +14,30 @@
 
 package com.github.owlcs.ontapi.internal.axioms;
 
-import org.apache.jena.rdf.model.Property;
-import org.semanticweb.owlapi.model.OWLAnnotation;
-import org.semanticweb.owlapi.model.OWLIndividual;
-import org.semanticweb.owlapi.model.OWLSameIndividualAxiom;
-import com.github.owlcs.ontapi.internal.InternalConfig;
-import com.github.owlcs.ontapi.internal.InternalObjectFactory;
-import com.github.owlcs.ontapi.internal.ONTObject;
-import com.github.owlcs.ontapi.internal.ONTWrapperImpl;
+import com.github.owlcs.ontapi.DataFactory;
+import com.github.owlcs.ontapi.internal.*;
+import com.github.owlcs.ontapi.internal.objects.FactoryAccessor;
+import com.github.owlcs.ontapi.internal.objects.ONTEntityImpl;
+import com.github.owlcs.ontapi.internal.objects.ONTStatementImpl;
+import com.github.owlcs.ontapi.jena.model.OntGraphModel;
 import com.github.owlcs.ontapi.jena.model.OntIndividual;
 import com.github.owlcs.ontapi.jena.model.OntStatement;
 import com.github.owlcs.ontapi.jena.vocabulary.OWL;
+import org.apache.jena.graph.Triple;
+import org.apache.jena.rdf.model.Property;
+import org.semanticweb.owlapi.model.*;
 
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
- * base class {@link AbstractNaryTranslator}
- * example:
+ * A translator that provides {@link OWLSameIndividualAxiom} implementations.
+ * Example:
  * <pre>{@code
  * :indi1 owl:sameAs :indi2, :indi3 .
  * }</pre>
@@ -39,7 +46,8 @@
  *
  * @see OWLSameIndividualAxiom
  */
-public class SameIndividualTranslator extends AbstractNaryTranslator<OWLSameIndividualAxiom, OWLIndividual, OntIndividual> {
+public class SameIndividualTranslator
+        extends AbstractNaryTranslator<OWLSameIndividualAxiom, OWLIndividual, OntIndividual> {
 
     @Override
     public Property getPredicate() {
@@ -53,14 +61,197 @@ Class<OntIndividual> getView() {
 
     @Override
     public ONTObject<OWLSameIndividualAxiom> toAxiom(OntStatement statement,
-                                                     InternalObjectFactory reader,
+                                                     Supplier<OntGraphModel> model,
+                                                     InternalObjectFactory factory,
                                                      InternalConfig config) {
-        ONTObject<? extends OWLIndividual> a = reader.getIndividual(statement.getSubject(getView()));
-        ONTObject<? extends OWLIndividual> b = reader.getIndividual(statement.getObject().as(getView()));
-        Collection<ONTObject<OWLAnnotation>> annotations = reader.getAnnotations(statement, config);
-        OWLSameIndividualAxiom res = reader.getOWLDataFactory()
+        return AxiomImpl.create(statement, model, factory, config);
+    }
+
+    @Override
+    public ONTObject<OWLSameIndividualAxiom> toAxiom(OntStatement statement,
+                                                     InternalObjectFactory factory,
+                                                     InternalConfig config) {
+        ONTObject<? extends OWLIndividual> a = factory.getIndividual(statement.getSubject(getView()));
+        ONTObject<? extends OWLIndividual> b = factory.getIndividual(statement.getObject().as(getView()));
+        Collection<ONTObject<OWLAnnotation>> annotations = factory.getAnnotations(statement, config);
+        OWLSameIndividualAxiom res = factory.getOWLDataFactory()
                 .getOWLSameIndividualAxiom(a.getOWLObject(), b.getOWLObject(), ONTObject.toSet(annotations));
         return ONTWrapperImpl.create(res, statement).append(annotations).append(a).append(b);
     }
 
+    /**
+     * @see com.github.owlcs.ontapi.owlapi.axioms.OWLSameIndividualAxiomImpl
+     */
+    public abstract static class AxiomImpl extends IndividualNaryAxiomImpl<OWLSameIndividualAxiom>
+            implements OWLSameIndividualAxiom {
+
+        protected AxiomImpl(Triple t, Supplier<OntGraphModel> m) {
+            this(strip(t.getSubject()), t.getPredicate().getURI(), strip(t.getObject()), m);
+        }
+
+        protected AxiomImpl(Object s, String p, Object o, Supplier<OntGraphModel> m) {
+            super(s, p, o, m);
+        }
+
+        /**
+         * Creates an {@link ONTObject} container, that is also {@link OWLSameIndividualAxiom}.
+         *
+         * @param statement {@link OntStatement}, not {@code null}
+         * @param model     {@link OntGraphModel} provider, not {@code null}
+         * @param factory   {@link InternalObjectFactory}, not {@code null}
+         * @param config    {@link InternalConfig}, not {@code null}
+         * @return {@link AxiomImpl}
+         */
+        public static AxiomImpl create(OntStatement statement,
+                                       Supplier<OntGraphModel> model,
+                                       InternalObjectFactory factory,
+                                       InternalConfig config) {
+            return WithManyObjects.create(statement, model,
+                    SimpleImpl.FACTORY, ComplexImpl.FACTORY, SET_HASH_CODE, factory, config);
+        }
+
+        @Override
+        protected final long count() {
+            return 2;
+        }
+
+        @Override
+        public boolean containsAnonymousIndividuals() {
+            return individuals().anyMatch(OWLIndividual::isAnonymous);
+        }
+
+        @FactoryAccessor
+        @Override
+        protected OWLSameIndividualAxiom createAxiom(Collection<OWLIndividual> members,
+                                                     Collection<OWLAnnotation> annotations) {
+            return getDataFactory().getOWLSameIndividualAxiom(members,
+                    annotations == null ? NO_ANNOTATIONS : annotations);
+        }
+
+        @FactoryAccessor
+        @Override
+        protected OWLSubClassOfAxiom createSubClassOf(OWLIndividual a, OWLIndividual b) {
+            DataFactory df = getDataFactory();
+            return df.getOWLSubClassOfAxiom(df.getOWLObjectOneOf(a), df.getOWLObjectOneOf(b));
+        }
+
+        @FactoryAccessor
+        @Override
+        public Collection<OWLSubClassOfAxiom> asOWLSubClassOfAxioms() { // OWL-API-impl returns a Set here
+            return fromPairs((a, b) -> createSubClassOf(eraseModel(a), eraseModel(b))).collect(Collectors.toSet());
+        }
+
+        /**
+         * An {@link OWLSameIndividualAxiom} that has named classes as subject and object and has no annotations.
+         */
+        protected static class SimpleImpl extends AxiomImpl implements Simple<OWLIndividual> {
+
+            private static final BiFunction<Triple, Supplier<OntGraphModel>, SimpleImpl> FACTORY = SimpleImpl::new;
+
+            protected SimpleImpl(Triple t, Supplier<OntGraphModel> m) {
+                super(t, m);
+            }
+
+            protected SimpleImpl(Object s, String p, Object o, Supplier<OntGraphModel> m) {
+                super(s, p, o, m);
+            }
+
+            @Override
+            protected boolean sameContent(ONTStatementImpl other) {
+                return other instanceof SimpleImpl && isReverseTriple((SimpleImpl) other);
+            }
+
+            @Override
+            protected AxiomImpl makeCopyWith(ONTObject<OWLSameIndividualAxiom> other) {
+                if (other instanceof SimpleImpl) {
+                    Triple t = ((SimpleImpl) other).asTriple();
+                    return new SimpleImpl(subject, predicate, object, model) {
+
+                        @Override
+                        public Stream<Triple> triples() {
+                            return Stream.concat(SimpleImpl.this.triples(), Stream.of(t));
+                        }
+                    };
+                }
+                return new SimpleImpl(subject, predicate, object, model) {
+                    @Override
+                    public Stream<Triple> triples() {
+                        return Stream.concat(SimpleImpl.this.triples(), other.triples());
+                    }
+                };
+            }
+
+            @Override
+            public boolean containsAnonymousIndividuals() {
+                return false;
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Set<OWLNamedIndividual> getNamedIndividualSet() {
+                return (Set<OWLNamedIndividual>) getOWLComponentsAsSet();
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Set<OWLEntity> getSignatureSet() {
+                return (Set<OWLEntity>) getOWLComponentsAsSet();
+            }
+
+            @Override
+            public boolean containsNamedIndividual(OWLNamedIndividual individual) {
+                return hasURIResource(ONTEntityImpl.getURI(individual));
+            }
+
+            @Override
+            public boolean canContainAnonymousIndividuals() {
+                return false;
+            }
+        }
+
+        /**
+         * An {@link OWLSameIndividualAxiom}
+         * that either has annotations or anonymous class expressions in subject or object positions.
+         * It has a public constructor since it is more generic then {@link SimpleImpl}.
+         */
+        public static class ComplexImpl extends AxiomImpl
+                implements Complex<ComplexImpl, OWLIndividual> {
+
+            private static final BiFunction<Triple, Supplier<OntGraphModel>, ComplexImpl> FACTORY = ComplexImpl::new;
+            protected final InternalCache.Loading<ComplexImpl, Object[]> content;
+
+            public ComplexImpl(Triple t, Supplier<OntGraphModel> m) {
+                this(strip(t.getSubject()), t.getPredicate().getURI(), strip(t.getObject()), m);
+            }
+
+            protected ComplexImpl(Object s, String p, Object o, Supplier<OntGraphModel> m) {
+                super(s, p, o, m);
+                this.content = createContentCache();
+            }
+
+            @Override
+            public InternalCache.Loading<ComplexImpl, Object[]> getContentCache() {
+                return content;
+            }
+
+            @Override
+            protected boolean sameContent(ONTStatementImpl other) {
+                return other instanceof ComplexImpl && Arrays.equals(getContent(), ((ComplexImpl) other).getContent());
+            }
+
+            @Override
+            protected ComplexImpl makeCopyWith(ONTObject<OWLSameIndividualAxiom> other) {
+                ComplexImpl res = new ComplexImpl(subject, predicate, object, model) {
+                    @Override
+                    public Stream<Triple> triples() {
+                        return Stream.concat(ComplexImpl.this.triples(), other.triples());
+                    }
+                };
+                if (hasContent()) {
+                    res.putContent(getContent());
+                }
+                return res;
+            }
+        }
+    }
 }