How to use

getOWLTypedLiteral

method

in

org.semanticweb.owlapi.model.OWLDataFactory

public static OWLTypedLiteral TypedLiteral(String literal) {
  return dataFactory.getOWLTypedLiteral(literal);
}

public static OWLTypedLiteral TypedLiteral(int literal) {
  return dataFactory.getOWLTypedLiteral(literal);
}

public static OWLTypedLiteral TypedLiteral(boolean literal) {
  return dataFactory.getOWLTypedLiteral(literal);
}

public static OWLTypedLiteral TypedLiteral(float literal) {
  return dataFactory.getOWLTypedLiteral(literal);
}

public static OWLTypedLiteral TypedLiteral(double literal) {
  return dataFactory.getOWLTypedLiteral(literal);
}

private SWRLLiteralArgument getSWRLTypedLiteral(OWLDataFactory factory, Object argument) {
  OWLLiteral owlLiteral;
  if (argument instanceof String) {
    owlLiteral = factory.getOWLTypedLiteral((String) argument);
  } else if (argument instanceof Integer) {
    owlLiteral = factory.getOWLTypedLiteral(((Integer) argument).intValue());
  } else if (argument instanceof Double) {
    owlLiteral = factory.getOWLTypedLiteral(((Double) argument).doubleValue());
  } else if (argument instanceof Float) {
    owlLiteral = factory.getOWLTypedLiteral(((Float) argument).floatValue());
  } else if (argument instanceof Boolean) {
    owlLiteral = factory.getOWLTypedLiteral(((Boolean) argument).booleanValue());
  } else {
    owlLiteral = factory.getOWLStringLiteral(argument.toString());
  }
  return factory.getSWRLLiteralArgument(owlLiteral);
}

/**
 * Given a number, returns a typed constant that represent the number.
 *
 * @param val The number to be translated to a typed constant.
 * @return The typed constant, consisting of a string literal and datatype that
 *         corresponds to the translation of the specified number.
 */
public static <N extends Number> OWLTypedLiteral getTypedConstant(OWLDataFactory dataFactory, N val) {
  return dataFactory.getOWLTypedLiteral(val.toString(), getDatatype(dataFactory, val));
}

private OWLLiteral process(OWLDataPropertyExpression prop, OWLLiteral con) {
  OWLDatatype dt = map.get(prop);
  if (dt != null) {
    return getDataFactory().getOWLTypedLiteral(con.getLiteral(), dt);
  } else {
    return con;
  }
}

final public OWLLiteral parseLiteral() throws ParseException {
 Token t;
 if (jj_2_49(5)) {
  t = jj_consume_token(INT);
     {if (true) return factory.getOWLTypedLiteral(Integer.parseInt(t.image));}
 } else if (jj_2_50(5)) {
  t = jj_consume_token(DOUBLE);
       {if (true) return factory.getOWLTypedLiteral(Double.parseDouble(t.image));}
 } else {
  jj_consume_token(-1);
  throw new ParseException();
 }
 throw new Error("Missing return statement in function");
}

public void visit(OWLTypedLiteral node) {
  node.getDatatype().accept(this);
  OWLDatatype dt = (OWLDatatype) obj;
  obj = dataFactory.getOWLTypedLiteral(node.getLiteral(), dt);
}

final public OWLTypedLiteral TypedLiteral() throws ParseException {
 String literal;
 OWLDatatype datatype=null;
 literal = QuotedString();
 jj_consume_token(129);
 datatype = DatatypeIRI();
     {if (true) return dataFactory.getOWLTypedLiteral(literal, datatype);}
 throw new Error("Missing return statement in function");
}

private OWLTypedLiteral toTypedConstant(int i) {
  return manager.getOWLDataFactory().getOWLTypedLiteral(Integer.toString(i), manager.getOWLDataFactory().getOWLDatatype(XSDVocabulary.NON_NEGATIVE_INTEGER.getIRI()));
}

public void handleChild(OWLLiteralElementHandler handler) {
  if (handler.getOWLObject().isOWLTypedLiteral()) {
    constants.add((OWLTypedLiteral) handler.getOWLObject());
  } else {
    // Type as string?
    OWLLiteral currentLiteral = handler.getOWLObject();
    constants.add(getOWLDataFactory().getOWLTypedLiteral(currentLiteral.getLiteral()));
  }
}

/**
 * A convenience method to obtain an <code>OWLConstant</code>
 *
 * @param literal The literal - must NOT be <code>null</code>
 * @param datatype The data type - may be <code>null</code>
 * @param lang The lang - may be <code>null</code>
 * @return The <code>OWLConstant</code> (either typed or untyped depending on the params)
 */
private OWLLiteral getOWLConstant(String literal, String datatype, String lang) {
  if (datatype != null) {
    return dataFactory.getOWLTypedLiteral(literal, dataFactory.getOWLDatatype(getIRI(datatype)));
  }
  else {
    return dataFactory.getOWLStringLiteral(literal, lang);
  }
}

protected OWLLiteral getBooleanConstant(Boolean b) {
  if (b) {
    return getDataFactory().getOWLTypedLiteral("true",
        getDataFactory().getOWLDatatype(XSDVocabulary.BOOLEAN.getIRI()));
  } else {
    return getDataFactory().getOWLTypedLiteral("false",
        getDataFactory().getOWLDatatype(XSDVocabulary.BOOLEAN.getIRI()));
  }
}

  public void handleTriple(IRI subject, IRI predicate, IRI object) throws UnloadableImportException {
    consumeTriple(subject, predicate, object);
    getConsumer().addRestriction(subject);
    // Patch to new OWL syntax
    getConsumer().addTriple(subject, OWLRDFVocabulary.OWL_HAS_SELF.getIRI(), getDataFactory().getOWLTypedLiteral(true));
  }
}

public void endElement() throws OWLParserException, UnloadableImportException {
  if (iri != null) {
    literal = getOWLDataFactory().getOWLTypedLiteral(getText(), getOWLDataFactory().getOWLDatatype(iri));
  } else {
    literal = getOWLDataFactory().getOWLStringLiteral(getText(), lang);
  }
  lang = null;
  iri = null;
  getParentHandler().handleChild(this);
}

public void visit(OWLObjectHasSelf desc) {
  translateAnonymousNode(desc);
  addTriple(desc, RDF_TYPE.getIRI(), OWL_RESTRICTION.getIRI());
  addTriple(desc, OWL_ON_PROPERTY.getIRI(), desc.getProperty());
  addTriple(desc, OWL_HAS_SELF.getIRI(), manager.getOWLDataFactory().getOWLTypedLiteral(true));
}

protected OWLLiteral convert(LiteralValue prop) {
  if (prop instanceof OWLAPILiteralValue) {
    return ((OWLAPILiteralValue) prop).lit;
  } else {
    if (prop.getLanguage() != null) {
      return factory.getOWLStringLiteral(prop.getValue(), prop.getLanguage().toString());
    } else if (prop.getDatatype() != null) {
      return factory.getOWLTypedLiteral(prop.getValue(), convert(prop.getDatatype()));
    } else {
      return factory.getOWLStringLiteral(prop.getValue());
    }
  }
}

  public void handle(String id, String value) {
    // This is an annotation - but add as a label
    OWLEntity ent;
    if (getConsumer().isTerm()) {
      ent = getDataFactory().getOWLClass(getIRIFromValue(id));
    } else if (getConsumer().isTypedef()) {
      ent = getDataFactory().getOWLObjectProperty(getIRIFromValue(id));
    } else {
      ent = getDataFactory().getOWLNamedIndividual(getIRIFromValue(id));
    }
    OWLLiteral con = getDataFactory().getOWLTypedLiteral(value);
    OWLAxiom ax = getDataFactory().getOWLAnnotationAssertionAxiom(getDataFactory().getOWLAnnotationProperty(OWLRDFVocabulary.RDFS_LABEL.getIRI()), ent.getIRI(), con);
    applyChange(new AddAxiom(getOntology(), ax));
  }
}