## Uses of Interface
org.eclipse.rdf4j.model.Literal

- Packages that use Literal
  Package | Description
  --- | ---
  org.eclipse.rdf4j.federated.util |
  org.eclipse.rdf4j.http.protocol.transaction |
  org.eclipse.rdf4j.model | The RDF Model API
  org.eclipse.rdf4j.model.base | Abstract base classes for RDF Model API interfaces.
  org.eclipse.rdf4j.model.impl | Default implementations of the RDF model interfaces
  org.eclipse.rdf4j.model.util | Helper classes for working with RDF models.
  org.eclipse.rdf4j.query.algebra.evaluation.function.datetime |
  org.eclipse.rdf4j.query.algebra.evaluation.function.hash |
  org.eclipse.rdf4j.query.algebra.evaluation.function.numeric |
  org.eclipse.rdf4j.query.algebra.evaluation.function.rdfterm |
  org.eclipse.rdf4j.query.algebra.evaluation.function.string |
  org.eclipse.rdf4j.query.algebra.evaluation.function.xsd | Functions for casting values to various XML Schema datatypes
  org.eclipse.rdf4j.query.algebra.evaluation.util |
  org.eclipse.rdf4j.query.dawg | Functionality to convert tuple query results to and from the Data Access Working Group Test Result Set RDF Vocabulary
  org.eclipse.rdf4j.query.resultio.text.tsv |
  org.eclipse.rdf4j.repository | The Repository API: the main API for accessing rdf databases and SPARQL endpoints.
  org.eclipse.rdf4j.repository.optimistic |
  org.eclipse.rdf4j.rio | Rio: The RDF4J parser/writer API.
  org.eclipse.rdf4j.rio.datatypes | Various `DatatypeHandler` implementations.
  org.eclipse.rdf4j.rio.helpers | Provides helpers classes for Rio.
  org.eclipse.rdf4j.rio.languages | Various `LanguageHandler` implementations for processing language-tags.
  org.eclipse.rdf4j.rio.ntriples | Parser/writer for the N-Triples format.
  org.eclipse.rdf4j.rio.rdfjson | Parser/writer for the RDF/JSON format.
  org.eclipse.rdf4j.rio.rdfxml | Parser/writer for the RDF/XML format.
  org.eclipse.rdf4j.rio.trix | Parser/writer for the TriX format.
  org.eclipse.rdf4j.rio.turtle | Parser/writer for the Turtle format.
  org.eclipse.rdf4j.sail | RDF Storage And Inference Layer (RDF Sail): a set of interfaces defining an SPI for RDF databases.
  org.eclipse.rdf4j.sail.lucene | A Sail implementation that supports full-text indexing via the Lucene API.
  org.eclipse.rdf4j.sail.memory.model |
  org.eclipse.rdf4j.sail.nativerdf | The Native Store.
  org.eclipse.rdf4j.sail.nativerdf.model |
  org.eclipse.rdf4j.sail.shacl.planNodes |
  org.eclipse.rdf4j.spin.function | Core functions required for SPIN.

- - ### Uses of Literal in org.eclipse.rdf4j.federated.util

    Methods in org.eclipse.rdf4j.federated.util that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `static Literal` | FedXUtil.`literal(String literal)`

    Methods in org.eclipse.rdf4j.federated.util with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected static StringBuilder` | FilterUtils.`appendLiteral(StringBuilder sb, Literal lit)`
    `protected static StringBuilder` | QueryStringUtil.`appendLiteral(StringBuilder sb, Literal lit)` Append the literal to the stringbuilder.

  - ### Uses of Literal in org.eclipse.rdf4j.http.protocol.transaction

    Methods in org.eclipse.rdf4j.http.protocol.transaction with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | TransactionWriter.`serialize(Literal literal, XMLWriter xmlWriter)`

  - ### Uses of Literal in org.eclipse.rdf4j.model

    Fields in org.eclipse.rdf4j.model declared as Literal
    Modifier and Type | Field and Description
    --- | ---
    `protected Literal` | ModelTest.`literal1`
    `protected Literal` | ModelTest.`literal2`
    `protected Literal` | ModelTest.`literal3`

    Methods in org.eclipse.rdf4j.model that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | ValueFactory.`createLiteral(BigDecimal bigDecimal)` Creates a new literal representing the specified bigDecimal that is typed as an `xsd:Decimal`.
    `Literal` | ValueFactory.`createLiteral(BigInteger bigInteger)` Creates a new literal representing the specified bigInteger that is typed as an `xsd:Integer`.
    `Literal` | ValueFactory.`createLiteral(boolean value)` Creates a new `xsd:boolean`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(byte value)` Creates a new `xsd:byte`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(Date date)` Creates a new literal representing the specified date that is typed using the appropriate XML Schema date/time datatype.
    `Literal` | ValueFactory.`createLiteral(double value)` Creates a new `xsd:double`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(float value)` Creates a new `xsd:float`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(int value)` Creates a new `xsd:int`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(long value)` Creates a new `xsd:long`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(short value)` Creates a new `xsd:short`-typed literal representing the specified value.
    `Literal` | ValueFactory.`createLiteral(String label)` Creates a new literal with the supplied label.
    `Literal` | ValueFactory.`createLiteral(String label, IRI datatype)` Creates a new literal with the supplied label and datatype.
    `Literal` | ValueFactory.`createLiteral(String label, String language)` Creates a new literal with the supplied label and language attribute.
    `default Literal` | ValueFactory.`createLiteral(String label, URI datatype)` Deprecated. Use `ValueFactory.createLiteral(String, IRI)` instead.
    `default Literal` | ValueFactory.`createLiteral(java.time.temporal.TemporalAccessor value)` Creates a new literal representing a temporal accessor value.
    `default Literal` | ValueFactory.`createLiteral(java.time.temporal.TemporalAmount value)` Creates a new literal representing a temporal amount value.
    `Literal` | ValueFactory.`createLiteral(XMLGregorianCalendar calendar)` Creates a new literal representing the specified calendar that is typed using the appropriate XML Schema date/time datatype.

  - ### Uses of Literal in org.eclipse.rdf4j.model.base

    Classes in org.eclipse.rdf4j.model.base that implement Literal
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractLiteral` Base class for `Literal`, offering common functionality.

    Methods in org.eclipse.rdf4j.model.base that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | AbstractValueFactory.`createLiteral(BigDecimal bigDecimal)`
    `Literal` | AbstractValueFactory.`createLiteral(BigInteger bigInteger)`
    `Literal` | AbstractValueFactory.`createLiteral(boolean value)`
    `Literal` | AbstractValueFactory.`createLiteral(byte value)`
    `Literal` | AbstractValueFactory.`createLiteral(Date date)`
    `Literal` | AbstractValueFactory.`createLiteral(double value)`
    `Literal` | AbstractValueFactory.`createLiteral(float value)`
    `Literal` | AbstractValueFactory.`createLiteral(int value)`
    `Literal` | AbstractValueFactory.`createLiteral(long value)`
    `Literal` | AbstractValueFactory.`createLiteral(short value)`
    `Literal` | AbstractValueFactory.`createLiteral(String label)`
    `Literal` | AbstractValueFactory.`createLiteral(String label, IRI datatype)`
    `Literal` | AbstractValueFactory.`createLiteral(String label, String language)`
    `Literal` | AbstractValueFactory.`createLiteral(java.time.temporal.TemporalAccessor value)`
    `Literal` | AbstractValueFactory.`createLiteral(java.time.temporal.TemporalAmount value)`
    `Literal` | AbstractValueFactory.`createLiteral(XMLGregorianCalendar calendar)`

  - ### Uses of Literal in org.eclipse.rdf4j.model.impl

    Classes in org.eclipse.rdf4j.model.impl that implement Literal
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BooleanLiteral` An extension of `SimpleLiteral` that stores a boolean value to avoid parsing.
    `class` | `BooleanLiteralImpl` Deprecated. since 2.0. Use `BooleanLiteral` instead.
    `class` | `CalendarLiteral` An extension of `SimpleLiteral` that stores a calendar value to avoid parsing.
    `class` | `DecimalLiteral` An extension of `SimpleLiteral` that stores an integer value using a `BigDecimal` object.
    `class` | `IntegerLiteral` An extension of `SimpleLiteral` that stores an integer value using a `BigInteger` object.
    `class` | `LiteralImpl` Deprecated. since 2.0. Use `SimpleLiteral` for extending, and instantiate using a `ValueFactory`.
    `class` | `NumericLiteral` An extension of `SimpleLiteral` that stores a numeric value to avoid parsing.
    `class` | `SimpleLiteral` A simple default implementation of the `Literal` interface.

    Methods in org.eclipse.rdf4j.model.impl that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | AbstractValueFactory.`createFPLiteral(Number value, IRI datatype)` Deprecated. Calls `AbstractValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | SimpleValueFactory.`createFPLiteral(Number value, IRI datatype)` Calls `SimpleValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | AbstractValueFactory.`createFPLiteral(Number value, XSD.Datatype datatype)` Deprecated.
    `protected Literal` | SimpleValueFactory.`createFPLiteral(Number value, XSD.Datatype datatype)`
    `protected Literal` | AbstractValueFactory.`createIntegerLiteral(Number value, IRI datatype)` Deprecated. Calls `AbstractValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | SimpleValueFactory.`createIntegerLiteral(Number value, IRI datatype)` Calls `SimpleValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | AbstractValueFactory.`createIntegerLiteral(Number value, XSD.Datatype datatype)` Deprecated.
    `protected Literal` | SimpleValueFactory.`createIntegerLiteral(Number value, XSD.Datatype datatype)`
    `Literal` | ValidatingValueFactory.`createLiteral(BigDecimal bigDecimal)`
    `Literal` | AbstractValueFactory.`createLiteral(BigDecimal bigDecimal)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(BigDecimal bigDecimal)`
    `Literal` | ValidatingValueFactory.`createLiteral(BigInteger bigInteger)`
    `Literal` | AbstractValueFactory.`createLiteral(BigInteger bigInteger)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(BigInteger bigInteger)`
    `Literal` | ValidatingValueFactory.`createLiteral(boolean value)`
    `Literal` | AbstractValueFactory.`createLiteral(boolean b)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(boolean b)`
    `Literal` | ValidatingValueFactory.`createLiteral(byte value)`
    `Literal` | AbstractValueFactory.`createLiteral(byte value)` Deprecated. Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.BYTE` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(byte value)` Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.BYTE` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(Date date)`
    `Literal` | AbstractValueFactory.`createLiteral(Date date)` Deprecated. Converts the supplied `Date` to a `XMLGregorianCalendar`, then calls `ValueFactory.createLiteral(XMLGregorianCalendar)`.
    `Literal` | SimpleValueFactory.`createLiteral(Date date)` Converts the supplied `Date` to a `XMLGregorianCalendar`, then calls `ValueFactory.createLiteral(XMLGregorianCalendar)`.
    `Literal` | ValidatingValueFactory.`createLiteral(double value)`
    `Literal` | AbstractValueFactory.`createLiteral(double value)` Deprecated. Calls `AbstractValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.DOUBLE` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(double value)` Calls `SimpleValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.DOUBLE` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(float value)`
    `Literal` | AbstractValueFactory.`createLiteral(float value)` Deprecated. Calls `AbstractValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.FLOAT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(float value)` Calls `SimpleValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.FLOAT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(int value)`
    `Literal` | AbstractValueFactory.`createLiteral(int value)` Deprecated. Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.INT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(int value)` Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.INT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(long value)`
    `Literal` | AbstractValueFactory.`createLiteral(long value)` Deprecated. Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.LONG` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(long value)` Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.LONG` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(short value)`
    `Literal` | AbstractValueFactory.`createLiteral(short value)` Deprecated. Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.SHORT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(short value)` Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.SHORT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(String label)`
    `Literal` | AbstractValueFactory.`createLiteral(String value)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(String value)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, IRI datatype)`
    `Literal` | AbstractValueFactory.`createLiteral(String value, IRI datatype)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(String value, IRI datatype)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, String language)`
    `Literal` | AbstractValueFactory.`createLiteral(String value, String language)` Deprecated.
    `Literal` | SimpleValueFactory.`createLiteral(String value, String language)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, URI datatype)`
    `Literal` | ValidatingValueFactory.`createLiteral(java.time.temporal.TemporalAccessor value)`
    `Literal` | ValidatingValueFactory.`createLiteral(java.time.temporal.TemporalAmount value)`
    `Literal` | ValidatingValueFactory.`createLiteral(XMLGregorianCalendar calendar)`
    `Literal` | AbstractValueFactory.`createLiteral(XMLGregorianCalendar calendar)` Deprecated. Calls `ValueFactory.createLiteral(String, IRI)` with the String-value of the supplied calendar and the appropriate datatype as parameters.
    `Literal` | SimpleValueFactory.`createLiteral(XMLGregorianCalendar calendar)` Calls `ValueFactory.createLiteral(String, IRI)` with the String-value of the supplied calendar and the appropriate datatype as parameters.
    `protected Literal` | AbstractValueFactory.`createNumericLiteral(Number number, IRI datatype)` Deprecated. Creates specific optimized subtypes of SimpleLiteral for numeric datatypes.
    `protected Literal` | SimpleValueFactory.`createNumericLiteral(Number number, IRI datatype)` Creates specific optimized subtypes of SimpleLiteral for numeric datatypes.
    `protected Literal` | AbstractValueFactory.`createNumericLiteral(Number number, XSD.Datatype datatype)` Deprecated.
    `protected Literal` | SimpleValueFactory.`createNumericLiteral(Number number, XSD.Datatype datatype)`

  - ### Uses of Literal in org.eclipse.rdf4j.model.util

    Methods in org.eclipse.rdf4j.model.util that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `static Literal` | Literals.`createLiteral(ValueFactory valueFactory, Object object)` Deprecated. since 3.5.0 - use `Values.literal(Object)` instead.
    `static Literal` | Literals.`createLiteralOrFail(ValueFactory valueFactory, Object object)` Deprecated. since 3.5.0 - use `Values.literal(Object, boolean)` instead.
    `static Literal` | Values.`literal(BigDecimal bigDecimal)` Creates a new `Literal` with the supplied `BigDecimal` value
    `static Literal` | Values.`literal(BigInteger bigInteger)` Creates a new `Literal` with the supplied `BigInteger` value
    `static Literal` | Values.`literal(boolean booleanValue)` Creates a new `Literal` with the supplied boolean value
    `static Literal` | Values.`literal(byte byteValue)` Creates a new `Literal` with the supplied byte value
    `static Literal` | Values.`literal(double doubleValue)` Creates a new `Literal` with the supplied double value
    `static Literal` | Values.`literal(float floatValue)` Creates a new `Literal` with the supplied float value
    `static Literal` | Values.`literal(int intValue)` Creates a new `Literal` with the supplied int value
    `static Literal` | Values.`literal(long longValue)` Creates a new `Literal` with the supplied long value
    `static Literal` | Values.`literal(Object object)` Creates a new typed `Literal` out of the supplied object, mapping the runtime type of the object to the appropriate `XSD` datatype.
    `static Literal` | Values.`literal(Object object, boolean failOnUnknownType)` Creates a new typed `Literal` out of the supplied object, mapping the runtime type of the object to the appropriate `XSD` datatype.
    `static Literal` | Values.`literal(short shortValue)` Creates a new `Literal` with the supplied short value
    `static Literal` | Values.`literal(String lexicalValue)` Creates a new `Literal` with the supplied lexical value.
    `static Literal` | Values.`literal(String lexicalValue, IRI datatype)` Creates a new `Literal` with the supplied lexical value and datatype.
    `static Literal` | Values.`literal(java.time.temporal.TemporalAccessor value)` Creates a new `Literal` with the supplied `TemporalAccessor` value
    `static Literal` | Values.`literal(ValueFactory vf, BigDecimal bigDecimal)` Creates a new `Literal` with the supplied `BigDecimal` value
    `static Literal` | Values.`literal(ValueFactory vf, BigInteger bigInteger)` Creates a new `Literal` with the supplied `BigInteger` value
    `static Literal` | Values.`literal(ValueFactory vf, boolean booleanValue)` Creates a new `Literal` with the supplied boolean value
    `static Literal` | Values.`literal(ValueFactory vf, byte byteValue)` Creates a new `Literal` with the supplied byte value
    `static Literal` | Values.`literal(ValueFactory vf, double doubleValue)` Creates a new `Literal` with the supplied double value
    `static Literal` | Values.`literal(ValueFactory vf, float floatValue)` Creates a new `Literal` with the supplied float value
    `static Literal` | Values.`literal(ValueFactory vf, int intValue)` Creates a new `Literal` with the supplied int value
    `static Literal` | Values.`literal(ValueFactory vf, long longValue)` Creates a new `Literal` with the supplied long value
    `static Literal` | Values.`literal(ValueFactory vf, Object object, boolean failOnUnknownType)` Creates a new typed `Literal` out of the supplied object, mapping the runtime type of the object to the appropriate `XSD` datatype.
    `static Literal` | Values.`literal(ValueFactory vf, short shortValue)` Creates a new `Literal` with the supplied short value
    `static Literal` | Values.`literal(ValueFactory vf, String lexicalValue)` Creates a new `Literal` with the supplied lexical value.
    `static Literal` | Values.`literal(ValueFactory vf, String lexicalValue, IRI datatype)` Creates a new `Literal` with the supplied lexical value and datatype.
    `static Literal` | Values.`literal(ValueFactory vf, java.time.temporal.TemporalAccessor value)` Creates a new `Literal` with the supplied `TemporalAccessor` value

    Methods in org.eclipse.rdf4j.model.util that return types with arguments of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static Optional<Literal>` | Models.`getPropertyLiteral(Model m, Resource subject, IRI property, Resource... contexts)` Retrieve a property value as a `Literal` for the supplied subject from the given model.
    `static Set<Literal>` | Models.`getPropertyLiterals(Model m, Resource subject, IRI property, Resource... contexts)` Retrieve all property Literal values for the supplied subject and property from the given model.
    `static Optional<Literal>` | Models.`objectLiteral(Iterable<Statement> statements)` Retrieves an object `Literal` value from the supplied statements.
    `static Optional<Literal>` | Models.`objectLiteral(Model m)` Retrieves an object `Literal` value from the statements in the given model.
    `static Set<Literal>` | Models.`objectLiterals(Iterable<Statement> statements)` Retrieves all object `Literal` values from the supplied statements.
    `static Set<Literal>` | Models.`objectLiterals(Model m)` Retrieves all object `Literal` values from the statements in the given model.

    Methods in org.eclipse.rdf4j.model.util with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | Literals.`getBooleanValue(Literal l, boolean fallback)` Gets the boolean value of the supplied literal.
    `static byte` | Literals.`getByteValue(Literal l, byte fallback)` Gets the byte value of the supplied literal.
    `static XMLGregorianCalendar` | Literals.`getCalendarValue(Literal l, XMLGregorianCalendar fallback)` Gets the calendar value of the supplied literal.
    `static BigDecimal` | Literals.`getDecimalValue(Literal l, BigDecimal fallback)` Gets the decimal value of the supplied literal.
    `static double` | Literals.`getDoubleValue(Literal l, double fallback)` Gets the double value of the supplied literal.
    `static Duration` | Literals.`getDurationValue(Literal l, Duration fallback)` Gets the `Duration` value of the supplied literal.
    `static float` | Literals.`getFloatValue(Literal l, float fallback)` Gets the float value of the supplied literal.
    `static BigInteger` | Literals.`getIntegerValue(Literal l, BigInteger fallback)` Gets the integer value of the supplied literal.
    `static int` | Literals.`getIntValue(Literal l, int fallback)` Gets the int value of the supplied literal.
    `static String` | Literals.`getLabel(Literal l, String fallback)` Gets the label of the supplied literal.
    `static long` | Literals.`getLongValue(Literal l, long fallback)` Gets the long value of the supplied literal.
    `static short` | Literals.`getShortValue(Literal l, short fallback)` Gets the short value of the supplied literal.
    `static Optional<XSD.Datatype>` | Literals.`getXsdDatatype(Literal l)` Retrieves the `XSD.Datatype` value for the supplied Literal, if it has one.
    `static boolean` | Literals.`isLanguageLiteral(Literal literal)` Helper method to determine whether a literal is a language literal, and not a typed literal.

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.datetime

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.datetime that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | Tz.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Hours.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Month.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Seconds.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Minutes.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Timezone.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Year.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Day.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Now.`evaluate(ValueFactory valueFactory, Value... args)`

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.hash

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.hash that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | SHA256.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | SHA384.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | SHA512.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | SHA1.`evaluate(ValueFactory valueFactory, Value... args)`
    `abstract Literal` | HashFunction.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | MD5.`evaluate(ValueFactory valueFactory, Value... args)`

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.numeric

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.numeric that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | Ceil.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Abs.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Floor.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Round.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Rand.`evaluate(ValueFactory valueFactory, Value... args)`

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.rdfterm

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.rdfterm that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | STRUUID.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrLang.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrDt.`evaluate(ValueFactory valueFactory, Value... args)`

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.string

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.string that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | Replace.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrAfter.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrLen.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Concat.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Substring.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrStarts.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | LowerCase.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrBefore.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | Contains.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | UpperCase.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | EncodeForUri.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | StrEnds.`evaluate(ValueFactory valueFactory, Value... args)`

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.string with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static int` | Substring.`intFromLiteral(Literal literal)`

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.function.xsd

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.xsd that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | DateTimeCast.`convert(ValueFactory vf, Value value)`
    `protected Literal` | DecimalCast.`convert(ValueFactory valueFactory, Value value)`
    `protected Literal` | DoubleCast.`convert(ValueFactory valueFactory, Value value)`
    `protected Literal` | StringCast.`convert(ValueFactory valueFactory, Value value)`
    `protected Literal` | BooleanCast.`convert(ValueFactory valueFactory, Value value)`
    `protected Literal` | FloatCast.`convert(ValueFactory valueFactory, Value value)`
    `protected abstract Literal` | CastFunction.`convert(ValueFactory vf, Value v)` Convert the supplied value to a literal of the function output datatype.
    `protected Literal` | IntegerCastFunction.`convert(ValueFactory valueFactory, Value value)`
    `Literal` | StringCast.`evaluate(ValueFactory valueFactory, Value... args)`
    `Literal` | CastFunction.`evaluate(ValueFactory valueFactory, Value... args)`

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.xsd that return types with arguments of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Optional<Literal>` | ByteCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | NegativeIntegerCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | UnsignedIntCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | UnsignedShortCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | NonPositiveIntegerCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | PositiveIntegerCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | UnsignedLongCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | IntCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | LongCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | UnsignedByteCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | IntegerCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | NonNegativeIntegerCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected abstract Optional<Literal>` | IntegerCastFunction.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)` create a `Literal` with the specific datatype for the supplied `BigInteger` value.
    `protected Optional<Literal>` | ShortCast.`createTypedLiteral(ValueFactory vf, BigInteger integerValue)`
    `protected Optional<Literal>` | NonPositiveIntegerCast.`createTypedLiteral(ValueFactory vf, boolean booleanValue)`
    `protected Optional<Literal>` | PositiveIntegerCast.`createTypedLiteral(ValueFactory vf, boolean booleanValue)`
    `protected Optional<Literal>` | IntegerCastFunction.`createTypedLiteral(ValueFactory vf, boolean booleanValue)` create a `Literal` with the specific datatype for the supplied boolean value.

  - ### Uses of Literal in org.eclipse.rdf4j.query.algebra.evaluation.util

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.util that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `static Literal` | XMLDatatypeMathUtil.`compute(Literal leftLit, Literal rightLit, MathExpr.MathOp op)` Computes the result of applying the supplied math operator on the supplied left and right operand.
    `static Literal` | MathUtil.`compute(Literal leftLit, Literal rightLit, MathExpr.MathOp op)` Computes the result of applying the supplied math operator on the supplied left and right operand.

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.util that return types with arguments of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static CloseableIteration<Literal,QueryEvaluationException>` | TripleSources.`getObjectLiterals(Resource subject, IRI predicate, TripleSource store)`

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.util with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | QueryEvaluationUtil.`compareLiterals(Literal leftLit, Literal rightLit, Compare.CompareOp operator)` Compares the supplied `Literal` arguments using the supplied operator, using strict (minimally-conforming) SPARQL 1.1 operator behavior.
    `static boolean` | QueryEvaluationUtil.`compareLiterals(Literal leftLit, Literal rightLit, Compare.CompareOp operator, boolean strict)` Compares the supplied `Literal` arguments using the supplied operator.
    `static boolean` | QueryEvaluationUtil.`compatibleArguments(Literal arg1, Literal arg2)` Checks whether the supplied two literal arguments are 'argument compatible' according to the SPARQL definition.
    `static Literal` | XMLDatatypeMathUtil.`compute(Literal leftLit, Literal rightLit, MathExpr.MathOp op)` Computes the result of applying the supplied math operator on the supplied left and right operand.
    `static Literal` | MathUtil.`compute(Literal leftLit, Literal rightLit, MathExpr.MathOp op)` Computes the result of applying the supplied math operator on the supplied left and right operand.
    `static boolean` | QueryEvaluationUtil.`isPlainLiteral(Literal l)`
    `static boolean` | QueryEvaluationUtil.`isSimpleLiteral(Literal l)` Checks whether the supplied literal is a "simple literal".
    `static boolean` | QueryEvaluationUtil.`isStringLiteral(Literal l)` Checks whether the supplied literal is a "string literal".

  - ### Uses of Literal in org.eclipse.rdf4j.query.dawg

    Fields in org.eclipse.rdf4j.query.dawg declared as Literal
    Modifier and Type | Field and Description
    --- | ---
    `static Literal` | DAWGTestResultSetSchema.`FALSE`
    `static Literal` | DAWGTestResultSetSchema.`TRUE`

  - ### Uses of Literal in org.eclipse.rdf4j.query.resultio.text.tsv

    Methods in org.eclipse.rdf4j.query.resultio.text.tsv that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | SPARQLResultsTSVMappingStrategy.`parseLiteral(String literal)` Parses a literal, creates an object for it and returns this object.

  - ### Uses of Literal in org.eclipse.rdf4j.repository

    Fields in org.eclipse.rdf4j.repository declared as Literal
    Modifier and Type | Field and Description
    --- | ---
    `protected Literal` | RepositoryTest.`mboxAlice`
    `protected Literal` | RepositoryConnectionTest.`mboxAlice`
    `protected Literal` | RepositoryTest.`mboxBob`
    `protected Literal` | RepositoryConnectionTest.`mboxBob`
    `protected Literal` | RepositoryTest.`nameAlice`
    `protected Literal` | RepositoryConnectionTest.`nameAlice`
    `protected Literal` | RepositoryTest.`nameBob`
    `protected Literal` | RepositoryConnectionTest.`nameBob`
    `protected Literal` | RepositoryTest.`Александър`
    `protected Literal` | RepositoryConnectionTest.`Александър`

  - ### Uses of Literal in org.eclipse.rdf4j.repository.optimistic

    Methods in org.eclipse.rdf4j.repository.optimistic that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | IsolationLevelTest.`readLiteral(RepositoryConnection con, IRI subj, IRI pred)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio

    Methods in org.eclipse.rdf4j.rio that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | DatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)` Normalize both the datatype URI and the literal value if appropriate, and use the given value factory to generate a literal matching a literal value and datatype URI.
    `Literal` | LanguageHandler.`normalizeLanguage(String literalValue, String languageTag, ValueFactory valueFactory)` Normalize both the language tag and the language if appropriate, and use the given value factory to generate a literal matching the literal value and language tag.

  - ### Uses of Literal in org.eclipse.rdf4j.rio.datatypes

    Methods in org.eclipse.rdf4j.rio.datatypes that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | GeoSPARQLDatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)`
    `Literal` | VirtuosoGeometryDatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)`
    `Literal` | XMLSchemaDatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)`
    `Literal` | RDFDatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)`
    `Literal` | DBPediaDatatypeHandler.`normalizeDatatype(String literalValue, IRI datatypeUri, ValueFactory valueFactory)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio.helpers

    Methods in org.eclipse.rdf4j.rio.helpers that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | AbstractRDFParser.`createLiteral(String label, String lang, IRI datatype)` Creates a `Literal` object with the supplied parameters.
    `protected Literal` | AbstractRDFParser.`createLiteral(String label, String lang, IRI datatype, long lineNo, long columnNo)` Creates a `Literal` object with the supplied parameters, using the lineNo and columnNo to enhance error messages or exceptions that may be generated during the creation of the literal.
    `static Literal` | RDFParserHelper.`createLiteral(String label, String lang, IRI datatype, ParserConfig parserConfig, ParseErrorListener errListener, ValueFactory valueFactory)` Create a literal using the given parameters, including iterative verification and normalization by any `DatatypeHandler` or `LanguageHandler` implementations that are found in the `ParserConfig`.
    `static Literal` | RDFParserHelper.`createLiteral(String label, String lang, IRI datatype, ParserConfig parserConfig, ParseErrorListener errListener, ValueFactory valueFactory, long lineNo, long columnNo)` Create a literal using the given parameters, including iterative verification and normalization by any `DatatypeHandler` or `LanguageHandler` implementations that are found in the `ParserConfig`.
    `static Literal` | NTriplesUtil.`parseLiteral(String nTriplesLiteral, ValueFactory valueFactory)` Parses an N-Triples literal, creates an object for it using the supplied ValueFactory and returns this object.

    Methods in org.eclipse.rdf4j.rio.helpers with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `static void` | NTriplesUtil.`append(Literal lit, Appendable appendable)` Appends the N-Triples representation of the given `Literal` to the given `Appendable`.
    `static void` | NTriplesUtil.`append(Literal lit, Appendable appendable, boolean xsdStringToPlainLiteral, boolean escapeUnicode)` Appends the N-Triples representation of the given `Literal` to the given `Appendable`, optionally ignoring the xsd:string datatype as it is implied for RDF-1.1.
    `static String` | NTriplesUtil.`toNTriplesString(Literal lit)` Creates an N-Triples string for the supplied literal.
    `static String` | NTriplesUtil.`toNTriplesString(Literal lit, boolean xsdStringToPlainLiteral)` Creates an N-Triples string for the supplied literal, optionally ignoring the xsd:string datatype as it is implied for RDF-1.1.

  - ### Uses of Literal in org.eclipse.rdf4j.rio.languages

    Methods in org.eclipse.rdf4j.rio.languages that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | RFC3066LanguageHandler.`normalizeLanguage(String literalValue, String languageTag, ValueFactory valueFactory)`
    `Literal` | BCP47LanguageHandler.`normalizeLanguage(String literalValue, String languageTag, ValueFactory valueFactory)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio.ntriples

    Methods in org.eclipse.rdf4j.rio.ntriples that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | NTriplesParser.`createLiteral(String label, String lang, String datatype)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio.rdfjson

    Methods in org.eclipse.rdf4j.rio.rdfjson that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | RDFJSONParser.`createLiteral(String label, String language, IRI datatype, com.fasterxml.jackson.core.JsonLocation currentLocation)` Creates a literal, using the current value, language, and datatype, and additionally using the given `JsonLocation` to provide information about the line and column numbers in the event of a warning, error or exception being generated by the creation of the literal.

  - ### Uses of Literal in org.eclipse.rdf4j.rio.rdfxml

    Methods in org.eclipse.rdf4j.rio.rdfxml that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | RDFXMLParser.`createLiteral(String label, String lang, IRI datatype)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio.trix

    Methods in org.eclipse.rdf4j.rio.trix that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | TriXParser.`createLiteral(String label, String lang, IRI datatype)`

  - ### Uses of Literal in org.eclipse.rdf4j.rio.turtle

    Methods in org.eclipse.rdf4j.rio.turtle that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | TurtleParser.`parseNumber()`
    `protected Literal` | TurtleParser.`parseQuotedLiteral()` Parses a quoted string, optionally followed by a language tag or datatype.

    Methods in org.eclipse.rdf4j.rio.turtle with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | TurtleWriter.`writeLiteral(Literal lit)`

  - ### Uses of Literal in org.eclipse.rdf4j.sail

    Methods in org.eclipse.rdf4j.sail that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | SailIsolationLevelTest.`readLiteral(SailConnection con, IRI subj, IRI pred)`

  - ### Uses of Literal in org.eclipse.rdf4j.sail.lucene

    Fields in org.eclipse.rdf4j.sail.lucene declared as Literal
    Modifier and Type | Field and Description
    --- | ---
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`ARC_TRIOMPHE`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`EIFFEL_TOWER`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`NOTRE_DAME`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`POLY1`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`POLY2`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`TEST_POINT`
    `static Literal` | AbstractLuceneSailGeoSPARQLTest.`TEST_POLY`

    Methods in org.eclipse.rdf4j.sail.lucene that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `static Literal` | SearchFields.`distanceToLiteral(double d)`
    `Literal` | DistanceQuerySpec.`getFrom()`
    `Literal` | GeoRelationQuerySpec.`getQueryGeometry()`
    `static Literal` | SearchFields.`scoreToLiteral(float score)` Returns a score value encoded as a Literal.
    `static Literal` | SearchFields.`wktToLiteral(String wkt)`

    Methods in org.eclipse.rdf4j.sail.lucene with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | AbstractSearchIndex.`accept(Literal literal)` Returns whether the provided literal is accepted by the LuceneIndex to be indexed.
    `boolean` | SearchIndex.`accept(Literal literal)` Returns whether the provided literal is accepted by the LuceneIndex to be indexed.
    `void` | DistanceQuerySpec.`setFrom(Literal from)`
    `void` | GeoRelationQuerySpec.`setQueryGeometry(Literal shape)`

    Constructors in org.eclipse.rdf4j.sail.lucene with parameters of type Literal
    Constructor and Description
    `DistanceQuerySpec(Literal from, IRI units, double dist, String distVar, IRI geoProperty, String geoVar, String subjectVar, Var contextVar)`

  - ### Uses of Literal in org.eclipse.rdf4j.sail.memory.model

    Classes in org.eclipse.rdf4j.sail.memory.model that implement Literal
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BooleanMemLiteral` An extension of MemLiteral that stores a boolean value to avoid parsing.
    `class` | `CalendarMemLiteral` An extension of MemLiteral that stores a Calendar value to avoid parsing.
    `class` | `DecimalMemLiteral` An extension of MemLiteral that stores a decimal value to avoid parsing.
    `class` | `IntegerMemLiteral` An extension of MemLiteral that stores an integer value to avoid parsing.
    `class` | `MemLiteral` A MemoryStore-specific extension of Literal giving it node properties.
    `class` | `NumericMemLiteral` An extension of MemLiteral that stores a numeric value to avoid parsing.

    Methods in org.eclipse.rdf4j.sail.memory.model that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `protected Literal` | MemValueFactory.`createFPLiteral(Number n, IRI datatype)`
    `protected Literal` | MemValueFactory.`createIntegerLiteral(Number n, IRI datatype)`
    `Literal` | MemValueFactory.`createLiteral(boolean value)`
    `Literal` | MemValueFactory.`createLiteral(String value)`
    `Literal` | MemValueFactory.`createLiteral(String value, IRI datatype)`
    `Literal` | MemValueFactory.`createLiteral(String value, String language)`
    `Literal` | MemValueFactory.`createLiteral(XMLGregorianCalendar calendar)`

    Methods in org.eclipse.rdf4j.sail.memory.model with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `MemLiteral` | MemValueFactory.`getMemLiteral(Literal literal)` See getMemValue() for description.
    `MemLiteral` | MemValueFactory.`getOrCreateMemLiteral(Literal literal)` See `MemValueFactory.getOrCreateMemValue(Value)` for description.

  - ### Uses of Literal in org.eclipse.rdf4j.sail.nativerdf

    Methods in org.eclipse.rdf4j.sail.nativerdf with parameters of type Literal
    Modifier and Type | Method and Description
    --- | ---
    `NativeLiteral` | ValueStore.`getNativeLiteral(Literal l)` Deprecated. Creates an NativeLiteral that is equal to the supplied literal.

  - ### Uses of Literal in org.eclipse.rdf4j.sail.nativerdf.model

    Classes in org.eclipse.rdf4j.sail.nativerdf.model that implement Literal
    Modifier and Type | Class and Description
    --- | ---
    `class` | `NativeLiteral`

  - ### Uses of Literal in org.eclipse.rdf4j.sail.shacl.planNodes

    Constructors in org.eclipse.rdf4j.sail.shacl.planNodes with parameters of type Literal
    Constructor and Description
    `LiteralComparatorFilter(PlanNode parent, Literal compareTo, java.util.function.Function<Integer,Boolean> function)`

  - ### Uses of Literal in org.eclipse.rdf4j.spin.function

    Methods in org.eclipse.rdf4j.spin.function that return Literal
    Modifier and Type | Method and Description
    --- | ---
    `Literal` | Concat.`evaluate(ValueFactory valueFactory, Value... args)`

Copyright © 2015-2020 Eclipse Foundation. All Rights Reserved.