4.3 Nodes

Nodes are the basic building blocks of data. Nodes are essentially strings, but also have a type, and optionally either a datatype or a language.

In the abstract, a node is either a literal, a URI, or blank. Literals are essentially strings, but may have a datatype or a language tag. URIs are used to identify resources, as are blank nodes, except blank nodes only have labels with a limited scope and may be written anonymously.

Serd also has a type for variable nodes, which are used for some features but not present in RDF data.

4.3.1 Fundamental Constructors

To allow the application to manage node memory, node constructors are provided that construct nodes in existing memory buffers. The universal constructor serd_node_construct() can construct any type of node, but is somewhat verbose and tricky to use.

Several constructors for more specific types of node are also available:

• serd_node_construct_token()

• serd_node_construct_uri()

• serd_node_construct_file_uri()

• serd_node_construct_literal()

• serd_node_construct_boolean()

• serd_node_construct_decimal()

• serd_node_construct_double()

• serd_node_construct_float()

• serd_node_construct_integer()

• serd_node_construct_base64()

If explicit memory management is not required, high-level constructors that allocate nodes on the heap can be used instead:

• serd_new_token()

• serd_new_uri()

• serd_new_file_uri()

• serd_new_literal()

• serd_new_boolean()

• serd_new_decimal()

• serd_new_double()

• serd_new_float()

• serd_new_integer()

• serd_new_base64()

4.3.2 Accessors

The basic attributes of a node can be accessed with serd_node_type(), serd_node_string(), and serd_node_length().

A measured view of the string can be accessed with serd_node_string_view(). This can be passed to functions that take a string view, to avoid redundant measurement of the node string.

The datatype or language can be retrieved with serd_node_datatype() or serd_node_language(), respectively. Note that only literals can have a datatype or language, but never both at once.