ont-api: add OWLDisjointDataPropertiesAxiom model-impl (issue #2) + add/change tests

Author: sszuev

src/main/java/com/github/owlcs/ontapi/internal/AxiomTranslator.java

@@ -276,6 +276,7 @@ protected abstract ONTObject<Axiom> toAxiom(OntStatement statement,
      * @param config    {@link InternalConfig} to control process
      * @return {@link ONTObject} around {@link OWLAxiom}
      * @throws JenaException if no possible to get axiom from the statement
+     * @since 2.0.0
      */
     protected ONTObject<Axiom> toAxiom(OntStatement statement,
                                        Supplier<OntGraphModel> model,

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

@@ -388,6 +388,37 @@ public final boolean canContainDataProperties() {
         }
     }
 
+    /**
+     * An abstract {@link OWLNaryPropertyAxiom} implementation for member-type {@link OWLDataPropertyExpression}.
+     *
+     * @param <A> either {@link OWLEquivalentDataPropertiesAxiom} or {@link OWLDisjointDataPropertiesAxiom}
+     */
+    @SuppressWarnings("WeakerAccess")
+    protected abstract static class DataPropertyNaryAxiomImpl<A extends OWLNaryPropertyAxiom<OWLDataPropertyExpression>>
+            extends PropertyNaryAxiomImpl<A, OWLDataPropertyExpression> {
+
+        protected DataPropertyNaryAxiomImpl(Object subject, String predicate, Object object, Supplier<OntGraphModel> m) {
+            super(subject, predicate, object, m);
+        }
+
+        @Override
+        public ExtendedIterator<ONTObject<? extends OWLDataPropertyExpression>> listONTComponents(OntStatement statement,
+                                                                                                  InternalObjectFactory factory) {
+            return Iter.of(factory.getProperty(statement.getSubject(OntNDP.class)),
+                    factory.getProperty(statement.getObject(OntNDP.class)));
+        }
+
+        @Override
+        public ONTObject<? extends OWLDataPropertyExpression> findByURI(String uri, InternalObjectFactory factory) {
+            return ONTDataPropertyImpl.find(uri, factory, model);
+        }
+
+        @Override
+        public final boolean canContainObjectProperties() {
+            return false;
+        }
+    }
+
     /**
      * An abstraction, that combines common properties for {@link OWLNaryIndividualAxiom} and {@link OWLNaryClassAxiom}.
      *

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

@@ -14,34 +14,50 @@
 
 package com.github.owlcs.ontapi.internal.axioms;
 
-import org.apache.jena.rdf.model.Property;
-import org.apache.jena.rdf.model.Resource;
-import org.semanticweb.owlapi.model.OWLDataPropertyExpression;
-import org.semanticweb.owlapi.model.OWLDisjointDataPropertiesAxiom;
+import com.github.owlcs.ontapi.internal.InternalCache;
 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.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.OntDisjoint;
+import com.github.owlcs.ontapi.jena.model.OntGraphModel;
 import com.github.owlcs.ontapi.jena.model.OntNDP;
 import com.github.owlcs.ontapi.jena.model.OntStatement;
+import com.github.owlcs.ontapi.jena.utils.OntModels;
 import com.github.owlcs.ontapi.jena.vocabulary.OWL;
+import org.apache.jena.graph.FrontsTriple;
+import org.apache.jena.graph.Triple;
+import org.apache.jena.rdf.model.Property;
+import org.apache.jena.rdf.model.Resource;
+import org.apache.jena.util.iterator.ExtendedIterator;
+import org.semanticweb.owlapi.model.*;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
 
 /**
- * see {@link AbstractTwoWayNaryTranslator}
- * examples:
+ * A translator that provides {@link OWLDisjointDataPropertiesAxiom} implementations.
+ * Examples:
  * <ul>
  * <li>{@code  :objProperty1 owl:propertyDisjointWith :objProperty2}</li>
  * <li>{@code [ rdf:type owl:AllDisjointProperties; owl:members ( :objProperty1 :objProperty2 :objProperty3 ) ]}</li>
  * </ul>
  * <p>
  * Created by szuev on 12.10.2016.
- *
- * @see OWLDisjointDataPropertiesAxiom
  */
-public class DisjointDataPropertiesTranslator extends AbstractTwoWayNaryTranslator<OWLDisjointDataPropertiesAxiom, OWLDataPropertyExpression, OntNDP> {
+public class DisjointDataPropertiesTranslator
+        extends AbstractTwoWayNaryTranslator<OWLDisjointDataPropertiesAxiom, OWLDataPropertyExpression, OntNDP> {
+
+    private static final Property PREDICATE = OWL.propertyDisjointWith;
+
     @Override
     Property getPredicate() {
-        return OWL.propertyDisjointWith;
+        return PREDICATE;
     }
 
     @Override
@@ -66,11 +82,211 @@ Class<OntDisjoint.DataProperties> getDisjointView() {
 
     @Override
     public ONTObject<OWLDisjointDataPropertiesAxiom> toAxiom(OntStatement statement,
-                                                             InternalObjectFactory reader,
+                                                             Supplier<OntGraphModel> model,
+                                                             InternalObjectFactory factory,
+                                                             InternalConfig config) {
+        return AxiomImpl.create(statement, model, factory, config);
+    }
+
+    @Override
+    public ONTObject<OWLDisjointDataPropertiesAxiom> toAxiom(OntStatement statement,
+                                                             InternalObjectFactory factory,
                                                              InternalConfig config) {
-        return makeAxiom(statement, reader.getAnnotations(statement, config),
-                reader::getProperty,
-                (members, annotations) -> reader.getOWLDataFactory()
+        return makeAxiom(statement, factory.getAnnotations(statement, config),
+                factory::getProperty,
+                (members, annotations) -> factory.getOWLDataFactory()
                         .getOWLDisjointDataPropertiesAxiom(ONTObject.toSet(members), ONTObject.toSet(annotations)));
     }
+
+    /**
+     * @see com.github.owlcs.ontapi.owlapi.axioms.OWLDisjointDataPropertiesAxiomImpl
+     */
+    public abstract static class AxiomImpl extends DataPropertyNaryAxiomImpl<OWLDisjointDataPropertiesAxiom>
+            implements OWLDisjointDataPropertiesAxiom {
+
+        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 OWLDisjointDataPropertiesAxiom}.
+         *
+         * @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) {
+            if (PREDICATE.equals(statement.getPredicate())) {
+                return WithManyObjects.create(statement, model,
+                        SimpleImpl.FACTORY, ComplexImpl.FACTORY, SET_HASH_CODE, factory, config);
+            }
+            return WithManyObjects.create(statement, model, ComplexImpl.FACTORY, SET_HASH_CODE, factory, config);
+        }
+
+        @Override
+        public ExtendedIterator<ONTObject<? extends OWLDataPropertyExpression>> listONTComponents(OntStatement statement,
+                                                                                                  InternalObjectFactory factory) {
+            if (PREDICATE.equals(statement.getPredicate())) {
+                return super.listONTComponents(statement, factory);
+            }
+            return OntModels.listMembers(statement.getSubject(OntDisjoint.DataProperties.class).getList())
+                    .mapWith(factory::getProperty);
+        }
+
+        @FactoryAccessor
+        @Override
+        protected OWLDisjointDataPropertiesAxiom createAxiom(Collection<OWLDataPropertyExpression> members,
+                                                             Collection<OWLAnnotation> annotations) {
+            return getDataFactory().getOWLDisjointDataPropertiesAxiom(members,
+                    annotations == null ? NO_ANNOTATIONS : annotations);
+        }
+
+        /**
+         * An {@link OWLDisjointDataPropertiesAxiom}
+         * that is based on a single unannotated triple {@code s owl:propertyDisjointWith o},
+         * where {@code s} and {@code o} are data properties (URI {@link Resource}s).
+         */
+        protected static class SimpleImpl extends AxiomImpl implements Simple<OWLDataPropertyExpression> {
+
+            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 long count() {
+                return 2;
+            }
+
+            @Override
+            protected boolean sameContent(ONTStatementImpl other) {
+                return other instanceof SimpleImpl && isReverseTriple((SimpleImpl) other);
+            }
+
+            @Override
+            protected AxiomImpl makeCopyWith(ONTObject<OWLDisjointDataPropertiesAxiom> 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());
+                    }
+                };
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Set<OWLDataProperty> getDataPropertySet() {
+                return (Set<OWLDataProperty>) getOWLComponentsAsSet();
+            }
+
+            @SuppressWarnings("unchecked")
+            @Override
+            public Set<OWLEntity> getSignatureSet() {
+                return (Set<OWLEntity>) getOWLComponentsAsSet();
+            }
+
+            @Override
+            public boolean containsDataProperty(OWLDataProperty property) {
+                return hasURIResource(ONTEntityImpl.getURI(property));
+            }
+        }
+
+        /**
+         * An {@link OWLDisjointDataPropertiesAxiom}
+         * that either has annotations or it is based on {@link OntDisjoint.DataProperties} resource.
+         * It has a public constructor since it is more generic then {@link SimpleImpl}.
+         */
+        public static class ComplexImpl extends AxiomImpl implements Complex<ComplexImpl, OWLDataPropertyExpression> {
+
+            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
+            protected long count() {
+                return isSimple() ? 2 : members().count();
+            }
+
+            boolean isSimple() {
+                return predicate.equals(PREDICATE.getURI());
+            }
+
+            protected OntDisjoint.DataProperties asResource() {
+                return getPersonalityModel().getNodeAs(getSubjectNode(), OntDisjoint.DataProperties.class);
+            }
+
+            @Override
+            public Stream<Triple> triples() {
+                if (isSimple()) {
+                    return super.triples();
+                }
+                return Stream.concat(asResource().spec().map(FrontsTriple::asTriple),
+                        objects().flatMap(ONTObject::triples));
+            }
+
+            @Override
+            public OntStatement asStatement() {
+                if (isSimple()) {
+                    return super.asStatement();
+                }
+                return asResource().getRoot();
+            }
+
+            @Override
+            public InternalCache.Loading<ComplexImpl, Object[]> getContentCache() {
+                return content;
+            }
+
+            @Override
+            protected boolean sameContent(ONTStatementImpl other) {
+                return testSameContent(other);
+            }
+
+            @Override
+            protected ComplexImpl makeCopyWith(ONTObject<OWLDisjointDataPropertiesAxiom> 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;
+            }
+        }
+    }
 }

src/test/java/com/github/owlcs/ontapi/tests/TestFactory.java

@@ -2514,6 +2514,43 @@ public String toString() {
                                 "IRI.create(\"https://github.com/owlcs\"))))";
                     }
                 }
+                , new AxiomData() {
+                    @Override
+                    public AxiomType getType() {
+                        return AxiomType.DISJOINT_DATA_PROPERTIES;
+                    }
+
+                    @Override
+                    public OWLObject create(OWLDataFactory df) {
+                        return df.getOWLDisjointDataPropertiesAxiom(df.getOWLDataProperty("A"),
+                                df.getOWLDataProperty("B"));
+                    }
+
+                    @Override
+                    public String toString() {
+                        return "df.getOWLDisjointDataPropertiesAxiom(df.getOWLDataProperty(\"A\"), " +
+                                "df.getOWLDataProperty(\"B\"))";
+                    }
+                }
+                , new AxiomData() {
+                    @Override
+                    public AxiomType getType() {
+                        return AxiomType.DISJOINT_DATA_PROPERTIES;
+                    }
+
+                    @Override
+                    public OWLObject create(OWLDataFactory df) {
+                        return df.getOWLDisjointDataPropertiesAxiom(Collections.singleton(df.getOWLDataProperty("P")),
+                                Collections.singleton(df.getRDFSLabel(IRI.create("https://github.com/owlcs"))));
+                    }
+
+                    @Override
+                    public String toString() {
+                        return "df.getOWLDisjointDataPropertiesAxiom(Collections.singleton(" +
+                                "df.getOWLDataProperty(\"P\")), " +
+                                "Collections.singleton(df.getRDFSLabel(IRI.create(\"https://github.com/owlcs\"))))";
+                    }
+                }
         );
     }
 

src/test/java/com/github/owlcs/ontapi/tests/internal/AxiomPropertiesTest.java

@@ -78,6 +78,12 @@ public void testEquivalentObjectProperties() {
         testSplitNaryAxioms(data, (OWLNaryPropertyAxiom<?> a) -> a.properties().collect(Collectors.toList()));
     }
 
+    @Test
+    public void testDisjointDataProperties() {
+        List<TestFactory.AxiomData> data = CommonAxiomsTest.getAxiomData(AxiomType.DISJOINT_DATA_PROPERTIES);
+        testAxiom(data, (OWLNaryPropertyAxiom<?> a) -> a.properties().collect(Collectors.toList()));
+    }
+
     @SuppressWarnings("unchecked")
     @SafeVarargs
     private static <X extends OWLAxiom> void testAxiom(List<TestFactory.AxiomData> data,