View Source RDF.XML.Encoder (RDF-XML.ex v1.1.1)

An encoder for RDF/XML serializations of RDF.ex data structures.

As for all encoders of RDF.Serialization.Formats, you normally won't use these functions directly, but via one of the write_ functions on the RDF.XML format module or the generic RDF.Serialization module.

Options

  • :base: : Allows to specify the base URI to be used for a xml:base declaration. If not specified the one from the given graph is used or if there is also none specified for the graph the RDF.default_base_iri/0.

  • :prefixes: Allows to specify the prefixes to be used as a RDF.PrefixMap or anything from which a RDF.PrefixMap can be created with RDF.PrefixMap.new/1. If not specified the ones from the given graph are used or if these are also not present the RDF.default_prefixes/0.

  • :implicit_base: Allows to specify that the used base URI should not be encoded in the generated serialization (default: false).

  • :use_rdf_id: Allows to determine if rdf:ID should be used when possible. You can either provide a boolean value or a function which should return a boolean value for a given RDF.Description. (default: false)

  • :xml_declaration: Allows to specify the XML declaration. Possible values:

    • true (default): produces the default <?xml version="1.0" encoding="utf-8"?> declaration
    • false: omits the XML declaration
    • any value supported for prolog argument of Saxy.encode!/2 (only available on encode/2, not on stream/2)
  • :producer: This option allows you to provide a producer function, which will get the input data (usually a RDF.Graph) and should produce a stream of the descriptions to be encoded. This allows you to control the order of the descriptions, apply filters etc.

      iex> RDF.Graph.new([
      ...>   EX.S1 |> EX.p1(EX.O1),
      ...>   EX.S2 |> EX.p2(EX.O2),
      ...> ])
      ...> |> RDF.XML.write_string!(
      ...>     prefixes: [ex: EX],
      ...>     producer: fn graph ->
      ...>       {first, rest} = RDF.Graph.pop(graph, EX.S2)
      ...>       Stream.concat([first], RDF.Graph.descriptions(rest))
      ...>     end)
      ~S(<?xml version="1.0" encoding="utf-8"?><rdf:RDF xmlns:ex="http://example.com/"><rdf:Description rdf:about="http://example.com/S2"><ex:p2 rdf:resource="http://example.com/O2"/></rdf:Description><rdf:Description rdf:about="http://example.com/S1"><ex:p1 rdf:resource="http://example.com/O1"/></rdf:Description></rdf:RDF>)

Summary

Functions

Encodes the given RDF data structure to an RDF/XML string.

Encodes the given RDF data structure to an RDF/XML stream.

Functions

Link to this function

encode(data, opts \\ [])

View Source
@spec encode(
  RDF.Graph.t(),
  keyword()
) :: {:ok, String.t()} | {:error, any()}

Encodes the given RDF data structure to an RDF/XML string.

The result is returned in an :ok tuple or an :error tuple in case of an error.

For a description of the available options see the module documentation.

Link to this function

stream(data, opts \\ [])

View Source
@spec stream(
  RDF.Graph.t(),
  keyword()
) :: Enumerable.t()

Encodes the given RDF data structure to an RDF/XML stream.

By default, the RDF/XML stream will emit single line strings for each of the descriptions in the given data. But you can also receive the serialized RDF/XML description as IO lists aka iodata by setting the :mode option to :iodata.

For a description of the other available options see the module documentation.