| SERD(3) | Library Functions Manual | SERD(3) |
serd - A lightweight RDF syntax library
struct SerdNode
struct SerdChunk
struct SerdError
struct SerdURI
typedef struct SerdEnvImpl SerdEnv
typedef struct SerdReaderImpl SerdReader
typedef struct SerdWriterImpl SerdWriter
typedef uint32_t SerdStatementFlags
typedef uint32_t SerdNodeFlags
enum SerdStatus
enum SerdSyntax
enum SerdStatementFlag
enum SerdType
enum SerdNodeFlag
enum SerdStyle
void serd_free (void *ptr)
const uint8_t * serd_strerror (SerdStatus status)
size_t serd_strlen (const uint8_t *str, size_t *n_bytes,
SerdNodeFlags *flags)
double serd_strtod (const char *str, char **endptr)
void * serd_base64_decode (const uint8_t *str, size_t len, size_t
*size)
typedef int(* SerdStreamErrorFunc) (void *stream)
typedef size_t(* SerdSource) (void *buf, size_t size, size_t nmemb,
void *stream)
typedef size_t(* SerdSink) (const void *buf, size_t len, void *stream)
static const SerdURI SERD_URI_NULL
const uint8_t * serd_uri_to_path (const uint8_t *uri)
uint8_t * serd_file_uri_parse (const uint8_t *uri, uint8_t **hostname)
bool serd_uri_string_has_scheme (const uint8_t *utf8)
SerdStatus serd_uri_parse (const uint8_t *utf8, SerdURI
*out)
void serd_uri_resolve (const SerdURI *r, const SerdURI
*base, SerdURI *t)
size_t serd_uri_serialise (const SerdURI *uri, SerdSink
sink, void *stream)
size_t serd_uri_serialise_relative (const SerdURI *uri, const
SerdURI *base, const SerdURI *root, SerdSink sink, void
*stream)
static const SerdNode SERD_NODE_NULL = { NULL, 0, 0,
0, SERD_NOTHING }
SerdNode serd_node_from_string (SerdType type, const
uint8_t *str)
SerdNode serd_node_from_substring (SerdType type, const
uint8_t *str, size_t len)
SerdNode serd_node_copy (const SerdNode *node)
bool serd_node_equals (const SerdNode *a, const SerdNode
*b)
SerdNode serd_node_new_uri_from_node (const SerdNode
*uri_node, const SerdURI *base, SerdURI *out)
SerdNode serd_node_new_uri_from_string (const uint8_t *str,
const SerdURI *base, SerdURI *out)
SerdNode serd_node_new_file_uri (const uint8_t *path, const
uint8_t *hostname, SerdURI *out, bool escape)
SerdNode serd_node_new_uri (const SerdURI *uri, const
SerdURI *base, SerdURI *out)
SerdNode serd_node_new_relative_uri (const SerdURI *uri,
const SerdURI *base, const SerdURI *root, SerdURI *out)
SerdNode serd_node_new_decimal (double d, unsigned frac_digits)
SerdNode serd_node_new_integer (int64_t i)
SerdNode serd_node_new_blob (const void *buf, size_t size, bool
wrap_lines)
void serd_node_free (SerdNode *node)
typedef SerdStatus(* SerdErrorSink) (void *handle,
const SerdError *error)
typedef SerdStatus(* SerdBaseSink) (void *handle, const
SerdNode *uri)
typedef SerdStatus(* SerdPrefixSink) (void *handle, const
SerdNode *name, const SerdNode *uri)
typedef SerdStatus(* SerdStatementSink) (void *handle,
SerdStatementFlags flags, const SerdNode *graph, const
SerdNode *subject, const SerdNode *predicate, const
SerdNode *object, const SerdNode *object_datatype, const
SerdNode *object_lang)
typedef SerdStatus(* SerdEndSink) (void *handle, const
SerdNode *node)
SerdEnv * serd_env_new (const SerdNode
*base_uri)
void serd_env_free (SerdEnv *env)
const SerdNode * serd_env_get_base_uri (const SerdEnv
*env, SerdURI *out)
SerdStatus serd_env_set_base_uri (SerdEnv *env, const
SerdNode *uri)
SerdStatus serd_env_set_prefix (SerdEnv *env, const
SerdNode *name, const SerdNode *uri)
SerdStatus serd_env_set_prefix_from_strings (SerdEnv
*env, const uint8_t *name, const uint8_t *uri)
bool serd_env_qualify (const SerdEnv *env, const SerdNode
*uri, SerdNode *prefix, SerdChunk *suffix)
SerdStatus serd_env_expand (const SerdEnv *env, const
SerdNode *curie, SerdChunk *uri_prefix, SerdChunk
*uri_suffix)
SerdNode serd_env_expand_node (const SerdEnv *env, const
SerdNode *node)
void serd_env_foreach (const SerdEnv *env, SerdPrefixSink
func, void *handle)
SerdReader * serd_reader_new (SerdSyntax
syntax, void *handle, void(*free_handle)(void *), SerdBaseSink
base_sink, SerdPrefixSink prefix_sink, SerdStatementSink
statement_sink, SerdEndSink end_sink)
void serd_reader_set_strict (SerdReader *reader, bool strict)
void serd_reader_set_error_sink (SerdReader *reader,
SerdErrorSink error_sink, void *error_handle)
void * serd_reader_get_handle (const SerdReader *reader)
void serd_reader_add_blank_prefix (SerdReader *reader, const
uint8_t *prefix)
void serd_reader_set_default_graph (SerdReader *reader, const
SerdNode *graph)
SerdStatus serd_reader_read_file (SerdReader *reader,
const uint8_t *uri)
SerdStatus serd_reader_start_stream (SerdReader *reader,
FILE *file, const uint8_t *name, bool bulk)
SerdStatus serd_reader_start_source_stream (SerdReader
*reader, SerdSource read_func, SerdStreamErrorFunc error_func,
void *stream, const uint8_t *name, size_t page_size)
SerdStatus serd_reader_read_chunk (SerdReader *reader)
SerdStatus serd_reader_end_stream (SerdReader *reader)
SerdStatus serd_reader_read_file_handle (SerdReader
*reader, FILE *file, const uint8_t *name)
SerdStatus serd_reader_read_source (SerdReader *reader,
SerdSource source, SerdStreamErrorFunc error, void *stream,
const uint8_t *name, size_t page_size)
SerdStatus serd_reader_read_string (SerdReader *reader,
const uint8_t *utf8)
void serd_reader_free (SerdReader *reader)
SerdWriter * serd_writer_new (SerdSyntax
syntax, SerdStyle style, SerdEnv *env, const SerdURI
*base_uri, SerdSink ssink, void *stream)
void serd_writer_free (SerdWriter *writer)
SerdEnv * serd_writer_get_env (SerdWriter *writer)
size_t serd_file_sink (const void *buf, size_t len, void *stream)
size_t serd_chunk_sink (const void *buf, size_t len, void *stream)
uint8_t * serd_chunk_sink_finish (SerdChunk *stream)
void serd_writer_set_error_sink (SerdWriter *writer,
SerdErrorSink error_sink, void *error_handle)
void serd_writer_chop_blank_prefix (SerdWriter *writer, const
uint8_t *prefix)
SerdStatus serd_writer_set_base_uri (SerdWriter *writer,
const SerdNode *uri)
SerdStatus serd_writer_set_root_uri (SerdWriter *writer,
const SerdNode *uri)
SerdStatus serd_writer_set_prefix (SerdWriter *writer,
const SerdNode *name, const SerdNode *uri)
SerdStatus serd_writer_write_statement (SerdWriter
*writer, SerdStatementFlags flags, const SerdNode *graph,
const SerdNode *subject, const SerdNode *predicate, const
SerdNode *object, const SerdNode *datatype, const
SerdNode *lang)
SerdStatus serd_writer_end_anon (SerdWriter *writer,
const SerdNode *node)
SerdStatus serd_writer_finish (SerdWriter *writer)
A syntactic RDF node.
Data Fields:
size_t n_bytes Size in bytes (not including null)
size_t n_chars Length in characters (not including null)
SerdNodeFlags flags Node flags (e.g. string
properties)
SerdType type Node type.
An unterminated string fragment.
Data Fields:
size_t len Length of chunk in bytes.
An error description.
Data Fields:
const uint8_t * filename File where error was encountered,
or NULL.
unsigned line Line where error was encountered, or 0.
unsigned col Column where error was encountered.
const char * fmt Message format string (printf style)
va_list * args Arguments for fmt.
A parsed URI.
This struct directly refers to chunks in other strings, it does not own any memory itself. Thus, URIs can be parsed and/or resolved against a base URI in-place without allocating memory.
Data Fields:
SerdChunk authority Authority.
SerdChunk path_base Path prefix if relative.
SerdChunk path Path suffix.
SerdChunk query Query.
SerdChunk fragment Fragment.
Environment. Represents the state required to resolve a CURIE or relative URI, e.g. the base URI and set of namespace prefixes at a particular point.
RDF reader. Parses RDF by calling user-provided sink functions as input is consumed (much like an XML SAX parser).
RDF writer. Provides a number of functions to allow writing RDF syntax out to some stream. These functions are deliberately compatible with the sink functions used by SerdReader, so a reader can be directly connected to a writer to re-serialise a document with minimal overhead.
Bitwise OR of SerdStatementFlag values.
Bitwise OR of SerdNodeFlag values.
Function to detect I/O stream errors. Identical semantics to ferror.
Returns
Source function for raw string input. Identical semantics to fread, but may set errno for more informative error reporting than supported by SerdStreamErrorFunc.
Parameters
Returns
Sink function for raw string output.
Sink (callback) for errors.
Parameters
Sink (callback) for base URI changes. Called whenever the base URI of the serialisation changes.
Sink (callback) for namespace definitions. Called whenever a prefix is defined in the serialisation.
Sink (callback) for statements. Called for every RDF statement in the serialisation.
Sink (callback) for anonymous node end markers. This is called to indicate that the anonymous node with the given value will no longer be referred to by any future statements (i.e. the anonymous serialisation of the node is finished).
Return status code.
Enumerator
RDF syntax type.
Enumerator
See also
See also
See also
See also
Flags indicating inline abbreviation information for a statement.
Enumerator
Type of a syntactic RDF node. This is more precise than the type of an abstract RDF node. An abstract node is either a resource, literal, or blank. In syntax there are two ways to refer to a resource (by URI or CURIE) and two ways to refer to a blank (by ID or anonymously). Anonymous (inline) blank nodes are expressed using SerdStatementFlags rather than this type.
Enumerator
See also
See also
See also
Flags indicating certain string properties relevant to serialisation.
Enumerator
Syntax style options. The style of the writer output can be controlled by ORing together values from this enumeration. Note that some options are only supported for some syntaxes (e.g. NTriples does not support abbreviation and is always ASCII).
Enumerator
Free memory allocated by Serd. This function exists because some systems require memory allocated by a library to be freed by code in the same library. It is otherwise equivalent to the standard C free() function.
Return a string describing a status code.
Measure a UTF-8 string.
Returns
Parameters
Parse a string to a double. The API of this function is identical to the standard C strtod function, except this function is locale-independent and always matches the lexical format used in the Turtle grammar (the decimal point is always '.').
Decode a base64 string. This function can be used to deserialise a blob node created with serd_node_new_blob().
Parameters
Returns
Return the local path for uri, or NULL if uri is not a file URI. Note this (inappropriately named) function only removes the file scheme if necessary, and returns uri unmodified if it is an absolute path. Percent encoding and other issues are not handled, to properly convert a file URI to a path, use serd_file_uri_parse().
Get the unescaped path and hostname from a file URI.
Parameters
Returns
The returned path and *hostname must be freed with serd_free().
Return true iff utf8 starts with a valid URI scheme.
Parse utf8, writing result to out.
Set target t to reference r resolved against base.
See also
Serialise uri with a series of calls to sink.
Serialise uri relative to base with a series of calls to sink. The uri is written as a relative URI iff if it a child of base and root. The optional root parameter must be a prefix of base and can be used keep up-references ('../') within a certain namespace.
Make a (shallow) node from str. This measures, but does not copy, str. No memory is allocated.
Make a (shallow) node from a prefix of str. This measures, but does not copy, str. No memory is allocated. Note that the returned node may not be null terminated.
Make a deep copy of node.
Returns
Return true iff a is equal to b.
Simple wrapper for serd_node_new_uri() to resolve a URI node.
Simple wrapper for serd_node_new_uri() to resolve a URI string.
Create a new file URI node from a file system path and optional hostname. Backslashes in Windows paths will be converted and '' will always be percent encoded. If escape is true, all other invalid characters will be percent encoded as well.
If path is relative, hostname is ignored. If out is not NULL, it will be set to the parsed URI.
Create a new node by serialising uri into a new string.
Parameters
Create a new node by serialising uri into a new relative URI.
Parameters
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 (i.e. will have a leading and/or trailing `0' if necessary). It will never be in scientific notation. A maximum of frac_digits digits will be written after the decimal point, but trailing zeros will automatically be omitted (except one if d is a round integer).
Note that about 16 and 8 fractional digits are required to precisely represent a double and float, respectively.
Parameters
Create a new node by serialising i into an xsd:integer string.
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
Free any data owned by node. Note that if node is itself dynamically allocated (which is not the case for nodes created internally by serd), it will not be freed.
Create a new environment.
Free ns.
Get the current base URI.
Set the current base URI.
Set a namespace prefix.
Set a namespace prefix.
Qualify uri into a CURIE if possible.
Expand curie. Errors: SERD_ERR_BAD_ARG if curie is not valid, or SERD_ERR_BAD_CURIE if prefix is not defined in env.
Expand node, which must be a CURIE or URI, to a full URI. Returns null if node can not be expanded.
Call func for each prefix defined in env.
Create a new RDF reader.
Enable or disable strict parsing. The reader is non-strict (lax) by default, which will tolerate URIs with invalid characters. Setting strict will fail when parsing such files. An error is printed for invalid input in either case.
Set a function to be called when errors occur during reading. The error_sink will be called with handle as its first argument. If no error function is set, errors are printed to stderr in GCC style.
Return the handle passed to serd_reader_new().
Set a prefix to be added to all blank node identifiers. This is useful when multiple files are to be parsed into the same output (e.g. a store, or other files). Since Serd preserves blank node IDs, this could cause conflicts where two non-equivalent blank nodes are merged, resulting in corrupt data. By setting a unique blank node prefix for each parsed file, this can be avoided, while preserving blank node names.
Set the URI of the default graph. If this is set, the reader will emit quads with the graph set to the given node for any statements that are not in a named graph (which is currently all of them since Serd currently does not support any graph syntaxes).
Read a file at a given uri.
Start an incremental read from a file handle. Iff bulk is true, file will be read a page at a time. This is more efficient, but uses a page of memory and means that an entire page of input must be ready before any callbacks will fire. To react as soon as input arrives, set bulk to false.
Start an incremental read from a user-specified source. The read_func is guaranteed to only be called for page_size elements with size 1 (i.e. page_size bytes).
Read a single 'chunk' of data during an incremental read. This function will read a single top level description, and return. This may be a directive, statement, or several statements; essentially it reads until a '.' is encountered. This is particularly useful for reading directly from a pipe or socket.
Finish an incremental read from a file handle.
Read file.
Read a user-specified byte source.
Read utf8.
Free reader.
Create a new RDF writer.
Free writer.
Return the env used by writer.
A convenience sink function for writing to a FILE*. This function can be used as a SerdSink when writing to a FILE*. The stream parameter must be a FILE* opened for writing.
A convenience sink function for writing to a string. This function can be used as a SerdSink to write to a SerdChunk which is resized as necessary with realloc(). The stream parameter must point to an initialized SerdChunk. When the write is finished, the string should be retrieved with serd_chunk_sink_finish().
Finish a serialisation to a chunk with serd_chunk_sink(). The returned string is the result of the serialisation, which is NULL terminated (by this function) and owned by the caller.
Set a function to be called when errors occur during writing. The error_sink will be called with handle as its first argument. If no error function is set, errors are printed to stderr.
Set a prefix to be removed from matching blank node identifiers.
Set the current output base URI (and emit directive if applicable). Note this function can be safely casted to SerdBaseSink.
Set the current root URI. The root URI should be a prefix of the base URI. The path of the root URI is the highest path any relative up-reference can refer to. For example, with root file:///foo/root and base file:///foo/root/base, file:///foo/root will be written as <../>, but file:///foo will be written non-relatively as file:///foo. If the root is not explicitly set, it defaults to the base URI, so no up-references will be created at all.
Set a namespace prefix (and emit directive if applicable). Note this function can be safely casted to SerdPrefixSink.
Write a statement. Note this function can be safely casted to SerdStatementSink.
Mark the end of an anonymous node's description. Note this function can be safely casted to SerdEndSink.
Finish a write.
Initial value:
= {
{NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}
}
Generated by Doxygen for Serd from the source code and modified by Dennis Braun <d_braun@kabelmail.de>.
| '2020-04-28' |