redland(3)

📦 version 1.0.17, in alpine 3.24, centos-stream 9, debian bookworm, debian trixie, fedora 43, fedora 44, nixos 26.05, nixpkgs unstable, opensuse-leap 16.0, ubuntu jammy, ubuntu noble, ubuntu questing, ubuntu resolute, ubuntu stonking

🌸 NAME 🌸

hey bestie, welcome to the redland(3) page 💖 — this is the manual for the Redland RDF Application Framework, aka the Resource Description Framework (RDF) Library. yes, the whole thing. grab a snack, we're going on a journey. 🦋

⭐ VERSION ⭐

1.0.16 — that's the version, no cap. ✨

🎀 SYNOPSIS 🎀

like, here's how you even get at it:

#include <redland.h>

that's it. that's the whole vibe check. 💅

💜 DESCRIPTION 💜

okay so redland is a library that gives you support for the Resource Description Framework (RDF), and it's written in ANSI C with APIs in several other languages too. multilingual queen 👑

this manual page lists most of the redland public API functions, but ngl it does not claim to be a complete summary of the entire API. so if you need the complete API with full details of the function interface, go look at the HTML API documentation — either on the Redland web site at <http://librdf.org/> 🌈 or with the software release, in the docs/api directory. iykyk.

✨ FUNCTIONS ✨

every single function defined by redland is defined with the "librdf_" prefix. so if you see something starting with librdf_, that's us. 💅

🪐 class world 🪐

the world is, like, the whole universe your RDF stuff lives in — you make one, you open it, you free it. main character energy fr fr. 👑

librdf_world* librdf_new_world(void)
void librdf_free_world(librdf_world* world)
void librdf_world_open(librdf_world* world)
void librdf_world_set_error(librdf_world* world, void* user_data, void (*error_fn)(void* user_data, const char* msg, ...))
void librdf_world_set_warning(librdf_world* world, void* user_data, void (*warning_fn)(void* user_data, const char* msg, ...))
void librdf_world_set_digest(librdf_world*, const char* name)
void librdf_world_set_uris_hash(librdf_world* world, librdf_hash* uris_hash)
const char* librdf_world_get_feature(librdf_world* world, librdf_uri* feature)
int librdf_world_set_feature(librdf_world* world, librdf_uri* feature, const char* value)

🦋 class iterator 🦋

iterators are how you walk through stuff one item at a time without losing your mind. very demure, very mindful. 🧚

librdf_iterator* librdf_new_iterator(librdf_world* world, void* context, int (*is_end)(void*), void* (*get_next)(void*), void (*finished)(void*))
void librdf_free_iterator(librdf_iterator*)
int librdf_iterator_end(librdf_iterator* iterator)
int librdf_iterator_finished(librdf_iterator* iterator)
int librdf_iterator_next(librdf_iterator* iterator)
void* librdf_iterator_get_object(librdf_iterator* iterator)
void* librdf_iterator_get_context(librdf_iterator* iterator)
void* librdf_iterator_get_key(librdf_iterator* iterator)
void* librdf_iterator_get_value(librdf_iterator* iterator)
int librdf_iterator_add_map(librdf_iterator* iterator, void* (*fn)(void* context, void* item), void* context)
void* librdf_iterator_map_remove_duplicate_nodes(void* item, void* user_data)

🔐 class digest 🔐

digests = hashes. cryptographic-ish vibes. register a factory, make a digest, feed it bytes, get your digest out. slay. 🔥

void librdf_digest_register_factory(librdf_world* world, const char* name, void (*factory) (librdf_digest_factory*))
librdf_digest_factory* librdf_get_digest_factory(librdf_world* world, const char* name)
librdf_digest* librdf_new_digest(librdf_world* world, char* name)
librdf_digest* librdf_new_digest_from_factory(librdf_world* world, librdf_digest_factory* factory)
void librdf_free_digest(librdf_digest* digest)
void librdf_digest_init(librdf_digest* digest)
void librdf_digest_update(librdf_digest* digest, unsigned char* buf, size_t length)
void librdf_digest_final(librdf_digest* digest)
void* librdf_digest_get_digest(librdf_digest* digest)
char* librdf_digest_to_string(librdf_digest* digest)
void librdf_digest_print(librdf_digest* digest, FILE* fh)

🌈 class uri 🌈

URIs! the absolute backbone of RDF, periodt. make them, copy them, turn them into strings, compare them, check if they're file URIs, normalise them against a base, and build them from filenames. so much going on and every bit of it iconic. 👑

librdf_uri* librdf_new_uri(librdf_world* world, const unsigned char * string)
librdf_uri* librdf_new_uri_from_uri(librdf_uri* uri)
librdf_uri* librdf_new_uri_from_uri_local_name(librdf_uri* uri, const unsigned char* local_name)
void librdf_free_uri(librdf_uri* uri)
unsigned char* librdf_uri_as_string(librdf_uri* uri)
unsigned char* librdf_uri_as_counted_string(librdf_uri* uri, size_t* len_p)
librdf_digest* librdf_uri_get_digest(librdf_uri* uri)
void librdf_uri_print>(librdf_uri* uri, FILE* fh)
unsigned char* librdf_uri_to_string(librdf_uri* uri)
unsigned char* librdf_uri_to_counted_string(librdf_uri* uri, size_t* len_p)
int librdf_uri_equals(librdf_uri* first_uri, librdf_uri* second_uri)
int librdf_uri_is_file_uri(librdf_uri* uri)
const char* librdf_uri_to_filename(librdf_uri* uri)
librdf_uri* librdf_new_uri_normalised_to_base(const unsigned char* uri_string, librdf_uri* source_uri, librdf_uri* base_uri)
librdf_uri* librdf_new_uri_relative_to_base(librdf_uri* base_uri, const unsigned char* uri_string)
librdf_uri* librdf_new_uri_from_filename(librdf_world* world, const char* filename)
bestie, heads up: that librdf_uri_print> line is literally how it's written here, stray > and all. i am simply reporting the lore. 🙈

🫶 class node 🫶

nodes are the building blocks of RDF statements — URIs, literals, blank nodes. you can build them from uri strings, literals, typed literals, blank identifiers, other nodes… and then interrogate them about their whole life. obsessed. 💖

librdf_node* librdf_new_node(librdf_world* world)
librdf_node* librdf_new_node_from_uri_string(librdf_world* world, const char* string)
librdf_node* librdf_new_node_from_uri(librdf_world* world, librdf_uri* uri)
librdf_node* librdf_new_node_from_uri_local_name(librdf_world* world, librdf_uri* uri, const char* local_name)
librdf_node* librdf_new_node_from_normalised_uri_string(librdf_world* world, const char* uri_string, librdf_uri* source_uri, librdf_uri* base_uri)
librdf_node* librdf_new_node_from_literal(librdf_world* world, const char* string, const char* xml_language, int xml_space, int is_wf_xml)
librdf_node* librdf_new_node_from_typed_literal(librdf_world* world, const unsigned char* string, const char* xml_language, librdf_uri* datatype_uri)
librdf_node* librdf_new_node_from_blank_identifier(librdf_world* world, const unsigned char* identifier)
librdf_node* librdf_new_node_from_node(librdf_node* node)
void librdf_node_init(librdf_world* world, librdf_node* node)
void librdf_free_node(librdf_node* r)
librdf_uri* librdf_node_get_uri(librdf_node* node)
librdf_node_type librdf_node_get_type(librdf_node* node)
unsigned char* librdf_node_get_literal_value(librdf_node* node)
unsigned char* librdf_node_get_literal_value_as_counted_string(librdf_node* node, size_t* len_p)
char* librdf_node_get_literal_value_as_latin1(librdf_node* node)
char* librdf_node_get_literal_value_language(librdf_node* node)
int librdf_node_get_literal_value_is_wf_xml(librdf_node* node)
librdf_uri* librdf_node_get_literal_value_datatype_uri(librdf_node* node)
int librdf_node_get_li_ordinal(librdf_node* node)
unsigned char* librdf_node_get_blank_identifier(librdf_node* node)
int librdf_node_is_resource(librdf_node* node)
int librdf_node_is_literal(librdf_node* node)
int librdf_node_is_blank(librdf_node* node)
librdf_digest* librdf_node_get_digest(librdf_node* node)
size_t librdf_node_encode(librdf_node* node, unsigned char* buffer, size_t length)
size_t librdf_node_decode(librdf_node* node, unsigned char* buffer, size_t length)
unsigned char* librdf_node_to_string(librdf_node* node)
unsigned char* librdf_node_to_counted_string(librdf_node* node, size_t* len_p)
void librdf_node_print(librdf_node* node, FILE* fh)
int librdf_node_equals(librdf_node* first_node, librdf_node* second_node)

🧚 class concepts 🧚

the library provides macros for all of the RDF and RDFS concepts — nodes and URIs. 💫 for example, "LIBRDF_MS_Alt" for the librdf_node for the rdf:Alt concept, and "LIBRDF_MS_Alt_URI" for the librdf_uri for the URI reference of rdf:Alt.

"LIBRDF_URI_RDF_MS" and "LIBRDF_URI_RDF_SCHEMA" give you the librdf_uri objects for the RDF and RDFS namespace URIs. and listen — they must be copied using librdf_new_uri_from_uri to be shared correctly. don't skip that step, fr fr. ⚠️

void librdf_get_concept_by_name(librdf_world* world, int is_ms, const char* name, librdf_uri **uri_p, librdf_node **node_p)

💀 class statement 💀

statements = subject + predicate + object. the classic trio. make them, copy them, build them from nodes, get and set each part, check if they're complete, stringify them, print them, compare them, match them against a partial statement, and encode/decode them (whole or in parts). it's giving thorough. 🔥

librdf_statement* librdf_new_statement(librdf_world* world)
librdf_statement* librdf_new_statement_from_statement(librdf_statement* statement)
librdf_statement* librdf_new_statement_from_nodes(librdf_world* world, librdf_node* subject, librdf_node* predicate, librdf_node* object)
void librdf_statement_init(librdf_world* world, librdf_statement* statement)
void librdf_statement_clear(librdf_statement* statement)
void librdf_free_statement(librdf_statement* statement)
librdf_node* librdf_statement_get_subject(librdf_statement* statement)
void librdf_statement_set_subject(librdf_statement* statement, librdf_node* subject)
librdf_node* librdf_statement_get_predicate(librdf_statement* statement)
void librdf_statement_set_predicate(librdf_statement* statement, librdf_node* predicate)
librdf_node* librdf_statement_get_object(librdf_statement* statement)
void librdf_statement_set_object(librdf_statement* statement, librdf_node* object)
int librdf_statement_is_complete(librdf_statement* statement)
char* librdf_statement_to_string(librdf_statement* statement)
void librdf_statement_print(librdf_statement* statement, FILE* fh)
int librdf_statement_equals(librdf_statement* statement1, librdf_statement* statement2)
int librdf_statement_match(librdf_statement* statement, librdf_statement* partial_statement)
size_t librdf_statement_encode(librdf_statement* statement, unsigned char* buffer, size_t length)
size_t librdf_statement_encode_parts(librdf_statement* statement, unsigned char* buffer, size_t length, librdf_statement_part fields)
size_t librdf_statement_decode(librdf_statement* statement, unsigned char* buffer, size_t length)
size_t librdf_statement_decode_parts(librdf_statement* statement, librdf_node** context_node, unsigned char* buffer, size_t length)

and bestie… there's so much more coming. this was just part 1. 💅✨

💅 class model 💅

bestie, this is the model squad — the actual RDF graph energy, all the statements living their truth. every single signature below is verbatim, no cap, i did not touch a single character ✨

  • librdf_model* librdf_new_model(librdf_world* world, librdf_storage* storage, char* options_string) — constructor era 💖
  • librdf_model* librdf_new_model_with_options(librdf_world* world, librdf_storage* storage, librdf_hash* options) — the one where you hand over a hash instead 🎀
  • librdf_model* librdf_new_model_from_model(librdf_model* model) — copy the whole vibe 🌸
  • void librdf_free_model(librdf_model* model) — the goodbye 🫶
  • int librdf_model_size(librdf_model* model) — how big is the fit 👑
  • int librdf_model_add(librdf_model* model, librdf_node* subject, librdf_node* predicate, librdf_node* object) — subject, predicate, object, the holy trinity 🔥
  • int librdf_model_add_string_literal_statement(librdf_model* model, librdf_node* subject, librdf_node* predicate, char* string, char* xml_language, int xml_space, int is_wf_xml) — string literal, with the xml_language, xml_space and is_wf_xml options ✨
  • int librdf_model_add_typed_literal_statement(librdf_model* model, librdf_node* subject, librdf_node* predicate, const unsigned char* string, char* xml_language, librdf_uri* datatype_uri) — typed literal, so you get a datatype_uri instead 💜
  • int librdf_model_add_statement(librdf_model* model, librdf_statement* statement) — one whole statement, in it goes 🌈
  • int librdf_model_add_statements(librdf_model* model, librdf_stream* statement_stream) — the whole stream, she ate 💅
  • int librdf_model_remove_statement(librdf_model* model, librdf_statement* statement) — begone 🦋
  • int librdf_model_contains_statement(librdf_model* model, librdf_statement* statement) — is she in there or not 🍓
  • int librdf_model_has_arc_in(librdf_model* model, librdf_node* node, librdf_node* property) — arc in check ⭐
  • int librdf_model_has_arc_out(librdf_model* model, librdf_node* node, librdf_node* property) — arc out check ⭐
  • librdf_stream* librdf_model_as_stream(librdf_model* model) — turn the whole thing into a stream 🎀
  • librdf_stream* librdf_model_find_statements(librdf_model* model, librdf_statement* statement) — the find squad 🔍
  • librdf_stream* librdf_model_find_statements_in_context(librdf_model* model, librdf_statement* statement, librdf_node* context_node) — find, but in a context, she's specific 💖
  • librdf_stream* librdf_model_find_statements_with_options(librdf_model* model, librdf_statement* statement, librdf_node* context_node, librdf_hash* options) — find, context, and a hash of options, main character 🌟
  • librdf_iterator* librdf_model_get_contexts(librdf_model* model) — all the contexts, as an iterator 🧚
  • librdf_iterator* librdf_model_get_sources(librdf_model* model, librdf_node* arc, librdf_node* target) — sources, given arc + target 💜
  • librdf_iterator* librdf_model_get_arcs(librdf_model* model, librdf_node* source, librdf_node* target) — arcs, given source + target 🌈
  • librdf_iterator* librdf_model_get_targets(librdf_model* model, librdf_node* source, librdf_node* arc) — targets, given source + arc 🌸
  • librdf_node* librdf_model_get_source(librdf_model* model, librdf_node* arc, librdf_node* target) — same as above but a single node, not an iterator 👑
  • librdf_node* librdf_model_get_arc(librdf_model* model, librdf_node* source, librdf_node* target) — single arc ✨
  • librdf_node* librdf_model_get_target(librdf_model* model, librdf_node* source, librdf_node* arc) — single target 💅
  • librdf_iterator* librdf_model_get_arcs_in(librdf_model* model, librdf_node* node) — arcs in, iterator style 🦋
  • librdf_iterator* librdf_model_get_arcs_out(librdf_model* model, librdf_node* node) — arcs out, iterator style 🦋
  • int librdf_model_add_submodel(librdf_model* model, librdf_model* sub_model) — model inside a model, inception fr fr 😭
  • int librdf_model_remove_submodel(librdf_model* model, librdf_model* sub_model) — un-inception 💀
  • void librdf_model_print(librdf_model* model, FILE* fh) — spill it to fh 🖨️
  • int librdf_model_context_add_statement(librdf_model* model, librdf_node* context, librdf_statement* statement) — context + statement, added 🎀
  • int librdf_model_context_add_statements(librdf_model* model, librdf_node* context, librdf_stream* stream) — context + whole stream 🍓
  • int librdf_model_context_remove_statement(librdf_model* model, librdf_node* context, librdf_statement* statement) — context + statement, removed 🙈
  • int librdf_model_context_remove_statements(librdf_model* model, librdf_node* context) — nuke that context's statements 💥
  • librdf_stream* librdf_model_context_as_stream(librdf_model* model, librdf_node* context) — context, but as a stream 🌈
  • librdf_stream* librdf_model_query(librdf_model* model, librdf_query* query) — query time 👑
  • librdf_stream* librdf_model_query_string(librdf_model* model, const char* name, librdf_uri* uri, const unsigned char* query_string) — query, but from a name, uri and query_string 💜
  • void librdf_model_sync(librdf_model* model) — sync her 🫶
  • librdf_storage* librdf_model_get_storage(librdf_model* model) — grab the storage underneath 🎀
  • librdf_node* librdf_model_get_feature(librdf_model* model, librdf_uri* feature) =item int librdf_model_set_feature(librdf_model* model, librdf_uri* feature, librdf_node* value)
bestie. that =item in the middle? i know. 😭 it is literally in the original like that — librdf_model_get_feature and librdf_model_set_feature got glued together by a runaway manpage macro. i kept it character for character because that's the rule. get/set feature, both of them, that's the tea 💀

🌸 class storage 🌸

the storage layer — where the statements actually live. same deal, every signature exact, i'm just here for the commentary ✨

  • void librdf_storage_register_factory(const char* name, void (*factory)(librdf_storage_factory*)) — register a factory under a name 🏭
  • librdf_storage* librdf_new_storage(librdf_world* world, char* storage_name, char* name, char* options_string) — new storage, storage_name + name + options_string 💖
  • librdf_storage* librdf_new_storage_with_options(librdf_world* world, char* storage_name, char* name, librdf_hash* options) — same but the options come as a hash 🎀
  • librdf_storage* librdf_new_storage_from_storage(librdf_storage* old_storage) — copy era 🌸
  • librdf_storage* librdf_new_storage_from_factory(librdf_world* world, librdf_storage_factory* factory, char* name, librdf_hash* options) — straight from a factory 🏭
  • void librdf_free_storage(librdf_storage* storage) — bye bestie 🫶
  • int librdf_storage_open(librdf_storage* storage, librdf_model* model) — open, with a model in hand 🔓
  • int librdf_storage_close(librdf_storage* storage) — close it up 🔒
  • int librdf_storage_get(librdf_storage* storage, void* key, size_t key_len, void **value, size_t* value_len, unsigned int flags) — the raw get: key, key_len, value, value_len, flags, the whole buffet 💅
  • int librdf_storage_size(librdf_storage* storage) — size check 👑
  • int librdf_storage_add_statement(librdf_storage* storage, librdf_statement* statement) — add one 🌈
  • int librdf_storage_add_statements(librdf_storage* storage, librdf_stream* statement_stream) — add the whole statement_stream 🍓
  • int librdf_storage_remove_statement(librdf_storage* storage, librdf_statement* statement) — remove one 🙈
  • int librdf_storage_contains_statement(librdf_storage* storage, librdf_statement* statement) — does she contain it 💜
  • librdf_stream* librdf_storage_serialise(librdf_storage* storage) — serialise the whole storage into a stream ✨
  • librdf_stream* librdf_storage_find_statements(librdf_storage* storage, librdf_statement* statement) — find squad, storage edition 🔍
  • librdf_iterator* librdf_storage_get_sources(librdf_storage* storage, librdf_node* arc, librdf_node* target) — sources from arc + target 🧚
  • librdf_iterator* librdf_storage_get_arcs(librdf_storage* storage, librdf_node* source, librdf_node* target) — arcs from source + target 🌸
  • librdf_iterator* librdf_storage_get_targets(librdf_storage* storage, librdf_node* source, librdf_node* arc) — targets from source + arc 🌈
  • librdf_iterator* librdf_storage_get_arcs_in(librdf_storage* storage, librdf_node* node) — arcs in 🦋
  • librdf_iterator* librdf_storage_get_arcs_out(librdf_storage* storage, librdf_node* node) — arcs out 🦋
  • int librdf_storage_has_arc_in(librdf_storage* storage, librdf_node* node, librdf_node* property) — has arc in, yes or no ⭐
  • int librdf_storage_has_arc_out(librdf_storage* storage, librdf_node* node, librdf_node* property) — has arc out, yes or no ⭐
  • int librdf_storage_context_add_statement(librdf_storage* storage, librdf_node* context, librdf_statement* statement) — context + statement 🎀
  • int librdf_storage_context_add_statements(librdf_storage* storage, librdf_node* context, librdf_stream* stream) — context + stream 💖
  • int librdf_storage_context_remove_statement(librdf_storage* storage, librdf_node* context, librdf_statement* statement) — context + statement, removed 💀
  • int librdf_storage_context_remove_statements(librdf_storage* storage, librdf_node* context) — clear out the context 💥
  • librdf_stream* librdf_storage_context_as_stream(librdf_storage* storage, librdf_node* context) — context as a stream 🌟
  • int librdf_storage_supports_query(librdf_storage* storage, librdf_query* query) — can she even 🫶
  • librdf_stream* librdf_storage_query(librdf_storage* storage, librdf_query* query) — she can, and here's the stream 👑
  • void librdf_storage_sync(librdf_storage* storage) — sync 🧚

🦋 class parser 🦋

the parser girlies — she takes input and turns it into statements. every signature, untouched, i promise on my life 💜

  • void librdf_parser_register_factory(librdf_world* world, const char* name, const char* mime_type, const char* uri_string, void (*factory)(librdf_parser_factory*)) — register a parser factory by name, mime_type and uri_string 🏭
  • librdf_parser* librdf_new_parser(librdf_world* world, const char* name, const char* mime_type, librdf_uri* type_uri) — new parser from name, mime_type, type_uri ✨
  • librdf_parser* librdf_new_parser_from_factory(librdf_world* world, librdf_parser_factory* factory) — straight from the factory 🎀
  • void librdf_free_parser(librdf_parser* parser) — bye 🫶
  • librdf_stream* librdf_parser_parse_as_stream(librdf_parser* parser, librdf_uri* uri, librdf_uri* base_uri) — parse a uri into a stream, with a base_uri 🌈
  • int librdf_parser_parse_into_model(librdf_parser* parser, librdf_uri* uri, librdf_uri* base_uri, librdf_model* model) — parse that uri straight into a model 👑
  • librdf_stream* librdf_parser_parse_string_as_stream(librdf_parser* parser, const unsigned char* string, librdf_uri* base_uri) — parse a string into a stream 🍓
  • int librdf_parser_parse_string_into_model(librdf_parser* parser, const unsigned char* string, librdf_uri* base_uri, librdf_model* model) — parse that string into a model 🌸
  • void librdf_parser_set_error(librdf_parser* parser, void* user_data, void (*error_fn)(void* user_data, const char* msg, ...)) — set the error handler: user_data + error_fn 🚨
  • void librdf_parser_set_warning(librdf_parser* parser, void* user_data, void (*warning_fn)(void* user_data, const char* msg, ...)) — set the warning handler: user_data + warning_fn ⚠️
  • librdf_node* librdf_parser_get_feature(librdf_parser* parser, librdf_uri* feature) — get a feature 💖
  • int librdf_parser_set_feature(librdf_parser* parser, librdf_uri* feature, librdf_node* value) — set a feature 🎀

🎀 class serializer 🎀

the serializer bestie — she takes your model and writes it out all pretty. signatures verbatim, character for character, periodt 💅

  • librdf_serializer* librdf_new_serializer(librdf_world* world, const char *name, const char *mime_type, librdf_uri *type_uri) — new serializer from name, mime_type, type_uri ✨
  • librdf_serializer* librdf_new_serializer_from_factory(librdf_world* world, librdf_serializer_factory *factory) — from the factory 🏭
  • void librdf_free_serializer(librdf_serializer *serializer) — bye girl 🫶
  • int librdf_serializer_serialize_model(librdf_serializer* serializer, FILE* handle, librdf_uri* base_uri, librdf_model* model) — write the model to a handle, with a base_uri 🌈
  • int librdf_serializer_serialize_model_to_file(librdf_serializer* serializer, const char *name, librdf_uri* base_uri, librdf_model* model) — same but to a file name 📄
  • void librdf_serializer_set_error(librdf_serializer* serializer, void *user_data, void (*error_fn)(void *user_data, const char *msg, ...)) — error handler: user_data + error_fn 🚨
  • void librdf_serializer_set_warning(librdf_serializer* serializer, void *user_data, void (*warning_fn)(void *user_data, const char *msg, ...)) — warning handler: user_data + warning_fn ⚠️
  • librdf_node* librdf_serializer_get_feature(librdf_serializer* serializer, librdf_uri* feature) — get a feature 💖
  • int librdf_serializer_set_feature(librdf_serializer* serializer, librdf_uri* feature, librdf_node* value)b — set a feature
  • int librdf_serializer_set_namespace(librdf_serializer* serializer, librdf_uri* uri, const char* prefix) — set a namespace: uri + prefix 🎀
okay so about that lonely little b hanging off the end of librdf_serializer_set_feature… 😭 it's in the original, bestie, it's a lil typo that has been living there rent free. i kept it. don't come for me, come for the manpage 💀

⭐ class stream ⭐

and finally the stream crew — she's the "here's your stuff, one at a time" girlie. all signatures exact, all vibes immaculate 🦋

  • librdf_stream* librdf_new_stream(librdf_world* world, void* context, int (*end_of_stream)(void*), librdf_statement* (*next_statement)(void*), void (*finished)(void*)) — new stream with context, end_of_stream, next_statement and finished callbacks, the whole build-your-own setup ✨
  • librdf_stream* librdf_new_stream_from_node_iterator(librdf_iterator* iterator, librdf_statement* statement, librdf_statement_part field) — build one from an iterator, a statement and a field 🎀
  • void librdf_free_stream(librdf_stream* stream) — bye 🫶
  • int librdf_stream_end(librdf_stream* stream) — are we at the end 🍓
  • int librdf_stream_next(librdf_stream* stream) — next 🦋
  • librdf_statement* librdf_stream_get_object(librdf_stream* stream) — grab the current object 💖
  • void* librdf_stream_get_context(librdf_stream* stream) — grab the context 🌸
  • void librdf_stream_set_map(librdf_stream* stream, librdf_statement* (*map)(void* context, librdf_statement* statement), void* map_context) — set a map function plus a map_context 🗺️
  • void librdf_stream_print(librdf_stream* stream, FILE* fh) — print the stream to fh 🖨️

that's the whole function roster for these classes, bestie — nothing skipped, nothing merged, nothing invented. more coming in the next part, so don't wander off 💜

✨ EXAMPLES ✨

okay bestie this is the whole vibe in one little program, no cap 💖 here's a full working example, and yes you can literally copy-paste this:

#include <redland.h>

librdf_storage *storage;
librdf_model* model;
librdf_statement* statement;
librdf_world* world

world=librdf_new_world();

librdf_world_open(world);

storage=librdf_new_storage(world, "hashes", "test", "hash-type='bdb',dir='.'");
model=librdf_new_model(world, storage, NULL);
statement=librdf_new_statement_from_nodes(world, librdf_new_node_from_uri_string(world, "http://purl.org/net/dajobe/"), librdf_new_node_from_uri_string(world, "http://purl.org/dc/elements/1.1/creator"), librdf_new_node_from_literal(world, "Dave Beckett", NULL, 0));

librdf_model_add_statement(model, statement);
librdf_free_statement(statement);

librdf_model_print(model, stdout);

librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);

so what's happening here, step by step? 🎀 you make a world, you open it, you build a "hashes" storage called "test" with the options hash-type='bdb',dir='.', you make a model on top of it, you build one statement out of three nodes (a URI subject, a URI predicate, and a literal object saying "Dave Beckett"), you add it, you free the statement, you print the model to stdout, and then you clean up model → storage → world, in that order. icon behavior, truly 🫶

🌈 SEE ALSO 🌈

  • libraptor(3)
  • libxml(4)

📜 HISTORY 📜

the redland RDF library was created by Dave Beckett back in June 2000 — a whole legend, fr fr 👑

💜 AUTHOR 💜

Dave Beckett <http://purl.org/net/dajobe/>

okay that's the whole page bestie, you're officially a redland girlie now 💅 this was redland 1.0.16, dated 28-Jun-2012, and it lives in the redland(3) section — go forth and build your triples, mwah 🦋✨

📦 where this page comes from