@spec add(t(), input()) :: {:ok, t()} | {:error, String.t()}

Adds a set of property mappings to property_map.

The mappings can be passed in various ways:

• as keyword lists or maps where terms for the RDF properties can be given as atoms or strings, while the property IRIs can be given as RDF.IRIs or strings
• a strict RDF.Vocabulary.Namespace from which all lowercase terms are added with their respective IRI; since IRIs can also be once in a RDF.PropertyMap a defined alias term is preferred over an original term
• a RDF.Namespace from which all lowercase terms are added with their respective IRI
• another RDF.PropertyMap from which all mappings are merged

Unless a mapping for any of the terms or IRIs in the input already exists, an :ok tuple is returned, otherwise an :error tuple.

@spec add(t(), coercible_term(), RDF.IRI.coercible()) ::
  {:ok, t()} | {:error, String.t()}

Adds a property mapping between term and iri to property_map.

Unless another mapping for term or iri already exists, an :ok tuple is returned, otherwise an :error tuple.

@spec add!(t(), input()) :: t()

Adds a set of property mappings to property_map and raises an error on conflicts.

See add/2 for the different forms in which mappings can be provided.

@spec delete(t(), coercible_term()) :: t()

Deletes the property mapping for term from property_map.

If no mapping for term exists, property_map is returned unchanged.

@spec drop(t(), [coercible_term()]) :: t()

Drops the given terms from the property_map.

If terms contains terms that are not in property_map, they're simply ignored.

@spec iri(t(), coercible_term()) :: RDF.IRI.t() | nil

Returns the IRI for the given term in property_map.

Returns nil, when the given term is not present in property_map.

@spec iri_defined?(t(), coercible_term()) :: boolean()

Returns whether a mapping for the given term is defined in property_map.

@spec iris(t()) :: [RDF.IRI.t()]

Returns the list of all IRIs in the given property_map.

@spec new() :: t()

Creates an empty RDF.PropertyMap.

@spec new(input()) :: t()

Creates a new RDF.PropertyMap with initial mappings.

See add/2 for the different forms in which mappings can be provided.

@spec put(t(), input()) :: t()

Adds a set of property mappings to property_map overwriting all existing mappings.

See add/2 for the different forms in which mappings can be provided.

Note, that not just all mappings with the used terms in the input mappings are overwritten, but also all mappings with IRIs in the input mappings

@spec put(t(), coercible_term(), RDF.IRI.coercible()) :: t()

Adds a property mapping between term and iri to property_map overwriting existing mappings.

@spec term(t(), RDF.IRI.coercible()) :: atom() | nil

Returns the term for the given namespace in prefix_map.

Returns nil, when the given namespace is not present in prefix_map.

@spec term_defined?(t(), RDF.IRI.coercible()) :: boolean()

Returns whether a mapping for the given iri is defined in property_map.

@spec terms(t()) :: [atom()]

Returns the list of all terms in the given property_map.

@spec to_list(t()) :: [{atom(), RDF.IRI.t()}]

Converts property map to a list.

Each term-IRI pair in the property map is converted to a two-element tuple {term, iri} in the resulting list.

Examples

iex> RDF.PropertyMap.new(foo: "http://example.com/foo") |> RDF.PropertyMap.to_list()
[foo: ~I<http://example.com/foo>]

@spec to_sorted_list(t()) :: [{atom(), RDF.IRI.t()}]

Converts property map to a list sorted by property.

Each term-IRI pair in the property map is converted to a two-element tuple {term, iri} in the resulting list.

Examples

iex> RDF.PropertyMap.new(
...>   foo: "http://example.com/foo",
...>   bar: "http://example.com/bar")
...> |> RDF.PropertyMap.to_sorted_list()
[bar: ~I<http://example.com/bar>, foo: ~I<http://example.com/foo>]