Node

SerdNode *serd_node_from_syntax(const char *str, SerdSyntax syntax)

Create a node from a string representation in syntax.

The string should be a node as if written as an object in the given syntax, without any extra quoting or punctuation, which is the format returned by serd_node_to_syntax(). These two functions, when used with SerdSyntax.SERD_TURTLE, can be used to round-trip any node to a string and back.

Parameters

  • str – String representation of a node.

  • syntax – Syntax to use. Should be either SERD_TURTLE or SERD_NTRIPLES (the others are redundant). Note that namespaced (CURIE) nodes and relative URIs can not be expressed in NTriples.

Returns

A newly allocated node that must be freed with serd_node_free().

char *serd_node_to_syntax(const SerdNode *node, SerdSyntax syntax)

Return a string representation of node in syntax.

The returned string represents that node as if written as an object in the given syntax, without any extra quoting or punctuation.

Parameters

  • node – Node to write as a string.

  • syntax – Syntax to use. Should be either SERD_TURTLE or SERD_NTRIPLES (the others are redundant). Note that namespaced (CURIE) nodes and relative URIs can not be expressed in NTriples.

Returns

A newly allocated string that must be freed with serd_free().

SerdNode *serd_new_simple_node(SerdNodeType type, SerdStringView string)

Create a new “simple” node that is just a string.

This can be used to create nodes from an already measured string or slice of a buffer, which avoids measuring the string compared to the friendlier constructors. If type is SerdNodeType.SERD_LITERAL, then this creates a plain literal with no language tag.

Parameters

  • type – The type of node to create.

  • string – The string contents of the node.

SerdNode *serd_new_string(SerdStringView string)

Create a new plain literal string node from str

SerdNode *serd_new_plain_literal(SerdStringView str, SerdStringView lang)

Create a new literal node from str.

A plain literal has no datatype, but may have a language tag. The lang may be NULL, in which case this is equivalent to serd_new_string().

SerdNode *serd_new_typed_literal(SerdStringView str, SerdStringView datatype_uri)

Create a new typed literal node from str.

A typed literal has no language tag, but may have a datatype. The datatype may be NULL, in which case this is equivalent to serd_new_string().

SerdNode *serd_new_blank(SerdStringView string)

Create a new blank node.

SerdNode *serd_new_curie(SerdStringView string)

Create a new CURIE node.

SerdNode *serd_new_uri(SerdStringView string)

Create a new URI from a string.

SerdNode *serd_new_parsed_uri(SerdURIView uri)

Create a new URI from a URI view.

SerdNode *serd_new_file_uri(SerdStringView path, SerdStringView hostname)

Create a new file URI node from a file system path and optional hostname.

Backslashes in Windows paths will be converted, and other characters will be percent encoded as necessary.

If path is relative, hostname is ignored.

SerdNode *serd_new_boolean(bool b)

Create a new node by serialising b into an xsd:boolean string.

SerdNode *serd_new_real_file_uri(const char *path, const char *hostname)

Create a new file URI node for a file that exists on this system.

This is like serd_new_file_uri() except it resolves and canonicalizes the path, so the returned node is always a complete file URI with a scheme and absolute path that does not contain any dot references or links, or NULL if this is impossible (for example, because the path does not exist).

This should be used wherever the URI for an existent file is required, for example to set the base URI of a document.

SerdNode *serd_new_decimal(double d, const SerdNode *datatype)

Create a new node by serialising d into an xsd:decimal string.

The resulting node will always contain a .’, start with a digit, and end with a digit (a leading and/or trailing ``0` will be added if necessary). It will never be in scientific notation.

Parameters

  • d – The value for the new node.

  • datatype – Datatype of node, or NULL for xsd:decimal.

SerdNode *serd_new_double(double d)

Create a new node by serialising d into a normalised xsd:double string.

The returned node will always be in normalised scientific notation, like “1.23E4”, except for NaN and negative/positive infinity, which are “NaN”, “-INF”, and “INF”, respectively.

Uses the shortest possible representation that precisely describes d, which has at most 17 significant digits (under 24 characters total).

Parameters

  • d – Double value to serialise.

Returns

A literal node with datatype xsd:double.

SerdNode *serd_new_float(float f)

Create a new node by serialising f into a normalised xsd:float string.

Uses identical formatting to serd_new_double(), except with at most 9 significant digits (under 14 characters total).

Parameters

  • f – Float value of literal.

Returns

A literal node with datatype xsd:float.

SerdNode *serd_new_integer(int64_t i, const SerdNode *datatype)

Create a new node by writing i as an xsd:integer string.

Parameters

  • i – Integer value of literal.

  • datatype – Datatype of node, or NULL for xsd:integer.

SerdNode *serd_new_blob(const void *buf, size_t size, const SerdNode *datatype)

Create a node by serialising buf into an xsd:base64Binary string.

This function can be used to make a serialisable node out of arbitrary binary data, which can be decoded using serd_base64_decode().

Parameters

  • buf – Raw binary input data.

  • size – Size of buf.

  • datatype – Datatype of node, or NULL for xsd:base64Binary.

bool serd_get_boolean(const SerdNode *node)

Return the value of node as a boolean.

This will work for booleans, and numbers of any datatype if they are 0 or 1.

Returns

The value of node as a bool, or false on error.

double serd_get_double(const SerdNode *node)

Return the value of node as a double.

This will coerce numbers of any datatype to double, if the value fits.

Returns

The value of node as a double, or NaN on error.

float serd_get_float(const SerdNode *node)

Return the value of node as a float.

This will coerce numbers of any datatype to float, if the value fits.

Returns

The value of node as a float, or NaN on error.

int64_t serd_get_integer(const SerdNode *node)

Return the value of node as a long (signed 64-bit integer).

This will coerce numbers of any datatype to long, if the value fits.

Returns

The value of node as a int64_t, or 0 on error.

SerdNode *serd_node_copy(const SerdNode *node)

Return a deep copy of node

void serd_node_free(SerdNode *node)

Free any data owned by node

SerdNodeType serd_node_type(const SerdNode *node)

Return the type of a node (SERD_URI, SERD_BLANK, or SERD_LITERAL)

const char *serd_node_string(const SerdNode *node)

Return the string value of a node.

size_t serd_node_length(const SerdNode *node)

Return the length of the string value of a node in bytes.

SerdStringView serd_node_string_view(const SerdNode *node)

Return a view of the string in a node.

This is a convenience wrapper for serd_node_string() and serd_node_length() that can be used to get both in a single call.

SerdURIView serd_node_uri_view(const SerdNode *node)

Return a parsed view of the URI in a node.

It is best to check the node type before calling this function, though it is safe to call on non-URI nodes. In that case, it will return a null view with all fields zero.

Note that this parses the URI string contained in the node, so it is a good idea to keep the value if you will be using it several times in the same scope.

const SerdNode *serd_node_datatype(const SerdNode *node)

Return the datatype of a literal node, or NULL.

const SerdNode *serd_node_language(const SerdNode *node)

Return the language tag of a literal node, or NULL.

bool serd_node_equals(const SerdNode *a, const SerdNode *b)

Return true iff a is equal to b

int serd_node_compare(const SerdNode *a, const SerdNode *b)

Compare two nodes.

Returns less than, equal to, or greater than zero if a is less than, equal to, or greater than b, respectively. NULL is treated as less than any other node.