Java 类org.semanticweb.owlapi.model.OWLImportsDeclaration 实例源码

/**
 * Translate the given {@link GafDocument} into an OWL representation of the LEGO model.
 * 
 * @param gaf
 * @return lego ontology
 * @throws OWLException
 * @throws UnknownIdentifierException 
 */
public OWLOntology translate(GafDocument gaf) throws OWLException, UnknownIdentifierException {
    final OWLOntologyManager m = graph.getManager();
    OWLOntology lego = m.createOntology(IRI.generateDocumentIRI());
    OWLOntology sourceOntology = graph.getSourceOntology();
    OWLOntologyID ontologyID = sourceOntology.getOntologyID();
    if (ontologyID != null) {
        Optional<IRI> ontologyIRI = ontologyID.getOntologyIRI();
        if (ontologyIRI.isPresent()) {
            OWLDataFactory f = m.getOWLDataFactory();
            OWLImportsDeclaration importDeclaration = f.getOWLImportsDeclaration(ontologyIRI.get());
            m.applyChange(new AddImport(lego, importDeclaration ));
        }
    }
    translate(gaf.getGeneAnnotations(), lego);
    return lego;
}

public OntologyMetadata(OWLOntology ont) {
    super();
    OWLOntologyID id = ont.getOntologyID();
    if (id.getOntologyIRI().isPresent())
        ontologyIRI = id.getOntologyIRI().get().toString();
    if (id.getVersionIRI().isPresent())
        versionIRI = id.getVersionIRI().get().toString();
    importDirectives = new HashSet<String>();
    for (OWLImportsDeclaration oid : ont.getImportsDeclarations()) {
        importDirectives.add(oid.getIRI().toString());
    }
    classCount = ont.getClassesInSignature().size();
    namedIndividualCount = ont.getIndividualsInSignature().size();
    axiomCount = ont.getAxiomCount();
    annotations = new HashSet<OntologyAnnotation>();
    for (OWLAnnotation ann : ont.getAnnotations()) {
        annotations.add(new OntologyAnnotation(ann));
    }
}

public void addImportsFromSupportOntologies() {
    OWLOntology sourceOntology = getSourceOntology();
    OWLDataFactory factory = getDataFactory();
    for (OWLOntology  o : getSupportOntologySet()) {
        Optional<IRI> ontologyIRI = o.getOntologyID().getOntologyIRI();
        if (ontologyIRI.isPresent()) {
            OWLImportsDeclaration importsDeclaration = factory.getOWLImportsDeclaration(ontologyIRI.get());
            AddImport ai = new AddImport(sourceOntology, importsDeclaration);
            LOG.info("Applying: "+ai);
            getManager().applyChange(ai);
        }
        else {
            String msg = "Could not add import due to missing ontology id: "+o;
            LOG.error(msg);
            throw new RuntimeException(msg);
        }
    }
    this.setSupportOntologySet(new HashSet<OWLOntology>());
}

public void mergeImportClosure(boolean isRemovedImportsDeclarations) throws OWLOntologyCreationException {
    OWLOntologyManager manager = getManager();
    Set<OWLOntology> imports = sourceOntology.getImportsClosure();
    for (OWLOntology o : imports) {
        if (o.equals(sourceOntology))
            continue;

        String comment = "Includes "+summarizeOntology(o);
        LOG.info(comment);
        addCommentToOntology(sourceOntology, comment);

        manager.addAxioms(sourceOntology, o.getAxioms());
    }
    Set<OWLImportsDeclaration> oids = sourceOntology.getImportsDeclarations();
    for (OWLImportsDeclaration oid : oids) {
        RemoveImport ri = new RemoveImport(sourceOntology, oid);
        getManager().applyChange(ri);
    }
}

/**
 * Merge a specific ontology from the import closure into the main ontology.
 * Removes the import statement.
 * 
 * @param ontologyIRI id of the ontology to merge
 * @throws OWLOntologyCreationException
 */
public void mergeSpecificImport(IRI ontologyIRI) throws OWLOntologyCreationException {
    OWLOntologyManager manager = getManager();
    Set<OWLOntology> imports = sourceOntology.getImportsClosure();
    for (OWLOntology o : imports) {
        if (o.equals(sourceOntology))
            continue;
        Optional<IRI> currentIRI = o.getOntologyID().getOntologyIRI();
        if (currentIRI.isPresent() && currentIRI.get().equals(ontologyIRI)) {
            String comment = "Includes "+summarizeOntology(o);
            LOG.info(comment);
            addCommentToOntology(sourceOntology, comment);
            manager.addAxioms(sourceOntology, o.getAxioms());   
        }
    }
    Set<OWLImportsDeclaration> oids = sourceOntology.getImportsDeclarations();
    for (OWLImportsDeclaration oid : oids) {
        if (ontologyIRI.equals(oid.getIRI())) {
            RemoveImport ri = new RemoveImport(sourceOntology, oid);
            getManager().applyChange(ri);
        }
    }
}

private static List<OWLOntologyChange> handleSupportOntologies(OWLGraphWrapper graph)
{
    OWLOntology ontology = graph.getSourceOntology();
    OWLOntologyManager manager = ontology.getOWLOntologyManager();
    OWLDataFactory factory = manager.getOWLDataFactory();

    List<OWLOntologyChange> removeImportChanges = new ArrayList<OWLOntologyChange>();
    Set<OWLOntology> supportOntologySet = graph.getSupportOntologySet();
    for (OWLOntology support : supportOntologySet) {
        Optional<IRI> supportIRI = support.getOntologyID().getOntologyIRI();
        if(supportIRI.isPresent()) {
            IRI ontologyIRI = supportIRI.get();
            OWLImportsDeclaration importDeclaration = factory.getOWLImportsDeclaration(ontologyIRI);
            ChangeApplied status = manager.applyChange(new AddImport(ontology, importDeclaration));
            if (ChangeApplied.SUCCESSFULLY == status) {
                // the change was successful, create remove import for later
                removeImportChanges.add(new RemoveImport(ontology, importDeclaration));
            }
        }
    }
    return removeImportChanges;
}

void addOntologyStructure(OWLOntologyManager manager, OWLOntology ontology) {
  long parent = graph.createNode(OwlApiUtils.getIri(ontology));
  graph.addLabel(parent, OwlLabels.OWL_ONTOLOGY);
  for (OWLImportsDeclaration importDeclaration : ontology.getImportsDeclarations()) {
    OWLOntology childOnt = manager.getImportedOntology(importDeclaration);
    if (null == childOnt) {
      // TODO: Why is childOnt sometimes null (when importing rdf)?
      continue;
    }
    long child = graph.createNode(OwlApiUtils.getIri(childOnt));
    graph.addLabel(parent, OwlLabels.OWL_ONTOLOGY);
    if (graph.getRelationship(child, parent, OwlRelationships.RDFS_IS_DEFINED_BY).isPresent()) {
      continue;
    }
    graph.createRelationship(child, parent, OwlRelationships.RDFS_IS_DEFINED_BY);
    addOntologyStructure(manager, childOnt);
  }
}

@Test
public void testAnnotations() throws Exception {
    // setup test model/ontology
    OWLOntology o = m.createOntology();
    OWLImportsDeclaration importDeclaration = f.getOWLImportsDeclaration(g.getSourceOntology().getOntologyID().getOntologyIRI().get());
    m.applyChange(new AddImport(o, importDeclaration));

    final IRI i1IRI = IRI.generateDocumentIRI();
    final OWLNamedIndividual ni1 = f.getOWLNamedIndividual(i1IRI);
    // declare individual
    m.addAxiom(o, f.getOWLDeclarationAxiom(ni1));
    // add annotations
    m.addAxiom(o, f.getOWLAnnotationAssertionAxiom(i1IRI, 
            f.getOWLAnnotation(f.getOWLAnnotationProperty(
                    AnnotationShorthand.comment.getAnnotationProperty()), 
                    f.getOWLLiteral("Comment 1"))));
    m.addAxiom(o, f.getOWLAnnotationAssertionAxiom(i1IRI, 
            f.getOWLAnnotation(f.getOWLAnnotationProperty(
                    AnnotationShorthand.comment.getAnnotationProperty()), 
                    f.getOWLLiteral("Comment 2"))));
    // declare type
    m.addAxiom(o, f.getOWLClassAssertionAxiom(g.getOWLClassByIdentifier("GO:0000003"), ni1));

    MolecularModelJsonRenderer r = new MolecularModelJsonRenderer(null, o, null, curieHandler);

    JsonOwlIndividual jsonOwlIndividualOriginal = r.renderObject(ni1);
    assertEquals(2, jsonOwlIndividualOriginal.annotations.length);

    String json = MolecularModelJsonRenderer.renderToJson(jsonOwlIndividualOriginal, true);

    JsonOwlIndividual jsonOwlIndividualParse = MolecularModelJsonRenderer.parseFromJson(json, JsonOwlIndividual.class);

    assertNotNull(jsonOwlIndividualParse);
    assertEquals(jsonOwlIndividualOriginal, jsonOwlIndividualParse);
}

private void testSimpleClassExpression(OWLClassExpression ce, String expectedJsonType) throws Exception {
    // setup test model/ontology
    OWLOntology o = m.createOntology();
    OWLImportsDeclaration importDeclaration = f.getOWLImportsDeclaration(g.getSourceOntology().getOntologyID().getOntologyIRI().get());
    m.applyChange(new AddImport(o, importDeclaration));

    // create indivdual with a ce type
    final IRI i1IRI = IRI.generateDocumentIRI();
    final OWLNamedIndividual ni1 = f.getOWLNamedIndividual(i1IRI);
    // declare individual
    m.addAxiom(o, f.getOWLDeclarationAxiom(ni1));
    // declare type
    m.addAxiom(o, f.getOWLClassAssertionAxiom(ce, ni1));


    MolecularModelJsonRenderer r = new MolecularModelJsonRenderer(null, o, null, curieHandler);

    JsonOwlIndividual jsonOwlIndividualOriginal = r.renderObject(ni1);

    String json = MolecularModelJsonRenderer.renderToJson(jsonOwlIndividualOriginal, true);
    assertTrue(json, json.contains("\"type\": \""+expectedJsonType+"\""));

    JsonOwlIndividual jsonOwlIndividualParse = MolecularModelJsonRenderer.parseFromJson(json, JsonOwlIndividual.class);

    assertNotNull(jsonOwlIndividualParse);
    assertEquals(jsonOwlIndividualOriginal, jsonOwlIndividualParse);

    Set<OWLClassExpression> ces = TestJsonOwlObjectParser.parse(new OWLGraphWrapper(o), jsonOwlIndividualParse.type);
    assertEquals(1, ces.size());
    assertEquals(ce, ces.iterator().next());
}

@Deprecated
public void addImport(String importedIRIString) {
    OWLImportsDeclaration iax = dataFactory.getOWLImportsDeclaration(IRI.create(importedIRIString));
    //AddImport addAx = new AddImport(ontology, iax);
    AddImport addAx = new AddImport(getOntology(), iax);
    manager.applyChange(addAx);
}

public void mergeOntology(OWLOntology extOnt, LabelPolicy labelPolicy) throws OWLOntologyCreationException {
    OWLOntologyManager manager = getManager();
    LOG.info("Merging "+extOnt+" policy: "+labelPolicy);
    for (OWLAxiom axiom : extOnt.getAxioms()) {
        if (labelPolicy != LabelPolicy.ALLOW_DUPLICATES) {
            if (axiom instanceof OWLAnnotationAssertionAxiom) {
                OWLAnnotationAssertionAxiom aa = (OWLAnnotationAssertionAxiom)axiom;
                if (aa.getProperty().isLabel()) {
                    OWLAnnotationSubject subj = aa.getSubject();
                    if (subj instanceof IRI) {
                        Optional<OWLLiteral> label = null;
                        for (OWLAnnotationAssertionAxiom a1 : sourceOntology.getAnnotationAssertionAxioms(subj)) {
                            if (a1.getProperty().isLabel()) {
                                label = a1.getValue().asLiteral();
                            }
                        }
                        if (label != null && label.isPresent()) {
                               if (labelPolicy == LabelPolicy.PRESERVE_SOURCE) {
                                   LOG.info("Preserving existing label:" +subj+" "+label+" // ditching: "+axiom);
                                   continue;
                               }
                               if (labelPolicy == LabelPolicy.PRESERVE_EXT) {
                                   LOG.info("Replacing:" +subj+" "+label+" with: "+axiom);
                                   LOG.error("NOT IMPLEMENTED");
                               }
                        }
                    }
                }
            }
        }
        manager.applyChange(new AddAxiom(sourceOntology, axiom));
    }
    for (OWLImportsDeclaration oid: extOnt.getImportsDeclarations()) {
        manager.applyChange(new AddImport(sourceOntology, oid));
    }
    addCommentToOntology(sourceOntology, "Includes "+summarizeOntology(extOnt));
}

private Object[] convertSet(Set objs) {
    Object[] arr = new Object[objs.size()];
    int i=0;
    for (Object obj : objs) {
        if (obj instanceof OWLAxiom)
            arr[i] = convert((OWLAxiom) obj);
        else if (obj instanceof OWLImportsDeclaration)
            arr[i] = convert((OWLImportsDeclaration) obj);
        else 
            arr[i] = convert((OWLObject) obj);
        i++;
    }
    return arr;
}

@Test
public void test() throws Exception {
    // load the base ontology
    ParserWrapper pw = new ParserWrapper();
    OWLOntology direct = pw.parseOBO(getResourceIRIString("graph/xref_test.obo"));

    OWLGraphWrapper directGraph = new OWLGraphWrapper(direct);

    // check that the test class has the expected number of xrefs
    OWLClass c = directGraph.getOWLClassByIdentifier("FOO:0001");

    List<String> directDefXrefs = directGraph.getDefXref(c);
    assertEquals(2, directDefXrefs.size());

    List<String> directXrefs = directGraph.getXref(c);
    assertEquals(2, directXrefs.size());

    // create an ontology using an import
    OWLOntologyManager manager = pw.getManager();
    OWLDataFactory factory = manager.getOWLDataFactory();
    OWLOntology importer = manager.createOntology();
    OWLImportsDeclaration importDeclaration = factory.getOWLImportsDeclaration(direct.getOntologyID().getOntologyIRI().orNull());
    manager.applyChange(new AddImport(importer, importDeclaration));

    OWLGraphWrapper importerGraph = new OWLGraphWrapper(importer);

    // check that the wrapper uses also imports for lookups of xrefs
    List<String> importedDefXrefs = importerGraph.getDefXref(c);
    assertEquals(2, importedDefXrefs.size());

    List<String> importedXrefs = importerGraph.getXref(c);
    assertEquals(2, importedXrefs.size());
}

@Override
public boolean equals(Object obj) {
    if (obj == this) {
        return true;
    }
    if (!(obj instanceof OWLImportsDeclaration)) {
        return false;
    }
    OWLImportsDeclaration other = (OWLImportsDeclaration) obj;
    return iri.equals(other.getIRI());
}

public BinaryOWLImportsDeclarationSet(BinaryOWLInputStream inputStream) throws IOException, BinaryOWLParseException {
    int size = inputStream.readInt();
    if(size == 0) {
        importsDeclarations = Collections.emptySet();
    }
    else {
        Set<OWLImportsDeclaration> read = new LinkedHashSet<OWLImportsDeclaration>(size);
        for(int i = 0; i < size; i++) {
            BinaryOWLImportsDeclaration binDecl = new BinaryOWLImportsDeclaration(inputStream);
            read.add(binDecl.getImportsDeclaration());
        }
        importsDeclarations = Collections.unmodifiableSet(read);
    }

}

public void write(BinaryOWLOutputStream dataOutput) throws IOException {
    dataOutput.writeInt(importsDeclarations.size());
    for(OWLImportsDeclaration declaration : importsDeclarations) {
        BinaryOWLImportsDeclaration binDecl = new BinaryOWLImportsDeclaration(declaration);
        binDecl.write(dataOutput);
    }
}

@Test
public void testUpdateImports() throws Exception {
    final OWLOntologyManager m = OWLManager.createOWLOntologyManager();
    final OWLDataFactory f = m.getOWLDataFactory();

    // setup other import
    final IRI other = IRI.generateDocumentIRI();
    m.createOntology(other);

    // setup additional
    final IRI add1 = IRI.generateDocumentIRI();
    m.createOntology(add1);
    final IRI add2 = IRI.generateDocumentIRI();
    m.createOntology(add2);
    final Set<IRI> additional = new HashSet<IRI>();
    additional.add(add1);
    additional.add(add2);

    // setup tbox
    final IRI tboxIRI = IRI.generateDocumentIRI();
    m.createOntology(tboxIRI);

    // setup abox
    final OWLOntology abox = m.createOntology(IRI.generateDocumentIRI());
    // add initial imports to abox
    m.applyChange(new AddImport(abox, f.getOWLImportsDeclaration(other)));

    // update imports
    CoreMolecularModelManager.updateImports(abox, tboxIRI, additional);

    // check the resulting imports
    Set<OWLImportsDeclaration> declarations = abox.getImportsDeclarations();
    assertEquals(4, declarations.size());
    Set<IRI> declaredImports = new HashSet<IRI>();
    for (OWLImportsDeclaration importsDeclaration : declarations) {
        declaredImports.add(importsDeclaration.getIRI());
    }
    assertEquals(4, declaredImports.size());
    assertTrue(declaredImports.contains(tboxIRI));
    assertTrue(declaredImports.contains(add1));
    assertTrue(declaredImports.contains(add1));
    assertTrue(declaredImports.contains(other));
}

public void visit(OWLImportsDeclaration axiom) {
}

public Boolean visit(OWLImportsDeclaration axiom) {
    return Boolean.TRUE;
}

/**
 * Testing correctness of the reasoner with respect to ontology changes
 * <p>
 * removing the import declaration for </impA>
 */
@Test
public void testRemovingImpA() throws Exception {

    OWLOntologyManager man = TestOWLManager.createOWLOntologyManager();
    OWLDataFactory dataFactory = man.getOWLDataFactory();

    // set up resolution of prefixes
    PrefixManager pm = new DefaultPrefixManager();
    pm.setDefaultPrefix("http://www.example.com/main#");
    pm.setPrefix("A:", "http://www.example.com/A#");
    pm.setPrefix("B:", "http://www.example.com/B#");

    // define query classes
    OWLClass mainX = dataFactory.getOWLClass(":X", pm);
    OWLClass mainY = dataFactory.getOWLClass(":Y", pm);
    OWLClass extA = dataFactory.getOWLClass("A:A", pm);
    OWLClass extB = dataFactory.getOWLClass("B:B", pm);
    OWLClass extC = dataFactory.getOWLClass("B:C", pm);

    // loading the root ontology
    OWLOntology root = loadOntology(man, "root.owl");

    // Create an ELK reasoner.
    OWLReasonerFactory reasonerFactory = new ElkReasonerFactory();
    OWLReasoner reasoner = reasonerFactory.createReasoner(root);

    try {

        // ************************************
        // ** removing the import declaration for </impA>
        // ************************************

        OWLImportsDeclaration importA = new OWLImportsDeclarationImpl(
                IRI.create("http://www.example.com#impA"));
        OWLOntologyChange change = new RemoveImport(root, importA);
        man.applyChange(change);
        reasoner.flush();

        // Now the root ontology should not import anything
        assertEquals(root.getAxiomCount(), 3);
        assertEquals(root.getImportsClosure().size(), 1);
        assertEquals(getAxioms(root).size(), 3);

        // reasoner queries -- only subsumptions of the root ontology are
        // there
        assertTrue(reasoner.getSuperClasses(mainX, true).containsEntity(
                mainY));
        assertTrue(reasoner.getSuperClasses(mainX, true).containsEntity(
                extA));
        assertTrue(reasoner.getSuperClasses(mainY, true).containsEntity(
                extB));
        assertFalse(reasoner.getSuperClasses(extA, true).containsEntity(
                extB));
        assertFalse(reasoner.getSuperClasses(extB, true).containsEntity(
                extC));

    } finally {
        reasoner.dispose();
    }

}

public void visit(OWLImportsDeclaration axiom) {
}

public Boolean visit(OWLImportsDeclaration axiom) {
    return Boolean.TRUE;
}

public Object convert(OWLImportsDeclaration obj) {
    return convert(((OWLImportsDeclaration)obj).getIRI());
}

public void visit(OWLImportsDeclaration axiom) {
}

@Override
public int compareTo(OWLImportsDeclaration o) {
    return iri.compareTo(o.getIRI());
}

/**
 * Remove all imports from the given ontology
 * @param ont   OWL ontology
 */
private void removeImports(OWLOntology ont) {
    for(OWLImportsDeclaration importDecl : ont.getImportsDeclarations())
        ont.getOWLOntologyManager().applyChange(new RemoveImport(ont.getOWLOntologyManager().getImportedOntology(importDecl), importDecl));
}

@Override
public void handleImportsDeclarations(Set<OWLImportsDeclaration> importsDeclarations) throws E {
}

public <E extends Throwable> void read(DataInputStream dis, BinaryOWLOntologyDocumentHandler<E> handler, OWLDataFactory df) throws IOException, BinaryOWLParseException, UnloadableImportException, E {

        BinaryOWLInputStream inputStream = new BinaryOWLInputStream(dis, df, VERSION);

        // Metadata
        BinaryOWLMetadataChunk chunk = new BinaryOWLMetadataChunk(inputStream);
        BinaryOWLMetadata metadata = chunk.getMetadata();
        handler.handleDocumentMetaData(metadata);

        handler.handleBeginInitialDocumentBlock();

        // Ontology ID
        BinaryOWLOntologyID serializer = new BinaryOWLOntologyID(inputStream);
        OWLOntologyID ontologyID = serializer.getOntologyID();
        handler.handleOntologyID(ontologyID);

        // Imported ontologies
        BinaryOWLImportsDeclarationSet importsDeclarationSet = new BinaryOWLImportsDeclarationSet(inputStream);
        Set<OWLImportsDeclaration> importsDeclarations = importsDeclarationSet.getImportsDeclarations();
        handler.handleImportsDeclarations(importsDeclarations);

        // IRI Table
        IRILookupTable iriLookupTable = new IRILookupTable(dis);

        // Used to be literal table
        // Skip 1 byte - the interning marker
        inputStream.skip(1);


        LookupTable lookupTable = new LookupTable(iriLookupTable);


        BinaryOWLInputStream lookupTableStream = new BinaryOWLInputStream(dis, lookupTable, df, VERSION);

        // Ontology Annotations
        Set<OWLAnnotation> annotations = lookupTableStream.readOWLObjects();
        handler.handleOntologyAnnotations(annotations);

        // Axiom tables - axioms by type
        for (int i = 0; i < AxiomType.AXIOM_TYPES.size(); i++) {
            Set<OWLAxiom> axiomsOfType = lookupTableStream.readOWLObjects();
            handler.handleAxioms(axiomsOfType);
        }

        handler.handleEndInitialDocumentBlock();
        handler.handleBeginDocumentChangesBlock();
        BinaryOWLInputStream changesInputStream = new BinaryOWLInputStream(dis, df, VERSION);
        // Read any changes that have been appended to the end of the file - no look up table for this
        readOntologyChanges(changesInputStream, handler);
        handler.handleEndDocumentChangesBlock();
        handler.handleEndDocument();
    }

@Override
public RemoveImportData read(BinaryOWLInputStream inputStream) throws IOException {
    IRI iri = inputStream.readIRI();
    OWLImportsDeclaration declaration = inputStream.getDataFactory().getOWLImportsDeclaration(iri);
    return new RemoveImportData(declaration);
}

@Override
public void write(AddImportData changeData, BinaryOWLOutputStream outputStream) throws IOException {
    OWLImportsDeclaration declaration = changeData.getDeclaration();
    IRI iri = declaration.getIRI();
    outputStream.writeIRI(iri);
}

@Override
public AddImportData read(BinaryOWLInputStream inputStream) throws IOException, BinaryOWLParseException {
    IRI iri = inputStream.readIRI();
    OWLImportsDeclaration declaration = inputStream.getDataFactory().getOWLImportsDeclaration(iri);
    return new AddImportData(declaration);
}

public BinaryOWLImportsDeclaration(OWLImportsDeclaration importsDeclaration) {
    this.importsDeclaration = importsDeclaration;
}

public OWLImportsDeclaration getImportsDeclaration() {
    return importsDeclaration;
}

public BinaryOWLImportsDeclarationSet(Set<OWLImportsDeclaration> importsDeclarations) {
    this.importsDeclarations = Collections.unmodifiableSet(new LinkedHashSet<OWLImportsDeclaration>(importsDeclarations));
}

public Set<OWLImportsDeclaration> getImportsDeclarations() {
    return importsDeclarations;
}

void handleImportsDeclarations(Set<OWLImportsDeclaration> importsDeclarations) throws E;

Set<OWLImportsDeclaration> getImportsDeclarations();