org.semanticweb.owlapi.model.OWLAnonymousIndividual Java Examples

/**
 * .
 */
public static Annotation mobiAnnotation(OWLAnnotation owlAnno) {
    // TODO: ??? Fix this.
    if (owlAnno == null) {
        return null;
    }

    AnnotationProperty property = mobiAnnotationProperty(owlAnno.getProperty());
    OWLAnnotationValue value = owlAnno.getValue();
    if (value instanceof OWLLiteral) {
        OWLLiteral literal = (OWLLiteral) value;
        Literal simpleLiteral = mobiLiteral(literal);
        return new SimpleAnnotation(property, simpleLiteral);
    } else if (value instanceof org.semanticweb.owlapi.model.IRI) {
        org.semanticweb.owlapi.model.IRI iri = (org.semanticweb.owlapi.model.IRI) value;
        IRI simpleIri = mobiIRI(iri);
        return new SimpleAnnotation(property, simpleIri);
    } else if (value instanceof OWLAnonymousIndividual) {
        OWLAnonymousIndividual individual = (OWLAnonymousIndividual) value;
        Individual simpleIndividual = mobiIndividual(individual);
        return new SimpleAnnotation(property, simpleIndividual);
    } else {
        throw new OWLRuntimeException("Invalid annotation value");
    }
}
 

/**
 * .
 */
public static OWLAnnotation owlapiAnnotation(Annotation anno) {
    // TODO: ??? Fix this.
    if (anno == null) {
        return null;
    }
    OWLAnnotationProperty owlAnnoProperty = owlapiAnnotationProperty(anno.getProperty());
    Value value = anno.getValue();
    if (value instanceof IRI) {
        org.semanticweb.owlapi.model.IRI iri = owlapiIRI((IRI) value);
        return new OWLAnnotationImpl(owlAnnoProperty, iri, Stream.empty());
    } else if (value instanceof Literal) {
        OWLLiteral literal = owlapiLiteral((Literal) value);
        return new OWLAnnotationImpl(owlAnnoProperty, literal, Stream.empty());
    } else if (value instanceof SimpleIndividual) {
        OWLIndividual individual = owlapiIndividual((SimpleIndividual) value);
        return new OWLAnnotationImpl(owlAnnoProperty, (OWLAnonymousIndividual) individual, Stream.empty());
    } else {
        throw new MobiOntologyException("Invalid annotation value");
    }
}
 

public String getValueAsString() {
    if (value instanceof IRI) {
        return value.toString();
    }
    else if (value instanceof OWLLiteral) {
        return ((OWLLiteral) value).getLiteral();
    }
    else if (value instanceof OWLAnonymousIndividual) {
        return ((OWLAnonymousIndividual) value).getID().toString();
    }
    else if (value instanceof Var) {
        return ((Var) value).getName();
    }
    else {
        return value.toString();
    }
}
 

private OWLNamedIndividual findEvidenceIndividual(OWLAnnotationValue value) {
	return value.accept(new OWLAnnotationValueVisitorEx<OWLNamedIndividual>() {

		@Override
		public OWLNamedIndividual visit(final IRI iri) {
			OWLNamedIndividual i = null;
			for(OWLNamedIndividual current : model.getIndividualsInSignature()) {
				if (current.getIRI().equals(iri)) {
					i = current;
					break;
				}
			}
			return i;
		}

		@Override
		public OWLNamedIndividual visit(OWLAnonymousIndividual individual) {
			return null;
		}

		@Override
		public OWLNamedIndividual visit(OWLLiteral literal) {
			return null;
		}
	});
}
 

@Test
public void testIsBnode() 
{
	QueryArgument arg = new QueryArgument(mock(OWLAnonymousIndividual.class));
	assertTrue(arg.isBnode());
	QueryArgument arg2 = new QueryArgument(new Var("x"));
	assertFalse(arg2.isBnode());
}
 

public static Set<OWLObject> findTaggedEntities(OWLAnnotationProperty p, Set<OWLAnnotationValue> values, final OWLGraphWrapper graph) {
	if (p == null || values == null || values.isEmpty()) {
		return Collections.emptySet();
	}
	final Set<OWLObject> entities = new HashSet<OWLObject>();
	Set<OWLOntology> allOntologies = graph.getAllOntologies();
	for (OWLOntology ontology : allOntologies) {
		Set<OWLAnnotationAssertionAxiom> axioms = ontology.getAxioms(AxiomType.ANNOTATION_ASSERTION);
		for (OWLAnnotationAssertionAxiom axiom : axioms) {
			if (p.equals(axiom.getProperty()) && values.contains(axiom.getValue())) {
				axiom.getSubject().accept(new OWLAnnotationSubjectVisitor(){

					@Override
					public void visit(IRI iri) {
						OWLObject owlObject = graph.getOWLObject(iri);
						if (owlObject != null) {
							entities.add(owlObject);
						}
					}

					@Override
					public void visit(OWLAnonymousIndividual individual) {
						// do nothing
					}
				});
			}
		}
	}
	return entities;
}
 

public static String getIri(OWLIndividual individual) {
  if (individual.isAnonymous()) {
    return ((OWLAnonymousIndividual)individual).getID().getID();
  } else {
    return individual.asOWLNamedIndividual().getIRI().toString();
  }
}
 

public QueryArgument(OWLAnonymousIndividual value) {
    this.type = QueryArgumentType.BNODE;
    this.value = value;
}
 

public OWLAnonymousIndividual getValueAsBNode() {
    return (OWLAnonymousIndividual) value;
}
 

@Override
public OWLAnonymousIndividual visit(ElkAnonymousIndividual expression) {
	return owlFactory_.getOWLAnonymousIndividual(expression.getNodeId());
}
 

@SuppressWarnings("static-method")
public ElkAnonymousIndividual convert(
		OWLAnonymousIndividual owlAnonymousIndividual) {
	return new ElkAnonymousIndividualWrap<OWLAnonymousIndividual>(
			owlAnonymousIndividual);
}
 

@Override
public ElkAnonymousIndividual visit(
		OWLAnonymousIndividual owlAnonymousIndividual) {
	return CONVERTER.convert(owlAnonymousIndividual);
}
 

@Override
public ElkAnonymousIndividual visit(OWLAnonymousIndividual anon) {
	return CONVERTER.convert(anon);
}
 

@Override
public String visit(OWLAnonymousIndividual individual) {
	return null;
}
 

@Override
public Void visit(OWLAnnotationAssertionAxiom axiom) {
  if ((axiom.getSubject() instanceof IRI)
      || (axiom.getSubject() instanceof OWLAnonymousIndividual)) {
    long subject = 0L;
    if (axiom.getSubject() instanceof IRI) {
      subject = getOrCreateNode(((IRI) axiom.getSubject()).toString());
    } else if (axiom.getSubject() instanceof OWLAnonymousIndividual) {
      subject = getOrCreateNode(OwlApiUtils.getIri((OWLAnonymousIndividual) axiom.getSubject()));
    }

    String property = getIri(axiom.getProperty()).toString();
    if (axiom.getValue() instanceof OWLLiteral) {
      Optional<Object> literal =
          OwlApiUtils.getTypedLiteralValue((OWLLiteral) (axiom.getValue()));
      if (literal.isPresent()) {
        graph.addNodeProperty(subject, property, literal.get());
        if (mappedProperties.containsKey(property)) {
          graph.addNodeProperty(subject, mappedProperties.get(property), literal.get());
        }
      }
    } else if ((axiom.getValue() instanceof IRI)
        || (axiom.getValue() instanceof OWLAnonymousIndividual)) {
      long object = 0L;
      if (axiom.getValue() instanceof IRI) {
        object = getOrCreateNode(((IRI) axiom.getValue()).toString());
      } else if (axiom.getValue() instanceof OWLAnonymousIndividual) {
        object = getOrCreateNode(OwlApiUtils.getIri((OWLAnonymousIndividual) axiom.getValue()));
      }
      long assertion =
          getOrCreateRelationship(subject, object, RelationshipType.withName(property));
      graph.setRelationshipProperty(assertion, CommonProperties.IRI, property);
      graph.setRelationshipProperty(assertion, CommonProperties.OWL_TYPE,
          OwlRelationships.OWL_ANNOTATION.name());
    } else {
      logger.info("Ignoring assertion axiom: " + axiom);
    }
  } else {
    logger.info("Ignoring assertion axiom: " + axiom);
  }
  return null;
}
 

/**
 * Factory method to create a QueryArgument instance with type BNODE by string.
 *
 * @param value
 * @return
 */
public static QueryArgument newBnode(OWLAnonymousIndividual value) {
    return new QueryArgument(value);
}