## 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.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` | AbstractModelTest.`literal1`
    `protected Literal` | AbstractModelTest.`literal2`
    `protected Literal` | AbstractModelTest.`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 using the appropriate XML Schema date/time datatype.
    `Literal` | ValueFactory.`createLiteral(BigInteger bigInteger)` Creates a new literal representing the specified bigInteger that is typed using the appropriate XML Schema date/time datatype.
    `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.
    `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.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)` Calls `AbstractValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `protected Literal` | AbstractValueFactory.`createIntegerLiteral(Number value, IRI datatype)` Calls `AbstractValueFactory.createNumericLiteral(Number, IRI)` with the supplied value and datatype as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(BigDecimal bigDecimal)`
    `Literal` | AbstractValueFactory.`createLiteral(BigDecimal bigDecimal)`
    `Literal` | ValidatingValueFactory.`createLiteral(BigInteger bigInteger)`
    `Literal` | AbstractValueFactory.`createLiteral(BigInteger bigInteger)`
    `Literal` | ValidatingValueFactory.`createLiteral(boolean value)`
    `Literal` | AbstractValueFactory.`createLiteral(boolean b)`
    `Literal` | ValidatingValueFactory.`createLiteral(byte value)`
    `Literal` | AbstractValueFactory.`createLiteral(byte value)` Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.BYTE` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(Date date)`
    `Literal` | AbstractValueFactory.`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)` Calls `AbstractValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.DOUBLE` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(float value)`
    `Literal` | AbstractValueFactory.`createLiteral(float value)` Calls `AbstractValueFactory.createFPLiteral(Number, IRI)` with the supplied value and `XSD.FLOAT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(int value)`
    `Literal` | AbstractValueFactory.`createLiteral(int value)` Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.INT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(long value)`
    `Literal` | AbstractValueFactory.`createLiteral(long value)` Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.LONG` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(short value)`
    `Literal` | AbstractValueFactory.`createLiteral(short value)` Calls `AbstractValueFactory.createIntegerLiteral(Number, IRI)` with the supplied value and `XSD.SHORT` as parameters.
    `Literal` | ValidatingValueFactory.`createLiteral(String label)`
    `Literal` | AbstractValueFactory.`createLiteral(String value)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, IRI datatype)`
    `Literal` | AbstractValueFactory.`createLiteral(String value, IRI datatype)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, String language)`
    `Literal` | AbstractValueFactory.`createLiteral(String value, String language)`
    `Literal` | ValidatingValueFactory.`createLiteral(String label, URI datatype)`
    `Literal` | ValidatingValueFactory.`createLiteral(XMLGregorianCalendar calendar)`
    `Literal` | AbstractValueFactory.`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)` Creates specific optimized subtypes of SimpleLiteral for numeric datatypes.

  - ### 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)` Creates a typed `Literal` out of the supplied object, mapping the runtime type of the object to the appropriate XML Schema type.
    `static Literal` | Literals.`createLiteralOrFail(ValueFactory valueFactory, Object object)` Creates a typed `Literal` out of the supplied object, mapping the runtime type of the object to the appropriate XML Schema type.

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