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

项目：owltools 文件：OWLGraphManipulatorTest.java

/**
 * Test that two {@code OWLClass}es that are equal have a same hashcode, 
 * because the OWLGraphEdge bug get me paranoid. 
 */
@Test
public void testOWLClassHashCode()
{
     OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
     OWLDataFactory factory = manager.getOWLDataFactory(); 
     IRI iri = IRI.create("http://www.foo.org/#A");
     OWLClass class1 = factory.getOWLClass(iri);
     //get the class by another way, even if if I suspect the two references 
     //will point to the same object
     PrefixManager pm = new DefaultPrefixManager("http://www.foo.org/#"); 
     OWLClass class2 = factory.getOWLClass(":A", pm);

     assertTrue("The two references point to different OWLClass objects", 
             class1 == class2);
     //then of course the hashcodes will be the same...
     assertTrue("Two OWLClasses are equal but have different hashcode", 
             class1.equals(class2) && class1.hashCode() == class2.hashCode());
}

项目：OntoBench 文件：OwlApiConfig.java

@Bean
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.INTERFACES)
public OWLMutableOntology owlOntology(PrefixManager prefixManager) throws OWLOntologyCreationException {
  if (prefixManager.getDefaultPrefix() == null) {
    throw new IllegalStateException("Default ontology prefix must not be null.");
  }

  OWLOntologyManager ontologyManager = OWLManager.createOWLOntologyManager();
  // Cast to a mutable ontology to pass OWLApi's strange checks
  return (OWLMutableOntology) ontologyManager.createOntology(IRI.create(prefixManager.getDefaultPrefix()));
}

项目：ISAAC 文件：OWLExporter.java

/**
 * Creates the owl axioms from concept version bi.
 *
 * @param setOfAxioms the set of axioms
 * @param factory the factory
 * @param pm the pm
 * @param conceptVersionBI the concept version bi
 * @return the OWL class
 * @throws Exception the exception
 */
private OWLClass createOWLAxiomsFromConceptVersionBI(
  Set<OWLAxiom> setOfAxioms, OWLDataFactory factory, PrefixManager pm,
  ConceptVersionBI conceptVersionBI) throws Exception {
  // Declaration
  OWLClass owlClass =
      factory.getOWLClass(":" + getSnomedConceptID(conceptVersionBI), pm);
  OWLDeclarationAxiom declarationAxiom =
      factory.getOWLDeclarationAxiom(owlClass);
  setOfAxioms.add(declarationAxiom);
  // Create annotation type axiom
  // Fully specified description
  OWLAnnotation labelAnnotation =
      factory.getOWLAnnotation(factory.getRDFSLabel(), factory.getOWLLiteral(
          conceptVersionBI.getFullySpecifiedDescription().getText(),
          conceptVersionBI.getFullySpecifiedDescription().getLang()));
  OWLAxiom labelAnnotationAxiom =
      factory.getOWLAnnotationAssertionAxiom(owlClass.getIRI(),
          labelAnnotation);
  setOfAxioms.add(labelAnnotationAxiom);

  // Preferred name
  OWLAnnotation preferredTerm =
      factory.getOWLAnnotation(factory.getOWLAnnotationProperty(IRI
          .create(snomedEnUsPreferredAnnotation)), factory.getOWLLiteral(
          conceptVersionBI.getPreferredDescription().getText(),
          conceptVersionBI.getPreferredDescription().getLang()));
  OWLAxiom preferredTermAx =
      factory
          .getOWLAnnotationAssertionAxiom(owlClass.getIRI(), preferredTerm);
  setOfAxioms.add(preferredTermAx);

  return owlClass;
}

项目：relex 文件：OWLView.java

/**
* Print out RelEx relations. All relations shown
* in a binary form.
*
* Example:
*       _subj(throw, John)
*       _obj(throw, ball)
*       tense(throw, past)
*       definite-FLAG(ball, T)
*       noun_number(ball, singular)
*/
public void printRelations(ParsedSentence parse, String sentence, int sentence_id, String ontologyname)
{
    try
    {
        sent = sentence;

        //Add the sentence to Sentence Class
        this.sentence_id = sentence_id;
        sentenceInd = factory.getOWLNamedIndividual(IRI.create(ontologyURI + "#" + "sentence_" + sentence_id));
        //OWLAnnotationProperty p = new OWLAnnotationPropertyImpl(IRI.create(sentence));

        //OWLAnnotation label = factory.getOWLAnnotation(sentence);
        OWLOntologyFormat ontologyFormat = manager.getOntologyFormat(ontology);
        OWLAnnotation label = (OWLAnnotation) factory.getOWLAnnotationProperty(sentence, (PrefixManager) ontologyFormat);

        OWLClassAssertionAxiom sentClass = factory.getOWLClassAssertionAxiom(this.sentence,sentenceInd);
        OWLAnnotationAssertionAxiom labelClass = factory.getOWLAnnotationAssertionAxiom((OWLAnnotationSubject) sentClass, label);
        manager.applyChange(new AddAxiom(ontology, sentClass));
        manager.applyChange(new AddAxiom(ontology, labelClass));

        printRelations(parse, null);

    }
    catch (OWLOntologyChangeException ex)
    {
        Logger.getLogger(OWLView.class.getName()).log(Level.SEVERE, null, ex);
    }
}

项目：owlapi-gwt 文件：DefaultPrefixManager.java

/**
 * @param pm
 *        the prefix manager to copy
 * @param c
 *        comparator to sort prefixes
 * @param defaultPrefix
 *        default prefix
 */
public DefaultPrefixManager(@Nullable PrefixManager pm, @Nullable StringComparator c,
    @Nullable String defaultPrefix) {
    comparator = c == null ? new StringLengthComparator() : c;
    prefix2NamespaceMap = new TreeMap<>(comparator);
    setupDefaultPrefixes();
    if (pm != null) {
        copyPrefixesFrom(pm);
    }
    if (defaultPrefix != null) {
        setDefaultPrefix(defaultPrefix);
    }
}

项目：OntoBench 文件：ClassPool.java

@Autowired
public ClassPool(OWLDataFactory factory, PrefixManager prefixManager) {
  super(MAX_REUSES);
  this.factory = factory;
  this.prefixManager = prefixManager;
}

项目：OntoBench 文件：PropertyPool.java

@Autowired
public PropertyPool(OWLDataFactory factory, PrefixManager prefixManager) {
  this.factory = factory;
  this.prefixManager = prefixManager;
}

项目：OntoBench 文件：OwlApiConfig.java

@Bean
@Scope(value = WebApplicationContext.SCOPE_REQUEST, proxyMode = ScopedProxyMode.INTERFACES)
public PrefixManager prefixManager(RequestInformation requestInformation) {
  return new DefaultPrefixManager(null, null, requestInformation.getOntologyIri());
}

项目：OWLAx 文件：BasicGraphEditor.java

/**
 * @return the protegePrefixmanager
 */
public PrefixManager getProtegePrefixmanager() {
    return protegePrefixmanager;
}

项目：OWLAx 文件：BasicGraphEditor.java

/**
 * @param protegePrefixmanager the protegePrefixmanager to set
 */
public void setProtegePrefixmanager(PrefixManager protegePrefixmanager) {
    this.protegePrefixmanager = protegePrefixmanager;
}

项目：elk-reasoner 文件：QueryingUnnamedClassExpressions.java

public static void main(String[] args) throws OWLOntologyCreationException {
    OWLOntologyManager man = OWLManager.createOWLOntologyManager();
    OWLDataFactory dataFactory = man.getOWLDataFactory();

    // Load your ontology.
    OWLOntology ont = man.loadOntologyFromOntologyDocument(new File(
            "c:/ontologies/ontology.owl"));

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

    // Create your desired query class expression. In this example we
    // will query ObjectIntersectionOf(A ObjectSomeValuesFrom(R B)).
    PrefixManager pm = new DefaultPrefixManager("http://example.org/");
    OWLClass A = dataFactory.getOWLClass(":A", pm);
    OWLObjectProperty R = dataFactory.getOWLObjectProperty(":R", pm);
    OWLClass B = dataFactory.getOWLClass(":B", pm);
    OWLClassExpression query = dataFactory.getOWLObjectIntersectionOf(A,
            dataFactory.getOWLObjectSomeValuesFrom(R, B));

    // Create a fresh name for the query.
    OWLClass newName = dataFactory.getOWLClass(IRI.create("temp001"));
    // Make the query equivalent to the fresh class
    OWLAxiom definition = dataFactory.getOWLEquivalentClassesAxiom(newName,
            query);
    man.addAxiom(ont, definition);

    // Remember to either flush the reasoner after the ontology change
    // or create the reasoner in non-buffering mode. Note that querying
    // a reasoner after an ontology change triggers re-classification of
    // the whole ontology which might be costly. Therefore, if you plan
    // to query for multiple complex class expressions, it will be more
    // efficient to add the corresponding definitions to the ontology at
    // once before asking any queries to the reasoner.
    reasoner.flush();

    // You can now retrieve subclasses, superclasses, and instances of
    // the query class by using its new name instead.
    reasoner.getSubClasses(newName, true);
    reasoner.getSuperClasses(newName, true);
    reasoner.getInstances(newName, false);

    // After you are done with the query, you should remove the definition
    man.removeAxiom(ont, definition);

    // You can now add new definitions for new queries in the same way

    // After you are done with all queries, do not forget to free the
    // resources occupied by the reasoner
    reasoner.dispose();
}