## 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.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.ast.constraintcomponents |
  org.eclipse.rdf4j.sail.shacl.ast.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 | Description
    --- | --- | ---
    `static Literal` | FedXUtil.`literal​(String literal)` |

    Methods in org.eclipse.rdf4j.federated.util with parameters of type Literal
    Modifier and Type | Method | 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 | 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 | 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 | Description
    --- | --- | ---
    `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​(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, String language)` | Creates a new literal with the supplied label and language attribute.
    `Literal` | ValueFactory.`createLiteral​(String label, IRI datatype)` | Creates a new literal with the supplied label and datatype.
    `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.
    `default Literal` | ValueFactory.`createLiteral​(TemporalAccessor value)` | Creates a new literal representing a temporal accessor value.
    `default Literal` | ValueFactory.`createLiteral​(TemporalAmount value)` | Creates a new literal representing a temporal amount 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​(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 | Description
    --- | --- | ---
    `class` | `AbstractLiteral` | Base class for `Literal`, offering common functionality.

    Methods in org.eclipse.rdf4j.model.base that return Literal
    Modifier and Type | Method | Description
    --- | --- | ---
    `Literal` | AbstractValueFactory.`createLiteral​(boolean value)` |
    `Literal` | AbstractValueFactory.`createLiteral​(byte value)` |
    `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, String language)` |
    `Literal` | AbstractValueFactory.`createLiteral​(String label, IRI datatype)` |
    `Literal` | AbstractValueFactory.`createLiteral​(BigDecimal bigDecimal)` |
    `Literal` | AbstractValueFactory.`createLiteral​(BigInteger bigInteger)` |
    `Literal` | AbstractValueFactory.`createLiteral​(TemporalAccessor value)` |
    `Literal` | AbstractValueFactory.`createLiteral​(TemporalAmount value)` |
    `Literal` | AbstractValueFactory.`createLiteral​(Date date)` |
    `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 | Description
    --- | --- | ---
    `class` | `BooleanLiteral` | An extension of `SimpleLiteral` that stores a boolean value to avoid parsing.
    `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` | `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 | Description
    --- | --- | ---
    `protected Literal` | SimpleValueFactory.`createFPLiteral​(Number value, IRI datatype)` | Calls `SimpleValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | SimpleValueFactory.`createFPLiteral​(Number value, XSD.Datatype datatype)` |
    `protected Literal` | SimpleValueFactory.`createIntegerLiteral​(Number value, IRI datatype)` | Calls `SimpleValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | SimpleValueFactory.`createIntegerLiteral​(Number value, XSD.Datatype datatype)` |
    `Literal` | SimpleValueFactory.`createLiteral​(boolean b)` |
    `Literal` | SimpleValueFactory.`createLiteral​(byte value)` | Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.BYTE` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(double value)` | Calls `SimpleValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.DOUBLE` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(float value)` | Calls `SimpleValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.FLOAT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(int value)` | Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.INT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(long value)` | Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.LONG` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(short value)` | Calls `SimpleValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.SHORT` as parameters.
    `Literal` | SimpleValueFactory.`createLiteral​(String value)` |
    `Literal` | SimpleValueFactory.`createLiteral​(String value, String language)` |
    `Literal` | SimpleValueFactory.`createLiteral​(String value, IRI datatype)` |
    `Literal` | SimpleValueFactory.`createLiteral​(BigDecimal bigDecimal)` |
    `Literal` | SimpleValueFactory.`createLiteral​(BigInteger bigInteger)` |
    `Literal` | SimpleValueFactory.`createLiteral​(Date date)` | Converts the supplied `Date` to a `XMLGregorianCalendar`, then calls `ValueFactory.createLiteral(XMLGregorianCalendar)`.
    `Literal` | SimpleValueFactory.`createLiteral​(XMLGregorianCalendar calendar)` | Calls `ValueFactory.createLiteral(String, IRI)` with the String-value of the supplied calendar and the appropriate datatype as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral​(boolean value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(byte value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(double value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(float value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(int value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(long value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(short value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(String label)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(String label, String language)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(String label, IRI datatype)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(BigDecimal bigDecimal)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(BigInteger bigInteger)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(TemporalAccessor value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(TemporalAmount value)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(Date date)` |
    `Literal` | ValidatingValueFactory.`createLiteral​(XMLGregorianCalendar calendar)` |
    `protected Literal` | SimpleValueFactory.`createNumericLiteral​(Number number, IRI datatype)` | Creates specific optimized subtypes of SimpleLiteral for numeric datatypes.
    `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 | 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​(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​(short shortValue)` | Creates a new `Literal` with the supplied short 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​(String lexicalValue)` | Creates a new `Literal` with the supplied lexical value.
    `static Literal` | Values.`literal​(String lexicalValue, String languageTag)` | 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​(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​(TemporalAccessor value)` | Creates a new `Literal` with the supplied `TemporalAccessor` 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, short shortValue)` | Creates a new `Literal` with the supplied short 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, String lexicalValue)` | Creates a new `Literal` with the supplied lexical value.
    `static Literal` | Values.`literal​(ValueFactory vf, String lexicalValue, String languageTag)` | 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, 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, 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 | 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 | 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 | Description
    --- | --- | ---
    `Literal` | Day.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Hours.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Minutes.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Month.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Now.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Seconds.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Timezone.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Tz.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Year.`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 | Description
    --- | --- | ---
    `abstract Literal` | HashFunction.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | MD5.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | SHA1.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | SHA256.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | SHA384.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | SHA512.`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 | Description
    --- | --- | ---
    `Literal` | Abs.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Ceil.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Floor.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Rand.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Round.`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 | Description
    --- | --- | ---
    `Literal` | StrDt.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrLang.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | STRUUID.`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 | Description
    --- | --- | ---
    `Literal` | Concat.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Contains.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | EncodeForUri.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | LowerCase.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Replace.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrAfter.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrBefore.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrEnds.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrLen.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StrStarts.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | Substring.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | UpperCase.`evaluate​(ValueFactory valueFactory, Value... args)` |

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.function.string with parameters of type Literal
    Modifier and Type | Method | 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 | Description
    --- | --- | ---
    `protected Literal` | BooleanCast.`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` | DateTimeCast.`convert​(ValueFactory vf, Value value)` |
    `protected Literal` | DecimalCast.`convert​(ValueFactory valueFactory, Value value)` |
    `protected Literal` | DoubleCast.`convert​(ValueFactory valueFactory, Value value)` |
    `protected Literal` | FloatCast.`convert​(ValueFactory valueFactory, Value value)` |
    `protected Literal` | IntegerCastFunction.`convert​(ValueFactory valueFactory, Value value)` |
    `protected Literal` | StringCast.`convert​(ValueFactory valueFactory, Value value)` |
    `Literal` | CastFunction.`evaluate​(ValueFactory valueFactory, Value... args)` |
    `Literal` | StringCast.`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 | Description
    --- | --- | ---
    `protected Optional<Literal>` | ByteCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | IntCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | IntegerCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | IntegerCastFunction.`createTypedLiteral​(ValueFactory vf, boolean booleanValue)` | create a `Literal` with the specific datatype for the supplied boolean value.
    `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>` | LongCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | NegativeIntegerCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | NonNegativeIntegerCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | NonPositiveIntegerCast.`createTypedLiteral​(ValueFactory vf, boolean booleanValue)` |
    `protected Optional<Literal>` | NonPositiveIntegerCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | PositiveIntegerCast.`createTypedLiteral​(ValueFactory vf, boolean booleanValue)` |
    `protected Optional<Literal>` | PositiveIntegerCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | ShortCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | UnsignedByteCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | UnsignedIntCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | UnsignedLongCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |
    `protected Optional<Literal>` | UnsignedShortCast.`createTypedLiteral​(ValueFactory vf, BigInteger integerValue)` |

  - ### 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 | Description
    --- | --- | ---
    `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 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.

    Methods in org.eclipse.rdf4j.query.algebra.evaluation.util that return types with arguments of type Literal
    Modifier and Type | Method | 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 | 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` | 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 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 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 | 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 | 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 | Description
    --- | --- | ---
    `protected Literal` | RepositoryConnectionTest.`mboxAlice` |
    `protected Literal` | RepositoryTest.`mboxAlice` |
    `protected Literal` | RepositoryConnectionTest.`mboxBob` |
    `protected Literal` | RepositoryTest.`mboxBob` |
    `protected Literal` | RepositoryConnectionTest.`nameAlice` |
    `protected Literal` | RepositoryTest.`nameAlice` |
    `protected Literal` | RepositoryConnectionTest.`nameBob` |
    `protected Literal` | RepositoryTest.`nameBob` |
    `protected Literal` | RepositoryConnectionTest.`Александър` |
    `protected Literal` | RepositoryTest.`Александър` |

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

    Methods in org.eclipse.rdf4j.repository.optimistic that return Literal
    Modifier and Type | Method | 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 | 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 | Description
    --- | --- | ---
    `Literal` | DBPediaDatatypeHandler.`normalizeDatatype​(String literalValue, IRI datatypeUri, ValueFactory valueFactory)` |
    `Literal` | GeoSPARQLDatatypeHandler.`normalizeDatatype​(String literalValue, IRI datatypeUri, ValueFactory valueFactory)` |
    `Literal` | RDFDatatypeHandler.`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)` |

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

    Methods in org.eclipse.rdf4j.rio.helpers that return Literal
    Modifier and Type | Method | 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 | 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 | Description
    --- | --- | ---
    `Literal` | BCP47LanguageHandler.`normalizeLanguage​(String literalValue, String languageTag, ValueFactory valueFactory)` |
    `Literal` | RFC3066LanguageHandler.`normalizeLanguage​(String literalValue, String languageTag, ValueFactory valueFactory)` |

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

    Methods in org.eclipse.rdf4j.rio.rdfjson that return Literal
    Modifier and Type | Method | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | Description
    --- | --- | ---
    `Literal` | MemValueFactory.`createLiteral​(boolean value)` |
    `Literal` | MemValueFactory.`createLiteral​(String value)` |
    `Literal` | MemValueFactory.`createLiteral​(String value, String language)` |
    `Literal` | MemValueFactory.`createLiteral​(String value, IRI datatype)` |
    `Literal` | MemValueFactory.`createLiteral​(XMLGregorianCalendar calendar)` |

    Methods in org.eclipse.rdf4j.sail.memory.model with parameters of type Literal
    Modifier and Type | Method | 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 | 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 | Description
    --- | --- | ---
    `class` | `NativeLiteral` |

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

    Constructors in org.eclipse.rdf4j.sail.shacl.ast.constraintcomponents with parameters of type Literal
    Constructor | Description
    --- | ---
    `MaxExclusiveConstraintComponent​(Literal maxExclusive)` |
    `MaxInclusiveConstraintComponent​(Literal maxInclusive)` |
    `MinExclusiveConstraintComponent​(Literal minExclusive)` |
    `MinInclusiveConstraintComponent​(Literal minInclusive)` |

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

    Constructors in org.eclipse.rdf4j.sail.shacl.ast.planNodes with parameters of type Literal
    Constructor | Description
    --- | ---
    `LiteralComparatorFilter​(PlanNode parent, Literal compareTo, Compare.CompareOp compareOp)` |

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

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