Specs

add(t(), statements() | [statements()]) :: t()

Adds statements to a RDF.Description.

Note: When the statements to be added are given as another RDF.Description, the subject must not match subject of the description to which the statements are added. As opposed to that RDF.Data.merge/2 will produce a RDF.Graph containing both descriptions.

Specs

add(
  t(),
  RDF.Statement.coercible_predicate(),
  RDF.Statement.coercible_object() | [RDF.Statement.coercible_object()]
) :: t()

Add objects to a predicate of a RDF.Description.

Examples

iex> RDF.Description.add(RDF.Description.new({EX.S, EX.P1, EX.O1}), EX.P2, EX.O2)
RDF.Description.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O2}])
iex> RDF.Description.add(RDF.Description.new({EX.S, EX.P, EX.O1}), EX.P, [EX.O2, EX.O3])
RDF.Description.new([{EX.S, EX.P, EX.O1}, {EX.S, EX.P, EX.O2}, {EX.S, EX.P, EX.O3}])

Specs

count(t()) :: non_neg_integer()

Returns the number of statements of a RDF.Description.

Specs

delete(t(), statements() | [statements()]) :: t()

Deletes statements from a RDF.Description.

Note: When the statements to be deleted are given as another RDF.Description, the subject must not match subject of the description from which the statements are deleted. If you want to delete only a matching description subject, you can use RDF.Data.delete/2.

Specs

delete(
  t(),
  RDF.Statement.coercible_predicate(),
  RDF.Statement.coercible_object() | [RDF.Statement.coercible_object()]
) :: t()

Deletes statements from a RDF.Description.

Specs

delete_predicates(
  t(),
  RDF.Statement.coercible_predicate() | [RDF.Statement.coercible_predicate()]
) :: t()

Deletes all statements with the given properties.

Specs

describes?(t(), RDF.Statement.subject()) :: boolean()

Checks if a RDF.Description has the given resource as subject.

Examples

  iex> RDF.Description.new(EX.S1, EX.p1, EX.O1) |> RDF.Description.describes?(EX.S1)
  true
  iex> RDF.Description.new(EX.S1, EX.p1, EX.O1) |> RDF.Description.describes?(EX.S2)
  false

Specs

equal?(t(), t()) :: boolean()

Checks if two RDF.Descriptions are equal.

Two RDF.Descriptions are considered to be equal if they contain the same triples.

Specs

fetch(t(), RDF.Statement.coercible_predicate()) ::
  {:ok, [RDF.Statement.object()]} | :error

Fetches the objects for the given predicate of a Description.

When the predicate can not be found :error is returned.

Examples

iex> RDF.Description.fetch(RDF.Description.new({EX.S, EX.p, EX.O}), EX.p)
{:ok, [RDF.iri(EX.O)]}
iex> RDF.Description.fetch(RDF.Description.new([{EX.S, EX.P, EX.O1},
...>                                            {EX.S, EX.P, EX.O2}]), EX.P)
{:ok, [RDF.iri(EX.O1), RDF.iri(EX.O2)]}
iex> RDF.Description.fetch(RDF.Description.new(EX.S), EX.foo)
:error

Specs

first(t(), RDF.Statement.coercible_predicate()) :: RDF.Statement.object() | nil

Gets a single object for the given predicate of a Description.

When the predicate can not be found, the optionally given default value or nil is returned.

Examples

iex> RDF.Description.first(RDF.Description.new({EX.S, EX.P, EX.O}), EX.P)
RDF.iri(EX.O)
iex> RDF.Description.first(RDF.Description.new(EX.S), EX.foo)
nil

Specs

get(t(), RDF.Statement.coercible_predicate(), any()) ::
  [RDF.Statement.object()] | any()

Gets the objects for the given predicate of a Description.

When the predicate can not be found, the optionally given default value or nil is returned.

Examples

iex> RDF.Description.get(RDF.Description.new({EX.S, EX.P, EX.O}), EX.P)
[RDF.iri(EX.O)]
iex> RDF.Description.get(RDF.Description.new(EX.S), EX.foo)
nil
iex> RDF.Description.get(RDF.Description.new(EX.S), EX.foo, :bar)
:bar

Specs

get_and_update(
  t(),
  RDF.Statement.coercible_predicate(),
  ([RDF.Statement.Object] -> {[RDF.Statement.Object], t()} | :pop)
) :: {[RDF.Statement.Object], t()}

Gets and updates the objects of the given predicate of a Description, in a single pass.

Invokes the passed function on the objects of the given predicate; this function should return either {objects_to_return, new_object} or :pop.

If the passed function returns {objects_to_return, new_objects}, the return value of get_and_update is {objects_to_return, new_description} where new_description is the input Description updated with new_objects for the given predicate.

If the passed function returns :pop the objects for the given predicate are removed and a {removed_objects, new_description} tuple gets returned.

Examples

iex> RDF.Description.new({EX.S, EX.P, EX.O}) |>
...>   RDF.Description.get_and_update(EX.P, fn current_objects ->
...>     {current_objects, EX.NEW}
...>   end)
{[RDF.iri(EX.O)], RDF.Description.new({EX.S, EX.P, EX.NEW})}
iex> RDF.Description.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O2}]) |>
...>   RDF.Description.get_and_update(EX.P1, fn _ -> :pop end)
{[RDF.iri(EX.O1)], RDF.Description.new({EX.S, EX.P2, EX.O2})}

Specs

include?(t(), statements()) :: boolean()

Checks if the given statement exists within a RDF.Description.

Specs

new(RDF.Statement.coercible_subject() | statements() | [statements()]) :: t()

Creates a new RDF.Description about the given subject with optional initial statements.

When given a list of statements, the first one must contain a subject.

Specs

new(RDF.Statement.coercible_subject(), statements() | [statements()]) :: t()

Creates a new RDF.Description about the given subject with optional initial statements.

Specs

new(
  RDF.Statement.coercible_subject() | statements() | [statements()],
  RDF.Statement.coercible_predicate(),
  RDF.Statement.coercible_object() | [RDF.Statement.coercible_object()]
) :: t()

Creates a new RDF.Description about the given subject with optional initial statements.

Specs

objects(t()) :: MapSet.t()

The set of all resources used in the objects within a RDF.Description.

Note: This function does collect only IRIs and BlankNodes, not Literals.

Examples

iex> RDF.Description.new([
...>   {EX.S1, EX.p1, EX.O1},
...>          {EX.p2, EX.O2},
...>          {EX.p3, EX.O2},
...>          {EX.p4, RDF.bnode(:bnode)},
...>          {EX.p3, "foo"}
...> ]) |> RDF.Description.objects
MapSet.new([RDF.iri(EX.O1), RDF.iri(EX.O2), RDF.bnode(:bnode)])

Specs

objects(t(), (RDF.Statement.object() -> boolean())) :: MapSet.t()

The set of all resources used in the objects within a RDF.Description satisfying the given filter criterion.

Specs

pop(t()) :: {RDF.Triple.t() | [RDF.Statement.Object] | nil, t()}

Pops an arbitrary triple from a RDF.Description.

Pops the objects of the given predicate of a Description.

When the predicate can not be found the optionally given default value or nil is returned.

Examples

iex> RDF.Description.pop(RDF.Description.new({EX.S, EX.P, EX.O}), EX.P)
{[RDF.iri(EX.O)], RDF.Description.new(EX.S)}
iex> RDF.Description.pop(RDF.Description.new({EX.S, EX.P, EX.O}), EX.Missing)
{nil, RDF.Description.new({EX.S, EX.P, EX.O})}

Specs

predicates(t()) :: MapSet.t()

The set of all properties used in the predicates within a RDF.Description.

Examples

iex> RDF.Description.new([
...>   {EX.S1, EX.p1, EX.O1},
...>          {EX.p2, EX.O2},
...>          {EX.p2, EX.O3}]) |>
...>   RDF.Description.predicates
MapSet.new([EX.p1, EX.p2])

Specs

put(t(), statements() | [statements()]) :: t()

Adds statements to a RDF.Description and overwrites all existing statements with already used predicates.

Examples

iex> RDF.Description.put(RDF.Description.new({EX.S, EX.P, EX.O1}), {EX.P, EX.O2})
RDF.Description.new([{EX.S, EX.P, EX.O2}])
iex> RDF.Description.new({EX.S, EX.P1, EX.O1}) |>
...>   RDF.Description.put([{EX.P2, EX.O2}, {EX.S, EX.P2, EX.O3}, {EX.P1, EX.O4}])
RDF.Description.new([{EX.S, EX.P1, EX.O4}, {EX.S, EX.P2, EX.O2}, {EX.S, EX.P2, EX.O3}])
iex> RDF.Description.new({EX.S, EX.P, EX.O1}) |>
...>   RDF.Description.put(RDF.Description.new(EX.S, EX.P, [EX.O1, EX.O2]))
RDF.Description.new([{EX.S, EX.P, EX.O1}, {EX.S, EX.P, EX.O2}])
iex> RDF.Description.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O2}]) |>
...>   RDF.Description.put(%{EX.P2 => [EX.O3, EX.O4]})
RDF.Description.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O3}, {EX.S, EX.P2, EX.O4}])

Specs

put(
  t(),
  RDF.Statement.coercible_predicate(),
  RDF.Statement.coercible_object() | [RDF.Statement.coercible_object()]
) :: t()

Puts objects to a predicate of a RDF.Description, overwriting all existing objects.

Examples

iex> RDF.Description.put(RDF.Description.new({EX.S, EX.P, EX.O1}), EX.P, EX.O2)
RDF.Description.new([{EX.S, EX.P, EX.O2}])
iex> RDF.Description.put(RDF.Description.new({EX.S, EX.P1, EX.O1}), EX.P2, EX.O2)
RDF.Description.new([{EX.S, EX.P1, EX.O1}, {EX.S, EX.P2, EX.O2}])

Specs

resources(t()) :: MapSet.t()

The set of all resources used within a RDF.Description.

Examples

iex> RDF.Description.new([
...>   {EX.S1, EX.p1, EX.O1},
...>          {EX.p2, EX.O2},
...>          {EX.p1, EX.O2},
...>          {EX.p2, RDF.bnode(:bnode)},
...>          {EX.p3, "foo"}
...> ]) |> RDF.Description.resources
MapSet.new([RDF.iri(EX.O1), RDF.iri(EX.O2), RDF.bnode(:bnode), EX.p1, EX.p2, EX.p3])

See RDF.Description.triples/1.

Specs

take(t(), [RDF.Statement.coercible_predicate()] | Enum.t() | nil) :: t()

Creates a description from another one by limiting its statements to those using one of the given predicates.

If predicates contains properties that are not used in the description, they're simply ignored.

If nil is passed, the description is left untouched.

Specs

triples(t()) :: keyword()

The list of all triples within a RDF.Description.

Specs

update(
  t(),
  RDF.Statement.coercible_predicate(),
  RDF.Statement.coercible_object() | nil,
  ([RDF.Statement.Object] -> [RDF.Statement.Object])
) :: t()

Updates the objects of the predicate in description with the given function.

If predicate is present in description with objects as value, fun is invoked with argument objects and its result is used as the new list of objects of predicate. If predicate is not present in description, initial is inserted as the objects of predicate. The initial value will not be passed through the update function.

The initial value and the returned objects by the update function will automatically coerced to proper RDF object values before added.

Examples

iex> RDF.Description.new({EX.S, EX.p, EX.O}) |>
...> RDF.Description.update(EX.p, fn objects -> [EX.O2 | objects] end)
RDF.Description.new([{EX.S, EX.p, EX.O}, {EX.S, EX.p, EX.O2}])
iex> RDF.Description.new(EX.S) |>
...> RDF.Description.update(EX.p, EX.O, fn _ -> EX.O2 end)
RDF.Description.new({EX.S, EX.p, EX.O})

Specs

values(t(), RDF.Statement.term_mapping()) :: map()

Returns a map of the native Elixir values of a RDF.Description.

The subject is not part of the result. It can be converted separately with 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 :predicate or :object, while rdf_term is the RDF term to be mapped.

Examples

iex> {~I<http://example.com/S>, ~I<http://example.com/p>, ~L"Foo"}
...> |> RDF.Description.new()
...> |> RDF.Description.values()
%{"http://example.com/p" => ["Foo"]}

iex> {~I<http://example.com/S>, ~I<http://example.com/p>, ~L"Foo"}
...> |> RDF.Description.new()
...> |> RDF.Description.values(fn
...>      {:predicate, predicate} ->
...>        predicate
...>        |> to_string()
...>        |> String.split("/")
...>        |> List.last()
...>        |> String.to_atom()
...>    {_, term} ->
...>      RDF.Term.value(term)
...>    end)
%{p: ["Foo"]}