• Home
• net.sourceforge.owlapi
• owlapi-osgidistribution
• 3.5.1
• source code
• OWLDataFactoryImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

uk.ac.manchester.cs.owl.owlapi.OWLDataFactoryImpl Maven / Gradle / Ivy

/*
 * This file is part of the OWL API.
 *
 * The contents of this file are subject to the LGPL License, Version 3.0.
 *
 * Copyright (C) 2011, The University of Manchester
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses/.
 *
 *
 * Alternatively, the contents of this file may be used under the terms of the Apache License, Version 2.0
 * in which case, the provisions of the Apache License Version 2.0 are applicable instead of those above.
 *
 * Copyright 2011, University of Manchester
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package uk.ac.manchester.cs.owl.owlapi;

import java.io.Serializable;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.semanticweb.owlapi.model.*;
import org.semanticweb.owlapi.util.CollectionFactory;
import org.semanticweb.owlapi.vocab.OWL2Datatype;
import org.semanticweb.owlapi.vocab.OWLFacet;
import org.semanticweb.owlapi.vocab.OWLRDFVocabulary;

/**
 * @author Matthew Horridge, The University Of Manchester, Bio-Health
 *         Informatics Group, Date: 26-Oct-2006
 */
public class OWLDataFactoryImpl implements OWLDataFactory, Serializable,
        OWLClassProvider {

    private static final String ANNOTATIONS = "annotations";
    private static final long serialVersionUID = 30406L;
    private static final String ABBREVIATED_IRI = "abbreviatedIRI";
    private static final String ID2 = "id";
    private static final String CURI2 = "curi";
    private static final String PREFIX_MANAGER = "prefixManager";
    private static final String IRI2 = "iri";
    private static final String VALUE2 = "value";
    private static final String DATATYPE2 = "datatype";
    private static final String LITERAL2 = "literal";
    private static final String VALUES2 = "values";
    private static final String DATA_RANGES = "dataRanges";
    private static final String DATA_RANGE = "dataRange";
    private static final OWLDataFactory instance = new OWLDataFactoryImpl(
            false, false);
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // //
    // // Distinguished Entities
    // //
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    private static final OWLClass OWL_THING = new OWLClassImpl(
            OWLRDFVocabulary.OWL_THING.getIRI());
    private static final OWLClass OWL_NOTHING = new OWLClassImpl(
            OWLRDFVocabulary.OWL_NOTHING.getIRI());
    private static final OWLAnnotationProperty RDFS_LABEL = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.RDFS_LABEL.getIRI());
    private static final OWLAnnotationProperty RDFS_COMMENT = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.RDFS_COMMENT.getIRI());
    private static final OWLAnnotationProperty RDFS_SEE_ALSO = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.RDFS_SEE_ALSO.getIRI());
    private static final OWLAnnotationProperty RDFS_IS_DEFINED_BY = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.RDFS_IS_DEFINED_BY.getIRI());
    private static final OWLAnnotationProperty OWL_BACKWARD_COMPATIBLE_WITH = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.OWL_BACKWARD_COMPATIBLE_WITH.getIRI());
    private static final OWLAnnotationProperty OWL_INCOMPATIBLE_WITH = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.OWL_INCOMPATIBLE_WITH.getIRI());
    private static final OWLAnnotationProperty OWL_VERSION_INFO = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.OWL_VERSION_INFO.getIRI());
    private static final OWLAnnotationProperty OWL_DEPRECATED = new OWLAnnotationPropertyImpl(
            OWLRDFVocabulary.OWL_DEPRECATED.getIRI());
    private static final OWLObjectProperty OWL_TOP_OBJECT_PROPERTY = new OWLObjectPropertyImpl(
            OWLRDFVocabulary.OWL_TOP_OBJECT_PROPERTY.getIRI());
    private static final OWLObjectProperty OWL_BOTTOM_OBJECT_PROPERTY = new OWLObjectPropertyImpl(
            OWLRDFVocabulary.OWL_BOTTOM_OBJECT_PROPERTY.getIRI());
    private static final OWLDataProperty OWL_TOP_DATA_PROPERTY = new OWLDataPropertyImpl(
            OWLRDFVocabulary.OWL_TOP_DATA_PROPERTY.getIRI());
    private static final OWLDataProperty OWL_BOTTOM_DATA_PROPERTY = new OWLDataPropertyImpl(
            OWLRDFVocabulary.OWL_BOTTOM_DATA_PROPERTY.getIRI());
    protected OWLDataFactoryInternals data;

    /** default constructor */
    public OWLDataFactoryImpl() {
        this(true, false);
    }

    /**
     * @param cache
     *        true if objects should be cached
     * @param useCompression
     *        true if literals should be compressed
     */
    public OWLDataFactoryImpl(boolean cache, boolean useCompression) {
        if (cache) {
            data = new OWLDataFactoryInternalsImpl(useCompression);
        } else {
            data = new InternalsNoCache(useCompression);
        }
    }

    /**
     * @return singleton instance
     * @deprecated Do not create data factories directly; use
     *             OWLOntologyManager::getOWLDataFactory()
     */
    @Deprecated
    public static OWLDataFactory getInstance() {
        System.err
                .println("OWLDataFactoryImpl.getInstance() WARNING: you should not use the implementation directly; this static method is here for backwards compatibility only");
        return instance;
    }

    @Override
    public void purge() {
        data.purge();
    }

    private void checkNull(Object o, String name) {
        // to enable semantic check on sets, turn to false - input sets will be
        // forbidden from being empty
        checkNull(o, name, true);
    }

    private void checkNull(Object o, String name, boolean emptyAllowed) {
        if (o == null) {
            throw new NullPointerException(name + " cannot be null");
        }
        if (o instanceof Iterable) {
            int i = 0;
            for (Object t : (Iterable) o) {
                if (t == null) {
                    throw new NullPointerException(name + " element " + i
                            + " cannot be null");
                }
                i++;
            }
            if (!emptyAllowed && i == 0) {
                throw new IllegalArgumentException(name + " cannot be empty");
            }
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public  E getOWLEntity(EntityType entityType,
            IRI iri) {
        checkNull(entityType, "entityType");
        checkNull(iri, IRI2);
        E ret = null;
        if (entityType.equals(EntityType.CLASS)) {
            ret = (E) getOWLClass(iri);
        } else if (entityType.equals(EntityType.OBJECT_PROPERTY)) {
            ret = (E) getOWLObjectProperty(iri);
        } else if (entityType.equals(EntityType.DATA_PROPERTY)) {
            ret = (E) getOWLDataProperty(iri);
        } else if (entityType.equals(EntityType.ANNOTATION_PROPERTY)) {
            ret = (E) getOWLAnnotationProperty(iri);
        } else if (entityType.equals(EntityType.NAMED_INDIVIDUAL)) {
            ret = (E) getOWLNamedIndividual(iri);
        } else if (entityType.equals(EntityType.DATATYPE)) {
            ret = (E) getOWLDatatype(iri);
        }
        return ret;
    }

    @Override
    public OWLClass getOWLClass(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLClass(iri);
    }

    @Override
    public OWLClass getOWLClass(String iri, PrefixManager prefixManager) {
        checkNull(iri, IRI2);
        checkNull(prefixManager, PREFIX_MANAGER);
        return getOWLClass(prefixManager.getIRI(iri));
    }

    @Override
    public OWLAnnotationProperty getOWLAnnotationProperty(
            String abbreviatedIRI, PrefixManager prefixManager) {
        checkNull(abbreviatedIRI, ABBREVIATED_IRI);
        checkNull(prefixManager, PREFIX_MANAGER);
        return getOWLAnnotationProperty(prefixManager.getIRI(abbreviatedIRI));
    }

    @Override
    public OWLAnnotationProperty getRDFSLabel() {
        return RDFS_LABEL;
    }

    @Override
    public OWLAnnotationProperty getRDFSComment() {
        return RDFS_COMMENT;
    }

    @Override
    public OWLAnnotationProperty getRDFSSeeAlso() {
        return RDFS_SEE_ALSO;
    }

    @Override
    public OWLAnnotationProperty getRDFSIsDefinedBy() {
        return RDFS_IS_DEFINED_BY;
    }

    @Override
    public OWLAnnotationProperty getOWLVersionInfo() {
        return OWL_VERSION_INFO;
    }

    @Override
    public OWLAnnotationProperty getOWLBackwardCompatibleWith() {
        return OWL_BACKWARD_COMPATIBLE_WITH;
    }

    @Override
    public OWLAnnotationProperty getOWLIncompatibleWith() {
        return OWL_INCOMPATIBLE_WITH;
    }

    @Override
    public OWLAnnotationProperty getOWLDeprecated() {
        return OWL_DEPRECATED;
    }

    @Override
    public OWLDatatype getOWLDatatype(String abbreviatedIRI,
            PrefixManager prefixManager) {
        checkNull(abbreviatedIRI, ABBREVIATED_IRI);
        checkNull(prefixManager, PREFIX_MANAGER);
        return data.getOWLDatatype(prefixManager.getIRI(abbreviatedIRI));
    }

    @Override
    public OWLClass getOWLThing() {
        return OWL_THING;
    }

    @Override
    public OWLClass getOWLNothing() {
        return OWL_NOTHING;
    }

    @Override
    public OWLDataProperty getOWLBottomDataProperty() {
        return OWL_BOTTOM_DATA_PROPERTY;
    }

    @Override
    public OWLObjectProperty getOWLBottomObjectProperty() {
        return OWL_BOTTOM_OBJECT_PROPERTY;
    }

    @Override
    public OWLDataProperty getOWLTopDataProperty() {
        return OWL_TOP_DATA_PROPERTY;
    }

    @Override
    public OWLObjectProperty getOWLTopObjectProperty() {
        return OWL_TOP_OBJECT_PROPERTY;
    }

    @Override
    public OWLObjectProperty getOWLObjectProperty(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLObjectProperty(iri);
    }

    @Override
    public OWLDataProperty getOWLDataProperty(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLDataProperty(iri);
    }

    @Override
    public OWLNamedIndividual getOWLNamedIndividual(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLNamedIndividual(iri);
    }

    @Override
    public OWLDataProperty getOWLDataProperty(String curi,
            PrefixManager prefixManager) {
        checkNull(curi, CURI2);
        checkNull(prefixManager, PREFIX_MANAGER);
        return getOWLDataProperty(prefixManager.getIRI(curi));
    }

    @Override
    public OWLNamedIndividual getOWLNamedIndividual(String curi,
            PrefixManager prefixManager) {
        checkNull(curi, CURI2);
        checkNull(prefixManager, PREFIX_MANAGER);
        return getOWLNamedIndividual(prefixManager.getIRI(curi));
    }

    @Override
    public OWLObjectProperty getOWLObjectProperty(String curi,
            PrefixManager prefixManager) {
        checkNull(curi, CURI2);
        checkNull(prefixManager, PREFIX_MANAGER);
        return getOWLObjectProperty(prefixManager.getIRI(curi));
    }

    @Override
    public OWLAnonymousIndividual getOWLAnonymousIndividual(String id) {
        checkNull(id, ID2);
        return new OWLAnonymousIndividualImpl(NodeID.getNodeID(id));
    }

    @Override
    public OWLAnonymousIndividual getOWLAnonymousIndividual() {
        return new OWLAnonymousIndividualImpl(NodeID.getNodeID(null));
    }

    @Override
    public OWLDatatype getOWLDatatype(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLDatatype(iri);
    }

    @Override
    public OWLLiteral getOWLLiteral(String lexicalValue, OWL2Datatype datatype) {
        checkNull(lexicalValue, "lexicalValue");
        checkNull(datatype, DATATYPE2);
        return getOWLLiteral(lexicalValue,
                OWL2DatatypeImpl.getDatatype(datatype));
    }

    @Override
    public OWLLiteral getOWLLiteral(boolean value) {
        return data.getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(String literal, OWLDatatype datatype) {
        checkNull(literal, LITERAL2);
        checkNull(datatype, DATATYPE2);
        return getOWLLiteral(literal, datatype);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(String literal, OWL2Datatype datatype) {
        checkNull(literal, LITERAL2);
        checkNull(datatype, DATATYPE2);
        return getOWLLiteral(literal, datatype);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(int value) {
        return getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(double value) {
        return getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(boolean value) {
        return getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(float value) {
        return getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLTypedLiteral(String value) {
        return getOWLLiteral(value);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLStringLiteral(String literal, String lang) {
        return getOWLLiteral(literal, lang);
    }

    @Override
    @Deprecated
    public OWLLiteral getOWLStringLiteral(String literal) {
        return getOWLLiteral(literal, "");
    }

    @Override
    public OWLDataOneOf getOWLDataOneOf(Set values) {
        checkNull(values, VALUES2);
        return new OWLDataOneOfImpl(values);
    }

    @Override
    public OWLDataOneOf getOWLDataOneOf(OWLLiteral... values) {
        checkNull(values, VALUES2);
        return getOWLDataOneOf(CollectionFactory.createSet(values));
    }

    @Override
    public OWLDataComplementOf getOWLDataComplementOf(OWLDataRange dataRange) {
        checkNull(dataRange, DATA_RANGE);
        return new OWLDataComplementOfImpl(dataRange);
    }

    @Override
    public OWLDataIntersectionOf getOWLDataIntersectionOf(
            OWLDataRange... dataRanges) {
        checkNull(dataRanges, DATA_RANGES);
        return getOWLDataIntersectionOf(CollectionFactory.createSet(dataRanges));
    }

    @Override
    public OWLDataIntersectionOf getOWLDataIntersectionOf(
            Set dataRanges) {
        checkNull(dataRanges, DATA_RANGES);
        return new OWLDataIntersectionOfImpl(dataRanges);
    }

    @Override
    public OWLDataUnionOf getOWLDataUnionOf(OWLDataRange... dataRanges) {
        checkNull(dataRanges, DATA_RANGES);
        return getOWLDataUnionOf(CollectionFactory.createSet(dataRanges));
    }

    @Override
    public OWLDataUnionOf getOWLDataUnionOf(
            Set dataRanges) {
        checkNull(dataRanges, DATA_RANGES);
        return new OWLDataUnionOfImpl(dataRanges);
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeRestriction(
            OWLDatatype datatype, Set facets) {
        checkNull(datatype, DATATYPE2);
        checkNull(facets, "facets");
        return new OWLDatatypeRestrictionImpl(datatype, facets);
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeRestriction(
            OWLDatatype datatype, OWLFacet facet, OWLLiteral typedConstant) {
        checkNull(datatype, DATATYPE2);
        checkNull(facet, "facet");
        checkNull(typedConstant, "typedConstant");
        return new OWLDatatypeRestrictionImpl(datatype,
                Collections.singleton(getOWLFacetRestriction(facet,
                        typedConstant)));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeRestriction(
            OWLDatatype dataRange, OWLFacetRestriction... facetRestrictions) {
        checkNull(facetRestrictions, "facetRestrictions");
        return getOWLDatatypeRestriction(dataRange,
                CollectionFactory.createSet(facetRestrictions));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinInclusiveRestriction(
            int minInclusive) {
        return getOWLDatatypeRestriction(getIntegerOWLDatatype(),
                OWLFacet.MIN_INCLUSIVE, getOWLLiteral(minInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMaxInclusiveRestriction(
            int maxInclusive) {
        return getOWLDatatypeRestriction(getIntegerOWLDatatype(),
                OWLFacet.MAX_INCLUSIVE, getOWLLiteral(maxInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinMaxInclusiveRestriction(
            int minInclusive, int maxInclusive) {
        return getOWLDatatypeRestriction(
                getIntegerOWLDatatype(),
                getOWLFacetRestriction(OWLFacet.MIN_INCLUSIVE,
                        getOWLLiteral(minInclusive)),
                getOWLFacetRestriction(OWLFacet.MAX_INCLUSIVE, maxInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinExclusiveRestriction(
            int minExclusive) {
        return getOWLDatatypeRestriction(getIntegerOWLDatatype(),
                OWLFacet.MIN_EXCLUSIVE, getOWLLiteral(minExclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMaxExclusiveRestriction(
            int maxExclusive) {
        return getOWLDatatypeRestriction(getIntegerOWLDatatype(),
                OWLFacet.MAX_EXCLUSIVE, getOWLLiteral(maxExclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinMaxExclusiveRestriction(
            int minExclusive, int maxExclusive) {
        return getOWLDatatypeRestriction(
                getIntegerOWLDatatype(),
                getOWLFacetRestriction(OWLFacet.MIN_EXCLUSIVE,
                        getOWLLiteral(minExclusive)),
                getOWLFacetRestriction(OWLFacet.MAX_EXCLUSIVE, maxExclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinInclusiveRestriction(
            double minInclusive) {
        return getOWLDatatypeRestriction(getDoubleOWLDatatype(),
                OWLFacet.MIN_INCLUSIVE, getOWLLiteral(minInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMaxInclusiveRestriction(
            double maxInclusive) {
        return getOWLDatatypeRestriction(getDoubleOWLDatatype(),
                OWLFacet.MAX_INCLUSIVE, getOWLLiteral(maxInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinMaxInclusiveRestriction(
            double minInclusive, double maxInclusive) {
        return getOWLDatatypeRestriction(
                getDoubleOWLDatatype(),
                getOWLFacetRestriction(OWLFacet.MIN_INCLUSIVE,
                        getOWLLiteral(minInclusive)),
                getOWLFacetRestriction(OWLFacet.MAX_INCLUSIVE, maxInclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinExclusiveRestriction(
            double minExclusive) {
        return getOWLDatatypeRestriction(getDoubleOWLDatatype(),
                OWLFacet.MIN_EXCLUSIVE, getOWLLiteral(minExclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMaxExclusiveRestriction(
            double maxExclusive) {
        return getOWLDatatypeRestriction(getDoubleOWLDatatype(),
                OWLFacet.MAX_EXCLUSIVE, getOWLLiteral(maxExclusive));
    }

    @Override
    public OWLDatatypeRestriction getOWLDatatypeMinMaxExclusiveRestriction(
            double minExclusive, double maxExclusive) {
        return getOWLDatatypeRestriction(
                getDoubleOWLDatatype(),
                getOWLFacetRestriction(OWLFacet.MIN_EXCLUSIVE,
                        getOWLLiteral(minExclusive)),
                getOWLFacetRestriction(OWLFacet.MAX_EXCLUSIVE, maxExclusive));
    }

    @Override
    public OWLFacetRestriction getOWLFacetRestriction(OWLFacet facet,
            int facetValue) {
        return getOWLFacetRestriction(facet, getOWLLiteral(facetValue));
    }

    @Override
    public OWLFacetRestriction getOWLFacetRestriction(OWLFacet facet,
            double facetValue) {
        return getOWLFacetRestriction(facet, getOWLLiteral(facetValue));
    }

    @Override
    public OWLFacetRestriction getOWLFacetRestriction(OWLFacet facet,
            float facetValue) {
        return getOWLFacetRestriction(facet, getOWLLiteral(facetValue));
    }

    @Override
    public OWLFacetRestriction getOWLFacetRestriction(OWLFacet facet,
            OWLLiteral facetValue) {
        checkNull(facet, "facet");
        checkNull(facetValue, "facetValue");
        return new OWLFacetRestrictionImpl(facet, facetValue);
    }

    @Override
    public OWLObjectIntersectionOf getOWLObjectIntersectionOf(
            Set operands) {
        checkNull(operands, "operands");
        return new OWLObjectIntersectionOfImpl(operands);
    }

    @Override
    public OWLObjectIntersectionOf getOWLObjectIntersectionOf(
            OWLClassExpression... operands) {
        checkNull(operands, "operands");
        return getOWLObjectIntersectionOf(CollectionFactory.createSet(operands));
    }

    @Override
    public OWLDataAllValuesFrom getOWLDataAllValuesFrom(
            OWLDataPropertyExpression property, OWLDataRange dataRange) {
        checkNull(dataRange, DATA_RANGE);
        checkNull(property, "property");
        return new OWLDataAllValuesFromImpl(property, dataRange);
    }

    @Override
    public OWLDataExactCardinality getOWLDataExactCardinality(int cardinality,
            OWLDataPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLDataExactCardinalityImpl(property, cardinality,
                getTopDatatype());
    }

    @Override
    public OWLDataExactCardinality getOWLDataExactCardinality(int cardinality,
            OWLDataPropertyExpression property, OWLDataRange dataRange) {
        checkNull(dataRange, DATA_RANGE);
        checkNull(property, "property");
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        return new OWLDataExactCardinalityImpl(property, cardinality, dataRange);
    }

    @Override
    public OWLDataMaxCardinality getOWLDataMaxCardinality(int cardinality,
            OWLDataPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLDataMaxCardinalityImpl(property, cardinality,
                getTopDatatype());
    }

    @Override
    public OWLDataMaxCardinality getOWLDataMaxCardinality(int cardinality,
            OWLDataPropertyExpression property, OWLDataRange dataRange) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        checkNull(dataRange, DATA_RANGE);
        return new OWLDataMaxCardinalityImpl(property, cardinality, dataRange);
    }

    @Override
    public OWLDataMinCardinality getOWLDataMinCardinality(int cardinality,
            OWLDataPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLDataMinCardinalityImpl(property, cardinality,
                getTopDatatype());
    }

    @Override
    public OWLDataMinCardinality getOWLDataMinCardinality(int cardinality,
            OWLDataPropertyExpression property, OWLDataRange dataRange) {
        checkNull(dataRange, DATA_RANGE);
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLDataMinCardinalityImpl(property, cardinality, dataRange);
    }

    @Override
    public OWLDataSomeValuesFrom getOWLDataSomeValuesFrom(
            OWLDataPropertyExpression property, OWLDataRange dataRange) {
        checkNull(dataRange, DATA_RANGE);
        checkNull(property, "property");
        return new OWLDataSomeValuesFromImpl(property, dataRange);
    }

    @Override
    public OWLDataHasValue getOWLDataHasValue(
            OWLDataPropertyExpression property, OWLLiteral value) {
        checkNull(property, "property");
        checkNull(value, VALUE2);
        return new OWLDataHasValueImpl(property, value);
    }

    @Override
    public OWLObjectComplementOf getOWLObjectComplementOf(
            OWLClassExpression operand) {
        checkNull(operand, "operand");
        return new OWLObjectComplementOfImpl(operand);
    }

    @Override
    public OWLObjectAllValuesFrom getOWLObjectAllValuesFrom(
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        checkNull(classExpression, "classExpression");
        checkNull(property, "property");
        return new OWLObjectAllValuesFromImpl(property, classExpression);
    }

    @Override
    public OWLObjectOneOf
            getOWLObjectOneOf(Set values) {
        checkNull(values, VALUES2);
        return new OWLObjectOneOfImpl(values);
    }

    @Override
    public OWLObjectOneOf getOWLObjectOneOf(OWLIndividual... individuals) {
        checkNull(individuals, "individuals");
        return getOWLObjectOneOf(CollectionFactory.createSet(individuals));
    }

    @Override
    public OWLObjectExactCardinality getOWLObjectExactCardinality(
            int cardinality, OWLObjectPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLObjectExactCardinalityImpl(property, cardinality,
                OWL_THING);
    }

    @Override
    public OWLObjectExactCardinality getOWLObjectExactCardinality(
            int cardinality, OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        checkNull(classExpression, "classExpression");
        checkNull(property, "property");
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        return new OWLObjectExactCardinalityImpl(property, cardinality,
                classExpression);
    }

    @Override
    public OWLObjectMinCardinality getOWLObjectMinCardinality(int cardinality,
            OWLObjectPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLObjectMinCardinalityImpl(property, cardinality, OWL_THING);
    }

    @Override
    public OWLObjectMinCardinality getOWLObjectMinCardinality(int cardinality,
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        checkNull(classExpression, "classExpression");
        checkNull(property, "property");
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        return new OWLObjectMinCardinalityImpl(property, cardinality,
                classExpression);
    }

    @Override
    public OWLObjectMaxCardinality getOWLObjectMaxCardinality(int cardinality,
            OWLObjectPropertyExpression property) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(property, "property");
        return new OWLObjectMaxCardinalityImpl(property, cardinality, OWL_THING);
    }

    @Override
    public OWLObjectMaxCardinality getOWLObjectMaxCardinality(int cardinality,
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        if (cardinality < 0) {
            throw new IllegalArgumentException("cardinality cannot be negative");
        }
        checkNull(classExpression, "classExpression");
        checkNull(property, "property");
        return new OWLObjectMaxCardinalityImpl(property, cardinality,
                classExpression);
    }

    @Override
    public OWLObjectHasSelf getOWLObjectHasSelf(
            OWLObjectPropertyExpression property) {
        checkNull(property, "property");
        return new OWLObjectHasSelfImpl(property);
    }

    @Override
    public OWLObjectSomeValuesFrom getOWLObjectSomeValuesFrom(
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        checkNull(classExpression, "classExpression");
        checkNull(property, "property");
        return new OWLObjectSomeValuesFromImpl(property, classExpression);
    }

    @Override
    public OWLObjectHasValue getOWLObjectHasValue(
            OWLObjectPropertyExpression property, OWLIndividual individual) {
        checkNull(property, "property");
        checkNull(individual, "individual");
        return new OWLObjectHasValueImpl(property, individual);
    }

    @Override
    public OWLObjectUnionOf getOWLObjectUnionOf(
            Set operands) {
        checkNull(operands, "operands");
        return new OWLObjectUnionOfImpl(operands);
    }

    @Override
    public OWLObjectUnionOf getOWLObjectUnionOf(OWLClassExpression... operands) {
        checkNull(operands, "operands");
        return getOWLObjectUnionOf(CollectionFactory.createSet(operands));
    }

    @Override
    public OWLAsymmetricObjectPropertyAxiom
            getOWLAsymmetricObjectPropertyAxiom(
                    OWLObjectPropertyExpression propertyExpression,
                    Set annotations) {
        checkNull(propertyExpression, "propertyExpression");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLAsymmetricObjectPropertyAxiomImpl(propertyExpression,
                annotations);
    }

    @Override
    public OWLAsymmetricObjectPropertyAxiom
            getOWLAsymmetricObjectPropertyAxiom(
                    OWLObjectPropertyExpression propertyExpression) {
        return getOWLAsymmetricObjectPropertyAxiom(propertyExpression,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyDomainAxiom getOWLDataPropertyDomainAxiom(
            OWLDataPropertyExpression property, OWLClassExpression domain,
            Set annotations) {
        checkNull(property, "property");
        checkNull(domain, "domain");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDataPropertyDomainAxiomImpl(property, domain, annotations);
    }

    @Override
    public OWLDataPropertyDomainAxiom getOWLDataPropertyDomainAxiom(
            OWLDataPropertyExpression property, OWLClassExpression domain) {
        return getOWLDataPropertyDomainAxiom(property, domain,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyRangeAxiom getOWLDataPropertyRangeAxiom(
            OWLDataPropertyExpression property, OWLDataRange owlDataRange,
            Set annotations) {
        checkNull(property, "property");
        checkNull(owlDataRange, "owlDataRange");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDataPropertyRangeAxiomImpl(property, owlDataRange,
                annotations);
    }

    @Override
    public OWLDataPropertyRangeAxiom getOWLDataPropertyRangeAxiom(
            OWLDataPropertyExpression property, OWLDataRange owlDataRange) {
        return getOWLDataPropertyRangeAxiom(property, owlDataRange,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSubDataPropertyOfAxiom getOWLSubDataPropertyOfAxiom(
            OWLDataPropertyExpression subProperty,
            OWLDataPropertyExpression superProperty,
            Set annotations) {
        checkNull(subProperty, "subProperty");
        checkNull(superProperty, "superProperty");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSubDataPropertyOfAxiomImpl(subProperty, superProperty,
                annotations);
    }

    @Override
    public OWLSubDataPropertyOfAxiom getOWLSubDataPropertyOfAxiom(
            OWLDataPropertyExpression subProperty,
            OWLDataPropertyExpression superProperty) {
        return getOWLSubDataPropertyOfAxiom(subProperty, superProperty,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDeclarationAxiom getOWLDeclarationAxiom(OWLEntity owlEntity) {
        return getOWLDeclarationAxiom(owlEntity, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDeclarationAxiom getOWLDeclarationAxiom(OWLEntity owlEntity,
            Set annotations) {
        checkNull(owlEntity, "owlEntity");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDeclarationAxiomImpl(owlEntity, annotations);
    }

    @Override
    public OWLDifferentIndividualsAxiom getOWLDifferentIndividualsAxiom(
            Set individuals,
            Set annotations) {
        checkNull(individuals, "individuals");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDifferentIndividualsAxiomImpl(individuals, annotations);
    }

    @Override
    public OWLDifferentIndividualsAxiom getOWLDifferentIndividualsAxiom(
            OWLIndividual... individuals) {
        checkNull(individuals, "individuals");
        return getOWLDifferentIndividualsAxiom(CollectionFactory
                .createSet(individuals));
    }

    @Override
    public OWLDifferentIndividualsAxiom getOWLDifferentIndividualsAxiom(
            Set individuals) {
        return getOWLDifferentIndividualsAxiom(individuals,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDisjointClassesAxiom getOWLDisjointClassesAxiom(
            Set classExpressions,
            Set annotations) {
        checkNull(classExpressions, "classExpressions");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDisjointClassesAxiomImpl(classExpressions, annotations);
    }

    @Override
    public OWLDisjointClassesAxiom getOWLDisjointClassesAxiom(
            Set classExpressions) {
        return getOWLDisjointClassesAxiom(classExpressions,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDisjointClassesAxiom getOWLDisjointClassesAxiom(
            OWLClassExpression... classExpressions) {
        checkNull(classExpressions, "classExpressions");
        Set clses = new HashSet();
        clses.addAll(Arrays.asList(classExpressions));
        return getOWLDisjointClassesAxiom(clses);
    }

    @Override
    public OWLDisjointDataPropertiesAxiom getOWLDisjointDataPropertiesAxiom(
            Set properties,
            Set annotations) {
        checkNull(properties, "properties");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDisjointDataPropertiesAxiomImpl(properties, annotations);
    }

    @Override
    public OWLDisjointDataPropertiesAxiom getOWLDisjointDataPropertiesAxiom(
            Set properties) {
        return getOWLDisjointDataPropertiesAxiom(properties,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDisjointDataPropertiesAxiom getOWLDisjointDataPropertiesAxiom(
            OWLDataPropertyExpression... properties) {
        checkNull(properties, "properties");
        return getOWLDisjointDataPropertiesAxiom(CollectionFactory
                .createSet(properties));
    }

    @Override
    public OWLDisjointObjectPropertiesAxiom
            getOWLDisjointObjectPropertiesAxiom(
                    OWLObjectPropertyExpression... properties) {
        checkNull(properties, "properties");
        return getOWLDisjointObjectPropertiesAxiom(CollectionFactory
                .createSet(properties));
    }

    @Override
    public OWLDisjointObjectPropertiesAxiom
            getOWLDisjointObjectPropertiesAxiom(
                    Set properties) {
        return getOWLDisjointObjectPropertiesAxiom(properties,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDisjointObjectPropertiesAxiom
            getOWLDisjointObjectPropertiesAxiom(
                    Set properties,
                    Set annotations) {
        checkNull(properties, "properties");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDisjointObjectPropertiesAxiomImpl(properties, annotations);
    }

    @Override
    public OWLEquivalentClassesAxiom getOWLEquivalentClassesAxiom(
            Set classExpressions,
            Set annotations) {
        checkNull(classExpressions, "classExpressions");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLEquivalentClassesAxiomImpl(classExpressions, annotations);
    }

    @Override
    public OWLEquivalentClassesAxiom getOWLEquivalentClassesAxiom(
            OWLClassExpression clsA, OWLClassExpression clsB) {
        checkNull(clsA, "clsA");
        checkNull(clsB, "clsB");
        return getOWLEquivalentClassesAxiom(clsA, clsB, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentClassesAxiom getOWLEquivalentClassesAxiom(
            OWLClassExpression clsA, OWLClassExpression clsB,
            Set annotations) {
        checkNull(clsA, "clsA");
        checkNull(clsB, "clsB");
        return getOWLEquivalentClassesAxiom(
                CollectionFactory.createSet(clsA, clsB), annotations);
    }

    @Override
    public OWLEquivalentClassesAxiom getOWLEquivalentClassesAxiom(
            OWLClassExpression... classExpressions) {
        checkNull(classExpressions, "classExpressions");
        Set clses = new HashSet();
        clses.addAll(Arrays.asList(classExpressions));
        return getOWLEquivalentClassesAxiom(clses);
    }

    @Override
    public OWLEquivalentClassesAxiom getOWLEquivalentClassesAxiom(
            Set classExpressions) {
        return getOWLEquivalentClassesAxiom(classExpressions,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentDataPropertiesAxiom
            getOWLEquivalentDataPropertiesAxiom(
                    Set properties,
                    Set annotations) {
        checkNull(properties, "properties");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLEquivalentDataPropertiesAxiomImpl(properties, annotations);
    }

    @Override
    public OWLEquivalentDataPropertiesAxiom
            getOWLEquivalentDataPropertiesAxiom(
                    Set properties) {
        return getOWLEquivalentDataPropertiesAxiom(properties,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentDataPropertiesAxiom
            getOWLEquivalentDataPropertiesAxiom(
                    OWLDataPropertyExpression propertyA,
                    OWLDataPropertyExpression propertyB) {
        return getOWLEquivalentDataPropertiesAxiom(propertyA, propertyB,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentDataPropertiesAxiom
            getOWLEquivalentDataPropertiesAxiom(
                    OWLDataPropertyExpression propertyA,
                    OWLDataPropertyExpression propertyB,
                    Set annotations) {
        checkNull(propertyA, "propertyA");
        checkNull(propertyB, "propertyB");
        return getOWLEquivalentDataPropertiesAxiom(
                CollectionFactory.createSet(propertyA, propertyB), annotations);
    }

    @Override
    public OWLEquivalentDataPropertiesAxiom
            getOWLEquivalentDataPropertiesAxiom(
                    OWLDataPropertyExpression... properties) {
        checkNull(properties, "properties");
        return getOWLEquivalentDataPropertiesAxiom(CollectionFactory
                .createSet(properties));
    }

    @Override
    public OWLEquivalentObjectPropertiesAxiom
            getOWLEquivalentObjectPropertiesAxiom(
                    OWLObjectPropertyExpression... properties) {
        checkNull(properties, "properties");
        return getOWLEquivalentObjectPropertiesAxiom(CollectionFactory
                .createSet(properties));
    }

    @Override
    public OWLEquivalentObjectPropertiesAxiom
            getOWLEquivalentObjectPropertiesAxiom(
                    Set properties) {
        return getOWLEquivalentObjectPropertiesAxiom(properties,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentObjectPropertiesAxiom
            getOWLEquivalentObjectPropertiesAxiom(
                    OWLObjectPropertyExpression propertyA,
                    OWLObjectPropertyExpression propertyB) {
        checkNull(propertyA, "propertyA");
        checkNull(propertyB, "propertyB");
        return getOWLEquivalentObjectPropertiesAxiom(propertyA, propertyB,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentObjectPropertiesAxiom
            getOWLEquivalentObjectPropertiesAxiom(
                    OWLObjectPropertyExpression propertyA,
                    OWLObjectPropertyExpression propertyB,
                    Set annotations) {
        checkNull(propertyA, "propertyA");
        checkNull(propertyB, "propertyB");
        return getOWLEquivalentObjectPropertiesAxiom(
                CollectionFactory.createSet(propertyA, propertyB), annotations);
    }

    @Override
    public OWLFunctionalDataPropertyAxiom getOWLFunctionalDataPropertyAxiom(
            OWLDataPropertyExpression property,
            Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLFunctionalDataPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLFunctionalDataPropertyAxiom getOWLFunctionalDataPropertyAxiom(
            OWLDataPropertyExpression property) {
        return getOWLFunctionalDataPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLFunctionalObjectPropertyAxiom
            getOWLFunctionalObjectPropertyAxiom(
                    OWLObjectPropertyExpression property,
                    Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLFunctionalObjectPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLFunctionalObjectPropertyAxiom
            getOWLFunctionalObjectPropertyAxiom(
                    OWLObjectPropertyExpression property) {
        return getOWLFunctionalObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLImportsDeclaration getOWLImportsDeclaration(
            IRI importedOntologyIRI) {
        checkNull(importedOntologyIRI, "importedOntologyIRI");
        return new OWLImportsDeclarationImpl(importedOntologyIRI);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            OWLLiteral object, Set annotations) {
        checkNull(property, "property");
        checkNull(object, "object");
        checkNull(subject, "subject");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDataPropertyAssertionAxiomImpl(subject, property, object,
                annotations);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            OWLLiteral object) {
        return getOWLDataPropertyAssertionAxiom(property, subject, object,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyAssertionAxiom
            getOWLDataPropertyAssertionAxiom(
                    OWLDataPropertyExpression property, OWLIndividual subject,
                    int value) {
        return getOWLDataPropertyAssertionAxiom(property, subject,
                getOWLLiteral(value), EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            double value) {
        return getOWLDataPropertyAssertionAxiom(property, subject,
                getOWLLiteral(value), EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            float value) {
        return getOWLDataPropertyAssertionAxiom(property, subject,
                getOWLLiteral(value), EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            boolean value) {
        return getOWLDataPropertyAssertionAxiom(property, subject,
                getOWLLiteral(value), EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDataPropertyAssertionAxiom getOWLDataPropertyAssertionAxiom(
            OWLDataPropertyExpression property, OWLIndividual subject,
            String value) {
        return getOWLDataPropertyAssertionAxiom(property, subject,
                getOWLLiteral(value), EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLNegativeDataPropertyAssertionAxiom
            getOWLNegativeDataPropertyAssertionAxiom(
                    OWLDataPropertyExpression property, OWLIndividual subject,
                    OWLLiteral object) {
        return getOWLNegativeDataPropertyAssertionAxiom(property, subject,
                object, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public
            OWLNegativeDataPropertyAssertionAxiom
            getOWLNegativeDataPropertyAssertionAxiom(
                    OWLDataPropertyExpression property, OWLIndividual subject,
                    OWLLiteral object, Set annotations) {
        checkNull(property, "property");
        checkNull(object, "object");
        checkNull(subject, "subject");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLNegativeDataPropertyAssertionAxiomImpl(subject, property,
                object, annotations);
    }

    @Override
    public OWLNegativeObjectPropertyAssertionAxiom
            getOWLNegativeObjectPropertyAssertionAxiom(
                    OWLObjectPropertyExpression property,
                    OWLIndividual subject, OWLIndividual object) {
        return getOWLNegativeObjectPropertyAssertionAxiom(property, subject,
                object, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLNegativeObjectPropertyAssertionAxiom
            getOWLNegativeObjectPropertyAssertionAxiom(
                    OWLObjectPropertyExpression property,
                    OWLIndividual subject, OWLIndividual object,
                    Set annotations) {
        checkNull(property, "property");
        checkNull(object, "object");
        checkNull(subject, "subject");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLNegativeObjectPropertyAssertionAxiomImpl(subject,
                property, object, annotations);
    }

    @Override
    public OWLObjectPropertyAssertionAxiom getOWLObjectPropertyAssertionAxiom(
            OWLObjectPropertyExpression property, OWLIndividual subject,
            OWLIndividual object) {
        return getOWLObjectPropertyAssertionAxiom(property, subject, object,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLClassAssertionAxiom getOWLClassAssertionAxiom(
            OWLClassExpression classExpression, OWLIndividual individual) {
        return getOWLClassAssertionAxiom(classExpression, individual,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLClassAssertionAxiom getOWLClassAssertionAxiom(
            OWLClassExpression classExpression, OWLIndividual individual,
            Set annotations) {
        checkNull(classExpression, "classExpression");
        checkNull(individual, "individual");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLClassAssertionAxiomImpl(individual, classExpression,
                annotations);
    }

    @Override
    public OWLInverseFunctionalObjectPropertyAxiom
            getOWLInverseFunctionalObjectPropertyAxiom(
                    OWLObjectPropertyExpression property) {
        return getOWLInverseFunctionalObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLInverseFunctionalObjectPropertyAxiom
            getOWLInverseFunctionalObjectPropertyAxiom(
                    OWLObjectPropertyExpression property,
                    Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLInverseFunctionalObjectPropertyAxiomImpl(property,
                annotations);
    }

    @Override
    public OWLIrreflexiveObjectPropertyAxiom
            getOWLIrreflexiveObjectPropertyAxiom(
                    OWLObjectPropertyExpression property,
                    Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLIrreflexiveObjectPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLReflexiveObjectPropertyAxiom getOWLReflexiveObjectPropertyAxiom(
            OWLObjectPropertyExpression property) {
        return getOWLReflexiveObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLIrreflexiveObjectPropertyAxiom
            getOWLIrreflexiveObjectPropertyAxiom(
                    OWLObjectPropertyExpression property) {
        return getOWLIrreflexiveObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLObjectPropertyDomainAxiom getOWLObjectPropertyDomainAxiom(
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression,
            Set annotations) {
        checkNull(property, "property");
        checkNull(classExpression, "classExpression");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLObjectPropertyDomainAxiomImpl(property, classExpression,
                annotations);
    }

    @Override
    public OWLObjectPropertyDomainAxiom getOWLObjectPropertyDomainAxiom(
            OWLObjectPropertyExpression property,
            OWLClassExpression classExpression) {
        return getOWLObjectPropertyDomainAxiom(property, classExpression,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLObjectPropertyRangeAxiom getOWLObjectPropertyRangeAxiom(
            OWLObjectPropertyExpression property, OWLClassExpression range,
            Set annotations) {
        checkNull(property, "property");
        checkNull(range, "range");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLObjectPropertyRangeAxiomImpl(property, range, annotations);
    }

    @Override
    public OWLObjectPropertyRangeAxiom getOWLObjectPropertyRangeAxiom(
            OWLObjectPropertyExpression property, OWLClassExpression range) {
        return getOWLObjectPropertyRangeAxiom(property, range,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSubObjectPropertyOfAxiom getOWLSubObjectPropertyOfAxiom(
            OWLObjectPropertyExpression subProperty,
            OWLObjectPropertyExpression superProperty,
            Set annotations) {
        checkNull(subProperty, "subProperty");
        checkNull(superProperty, "superProperty");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSubObjectPropertyOfAxiomImpl(subProperty, superProperty,
                annotations);
    }

    @Override
    public OWLSubObjectPropertyOfAxiom getOWLSubObjectPropertyOfAxiom(
            OWLObjectPropertyExpression subProperty,
            OWLObjectPropertyExpression superProperty) {
        return getOWLSubObjectPropertyOfAxiom(subProperty, superProperty,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLReflexiveObjectPropertyAxiom getOWLReflexiveObjectPropertyAxiom(
            OWLObjectPropertyExpression property,
            Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLReflexiveObjectPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLSameIndividualAxiom getOWLSameIndividualAxiom(
            Set individuals,
            Set annotations) {
        checkNull(individuals, "individuals");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSameIndividualAxiomImpl(individuals, annotations);
    }

    @Override
    public OWLSameIndividualAxiom getOWLSameIndividualAxiom(
            OWLIndividual... individuals) {
        checkNull(individuals, "individuals");
        Set inds = new HashSet();
        inds.addAll(Arrays.asList(individuals));
        return getOWLSameIndividualAxiom(inds);
    }

    @Override
    public OWLSameIndividualAxiom getOWLSameIndividualAxiom(
            Set individuals) {
        return getOWLSameIndividualAxiom(individuals, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSubClassOfAxiom getOWLSubClassOfAxiom(
            OWLClassExpression subClass, OWLClassExpression superClass,
            Set annotations) {
        checkNull(subClass, "subclass");
        checkNull(superClass, "superclass");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSubClassOfAxiomImpl(subClass, superClass, annotations);
    }

    @Override
    public OWLSubClassOfAxiom getOWLSubClassOfAxiom(
            OWLClassExpression subClass, OWLClassExpression superClass) {
        return getOWLSubClassOfAxiom(subClass, superClass,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSymmetricObjectPropertyAxiom getOWLSymmetricObjectPropertyAxiom(
            OWLObjectPropertyExpression property,
            Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSymmetricObjectPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLSymmetricObjectPropertyAxiom getOWLSymmetricObjectPropertyAxiom(
            OWLObjectPropertyExpression property) {
        return getOWLSymmetricObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLTransitiveObjectPropertyAxiom
            getOWLTransitiveObjectPropertyAxiom(
                    OWLObjectPropertyExpression property,
                    Set annotations) {
        checkNull(property, "property");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLTransitiveObjectPropertyAxiomImpl(property, annotations);
    }

    @Override
    public OWLTransitiveObjectPropertyAxiom
            getOWLTransitiveObjectPropertyAxiom(
                    OWLObjectPropertyExpression property) {
        return getOWLTransitiveObjectPropertyAxiom(property,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLObjectInverseOf getOWLObjectInverseOf(
            OWLObjectPropertyExpression property) {
        checkNull(property, "property");
        return new OWLObjectInverseOfImpl(property);
    }

    @Override
    public OWLInverseObjectPropertiesAxiom getOWLInverseObjectPropertiesAxiom(
            OWLObjectPropertyExpression forwardProperty,
            OWLObjectPropertyExpression inverseProperty,
            Set annotations) {
        checkNull(forwardProperty, "forwardProperty");
        checkNull(inverseProperty, "inverseProperty");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLInverseObjectPropertiesAxiomImpl(forwardProperty,
                inverseProperty, annotations);
    }

    @Override
    public OWLInverseObjectPropertiesAxiom getOWLInverseObjectPropertiesAxiom(
            OWLObjectPropertyExpression forwardProperty,
            OWLObjectPropertyExpression inverseProperty) {
        return getOWLInverseObjectPropertiesAxiom(forwardProperty,
                inverseProperty, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSubPropertyChainOfAxiom getOWLSubPropertyChainOfAxiom(
            List chain,
            OWLObjectPropertyExpression superProperty,
            Set annotations) {
        checkNull(superProperty, "superProperty");
        checkNull(chain, "chain");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSubPropertyChainAxiomImpl(chain, superProperty,
                annotations);
    }

    @Override
    public OWLSubPropertyChainOfAxiom getOWLSubPropertyChainOfAxiom(
            List chain,
            OWLObjectPropertyExpression superProperty) {
        return getOWLSubPropertyChainOfAxiom(chain, superProperty,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLHasKeyAxiom getOWLHasKeyAxiom(OWLClassExpression ce,
            Set> properties,
            Set annotations) {
        checkNull(ce, "ce");
        checkNull(properties, "properties");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLHasKeyAxiomImpl(ce, properties, annotations);
    }

    @Override
    public OWLHasKeyAxiom getOWLHasKeyAxiom(OWLClassExpression ce,
            Set> properties) {
        return getOWLHasKeyAxiom(ce, properties, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLHasKeyAxiom getOWLHasKeyAxiom(OWLClassExpression ce,
            OWLPropertyExpression... properties) {
        checkNull(ce, "ce");
        checkNull(properties, "properties");
        return getOWLHasKeyAxiom(ce, CollectionFactory.createSet(properties));
    }

    @Override
    public OWLDisjointUnionAxiom getOWLDisjointUnionAxiom(OWLClass owlClass,
            Set classExpressions,
            Set annotations) {
        checkNull(owlClass, "owlClass");
        checkNull(classExpressions, "classExpressions");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDisjointUnionAxiomImpl(owlClass, classExpressions,
                annotations);
    }

    @Override
    public OWLDisjointUnionAxiom getOWLDisjointUnionAxiom(OWLClass owlClass,
            Set classExpressions) {
        return getOWLDisjointUnionAxiom(owlClass, classExpressions,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLEquivalentObjectPropertiesAxiom
            getOWLEquivalentObjectPropertiesAxiom(
                    Set properties,
                    Set annotations) {
        checkNull(properties, "properties");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLEquivalentObjectPropertiesAxiomImpl(properties,
                annotations);
    }

    @Override
    public OWLObjectPropertyAssertionAxiom getOWLObjectPropertyAssertionAxiom(
            OWLObjectPropertyExpression property, OWLIndividual individual,
            OWLIndividual object, Set annotations) {
        checkNull(property, "property");
        checkNull(individual, "individual");
        checkNull(object, "object");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLObjectPropertyAssertionAxiomImpl(individual, property,
                object, annotations);
    }

    @Override
    public OWLSubAnnotationPropertyOfAxiom getOWLSubAnnotationPropertyOfAxiom(
            OWLAnnotationProperty sub, OWLAnnotationProperty sup) {
        return getOWLSubAnnotationPropertyOfAxiom(sub, sup,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLSubAnnotationPropertyOfAxiom getOWLSubAnnotationPropertyOfAxiom(
            OWLAnnotationProperty sub, OWLAnnotationProperty sup,
            Set annotations) {
        checkNull(sub, "sub");
        checkNull(sup, "sup");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLSubAnnotationPropertyOfAxiomImpl(sub, sup, annotations);
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Annotations
    @Override
    public OWLAnnotationProperty getOWLAnnotationProperty(IRI iri) {
        checkNull(iri, IRI2);
        return data.getOWLAnnotationProperty(iri);
    }

    @Override
    public OWLAnnotation getOWLAnnotation(OWLAnnotationProperty property,
            OWLAnnotationValue value) {
        return getOWLAnnotation(property, value, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLAnnotation getOWLAnnotation(OWLAnnotationProperty property,
            OWLAnnotationValue value, Set annotations) {
        checkNull(property, "property");
        checkNull(value, VALUE2);
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLAnnotationImpl(property, value, annotations);
    }

    @Override
    public OWLAnnotationAssertionAxiom getOWLAnnotationAssertionAxiom(
            OWLAnnotationSubject subject, OWLAnnotation annotation) {
        // PATCH: return
        // getOWLAnnotationAssertionAxiom(annotation.getProperty(), subject,
        // annotation.getValue(), annotation.getAnnotations());
        // ORIG: return getOWLAnnotationAssertionAxiom(annotation.getProperty(),
        // subject, annotation.getValue());
        // The patch makes a difference for the owl, owlfs, rdfxml and turtle
        // serializations of Annotation2.
        checkNull(annotation, "annotation");
        return getOWLAnnotationAssertionAxiom(annotation.getProperty(),
                subject, annotation.getValue(), annotation.getAnnotations());
    }

    @Override
    public OWLAnnotationAssertionAxiom getOWLAnnotationAssertionAxiom(
            OWLAnnotationSubject subject, OWLAnnotation annotation,
            Set annotations) {
        checkNull(annotation, "annotation");
        return getOWLAnnotationAssertionAxiom(annotation.getProperty(),
                subject, annotation.getValue(), annotations);
    }

    @Override
    public OWLAnnotationAssertionAxiom getOWLAnnotationAssertionAxiom(
            OWLAnnotationProperty property, OWLAnnotationSubject subject,
            OWLAnnotationValue value) {
        return getOWLAnnotationAssertionAxiom(property, subject, value,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLAnnotationAssertionAxiom getOWLAnnotationAssertionAxiom(
            OWLAnnotationProperty property, OWLAnnotationSubject subject,
            OWLAnnotationValue value, Set annotations) {
        checkNull(subject, "subject");
        checkNull(property, "property");
        checkNull(value, VALUE2);
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLAnnotationAssertionAxiomImpl(subject, property, value,
                annotations);
    }

    @Override
    public OWLAnnotationAssertionAxiom
            getDeprecatedOWLAnnotationAssertionAxiom(IRI subject) {
        checkNull(subject, "subject");
        return getOWLAnnotationAssertionAxiom(getOWLDeprecated(), subject,
                getOWLLiteral(true));
    }

    @Override
    public OWLAnnotationPropertyDomainAxiom
            getOWLAnnotationPropertyDomainAxiom(OWLAnnotationProperty prop,
                    IRI domain, Set annotations) {
        checkNull(prop, "prop");
        checkNull(domain, "domain");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLAnnotationPropertyDomainAxiomImpl(prop, domain,
                annotations);
    }

    @Override
    public OWLAnnotationPropertyDomainAxiom
            getOWLAnnotationPropertyDomainAxiom(OWLAnnotationProperty prop,
                    IRI domain) {
        return getOWLAnnotationPropertyDomainAxiom(prop, domain,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLAnnotationPropertyRangeAxiom getOWLAnnotationPropertyRangeAxiom(
            OWLAnnotationProperty prop, IRI range,
            Set annotations) {
        checkNull(prop, "prop");
        checkNull(range, "range");
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLAnnotationPropertyRangeAxiomImpl(prop, range, annotations);
    }

    @Override
    public OWLAnnotationPropertyRangeAxiom getOWLAnnotationPropertyRangeAxiom(
            OWLAnnotationProperty prop, IRI range) {
        return getOWLAnnotationPropertyRangeAxiom(prop, range,
                EMPTY_ANNOTATIONS_SET);
    }

    // ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    //
    // SWRL
    //
    // ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /**
     * @deprecated Use either
     *             {@link #getSWRLRule(java.util.Set, java.util.Set, java.util.Set)}
     *             or {@link #getSWRLRule(java.util.Set, java.util.Set)}
     *             instead. Gets a SWRL rule which is named with a URI
     */
    @Override
    @Deprecated
    public SWRLRule getSWRLRule(IRI iri, Set body,
            Set head) {
        checkNull(iri, "iri");
        checkNull(body, "body");
        checkNull(head, "head");
        Set annos = new HashSet(2);
        annos.add(getOWLAnnotation(getOWLAnnotationProperty(IRI.create(
                "http://www.semanticweb.org/owlapi#", "iri")),
                getOWLLiteral(iri.toQuotedString())));
        return new SWRLRuleImpl(body, head, annos);
    }

    /**
     * @deprecated Use either
     *             {@link #getSWRLRule(java.util.Set, java.util.Set, java.util.Set)}
     *             or {@link #getSWRLRule(java.util.Set, java.util.Set)}
     *             instead.
     */
    @Override
    @Deprecated
    public SWRLRule getSWRLRule(NodeID nodeID, Set body,
            Set head) {
        checkNull(head, "head");
        checkNull(body, "body");
        checkNull(nodeID, "nodeID");
        Set annos = new HashSet(2);
        annos.add(getOWLAnnotation(getOWLAnnotationProperty(IRI.create(
                "http://www.semanticweb.org/owlapi#", "nodeID")),
                getOWLLiteral(nodeID.toString())));
        return new SWRLRuleImpl(body, head, annos);
    }

    @Override
    public SWRLRule getSWRLRule(Set body,
            Set head, Set annotations) {
        checkNull(body, "body");
        checkNull(head, "head");
        checkNull(annotations, ANNOTATIONS, true);
        return new SWRLRuleImpl(body, head, annotations);
    }

    @Override
    public SWRLRule getSWRLRule(Set antecedent,
            Set consequent) {
        checkNull(antecedent, "antecedent");
        checkNull(consequent, "consequent");
        return new SWRLRuleImpl(antecedent, consequent, EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public SWRLClassAtom getSWRLClassAtom(OWLClassExpression predicate,
            SWRLIArgument arg) {
        checkNull(predicate, "predicate");
        checkNull(arg, "arg");
        return new SWRLClassAtomImpl(predicate, arg);
    }

    @Override
    public SWRLDataRangeAtom getSWRLDataRangeAtom(OWLDataRange predicate,
            SWRLDArgument arg) {
        checkNull(predicate, "predicate");
        checkNull(arg, "arg");
        return new SWRLDataRangeAtomImpl(predicate, arg);
    }

    @Override
    public SWRLObjectPropertyAtom getSWRLObjectPropertyAtom(
            OWLObjectPropertyExpression property, SWRLIArgument arg0,
            SWRLIArgument arg1) {
        checkNull(property, "property");
        checkNull(arg0, "arg0");
        checkNull(arg1, "arg1");
        return new SWRLObjectPropertyAtomImpl(property, arg0, arg1);
    }

    @Override
    public SWRLDataPropertyAtom getSWRLDataPropertyAtom(
            OWLDataPropertyExpression property, SWRLIArgument arg0,
            SWRLDArgument arg1) {
        checkNull(property, "property");
        checkNull(arg0, "arg0");
        checkNull(arg1, "arg1");
        return new SWRLDataPropertyAtomImpl(property, arg0, arg1);
    }

    @Override
    public SWRLBuiltInAtom getSWRLBuiltInAtom(IRI builtInIRI,
            List args) {
        checkNull(builtInIRI, "builtInIRI");
        checkNull(args, "args");
        return new SWRLBuiltInAtomImpl(builtInIRI, args);
    }

    @Override
    public SWRLVariable getSWRLVariable(IRI var) {
        checkNull(var, "var");
        return new SWRLVariableImpl(var);
    }

    @Override
    public SWRLIndividualArgument getSWRLIndividualArgument(
            OWLIndividual individual) {
        checkNull(individual, "individual");
        return new SWRLIndividualArgumentImpl(individual);
    }

    @Override
    public SWRLLiteralArgument getSWRLLiteralArgument(OWLLiteral literal) {
        checkNull(literal, "literal");
        return new SWRLLiteralArgumentImpl(literal);
    }

    @Override
    public SWRLDifferentIndividualsAtom getSWRLDifferentIndividualsAtom(
            SWRLIArgument arg0, SWRLIArgument arg1) {
        checkNull(arg0, "arg0");
        checkNull(arg1, "arg1");
        return new SWRLDifferentIndividualsAtomImpl(this, arg0, arg1);
    }

    @Override
    public SWRLSameIndividualAtom getSWRLSameIndividualAtom(SWRLIArgument arg0,
            SWRLIArgument arg1) {
        checkNull(arg0, "arg0");
        checkNull(arg1, "arg1");
        return new SWRLSameIndividualAtomImpl(this, arg0, arg1);
    }

    private static final Set EMPTY_ANNOTATIONS_SET = Collections
            .emptySet();

    @Override
    public OWLDatatypeDefinitionAxiom getOWLDatatypeDefinitionAxiom(
            OWLDatatype datatype, OWLDataRange dataRange) {
        checkNull(datatype, DATATYPE2);
        checkNull(dataRange, DATA_RANGE);
        return getOWLDatatypeDefinitionAxiom(datatype, dataRange,
                EMPTY_ANNOTATIONS_SET);
    }

    @Override
    public OWLDatatypeDefinitionAxiom getOWLDatatypeDefinitionAxiom(
            OWLDatatype datatype, OWLDataRange dataRange,
            Set annotations) {
        checkNull(datatype, DATATYPE2);
        checkNull(dataRange, DATA_RANGE);
        checkNull(annotations, ANNOTATIONS, true);
        return new OWLDatatypeDefinitionAxiomImpl(datatype, dataRange,
                annotations);
    }

    @Override
    public OWLLiteral getOWLLiteral(String lexicalValue, OWLDatatype datatype) {
        checkNull(lexicalValue, "lexicalValue");
        checkNull(datatype, DATATYPE2);
        return data.getOWLLiteral(lexicalValue, datatype);
    }

    @Override
    public OWLLiteral getOWLLiteral(int value) {
        return data.getOWLLiteral(value);
    }

    @Override
    public OWLLiteral getOWLLiteral(double value) {
        return data.getOWLLiteral(value);
    }

    @Override
    public OWLLiteral getOWLLiteral(float value) {
        return data.getOWLLiteral(value);
    }

    @Override
    public OWLLiteral getOWLLiteral(String value) {
        checkNull(value, "value");
        return data.getOWLLiteral(value);
    }

    @Override
    public OWLLiteral getOWLLiteral(String literal, String lang) {
        checkNull(literal, LITERAL2);
        return data.getOWLLiteral(literal, lang);
    }

    @Override
    public OWLDatatype getBooleanOWLDatatype() {
        return data.getBooleanOWLDatatype();
    }

    @Override
    public OWLDatatype getDoubleOWLDatatype() {
        return data.getDoubleOWLDatatype();
    }

    @Override
    public OWLDatatype getFloatOWLDatatype() {
        return data.getFloatOWLDatatype();
    }

    @Override
    public OWLDatatype getIntegerOWLDatatype() {
        return data.getIntegerOWLDatatype();
    }

    @Override
    public OWLDatatype getTopDatatype() {
        return data.getTopDatatype();
    }

    @Override
    public OWLDatatype getRDFPlainLiteral() {
        return data.getRDFPlainLiteral();
    }
}