org.eclipse.rdf4j.model.util

## Class Statements

- java.lang.Object
- - org.eclipse.rdf4j.model.util.Statements

-     public class Statements
      extends Object

  Utility methods for working with `Statement` objects, including conversion to/from `RDF* triple objects`.
  Author:
    Jeen Broekstra

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static java.util.function.Function<Triple,Resource>` | `TRIPLE_BNODE_MAPPER` A `Function` that maps `Triple` to `BNode` consistently.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Statements()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static void` | `consume(ValueFactory vf, Resource subject, IRI predicate, Value object, java.util.function.Consumer<Statement> consumer, Resource... contexts)` Creates one or more `Statement` objects with the given subject, predicate and object, one for each given context, and sends each created statement to the supplied `Consumer`.
    `static void` | `convertRDFStarToReification(Statement st, java.util.function.Consumer<Statement> consumer)` Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer.
    `static void` | `convertRDFStarToReification(ValueFactory vf, java.util.function.Function<Triple,Resource> reifiedIdMapper, Statement st, java.util.function.Consumer<Statement> consumer)` Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer.
    `static void` | `convertRDFStarToReification(ValueFactory vf, Statement st, java.util.function.Consumer<Statement> consumer)` Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer.
    `static <C extends Collection<Statement>> C` | `create(ValueFactory vf, Resource subject, IRI predicate, Value object, C collection, Resource... contexts)` Creates one or more `Statement` objects with the given subject, predicate and object, one for each given context.
    `static boolean` | `isSameTriple(Statement st1, Statement st2)` Checks if the two statements represent the same triple (that is, they have equal subject, predicate, and object).
    `static Statement` | `stripContext(Statement statement)` Strips the context (if any) from the supplied statement and returns a statement with the same subject, predicate and object, but with no assigned context.
    `static Statement` | `stripContext(ValueFactory vf, Statement statement)` Strips the context (if any) from the supplied statement and returns a statement with the same subject, predicate and object, but with no assigned context.
    `static Statement` | `toStatement(Triple triple)` Create a `Statement` from the supplied { @link Triple RDF* triple}
    `static Statement` | `toStatement(Triple triple, Resource context)` Create a `Statement` from the supplied { @link Triple RDF* triple} and context.
    `static Statement` | `toStatement(ValueFactory vf, Triple triple, Resource context)` Create a `Statement` from the supplied { @link Triple RDF* triple} and context.
    `static Triple` | `toTriple(Statement statement)` Create an `RDF* triple` from the supplied `Statement`
    `static Triple` | `toTriple(ValueFactory vf, Statement statement)` Create an `RDF* triple` from the supplied `Statement`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### TRIPLE_BNODE_MAPPER

          @Experimental
          public static java.util.function.Function<Triple,Resource> TRIPLE_BNODE_MAPPER

      A `Function` that maps `Triple` to `BNode` consistently. Multiple invocations for the same `Triple` will return the same `BNode`. The current implementation creates a `BNode` by encoding the string representation of the `Triple` using base64 URL-safe encoding.

  - ### Constructor Detail

    - #### Statements

          public Statements()

  - ### Method Detail

    - #### consume

          public static void consume(ValueFactory vf,
                                     Resource subject,
                                     IRI predicate,
                                     Value object,
                                     java.util.function.Consumer<Statement> consumer,
                                     Resource... contexts)

      Creates one or more `Statement` objects with the given subject, predicate and object, one for each given context, and sends each created statement to the supplied `Consumer`. If no context is supplied, only a single statement (without any assigned context) is created.
      Parameters:
        `vf` - the `ValueFactory` to use for creating statements.
        `subject` - the subject of each statement. May not be null.
        `predicate` - the predicate of each statement. May not be null.
        `object` - the object of each statement. May not be null.
        `consumer` - the `Consumer` function for the produced statements.
        `contexts` - the context(s) for which to produce statements. This argument is an optional vararg: leave it out completely to produce a single statement without context.

    - #### create

          public static <C extends Collection<Statement>> C create(ValueFactory vf,
                                                                   Resource subject,
                                                                   IRI predicate,
                                                                   Value object,
                                                                   C collection,
                                                                   Resource... contexts)

      Creates one or more `Statement` objects with the given subject, predicate and object, one for each given context. If no context is supplied, only a single statement (without any assigned context) is created.
      Parameters:
        `vf` - the `ValueFactory` to use for creating statements.
        `subject` - the subject of each statement. May not be null.
        `predicate` - the predicate of each statement. May not be null.
        `object` - the object of each statement. May not be null.
        `collection` - the collection of Statements to which the newly created Statements will be added. May not be null.
        `contexts` - the context(s) for which to produce statements. This argument is an optional vararg: leave it out completely to produce a single statement without context.
      Returns:
        the input collection of Statements, with the newly created Statements added.

    - #### stripContext

          public static Statement stripContext(Statement statement)

      Strips the context (if any) from the supplied statement and returns a statement with the same subject, predicate and object, but with no assigned context.
      Parameters:
        `statement` - the statement to strip the context from
      Returns:
        a statement without context
      Since:
        3.1.0

    - #### stripContext

          public static Statement stripContext(ValueFactory vf,
                                               Statement statement)

      Strips the context (if any) from the supplied statement and returns a statement with the same subject, predicate and object, but with no assigned context.
      Parameters:
        `vf` - the `ValueFactory` to use for creating a new `Statement`.
        `statement` - the statement to strip the context from.
      Returns:
        a statement without context
      Since:
        3.1.0

    - #### toTriple

          public static Triple toTriple(Statement statement)

      Create an `RDF* triple` from the supplied `Statement`
      Parameters:
        `statement` - a statement to convert to an RDF* triple
      Returns:
        an `RDF* triple` with the same subject, predicate and object as the input statement.
      Since:
        3.4.0

    - #### toTriple

          public static Triple toTriple(ValueFactory vf,
                                        Statement statement)

      Create an `RDF* triple` from the supplied `Statement`
      Parameters:
        `vf` - the `ValueFactory` to use for creating the `Triple` object.
        `statement` - a statement to convert to an RDF* triple
      Returns:
        an `RDF* triple` with the same subject, predicate and object as the input statement.
      Since:
        3.4.0

    - #### toStatement

          public static Statement toStatement(Triple triple)

      Create a `Statement` from the supplied { @link Triple RDF* triple}
      Parameters:
        `triple` - an RDF* triple to convert to a `Statement`.
      Returns:
        an `Statement` with the same subject, predicate and object as the input triple, and no context.
      Since:
        3.4.0

    - #### toStatement

          public static Statement toStatement(Triple triple,
                                              Resource context)

      Create a `Statement` from the supplied { @link Triple RDF* triple} and context.
      Parameters:
        `triple` - an RDF* triple to convert to a `Statement`.
        `context` - the context to assign to the `Statement`.
      Returns:
        an `Statement` with the same subject, predicate and object as the input triple, and having the supplied context.
      Since:
        3.4.0

    - #### toStatement

          public static Statement toStatement(ValueFactory vf,
                                              Triple triple,
                                              Resource context)

      Create a `Statement` from the supplied { @link Triple RDF* triple} and context.
      Parameters:
        `vf` - the `ValueFactory` to use for creating the `Statement` object.
        `triple` - an RDF* triple to convert to a `Statement`.
        `context` - the context to assign to the `Statement`. May be null to indicate no context.
      Returns:
        an `Statement` with the same subject, predicate and object as the input triple, and having the supplied context.
      Since:
        3.4.0

    - #### isSameTriple

          public static boolean isSameTriple(Statement st1,
                                             Statement st2)

      Checks if the two statements represent the same triple (that is, they have equal subject, predicate, and object). Context information is disregarded.
      Parameters:
        `st1` - the first statement to compare. May not be null.
        `st2` - the second statement to compare. May not be null.
      Returns:
        `true` iff the subject, predicate and object of `st1` and `st2` are equal, `false` otherwise.
      Since:
        2.0
      See Also:
        `Statement.equals(Object)`

    - #### convertRDFStarToReification

          @Experimental
          public static void convertRDFStarToReification(Statement st,
                                                                       java.util.function.Consumer<Statement> consumer)

      Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer. If the supplied statement is not RDF* it will be sent to the consumer as is.

      The statements needed to represent reification will use blank nodes.

      Parameters:
        `st` - the `Statement` to convert.
        `consumer` - the `Consumer` function for the produced statements.

    - #### convertRDFStarToReification

          @Experimental
          public static void convertRDFStarToReification(ValueFactory vf,
                                                                       Statement st,
                                                                       java.util.function.Consumer<Statement> consumer)

      Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer. If the supplied statement is not RDF* it will be sent to the consumer as is.

      The statements needed to represent reification will use blank nodes.

      The supplied value factory is used to create all new statements and blank nodes.

      Parameters:
        `vf` - the `ValueFactory` to use for creating statements.
        `st` - the `Statement` to convert.
        `consumer` - the `Consumer` function for the produced statements.

    - #### convertRDFStarToReification

          @Experimental
          public static void convertRDFStarToReification(ValueFactory vf,
                                                                       java.util.function.Function<Triple,Resource> reifiedIdMapper,
                                                                       Statement st,
                                                                       java.util.function.Consumer<Statement> consumer)

      Converts the supplied RDF* statement to RDF reification statements, and sends the resultant statements to the supplied consumer. If the supplied statement is not RDF* it will be sent to the consumer as is.

      The supplied value factory is used to create all new statements.

      The supplied mapper function maps a `Triple` to a `Resource` and is used to create the ID of the RDF reification statement corresponding to the converted triple. The function must return the same value for identical triples in order to produce consistent results between invocations. See `TRIPLE_BNODE_MAPPER`.

      Parameters:
        `vf` - the `ValueFactory` to use for creating statements.
        `reifiedIdMapper` - the mapper `Function` from `Triple` to `Resource`.
        `st` - the `Statement` to convert,
        `consumer` - the `Consumer` function for the produced statements.

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