How to use

createLiteral

method

in

org.eclipse.rdf4j.model.ValueFactory

/**
 * Creates a {@link Literal}.
 * @param d double representation of the {@link org.eclipse.rdf4j.model.Literal}
 * @return valid {@link org.eclipse.rdf4j.model.Literal}
 */
public static Literal literal(double d) {
  return valueFactory.createLiteral(d);
}

/**
 * Creates a {@link Literal}.
 * @param s string representation of the base namespace for the
 * {@link org.eclipse.rdf4j.model.Literal}
 * @param datatype the datatype to associate with the namespace.
 * @return valid {@link org.eclipse.rdf4j.model.Literal}
 */
public static Literal literal(String s, org.eclipse.rdf4j.model.IRI datatype) {
  return valueFactory.createLiteral(s, datatype);
}

/**
 * Creates a {@link Literal}.
 * @param f float representation of the {@link org.eclipse.rdf4j.model.Literal}
 * @return valid {@link org.eclipse.rdf4j.model.Literal}
 */
public static Literal literal(float f) {
  return valueFactory.createLiteral(f);
}

/**
 * Creates a {@link Literal}.
 * @param i int representation of the {@link org.eclipse.rdf4j.model.Literal}
 * @return valid {@link org.eclipse.rdf4j.model.Literal}
 */
public static Literal literal(int i) {
  return valueFactory.createLiteral(i);
}

/*******************************************************************************************************************
 *
 *
 ******************************************************************************************************************/
@Nonnull
public static Value literalFor (final Path path)
 {
  return FACTORY.createLiteral(Normalizer.normalize(path.toString(), NFC));
 }

public void writeTripleIntegerObject(Resource subject, IRI predicate,
    int objectLiteral) throws RDFHandlerException {
  writeTripleValueObject(subject, predicate,
      factory.createLiteral(objectLiteral));
}

public void writeTripleStringObject(Resource subject, IRI predicate,
    String objectLiteral) throws RDFHandlerException {
  writeTripleValueObject(subject, predicate,
      factory.createLiteral(objectLiteral));
}

@Override
protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
  throws ArithmeticException
{
  return Optional.of(vf.createLiteral(integerValue.intValueExact()));
}

  @Override
  protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
  {
    if (integerValue.compareTo(BigInteger.ZERO) >= 0) {
      return Optional.of(vf.createLiteral(integerValue.toString(), getXsdDatatype()));
    }
    return Optional.empty();
  }
}

@Override
protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
{
  if (integerValue.compareTo(BigInteger.ZERO) <= 0) {
    return Optional.of(vf.createLiteral(integerValue.toString(), getXsdDatatype()));
  }
  return Optional.empty();
}

public Literal createLiteral(String label, String language) {
  if (!Literals.isValidLanguageTag(language)) {
    throw new IllegalArgumentException("Not a valid language tag: " + language);
  }
  return delegate.createLiteral(label, language);
}

@Override
protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
  throws ArithmeticException
{
  return Optional.of(vf.createLiteral(integerValue.byteValueExact()));
}

@Override
public ValueConstant visit(ASTFalse node, Object data)
  throws VisitorException
{
  return new ValueConstant(valueFactory.createLiteral(false));
}

@Override
protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
{
  if (integerValue.compareTo(BigInteger.ZERO) <= 0) {
    return Optional.of(vf.createLiteral(integerValue.toString(), getXsdDatatype()));
  }
  return Optional.empty();
}

  @Override
  protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
  {
    if (integerValue.compareTo(BigInteger.ZERO) < 0) {
      return Optional.of(vf.createLiteral(integerValue.toString(), getXsdDatatype()));
    }
    return Optional.empty();
  }
}

@Override
protected Optional<Literal> createTypedLiteral(ValueFactory vf, BigInteger integerValue)
  throws ArithmeticException
{
  if (integerValue.compareTo(BigInteger.ZERO) >= 0) {
    return Optional.of(vf.createLiteral(String.valueOf(integerValue.byteValueExact()), getXsdDatatype()));
  }
  return Optional.empty();
}

@Override
public Literal normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)
  throws LiteralUtilException
{
  if (isRecognizedDatatype(datatypeUri) && verifyDatatypeInternal(literalValue, datatypeUri)) {
    // TODO: Implement normalization
    return valueFactory.createLiteral(literalValue, datatypeUri);
  }
  throw new LiteralUtilException("Could not normalise Virtuoso Geometry literal");
}

@Override
public Literal normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)
  throws LiteralUtilException
{
  if (isRecognizedDatatype(datatypeUri) && verifyDatatypeInternal(literalValue, datatypeUri)) {
    // TODO: Implement normalization
    return valueFactory.createLiteral(literalValue, datatypeUri);
  }
  throw new LiteralUtilException("Could not normalise Virtuoso Geometry literal");
}

public Value evaluate(Lang node, BindingSet bindings)
  throws ValueExprEvaluationException, QueryEvaluationException
{
  Value argValue = evaluate(node.getArg(), bindings);
  if (argValue instanceof Literal) {
    Literal literal = (Literal)argValue;
    return tripleSource.getValueFactory().createLiteral(literal.getLanguage().orElse(""));
  }
  throw new ValueExprEvaluationException();
}

  private void addQueryNode(Model m, Resource implNode, IRI predicate, String queryText) {
    if (null != queryText) {
      ValueFactory factory = SimpleValueFactory.getInstance();
      BNode queryNode = factory.createBNode();
      m.add(implNode, predicate, queryNode);
      m.add(queryNode, RDF.TYPE, SP.CONSTRUCT_CLASS);
      m.add(queryNode, SP.TEXT_PROPERTY, factory.createLiteral(queryText));
    }
  }
}