View Source RDF.Statement (RDF.ex v2.0.1)

Helper functions for RDF statements.

An RDF statement is either a RDF.Triple or a RDF.Quad.

Summary

Functions

Returns a list of all RDF.BlankNodes within the given statement.

Creates a RDF.Statement tuple with proper RDF values.

Coerces the given value to a valid graph context of an RDF statement.

Coerces the given value to a valid object of an RDF statement.

Coerces the given value to a valid predicate of an RDF statement.

Coerces the given term to a valid predicate of an RDF statement using a RDF.PropertyMap.

Coerces the given value to a valid subject of an RDF statement.

The graph name component of a statement.

Returns whether the given statement contains a blank node.

Returns whether the given value is a component of the given statement.

Returns a tuple of native Elixir values from a RDF.Statement of RDF terms.

Creates a RDF.Triple or RDF.Quad with proper RDF values.

The object component of a statement.

The predicate component of a statement.

The subject component of a statement.

Checks if the given tuple is a valid RDF statement, i.e. RDF triple or quad.

Returns a tuple of native Elixir values from a RDF.Statement of RDF terms.

Types

@type coercible() :: RDF.Triple.coercible() | RDF.Quad.coercible()
Link to this type

coercible_graph_name()

View Source
@type coercible_graph_name() :: graph_name() | atom() | String.t()
@type coercible_object() :: object() | any()
@type coercible_predicate() :: RDF.Resource.coercible()
@type coercible_subject() :: RDF.Resource.coercible()
@type graph_name() :: RDF.Resource.t() | nil
@type object() :: RDF.Resource.t() | RDF.Literal.t()
@type position() :: :subject | :predicate | :object | :graph_name
@type predicate() :: RDF.Resource.t()
@type qualified_term() :: {position(), RDF.Term.t() | nil}
@type subject() :: RDF.Resource.t()
@type t() :: RDF.Triple.t() | RDF.Quad.t()
@type term_mapping() :: (qualified_term() -> any() | nil)

Functions

@spec bnodes(t()) :: [RDF.BlankNode.t()]

Returns a list of all RDF.BlankNodes within the given statement.

Link to this function

coerce(statement, property_map \\ nil)

View Source
@spec coerce(coercible(), RDF.PropertyMap.t() | nil) :: RDF.Triple.t() | RDF.Quad.t()

Creates a RDF.Statement tuple with proper RDF values.

An error is raised when the given elements are not coercible to RDF values.

Examples

iex> RDF.Statement.coerce {"http://example.com/S", "http://example.com/p", 42}
{~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42)}
iex> RDF.Statement.coerce {"http://example.com/S", "http://example.com/p", 42, "http://example.com/Graph"}
{~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42), ~I<http://example.com/Graph>}
Link to this function

coerce_graph_name(value)

View Source
@spec coerce_graph_name(coercible_graph_name()) :: graph_name()

Coerces the given value to a valid graph context of an RDF statement.

Raises an RDF.Quad.InvalidGraphContextError when the value can not be coerced.

@spec coerce_object(coercible_object()) :: object()

Coerces the given value to a valid object of an RDF statement.

@spec coerce_predicate(coercible_predicate()) :: predicate()

Coerces the given value to a valid predicate of an RDF statement.

Raises an RDF.Triple.InvalidPredicateError when the value can not be coerced.

Link to this function

coerce_predicate(term, context)

View Source
@spec coerce_predicate(coercible_predicate(), RDF.PropertyMap.t()) :: predicate()

Coerces the given term to a valid predicate of an RDF statement using a RDF.PropertyMap.

Raises an RDF.Triple.InvalidPredicateError when the value can not be coerced.

@spec coerce_subject(coercible_subject()) :: subject()

Coerces the given value to a valid subject of an RDF statement.

Raises an RDF.Triple.InvalidSubjectError when the value can not be coerced.

Link to this function

default_property_mapping(property_map)

View Source
@spec default_property_mapping(RDF.PropertyMap.t()) :: term_mapping()

The graph name component of a statement.

Examples

iex> RDF.Statement.graph_name {"http://example.com/S", "http://example.com/p", 42, "http://example.com/Graph"}
~I<http://example.com/Graph>
iex> RDF.Statement.graph_name {"http://example.com/S", "http://example.com/p", 42}
nil
@spec has_bnode?(t()) :: boolean()

Returns whether the given statement contains a blank node.

Link to this function

include_value?(quad, value)

View Source
@spec include_value?(t(), any()) :: boolean()

Returns whether the given value is a component of the given statement.

@spec map(t(), term_mapping()) ::
  RDF.Triple.mapping_value() | RDF.Quad.mapping_value() | nil | nil

Returns a tuple of native Elixir values from a RDF.Statement of RDF terms.

Returns nil if one of the components of the given tuple is not convertible via RDF.Term.value/1.

The optional second argument allows to specify a custom mapping with a function which will receive a tuple {statement_position, rdf_term} where statement_position is one of the atoms :subject, :predicate, :object or :graph_name, while rdf_term is the RDF term to be mapped. When the given function returns nil this will be interpreted as an error and will become the overhaul result of the values/2 call.

Examples

iex> {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42), ~I<http://example.com/Graph>}
...> |> RDF.Statement.map(fn
...>      {:subject, subject} ->
...>        subject |> to_string() |> String.last()
...>      {:predicate, predicate} ->
...>        predicate |> to_string() |> String.last() |> String.to_atom()
...>      {:object, object} ->
...>        RDF.Term.value(object)
...>      {:graph_name, graph_name} ->
...>        graph_name
...>    end)
{"S", :p, 42, ~I<http://example.com/Graph>}
Link to this function

new(tuple, property_map \\ nil)

View Source

Creates a RDF.Triple or RDF.Quad with proper RDF values.

An error is raised when the given elements are not coercible to RDF values.

Note: The RDF.statement function is a shortcut to this function.

Examples

iex> RDF.Statement.new({EX.S, EX.p, 42})
{RDF.iri("http://example.com/S"), RDF.iri("http://example.com/p"), RDF.literal(42)}

iex> RDF.Statement.new({EX.S, EX.p, 42, EX.Graph})
{RDF.iri("http://example.com/S"), RDF.iri("http://example.com/p"), RDF.literal(42), RDF.iri("http://example.com/Graph")}

iex> RDF.Statement.new({EX.S, :p, 42, EX.Graph}, RDF.PropertyMap.new(p: EX.p))
{RDF.iri("http://example.com/S"), RDF.iri("http://example.com/p"), RDF.literal(42), RDF.iri("http://example.com/Graph")}

See RDF.Triple.new/3.

See RDF.Quad.new/4.

The object component of a statement.

Examples

iex> RDF.Statement.object {"http://example.com/S", "http://example.com/p", 42}
RDF.literal(42)

The predicate component of a statement.

Examples

iex> RDF.Statement.predicate {"http://example.com/S", "http://example.com/p", 42}
~I<http://example.com/p>

The subject component of a statement.

Examples

iex> RDF.Statement.subject {"http://example.com/S", "http://example.com/p", 42}
~I<http://example.com/S>
@spec valid?(RDF.Triple.t() | RDF.Quad.t() | any()) :: boolean()

Checks if the given tuple is a valid RDF statement, i.e. RDF triple or quad.

The elements of a valid RDF statement must be RDF terms. On the subject position only IRIs and blank nodes allowed, while on the predicate and graph context position only IRIs allowed. The object position can be any RDF term.

@spec valid_graph_name?(graph_name() | any()) :: boolean()
@spec valid_object?(object() | any()) :: boolean()
@spec valid_predicate?(predicate() | any()) :: boolean()
@spec valid_subject?(subject() | any()) :: boolean()
Link to this function

values(quad, opts \\ [])

View Source
@spec values(
  t(),
  keyword()
) :: RDF.Triple.mapping_value() | RDF.Quad.mapping_value() | nil

Returns a tuple of native Elixir values from a RDF.Statement of RDF terms.

When a :context option is given with a RDF.PropertyMap, predicates will be mapped to the terms defined in the RDF.PropertyMap, if present.

Returns nil if one of the components of the given tuple is not convertible via RDF.Term.value/1.

Examples

iex> RDF.Statement.values {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42)}
{"http://example.com/S", "http://example.com/p", 42}

iex> RDF.Statement.values {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42), ~I<http://example.com/Graph>}
{"http://example.com/S", "http://example.com/p", 42, "http://example.com/Graph"}

iex> {~I<http://example.com/S>, ~I<http://example.com/p>, RDF.literal(42)}
...> |> RDF.Statement.values(context: %{p: ~I<http://example.com/p>})
{"http://example.com/S", :p, 42}