/**
   * Method that s if two elements of an ontology are subsumes.
   *
   * @param requestParameter - A request parameter.
   * @param serviceParameter - A service parameter.
   * @param typoOfParameter - It informs if the parameters are inputs or outputs.
   * @return true/false - return true if they are the same and false if they are different.
   */
  @SuppressWarnings("unchecked")
  private boolean isSubsumesMatching(
      URI requestParameter, URI serviceParameter, char typeOfParameter) {
    Iterator iter = null;
    OntClass ontClass = null;

    loadOntology(
        requestParameter.getScheme() + ":" + requestParameter.getSchemeSpecificPart() + "#");

    if (typeOfParameter == FunctionalMatcher.INPUT) {
      ontClass = model.getOntClass(serviceParameter.toString());
      iter = ontClass.listSubClasses();
      while (iter.hasNext()) {
        if (requestParameter.toString().equals(iter.next().toString())) {
          return true;
        }
      }
    } else if (typeOfParameter == FunctionalMatcher.OUTPUT) {
      ontClass = model.getOntClass(requestParameter.toString());
      iter = ontClass.listSubClasses();
      while (iter.hasNext()) {
        if (serviceParameter.toString().equals(iter.next().toString())) {
          return true;
        }
      }
    }

    return false;
  }
  /**
   * Method that calculates if two elements of an ontology are exact.
   *
   * @param requestParameter - A request parameter.
   * @param serviceParameter - A service parameter.
   * @param typoOfParameter - It informs if the parameters are inputs or outputs.
   * @return true/false - return true if they are the same and false if they are different.
   */
  @SuppressWarnings("unchecked")
  private boolean isExactMatching(
      URI requestParameter, URI serviceParameter, char typeOfParameter) {
    Iterator iterClass = null;
    NodeIterator iter = null;
    OntClass ontClass = null;

    loadOntology(
        requestParameter.getScheme() + ":" + requestParameter.getSchemeSpecificPart() + "#");

    if (typeOfParameter == FunctionalMatcher.INPUT) {
      resource = model.getResource(ontology + requestParameter.getFragment());
      iter = model.listObjectsOfProperty(resource, OWL.equivalentClass);
      while (iter.hasNext()) {
        if (serviceParameter.toString().equals(iter.next().toString())) {
          return true;
        }
      }

      ontClass = model.getOntClass(requestParameter.toString());
      iterClass = ontClass.listSubClasses(true);
      while (iterClass.hasNext()) {
        if (serviceParameter.toString().equals(iterClass.next().toString())) {
          return true;
        }
      }
    } else if (typeOfParameter == FunctionalMatcher.OUTPUT) {
      resource = model.getResource(ontology + requestParameter.getFragment());
      iter = model.listObjectsOfProperty(resource, OWL.equivalentClass);
      while (iter.hasNext()) {
        if (serviceParameter.toString().equals(iter.next().toString())) {
          return true;
        }
      }

      ontClass = model.getOntClass(serviceParameter.toString());
      iterClass = ontClass.listSubClasses(true);
      while (iterClass.hasNext()) {
        if (requestParameter.toString().equals(iterClass.next().toString())) {
          return true;
        }
      }
    }
    if (requestParameter.toString().equals(serviceParameter.toString())) {
      return true;
    }
    return false;
  }
  /**
   * Method that s if two elements of an ontology are siblings.
   *
   * @param requestParameter - A request parameter.
   * @param serviceParameter - A service parameter.
   * @param typoOfParameter - It informs if the parameters are inputs or outputs.
   * @return true/false - return true if they are the same and false if they are different.
   */
  @SuppressWarnings("unchecked")
  private boolean isSiblingMatching(
      URI requestParameter, URI serviceParameter, char typeOfParameter) {

    boolean gotSuperClass = false;
    OntClass ontClass = null;
    Iterator iter = null;

    loadOntology(
        requestParameter.getScheme() + ":" + requestParameter.getSchemeSpecificPart() + "#");

    ontClass = model.getOntClass(serviceParameter.toString());
    iter = ontClass.listSuperClasses(true);
    if (iter.hasNext()) {
      ontClass = (OntClass) iter.next();
      gotSuperClass = true;
    }
    if (gotSuperClass) {
      iter = ontClass.listSubClasses(true);
    }
    while (iter.hasNext()) {
      String next = iter.next().toString();
      if (requestParameter.toString().equals(next)) {
        return true;
      }
    }
    return false;
  }
Beispiel #4
0
  private List<OntClass> OntClassInheritanceChain(List<OntClass> _subClasses) {

    List<OntClass> removeSubClasses = new ArrayList<OntClass>();

    for (OntClass jenaClass : _subClasses) {
      List<OntClass> subClassCopy = jenaClass.listSubClasses().toList();
      for (OntClass subClass : subClassCopy) {
        if (_subClasses.contains(subClass)) {
          if (!removeSubClasses.contains(subClass)) removeSubClasses.add(subClass);
        }
      }
    }

    for (OntClass subClass : removeSubClasses)
      _subClasses.remove(_subClasses.lastIndexOf(subClass));

    return _subClasses;
  }
Beispiel #5
0
  public static void main(String args[]) {
    String filename = "example6.rdf";

    // Create an empty model
    OntModel model = ModelFactory.createOntologyModel(OntModelSpec.RDFS_MEM);

    // Use the FileManager to find the input file
    InputStream in = FileManager.get().open(filename);

    if (in == null) throw new IllegalArgumentException("File: " + filename + " not found");

    // Read the RDF/XML file
    model.read(in, null);
    // model.write(System.out,"Turtle");

    ExtendedIterator<? extends OntResource> iterator;
    // ** TASK 7.1: List all individuals of "Person" **
    OntClass person = model.getOntClass(ns + "Person");

    iterator = person.listInstances();
    System.out.println("Individuals");
    System.out.println("------------------------------------");
    while (iterator.hasNext()) {
      OntResource r = iterator.next();
      System.out.println(r.getURI());
    }
    System.out.println("------------------------------------");
    // ** TASK 7.2: List all subclasses of "Person" **
    iterator = person.listSubClasses();
    System.out.println("Sublcasses");
    System.out.println("------------------------------------");
    while (iterator.hasNext()) {
      OntResource r = iterator.next();
      System.out.println(r.getURI());
    }
    System.out.println("------------------------------------");
    // ** TASK 7.3: Make the necessary changes to get as well indirect instances and subclasses.
    // TIP: you need some inference... **

  }
Beispiel #6
0
  /*
   * (non-Javadoc)
   * @see net.java.treaty.ContractVocabulary#getSubtypes(java.net.URI)
   */
  public Set<URI> getSubTypes(URI type) throws TreatyException {

    Set<URI> result;
    result = new HashSet<URI>();

    OntModel model;
    model = getOntology();

    OntClass clazz;
    clazz = model.getOntClass(type.toString());

    for (Iterator<OntClass> iterator = clazz.listSubClasses(false); iterator.hasNext(); ) {

      try {
        result.add(new URI(iterator.next().getURI()));
      } catch (URISyntaxException e) {
        throw new TreatyException(e);
      }
      // end catch.
    }
    // end for.

    return result;
  }
Beispiel #7
0
  private void ImportRelationsInheritanceOrEquivalence(int typeRelation) throws Exception {

    List<OntClass> classes = this.jena.listClasses().toList();
    for (OntClass jenaClass : classes) {
      Class mobiClass = new Class(jenaClass.getLocalName());
      // this.mobi.getClass(jenaClass.getLocalName());

      if (mobiClass != null) {
        List<OntClass> subClasses = null;

        if (typeRelation == Relation.INHERITANCE)
          subClasses = this.OntClassInheritanceChain(jenaClass.listSubClasses().toList());
        else if (typeRelation == Relation.EQUIVALENCE)
          subClasses = jenaClass.listEquivalentClasses().toList();

        for (OntClass jenaSubClass : subClasses) {
          if (jenaSubClass != null
              && !jenaSubClass.getLocalName().equals(mobiClass.getUri())
              && jenaSubClass.listInstances().hasNext()) {

            // this.mobi.addConcept(mobiClass);
            Class mobiSubClass = new Class(jenaSubClass.getLocalName());

            Relation relation = null;
            if (typeRelation == Relation.INHERITANCE)
              relation = this.mobi.createInheritanceRelation("isSuper");
            else if (typeRelation == Relation.EQUIVALENCE)
              relation = this.mobi.createEquivalenceRelation("equals");

            relation.setClassA(mobiClass);
            relation.setClassB(mobiSubClass);

            List<? extends OntResource> individualsClassA = jenaClass.listInstances().toList();
            List<? extends OntResource> individualsClassB = jenaSubClass.listInstances().toList();

            for (OntResource resourceA : individualsClassA) {
              Individual individualA = resourceA.asIndividual();

              Instance instanceA = new Instance(individualA.getLocalName());
              // this.mobi.getInstance(individualA.getLocalName());

              for (OntResource resourceB : individualsClassB) {
                Individual individualB = resourceB.asIndividual();
                Instance instanceB = new Instance(individualB.getLocalName());
                // this.mobi.getInstance(individualB.getLocalName());

                if (instanceB != null && instanceA.getUri().equals(instanceB.getUri())) {

                  this.mobi.addConcept(mobiClass);
                  this.mobi.addConcept(mobiSubClass);
                  this.mobi.addConcept(instanceA);
                  this.mobi.addConcept(instanceB);

                  try {
                    this.mobi.isOneOf(instanceA, mobiClass);
                    this.mobi.isOneOf(instanceB, mobiSubClass);
                  } catch (ExceptionURI e) {
                  }

                  this.mobi.addConcept(instanceB);

                  relation.addInstanceRelation(instanceA, instanceB);
                }
              }
            }

            relation.processCardinality();
            if (relation.getInstanceRelationMapA().size() > 0) this.mobi.addConcept(relation);
          }
        }
      }
    }
  }