* 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.

*/

* Author: Matthew Horridge<br>

* The University Of Manchester<br>

* Bio-Health Informatics Group<br>

* Date: 07-Dec-2006<br><br>

* A parser/interpreter for an RDF graph which represents an OWL ontology.  The

* consumer interprets triple patterns in the graph to produce the appropriate

* OWLAPI entities, class expressions and axioms.

* The parser is based on triple handlers.  A given triple handler handles a specific

* type of triple.  Generally speaking this is based on the predicate of a triple, for

* example, A rdfs:subClassOf B is handled by a subClassOf handler.  A handler determines

* if it can handle a triple in a streaming mode (i.e. while parsing is taking place) or

* if it can handle a triple after parsing has taken place and the complete graph is in

* memory.  Once a handler handles a triple, that triple is deemed to have been consumed

* an is discarded.

* The parser attempts to consume as many triples as possible while streaming parsing

* is taking place. Whether or not a triple can be consumed dIRIng parsing is determined

* by installed triple handlers.

*/

    public static final Logger logger = Logger.getLogger(OWLRDFConsumer.class.getName());

    private static final Logger tripleProcessor = Logger.getLogger("Triple processor");

    private OWLOntologyLoaderConfiguration configuration;

    //private Graph graph;

    private OWLOntologyManager owlOntologyManager;

    // A call back interface, which is used to check whether a node

    // is anonymous or not.

    private AnonymousNodeChecker anonymousNodeChecker;

    // The set of IRIs that are either explicitly typed

    // an an owl:Class, or are inferred to be an owl:Class

    // because they are used in some triple whose predicate

    // has the domain or range of owl:Class

    private Set<IRI> classExpressionIRIs;

    // Same as classExpressionIRIs but for object properties

    private Set<IRI> objectPropertyExpressionIRIs;

    // Same as classExpressionIRIs but for data properties

    private Set<IRI> dataPropertyExpressionIRIs;

    // Same as classExpressionIRIs but for rdf properties

    // Same as classExpressionIRIs but for rdf properties

    // things neither typed as a data or object property - bad!

    private Set<IRI> propertyIRIs;

    // Set of IRIs that are typed by non-system types and

    // also owl:Thing

    private Set<IRI> individualIRIs;

    // Same as classExpressionIRIs but for annotation properties

    private Set<IRI> annotationPropertyIRIs;

    private Set<IRI> annotationIRIs;

    // IRIs that had a type triple to rdfs:Datatange

    private Set<IRI> dataRangeIRIs;

    // The IRI of the first reource that is typed as an ontology

    private IRI firstOntologyIRI;

    // IRIs that had a type triple to owl:Ontology

    private Set<IRI> ontologyIRIs;

    // IRIs that had a type triple to owl:Restriction

    private Set<IRI> restrictionIRIs;

//    private Set<IRI> listIRIs;

    // Maps rdf:next triple subjects to objects

    private Map<IRI, IRI> listRestTripleMap;

    private Map<IRI, IRI> listFirstResourceTripleMap;

    private Map<IRI, OWLLiteral> listFirstLiteralTripleMap;

    private Set<IRI> axioms = new HashSet<IRI>();

    private Map<IRI, Object> sharedAnonymousNodes = new HashMap<IRI, Object>();

    // A translator for lists of class expressions (such lists are used

    // in intersections, unions etc.)

    private OptimisedListTranslator<OWLClassExpression> classExpressionListTranslator;

    // A translator for individual lists (such lists are used in

    // object oneOf constructs)

    private OptimisedListTranslator<OWLIndividual> individualListTranslator;

    private OptimisedListTranslator<OWLObjectPropertyExpression> objectPropertyListTranslator;

    private OptimisedListTranslator<OWLLiteral> constantListTranslator;

    private OptimisedListTranslator<OWLDataPropertyExpression> dataPropertyListTranslator;

    private OptimisedListTranslator<OWLDataRange> dataRangeListTranslator;

    private OptimisedListTranslator<OWLFacetRestriction> faceRestrictionListTranslator;

    // Handlers for built in types

    private Map<IRI, BuiltInTypeHandler> builtInTypeTripleHandlers;

    // Handler for triples that denote nodes which represent axioms.

    // i.e.

    // owl:AllDisjointClasses

    // owl:AllDisjointProperties

    // owl:AllDifferent

    // owl:NegativePropertyAssertion

    // owl:Axiom

    // These need to be handled separately from other types, because the base triples for annotated

    // axioms should be in the ontology before annotations on the annotated versions of these axioms are parsed.

    private Map<IRI, BuiltInTypeHandler> axiomTypeTripleHandlers = new HashMap<IRI, BuiltInTypeHandler>();

    // Handlers for build in predicates

    private Map<IRI, TriplePredicateHandler> predicateHandlers;

    // Handlers for general literal triples (i.e. triples which

    // have predicates that are not part of the built in OWL/RDFS/RDF

    // vocabulary.  Such triples either constitute annotationIRIs of

    // relationships between an individual and a data literal (typed or

    // untyped)

    private List<AbstractLiteralTripleHandler> literalTripleHandlers;

    // Handlers for general resource triples (i.e. triples which

    // have predicates that are not part of the built in OWL/RDFS/RDF

    // vocabulary.  Such triples either constitute annotationIRIs or

    // relationships between an individual and another individual.

    private List<AbstractResourceTripleHandler> resourceTripleHandlers;

    private Set<OWLAnnotation> pendingAnnotations = new HashSet<OWLAnnotation>();

    private Map<IRI, Set<IRI>> annotatedAnonSource2AnnotationMap = new HashMap<IRI, Set<IRI>>();

    /**

     * The ontology that the RDF will be parsed into

     */

    private OWLOntology ontology;

    private RDFXMLOntologyFormat ontologyFormat;

    private OWLDataFactory dataFactory;

//

//    private List<ClassExpressionTranslator> dataRestrictionTranslators = new ArrayList<ClassExpressionTranslator>();

    private List<ClassExpressionTranslator> classExpressionTranslators = new ArrayList<ClassExpressionTranslator>();

    private OWLAxiom lastAddedAxiom;

    private Map<IRI, IRI> synonymMap;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    // SWRL Stuff

    private Set<IRI> swrlRules;

    private Set<IRI> swrlIndividualPropertyAtoms;

    private Set<IRI> swrlDataValuedPropertyAtoms;

    private Set<IRI> swrlClassAtoms;

    private Set<IRI> swrlDataRangeAtoms;

    private Set<IRI> swrlBuiltInAtoms;

    private Set<IRI> swrlVariables;

    private Set<IRI> swrlSameAsAtoms;

    private Set<IRI> swrlDifferentFromAtoms;

    private IRIProvider iriProvider;

    private TPInverseOfHandler inverseOfHandler;

    private TPTypeHandler nonBuiltInTypeHandler;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////

    private boolean parsedAllTriples = false;

    public OWLRDFConsumer(OWLOntology ontology, AnonymousNodeChecker checker, OWLOntologyLoaderConfiguration configuration) {

        this.owlOntologyManager = ontology.getOWLOntologyManager();

        this.ontology = ontology;

        this.dataFactory = owlOntologyManager.getOWLDataFactory();

        this.anonymousNodeChecker = checker;

        this.configuration = configuration;

        classExpressionTranslators.add(new NamedClassTranslator(this));

        classExpressionTranslators.add(new ObjectIntersectionOfTranslator(this));

        classExpressionTranslators.add(new ObjectUnionOfTranslator(this));

        classExpressionTranslators.add(new ObjectComplementOfTranslator(this));

        classExpressionTranslators.add(new ObjectOneOfTranslator(this));

        classExpressionTranslators.add(new ObjectSomeValuesFromTranslator(this));

        classExpressionTranslators.add(new ObjectAllValuesFromTranslator(this));

        classExpressionTranslators.add(new ObjectHasValueTranslator(this));

        classExpressionTranslators.add(new ObjectHasSelfTranslator(this));

        classExpressionTranslators.add(new ObjectMinQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new ObjectMaxQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new ObjectQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new ObjectMinCardinalityTranslator(this));

        classExpressionTranslators.add(new ObjectMaxCardinalityTranslator(this));

        classExpressionTranslators.add(new ObjectCardinalityTranslator(this));

        classExpressionTranslators.add(new DataSomeValuesFromTranslator(this));

        classExpressionTranslators.add(new DataAllValuesFromTranslator(this));

        classExpressionTranslators.add(new DataHasValueTranslator(this));

        classExpressionTranslators.add(new DataMinQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new DataMaxQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new DataQualifiedCardinalityTranslator(this));

        classExpressionTranslators.add(new DataMinCardinalityTranslator(this));

        classExpressionTranslators.add(new DataMaxCardinalityTranslator(this));

        classExpressionTranslators.add(new DataCardinalityTranslator(this));

        classExpressionIRIs = CollectionFactory.createSet();

        objectPropertyExpressionIRIs = CollectionFactory.createSet();

        dataPropertyExpressionIRIs = CollectionFactory.createSet();

        individualIRIs = CollectionFactory.createSet();

        annotationPropertyIRIs = CollectionFactory.createSet();

        for (IRI iri : OWLRDFVocabulary.BUILT_IN_ANNOTATION_PROPERTY_IRIS) {

            annotationPropertyIRIs.add(iri);

        }

        annotationIRIs = new HashSet<IRI>();

//        annotationsBySubject = new HashMap<IRI, Set<OWLAnnotation>>();

        dataRangeIRIs = CollectionFactory.createSet();

        propertyIRIs = CollectionFactory.createSet();

        restrictionIRIs = CollectionFactory.createSet();

        ontologyIRIs = CollectionFactory.createSet();

        listFirstLiteralTripleMap = CollectionFactory.createMap();

        listFirstResourceTripleMap = CollectionFactory.createMap();

        listRestTripleMap = CollectionFactory.createMap();

        classExpressionListTranslator = new OptimisedListTranslator<OWLClassExpression>(this, new ClassExpressionListItemTranslator(this));

        individualListTranslator = new OptimisedListTranslator<OWLIndividual>(this, new IndividualListItemTranslator(this));

        constantListTranslator = new OptimisedListTranslator<OWLLiteral>(this, new TypedConstantListItemTranslator(this));

        objectPropertyListTranslator = new OptimisedListTranslator<OWLObjectPropertyExpression>(this, new ObjectPropertyListItemTranslator(this));

        dataPropertyListTranslator = new OptimisedListTranslator<OWLDataPropertyExpression>(this, new DataPropertyListItemTranslator(this));

        dataRangeListTranslator = new OptimisedListTranslator<OWLDataRange>(this, new DataRangeListItemTranslator(this));

        faceRestrictionListTranslator = new OptimisedListTranslator<OWLFacetRestriction>(this, new OWLFacetRestrictionListItemTranslator(this));

        builtInTypeTripleHandlers = CollectionFactory.createMap();

        setupTypeTripleHandlers();

        setupPredicateHandlers();

        // General literal triples - i.e. triples which have a predicate

        // that is not a built in IRI.  Annotation properties get precedence

        // over data properties, so that if we have the statement a:A a:foo a:B and a:foo

        // is typed as both an annotation and data property then the statement will be

        // translated as an annotation on a:A

        literalTripleHandlers = new ArrayList<AbstractLiteralTripleHandler>();

        literalTripleHandlers.add(new GTPDataPropertyAssertionHandler(this));

        literalTripleHandlers.add(new TPFirstLiteralHandler(this));

        literalTripleHandlers.add(new GTPAnnotationLiteralHandler(this));

        // General resource/object triples - i.e. triples which have a predicate

        // that is not a built in IRI.  Annotation properties get precedence

        // over object properties, so that if we have the statement a:A a:foo a:B and a:foo

        // is typed as both an annotation and data property then the statement will be

        // translated as an annotation on a:A

        resourceTripleHandlers = new ArrayList<AbstractResourceTripleHandler>();

        resourceTripleHandlers.add(new GTPObjectPropertyAssertionHandler(this));

        resourceTripleHandlers.add(new GTPAnnotationResourceTripleHandler(this));

        for (OWL2Datatype dt : OWL2Datatype.values()) {

            dataRangeIRIs.add(dt.getIRI());

        }

        dataRangeIRIs.add(OWLRDFVocabulary.RDFS_LITERAL.getIRI());

        if(!configuration.isStrict()) {

            for(XSDVocabulary vocabulary : XSDVocabulary.values()) {

                dataRangeIRIs.add(vocabulary.getIRI());

            }

        }

        swrlRules = new HashSet<IRI>();

        swrlIndividualPropertyAtoms = new HashSet<IRI>();

        swrlDataValuedPropertyAtoms = new HashSet<IRI>();

        swrlClassAtoms = new HashSet<IRI>();

        swrlDataRangeAtoms = new HashSet<IRI>();

        swrlBuiltInAtoms = new HashSet<IRI>();

        swrlVariables = new HashSet<IRI>();

        swrlSameAsAtoms = new HashSet<IRI>();

        swrlDifferentFromAtoms = new HashSet<IRI>();

        classExpressionIRIs.add(OWLRDFVocabulary.OWL_THING.getIRI());

        classExpressionIRIs.add(OWLRDFVocabulary.OWL_NOTHING.getIRI());

        objectPropertyExpressionIRIs.add(OWLRDFVocabulary.OWL_TOP_OBJECT_PROPERTY.getIRI());

        objectPropertyExpressionIRIs.add(OWLRDFVocabulary.OWL_BOTTOM_OBJECT_PROPERTY.getIRI());

        dataPropertyExpressionIRIs.add(OWLRDFVocabulary.OWL_TOP_DATA_PROPERTY.getIRI());

        dataPropertyExpressionIRIs.add(OWLRDFVocabulary.OWL_BOTTOM_DATA_PROPERTY.getIRI());

        setupSynonymMap();

        setupSinglePredicateMaps();

        // Cache anything in the existing imports closure

        importsClosureChanged();

    }

    @Deprecated

    public OWLRDFConsumer(OWLOntologyManager owlOntologyManager, OWLOntology ontology, AnonymousNodeChecker checker, OWLOntologyLoaderConfiguration configuration) {

        this(ontology, checker, configuration);

    }

    public void setIRIProvider(IRIProvider iriProvider) {

        this.iriProvider = iriProvider;

    }

    private void addSingleValuedResPredicate(OWLRDFVocabulary v) {

        Map<IRI, IRI> map = CollectionFactory.createMap();

        singleValuedResTriplesByPredicate.put(v.getIRI(), map);

    }

    private void setupSinglePredicateMaps() {

        addSingleValuedResPredicate(OWL_ON_PROPERTY);

        addSingleValuedResPredicate(OWL_SOME_VALUES_FROM);

        addSingleValuedResPredicate(OWL_ALL_VALUES_FROM);

        addSingleValuedResPredicate(OWL_ON_CLASS);

        addSingleValuedResPredicate(OWL_ON_DATA_RANGE);

    }

    private void setupSynonymMap() {

        // We can load legacy ontologies by providing synonyms for built in vocabulary

        // where the vocabulary has simply changed (e.g. DAML+OIL -> OWL)

        synonymMap = CollectionFactory.createMap();

        // Legacy protege-owlapi representation of QCRs

        synonymMap.put(IRI.create(Namespaces.OWL + "valuesFrom"), OWL_ON_CLASS.getIRI());

        if (!configuration.isStrict()) {

            addDAMLOILVocabulary();

            addIntermediateOWLSpecVocabulary();

        }

    }

    private void addDAMLOILVocabulary() {

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#subClassOf"), RDFS_SUBCLASS_OF.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#imports"), OWL_IMPORTS.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#range"), RDFS_RANGE.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#hasValue"), OWL_HAS_VALUE.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#type"), RDF_TYPE.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#domain"), RDFS_DOMAIN.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#versionInfo"), OWL_VERSION_INFO.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#comment"), RDFS_COMMENT.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#onProperty"), OWL_ON_PROPERTY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#toClass"), OWL_ALL_VALUES_FROM.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#hasClass"), OWL_SOME_VALUES_FROM.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#Restriction"), OWL_RESTRICTION.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#Class"), OWL_CLASS.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#Thing"), OWL_THING.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#Nothing"), OWL_NOTHING.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#minCardinality"), OWL_MIN_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#cardinality"), OWL_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#maxCardinality"), OWL_MAX_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#inverseOf"), OWL_INVERSE_OF.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#samePropertyAs"), OWL_EQUIVALENT_PROPERTY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#hasClassQ"), OWL_ON_CLASS.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#cardinalityQ"), OWL_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#maxCardinalityQ"), OWL_MAX_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#minCardinalityQ"), OWL_MIN_CARDINALITY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#complementOf"), OWL_COMPLEMENT_OF.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#unionOf"), OWL_UNION_OF.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#intersectionOf"), OWL_INTERSECTION_OF.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#label"), RDFS_LABEL.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#ObjectProperty"), OWL_OBJECT_PROPERTY.getIRI());

        synonymMap.put(IRI.create("http://www.daml.org/2001/03/daml+oil#DatatypeProperty"), OWL_DATA_PROPERTY.getIRI());

    }

    /**

     * There may be some ontologies floating about that use early versions

     * of the OWL 1.1 vocabulary.  We can map early versions of the vocabulary

     * to the current OWL 1.1 vocabulary.

     */

    @SuppressWarnings("deprecation")

    private void addIntermediateOWLSpecVocabulary() {

        for (OWLRDFVocabulary v : OWLRDFVocabulary.values()) {

            addLegacyMapping(v);

        }

        for (OWLFacet v : OWLFacet.values()) {

            synonymMap.put(IRI.create(Namespaces.OWL.toString() + v.getShortName()), v.getIRI());

            synonymMap.put(IRI.create(Namespaces.OWL11.toString() + v.getShortName()), v.getIRI());

            synonymMap.put(IRI.create(Namespaces.OWL2.toString() + v.getShortName()), v.getIRI());

        }

        for (OWLFacet v : OWLFacet.values()) {

            synonymMap.put(IRI.create(Namespaces.OWL2.toString() + v.getShortName()), v.getIRI());

        }

        synonymMap.put(OWLRDFVocabulary.OWL_NEGATIVE_DATA_PROPERTY_ASSERTION.getIRI(), OWLRDFVocabulary.OWL_NEGATIVE_PROPERTY_ASSERTION.getIRI());

        synonymMap.put(OWLRDFVocabulary.OWL_NEGATIVE_OBJECT_PROPERTY_ASSERTION.getIRI(), OWLRDFVocabulary.OWL_NEGATIVE_PROPERTY_ASSERTION.getIRI());

        // Intermediate OWL 2 spec

        synonymMap.put(OWL_SUBJECT.getIRI(), OWL_ANNOTATED_SOURCE.getIRI());

        synonymMap.put(OWL_PREDICATE.getIRI(), OWL_ANNOTATED_PROPERTY.getIRI());

        synonymMap.put(OWL_OBJECT.getIRI(), OWL_ANNOTATED_TARGET.getIRI());

        // Preliminary OWL 1.1 Vocab

        synonymMap.put(IRI.create(Namespaces.OWL + "cardinalityType"), OWL_ON_CLASS.getIRI());

        synonymMap.put(IRI.create(Namespaces.OWL + "dataComplementOf"), OWL_COMPLEMENT_OF.getIRI());

        synonymMap.put(OWL_ANTI_SYMMETRIC_PROPERTY.getIRI(), OWL_ASYMMETRIC_PROPERTY.getIRI());

        synonymMap.put(OWL_FUNCTIONAL_DATA_PROPERTY.getIRI(), OWL_FUNCTIONAL_PROPERTY.getIRI());

        synonymMap.put(OWL_FUNCTIONAL_OBJECT_PROPERTY.getIRI(), OWL_FUNCTIONAL_PROPERTY.getIRI());

        synonymMap.put(OWL_SUB_DATA_PROPERTY_OF.getIRI(), RDFS_SUB_PROPERTY_OF.getIRI());

        synonymMap.put(OWL_SUB_OBJECT_PROPERTY_OF.getIRI(), RDFS_SUB_PROPERTY_OF.getIRI());

        synonymMap.put(OWL_OBJECT_PROPERTY_RANGE.getIRI(), RDFS_RANGE.getIRI());

        synonymMap.put(OWL_DATA_PROPERTY_RANGE.getIRI(), RDFS_RANGE.getIRI());

        synonymMap.put(OWL_OBJECT_PROPERTY_DOMAIN.getIRI(), RDFS_DOMAIN.getIRI());

        synonymMap.put(OWL_DATA_PROPERTY_DOMAIN.getIRI(), RDFS_DOMAIN.getIRI());

        synonymMap.put(OWL_DISJOINT_DATA_PROPERTIES.getIRI(), OWL_PROPERTY_DISJOINT_WITH.getIRI());

        synonymMap.put(OWL_DISJOINT_OBJECT_PROPERTIES.getIRI(), OWL_PROPERTY_DISJOINT_WITH.getIRI());

        synonymMap.put(OWL_EQUIVALENT_DATA_PROPERTIES.getIRI(), OWL_EQUIVALENT_PROPERTY.getIRI());

        synonymMap.put(OWL_EQUIVALENT_OBJECT_PROPERTIES.getIRI(), OWL_EQUIVALENT_PROPERTY.getIRI());

        synonymMap.put(OWL_OBJECT_RESTRICTION.getIRI(), OWL_RESTRICTION.getIRI());

        synonymMap.put(OWL_DATA_RESTRICTION.getIRI(), OWL_RESTRICTION.getIRI());

        synonymMap.put(OWL_DATA_RANGE.getIRI(), RDFS_DATATYPE.getIRI());

        synonymMap.put(OWL_SUBJECT.getIRI(), OWL_ANNOTATED_SOURCE.getIRI());

        synonymMap.put(OWL_PREDICATE.getIRI(), OWL_ANNOTATED_PROPERTY.getIRI());

        synonymMap.put(OWL_OBJECT.getIRI(), OWL_ANNOTATED_TARGET.getIRI());

    }

    private void addLegacyMapping(OWLRDFVocabulary v) {

        // Map OWL11 to OWL

        // Map OWL2 to OWL

        synonymMap.put(IRI.create(Namespaces.OWL2.toString() + v.getShortName()), v.getIRI());

        synonymMap.put(IRI.create(Namespaces.OWL11.toString() + v.getShortName()), v.getIRI());

    }

    public OWLOntology getOntology() {

        return ontology;

    }

    public RDFXMLOntologyFormat getOntologyFormat() {

        return ontologyFormat;

    }

    public void setOntologyFormat(RDFXMLOntologyFormat format) {

        this.ontologyFormat = format;

    }

    private void addBuiltInTypeTripleHandler(BuiltInTypeHandler handler) {

        builtInTypeTripleHandlers.put(handler.getTypeIRI(), handler);

    }

    private void addAxiomTypeTripleHandler(BuiltInTypeHandler handler) {

        axiomTypeTripleHandlers.put(handler.getTypeIRI(), handler);

    }

    private void setupTypeTripleHandlers() {

        setupBasicTypeHandlers();

        setupAxiomTypeHandlers();

    }

    private void setupBasicTypeHandlers() {

        addBuiltInTypeTripleHandler(new TypeOntologyPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeAsymmetricPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeClassHandler(this));

        addBuiltInTypeTripleHandler(new TypeObjectPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeDataPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeDatatypeHandler(this));

        addBuiltInTypeTripleHandler(new TypeFunctionalPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeInverseFunctionalPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeIrreflexivePropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeReflexivePropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeSymmetricPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeTransitivePropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeRestrictionHandler(this));

        addBuiltInTypeTripleHandler(new TypeListHandler(this));

        addBuiltInTypeTripleHandler(new TypeAnnotationPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeDeprecatedClassHandler(this));

        addBuiltInTypeTripleHandler(new TypeDeprecatedPropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeDataRangeHandler(this));

        addBuiltInTypeTripleHandler(new TypeOntologyHandler(this));

        addBuiltInTypeTripleHandler(new TypeNegativeDataPropertyAssertionHandler(this));

        addBuiltInTypeTripleHandler(new TypeRDFSClassHandler(this));

        addBuiltInTypeTripleHandler(new TypeSelfRestrictionHandler(this));

        addBuiltInTypeTripleHandler(new TypePropertyHandler(this));

        addBuiltInTypeTripleHandler(new TypeNamedIndividualHandler(this));

        addBuiltInTypeTripleHandler(new TypeAnnotationHandler(this));

        if (!configuration.isStrict()) {

            addBuiltInTypeTripleHandler(new TypeSWRLAtomListHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLBuiltInAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLBuiltInHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLClassAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLDataRangeAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLDataValuedPropertyAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLDifferentIndividualsAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLImpHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLIndividualPropertyAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLSameIndividualAtomHandler(this));

            addBuiltInTypeTripleHandler(new TypeSWRLVariableHandler(this));

        }

    }

    private void setupAxiomTypeHandlers() {

        addAxiomTypeTripleHandler(new TypeAxiomHandler(this));

        addAxiomTypeTripleHandler(new TypeAllDifferentHandler(this));

        addAxiomTypeTripleHandler(new TypeAllDisjointClassesHandler(this));

        addAxiomTypeTripleHandler(new TypeAllDisjointPropertiesHandler(this));

       // addAxiomTypeTripleHandler(new TypeAllDifferentHandler(this));

        addAxiomTypeTripleHandler(new TypeNegativePropertyAssertionHandler(this));

    }

    private void addPredicateHandler(TriplePredicateHandler predicateHandler) {

        predicateHandlers.put(predicateHandler.getPredicateIRI(), predicateHandler);

    }

    private void setupPredicateHandlers() {

        predicateHandlers = CollectionFactory.createMap();

        addPredicateHandler(new TPDifferentFromHandler(this));

        addPredicateHandler(new TPDisjointUnionHandler(this));

        addPredicateHandler(new TPDisjointWithHandler(this));

        addPredicateHandler(new TPEquivalentClassHandler(this));

        addPredicateHandler(new TPEquivalentPropertyHandler(this));

        addPredicateHandler(new TPPropertyDomainHandler(this));

        addPredicateHandler(new TPPropertyRangeHandler(this));

        addPredicateHandler(new TPSameAsHandler(this));

        addPredicateHandler(new TPSubClassOfHandler(this));

        addPredicateHandler(new TPSubPropertyOfHandler(this));

        nonBuiltInTypeHandler = new TPTypeHandler(this);

        addPredicateHandler(nonBuiltInTypeHandler);

        addPredicateHandler(new TPDistinctMembersHandler(this));

      //  addPredicateHandler(new TPDistinctMembersHandlerAlternateForm(this));

        addPredicateHandler(new TPImportsHandler(this));

        addPredicateHandler(new TPIntersectionOfHandler(this));

        addPredicateHandler(new TPUnionOfHandler(this));

        addPredicateHandler(new TPComplementOfHandler(this));

        addPredicateHandler(new TPOneOfHandler(this));

        addPredicateHandler(new TPSomeValuesFromHandler(this));

        addPredicateHandler(new TPAllValuesFromHandler(this));

        addPredicateHandler(new TPRestHandler(this));

        addPredicateHandler(new TPFirstResourceHandler(this));

        addPredicateHandler(new TPDeclaredAsHandler(this));

        addPredicateHandler(new TPHasKeyHandler(this));

        addPredicateHandler(new TPVersionIRIHandler(this));

        addPredicateHandler(new TPPropertyChainAxiomHandler(this));

        addPredicateHandler(new TPAnnotatedSourceHandler(this));

        addPredicateHandler(new TPAnnotatedPropertyHandler(this));

        addPredicateHandler(new TPAnnotatedTargetHandler(this));

        addPredicateHandler(new TPPropertyDisjointWithHandler(this));

        inverseOfHandler = new TPInverseOfHandler(this);

        addPredicateHandler(inverseOfHandler);

        addPredicateHandler(new TPOnPropertyHandler(this));

        addPredicateHandler(new TPOnClassHandler(this));

        addPredicateHandler(new TPOnDataRangeHandler(this));

        addPredicateHandler(new TPComplementOfHandler(this));

        addPredicateHandler(new TPDatatypeComplementOfHandler(this));

    }

    public OWLDataFactory getDataFactory() {

        return dataFactory;

    }

    // We cache IRIs to save memory!!

    private Map<String, IRI> IRIMap = CollectionFactory.createMap();

    int currentBaseCount = 0;

    /**

     * Gets any annotations that were translated since the last call of this method (calling

     * this method clears the current pending annotations)

     * @return The set (possibly empty) of pending annotations.

     */

    public Set<OWLAnnotation> getPendingAnnotations() {

        if (!pendingAnnotations.isEmpty()) {

            Set<OWLAnnotation> annos = new HashSet<OWLAnnotation>(pendingAnnotations);

            pendingAnnotations.clear();

            return annos;

        }

        else {

            return Collections.emptySet();

        }

    }

    public void setPendingAnnotations(Set<OWLAnnotation> annotations) {

        if (!pendingAnnotations.isEmpty()) {

            for(OWLAnnotation ann : pendingAnnotations) {

                System.out.println(ann);

            }

            throw new OWLRuntimeException(pendingAnnotations.size() + " pending annotations should have been used by now.");

        }

        pendingAnnotations.addAll(annotations);

    }

    private IRI getIRI(String s) {

        IRI iri = null;

        if (iriProvider != null) {

            iri = iriProvider.getIRI(s);

        }

        if (iri != null) {

            return iri;

        }

        iri = IRIMap.get(s);

        if (iri == null) {

            iri = IRI.create(s);

            IRIMap.put(s, iri);

        }

        return iri;

    }

    public void importsClosureChanged() {

        // NOTE:  This method only gets called when the ontology being parsed adds a direct import.  This is enough

        // for resolving the imports closure.

        // We cache IRIs of various entities here.

        for (OWLOntology ont : owlOntologyManager.getImportsClosure(ontology)) {