## -*- perl -*-
##
## redland.pod - redland Unix manual page
##
## $Id: redland.pod 8539 2006-01-26 05:22:22Z cmdjb $
##
## Copyright (C) 2002-2006, David Beckett http://purl.org/net/dajobe/
## Copyright (C) 2002-2004, University of Bristol, UK http://www.bristol.ac.uk/
## 
## This package is Free Software and part of Redland http://librdf.org/
## 
## It is licensed under the following three licenses as alternatives:
##   1. GNU Lesser General Public License (LGPL) V2.1 or any newer version
##   2. GNU General Public License (GPL) V2 or any newer version
##   3. Apache License, V2.0 or any newer version
## 
## You may not use this file except in compliance with at least one of
## the above three licenses.
## 
## See LICENSE.html or LICENSE.txt at the top of this package for the
## complete terms and further detail along with the license texts for
## the licenses in COPYING.LIB, COPYING and LICENSE-2.0.txt respectively.
## 
## 

=pod

=head1 NAME

Redland Resource Description Framework (RDF) Library

=head1 VERSION

REDLAND_VERSION_STRING

=head1 SYNOPSIS

 #include <redland.h>

=head1 DESCRIPTION

B<redland> is a library providing support for the
Resource Description Framework (RDF) written in ANSI C with
APIs in several other languages.

This manual page lists most of the redland public API functions but
does not claim to be a complete summary of the entire API.  For the
complete API with full details of the function interface, see the
HTML API documentation either on the Redland web site at
L<http://librdf.org/> or with the software release in the docs/api
directory.

=head1 FUNCTIONS

The functions defined by B<redland> are all defined with the
C<librdf_> prefix

=head2 class world

=over 4

=item librdf_world* B<librdf_new_world>(I<void>)

=item void B<librdf_free_world>(librdf_world* I<world>)

=item void B<librdf_world_open>(librdf_world* I<world>)

=item void B<librdf_world_set_error>(librdf_world* I<world>, void* I<user_data>, void (*I<error_fn>)(void* I<user_data>, const char* I<msg>, ...))

=item void B<librdf_world_set_warning>(librdf_world* I<world>, void* I<user_data>, void (*I<warning_fn>)(void* I<user_data>, const char* I<msg>, ...))

=item void B<librdf_world_set_digest>(librdf_world*, const char* I<name>)

=item void B<librdf_world_set_uris_hash>(librdf_world* I<world>, librdf_hash* I<uris_hash>)

=item const char* B<librdf_world_get_feature>(librdf_world* I<world>, librdf_uri* I<feature>)

=item int B<librdf_world_set_feature>(librdf_world* I<world>, librdf_uri* I<feature>, const char* I<value>)

=back

=head2 class iterator

=over 4

=item librdf_iterator* B<librdf_new_iterator>(librdf_world* I<world>, void* I<context>, int (*I<is_end>)(void*), void* (*I<get_next>)(void*), void (*I<finished>)(void*))

=item void B<librdf_free_iterator>(librdf_iterator*)

=item int B<librdf_iterator_end>(librdf_iterator* I<iterator>)

=item int B<librdf_iterator_finished>(librdf_iterator* I<iterator>)

=item int B<librdf_iterator_next>(librdf_iterator* I<iterator>)

=item void* B<librdf_iterator_get_object>(librdf_iterator* I<iterator>)

=item void* B<librdf_iterator_get_context>(librdf_iterator* I<iterator>)

=item void* B<librdf_iterator_get_key>(librdf_iterator* I<iterator>)

=item void* B<librdf_iterator_get_value>(librdf_iterator* I<iterator>)

=item int B<librdf_iterator_add_map>(librdf_iterator* I<iterator>, void* (*I<fn>)(void* I<context>, void* I<item>), void* I<context>)

=item void* B<librdf_iterator_map_remove_duplicate_nodes>(void* I<item>, void* I<user_data>)

=back

=head2 class digest

=over 4

=item void B<librdf_digest_register_factory>(librdf_world* I<world>, const char* I<name>, void (*I<factory>) (librdf_digest_factory*))

=item librdf_digest_factory* B<librdf_get_digest_factory>(librdf_world* I<world>, const char* I<name>)

=item librdf_digest* B<librdf_new_digest>(librdf_world* I<world>, char* I<name>)

=item librdf_digest* B<librdf_new_digest_from_factory>(librdf_world* I<world>, librdf_digest_factory* I<factory>)

=item void B<librdf_free_digest>(librdf_digest* I<digest>)

=item void B<librdf_digest_init>(librdf_digest* I<digest>)

=item void B<librdf_digest_update>(librdf_digest* I<digest>, unsigned char* I<buf>, size_t I<length>)

=item void B<librdf_digest_final>(librdf_digest* I<digest>)

=item void* B<librdf_digest_get_digest>(librdf_digest* I<digest>)

=item char* B<librdf_digest_to_string>(librdf_digest* I<digest>)

=item void B<librdf_digest_print>(librdf_digest* I<digest>, FILE* I<fh>)

=back

=head2 class uri

=over 4

=item librdf_uri* B<librdf_new_uri>(librdf_world* I<world>, const unsigned char * I<string>)

=item librdf_uri* B<librdf_new_uri_from_uri>(librdf_uri* I<uri>)

=item librdf_uri* B<librdf_new_uri_from_uri_local_name>(librdf_uri* I<uri>, const unsigned char* I<local_name>)

=item void B<librdf_free_uri>(librdf_uri* I<uri>)

=item unsigned char* B<librdf_uri_as_string>(librdf_uri* I<uri>)

=item unsigned char* B<librdf_uri_as_counted_string>(librdf_uri* I<uri>, size_t* I<len_p>)

=item librdf_digest* B<librdf_uri_get_digest>(librdf_uri* I<uri>)

=item void librdf_uri_print>(librdf_uri* I<uri>, FILE* I<fh>)

=item unsigned char* B<librdf_uri_to_string>(librdf_uri* I<uri>)

=item unsigned char* B<librdf_uri_to_counted_string>(librdf_uri* I<uri>, size_t* I<len_p>)

=item int B<librdf_uri_equals>(librdf_uri* I<first_uri>, librdf_uri* I<second_uri>)

=item int B<librdf_uri_is_file_uri>(librdf_uri* I<uri>)

=item const char* B<librdf_uri_to_filename>(librdf_uri* I<uri>)

=item librdf_uri* B<librdf_new_uri_normalised_to_base>(const unsigned char* I<uri_string>, librdf_uri* I<source_uri>, librdf_uri* I<base_uri>)

=item librdf_uri* B<librdf_new_uri_relative_to_base>(librdf_uri* I<base_uri>, const unsigned char* I<uri_string>)

=item librdf_uri* B<librdf_new_uri_from_filename>(librdf_world* I<world>, const char* I<filename>)

=back

=head2 class node

=over 4

=item librdf_node* B<librdf_new_node>(librdf_world* I<world>)

=item librdf_node* B<librdf_new_node_from_uri_string>(librdf_world* I<world>, const char* I<string>)

=item librdf_node* B<librdf_new_node_from_uri>(librdf_world* I<world>, librdf_uri* I<uri>)

=item librdf_node* B<librdf_new_node_from_uri_local_name>(librdf_world* I<world>, librdf_uri* I<uri>, const char* I<local_name>)

=item librdf_node* B<librdf_new_node_from_normalised_uri_string>(librdf_world* I<world>, const char* I<uri_string>, librdf_uri* I<source_uri>, librdf_uri* I<base_uri>)

=item librdf_node* B<librdf_new_node_from_literal>(librdf_world* I<world>, const char* I<string>, const char* I<xml_language>, int I<xml_space>, int I<is_wf_xml>)

=item librdf_node* B<librdf_new_node_from_typed_literal>(librdf_world* I<world>, const unsigned char* I<string>, const char* I<xml_language>, librdf_uri* I<datatype_uri>)

=item librdf_node* B<librdf_new_node_from_blank_identifier>(librdf_world* I<world>, const unsigned char* I<identifier>)

=item librdf_node* B<librdf_new_node_from_node>(librdf_node* I<node>)

=item void B<librdf_node_init>(librdf_world* I<world>, librdf_node* I<node>)

=item void B<librdf_free_node>(librdf_node* I<r>)

=item librdf_uri* B<librdf_node_get_uri>(librdf_node* I<node>)

=item librdf_node_type B<librdf_node_get_type>(librdf_node* I<node>)

=item unsigned char* B<librdf_node_get_literal_value>(librdf_node* I<node>)

=item unsigned char* B<librdf_node_get_literal_value_as_counted_string>(librdf_node* I<node>, size_t* I<len_p>)

=item char* B<librdf_node_get_literal_value_as_latin1>(librdf_node* I<node>)

=item char* B<librdf_node_get_literal_value_language>(librdf_node* I<node>)

=item int B<librdf_node_get_literal_value_is_wf_xml>(librdf_node* I<node>)

=item librdf_uri* B<librdf_node_get_literal_value_datatype_uri>(librdf_node* I<node>)

=item int B<librdf_node_get_li_ordinal>(librdf_node* I<node>)

=item unsigned char* B<librdf_node_get_blank_identifier>(librdf_node* I<node>)

=item int B<librdf_node_is_resource>(librdf_node* I<node>)

=item int B<librdf_node_is_literal>(librdf_node* I<node>)

=item int B<librdf_node_is_blank>(librdf_node* I<node>)

=item librdf_digest* B<librdf_node_get_digest>(librdf_node* I<node>)

=item size_t B<librdf_node_encode>(librdf_node* I<node>, unsigned char* I<buffer>, size_t I<length>)

=item size_t B<librdf_node_decode>(librdf_node* I<node>, unsigned char* I<buffer>, size_t I<length>)

=item unsigned char* B<librdf_node_to_string>(librdf_node* I<node>)

=item unsigned char* B<librdf_node_to_counted_string>(librdf_node* I<node>, size_t* I<len_p>)

=item void B<librdf_node_print>(librdf_node* I<node>, FILE* I<fh>)

=item int B<librdf_node_equals>(librdf_node* I<first_node>, librdf_node* I<second_node>)

=back

=head2 class concepts

The library provides macros for all of the RDF and RDFS concepts -
nodes and URIs.  For example, C<LIBRDF_MS_Alt> for the librdf_node
for the rdf:Alt concept and C<LIBRDF_MS_Alt_URI> for the librdf_uri
for the URI reference of rdf:Alt.

C<LIBRDF_URI_RDF_MS> and C<LIBRDF_URI_RDF_SCHEMA> provide the librdf_uri
objects for the RDF and RDFS namespace URIs.  They must be copied
using B<librdf_new_uri_from_uri> to be shared correctly.

=over 4

=item void B<librdf_get_concept_by_name>(librdf_world* I<world>, int I<is_ms>, const char* I<name>, librdf_uri **I<uri_p>, librdf_node **I<node_p>)

=back

=head2 class statement

=over 4

=item librdf_statement* B<librdf_new_statement>(librdf_world* I<world>)

=item librdf_statement* B<librdf_new_statement_from_statement>(librdf_statement* I<statement>)

=item librdf_statement* B<librdf_new_statement_from_nodes>(librdf_world* I<world>, librdf_node* I<subject>, librdf_node* I<predicate>, librdf_node* I<object>)

=item void B<librdf_statement_init>(librdf_world* I<world>, librdf_statement* I<statement>)

=item void B<librdf_statement_clear>(librdf_statement* I<statement>)

=item void B<librdf_free_statement>(librdf_statement* I<statement>)

=item librdf_node* B<librdf_statement_get_subject>(librdf_statement* I<statement>)

=item void B<librdf_statement_set_subject>(librdf_statement* I<statement>, librdf_node* I<subject>)

=item librdf_node* B<librdf_statement_get_predicate>(librdf_statement* I<statement>)

=item void B<librdf_statement_set_predicate>(librdf_statement* I<statement>, librdf_node* I<predicate>)

=item librdf_node* B<librdf_statement_get_object>(librdf_statement* I<statement>)

=item void B<librdf_statement_set_object>(librdf_statement* I<statement>, librdf_node* I<object>)

=item int B<librdf_statement_is_complete>(librdf_statement* I<statement>)

=item char* B<librdf_statement_to_string>(librdf_statement* I<statement>)

=item void B<librdf_statement_print>(librdf_statement* I<statement>, FILE* I<fh>)

=item int B<librdf_statement_equals>(librdf_statement* I<statement1>, librdf_statement* I<statement2>)

=item int B<librdf_statement_match>(librdf_statement* I<statement>, librdf_statement* I<partial_statement>)

=item size_t B<librdf_statement_encode>(librdf_statement* I<statement>, unsigned char* I<buffer>, size_t I<length>)

=item size_t B<librdf_statement_encode_parts>(librdf_statement* I<statement>, unsigned char* I<buffer>, size_t I<length>, librdf_statement_part I<fields>)

=item size_t B<librdf_statement_decode>(librdf_statement* I<statement>, unsigned char* I<buffer>, size_t I<length>)

=item size_t B<librdf_statement_decode_parts>(librdf_statement* I<statement>, librdf_node** I<context_node>, unsigned char* I<buffer>, size_t I<length>)

=back

=head2 class model

=over 4

=item librdf_model* B<librdf_new_model>(librdf_world* I<world>, librdf_storage* I<storage>, char* I<options_string>)

=item librdf_model* B<librdf_new_model_with_options>(librdf_world* I<world>, librdf_storage* I<storage>, librdf_hash* I<options>)

=item librdf_model* B<librdf_new_model_from_model>(librdf_model* I<model>)

=item void B<librdf_free_model>(librdf_model* I<model>)

=item int B<librdf_model_size>(librdf_model* I<model>)

=item int B<librdf_model_add>(librdf_model* I<model>, librdf_node* I<subject>, librdf_node* I<predicate>, librdf_node* I<object>)

=item int B<librdf_model_add_string_literal_statement>(librdf_model* I<model>, librdf_node* I<subject>, librdf_node* I<predicate>, char* I<string>, char* I<xml_language>, int I<xml_space>, int I<is_wf_xml>)

=item int B<librdf_model_add_typed_literal_statement>(librdf_model* I<model>, librdf_node* I<subject>, librdf_node* I<predicate>, const unsigned char* I<string>, char* I<xml_language>, librdf_uri* I<datatype_uri>)

=item int B<librdf_model_add_statement>(librdf_model* I<model>, librdf_statement* I<statement>)

=item int B<librdf_model_add_statements>(librdf_model* I<model>, librdf_stream* I<statement_stream>)

=item int B<librdf_model_remove_statement>(librdf_model* I<model>, librdf_statement* I<statement>)

=item int B<librdf_model_contains_statement>(librdf_model* I<model>, librdf_statement* I<statement>)

=item int B<librdf_model_has_arc_in>(librdf_model* I<model>, librdf_node* I<node>, librdf_node* I<property>)

=item int B<librdf_model_has_arc_out>(librdf_model* I<model>, librdf_node* I<node>, librdf_node* I<property>)

=item librdf_stream* B<librdf_model_as_stream>(librdf_model* I<model>)

=item librdf_stream* B<librdf_model_find_statements>(librdf_model* I<model>, librdf_statement* I<statement>)

=item librdf_stream* B<librdf_model_find_statements_in_context>(librdf_model* I<model>, librdf_statement* I<statement>, librdf_node* I<context_node>)

=item librdf_stream* B<librdf_model_find_statements_with_options>(librdf_model* I<model>, librdf_statement* I<statement>, librdf_node* I<context_node>, librdf_hash* I<options>)

=item librdf_iterator* B<librdf_model_get_contexts>(librdf_model* I<model>)

=item librdf_iterator* B<librdf_model_get_sources>(librdf_model* I<model>, librdf_node* I<arc>, librdf_node* I<target>)

=item librdf_iterator* B<librdf_model_get_arcs>(librdf_model* I<model>, librdf_node* I<source>, librdf_node* I<target>)

=item librdf_iterator* B<librdf_model_get_targets>(librdf_model* I<model>, librdf_node* I<source>, librdf_node* I<arc>)

=item librdf_node* B<librdf_model_get_source>(librdf_model* I<model>, librdf_node* I<arc>, librdf_node* I<target>)

=item librdf_node* B<librdf_model_get_arc>(librdf_model* I<model>, librdf_node* I<source>, librdf_node* I<target>)

=item librdf_node* B<librdf_model_get_target>(librdf_model* I<model>, librdf_node* I<source>, librdf_node* I<arc>)

=item librdf_iterator* B<librdf_model_get_arcs_in>(librdf_model* I<model>, librdf_node* I<node>)

=item librdf_iterator* B<librdf_model_get_arcs_out>(librdf_model* I<model>, librdf_node* I<node>)

=item int B<librdf_model_add_submodel>(librdf_model* I<model>, librdf_model* I<sub_model>)

=item int B<librdf_model_remove_submodel>(librdf_model* I<model>, librdf_model* I<sub_model>)

=item void B<librdf_model_print>(librdf_model* I<model>, FILE* I<fh>)

=item int B<librdf_model_context_add_statement>(librdf_model* I<model>, librdf_node* I<context>, librdf_statement* I<statement>)

=item int B<librdf_model_context_add_statements>(librdf_model* I<model>, librdf_node* I<context>, librdf_stream* I<stream>)

=item int B<librdf_model_context_remove_statement>(librdf_model* I<model>, librdf_node* I<context>, librdf_statement* I<statement>)

=item int B<librdf_model_context_remove_statements>(librdf_model* I<model>, librdf_node* I<context>)

=item librdf_stream* B<librdf_model_context_as_stream>(librdf_model* I<model>, librdf_node* I<context>)

=item librdf_stream* B<librdf_model_query>(librdf_model* I<model>, librdf_query* I<query>)

=item librdf_stream* B<librdf_model_query_string>(librdf_model* I<model>, const char* I<name>, librdf_uri* I<uri>, const unsigned char* I<query_string>)

=item void B<librdf_model_sync>(librdf_model* I<model>)

=item librdf_storage* B<librdf_model_get_storage>(librdf_model* I<model>)

=item librdf_node* B<librdf_model_get_feature>(librdf_model* I<model>, librdf_uri* I<feature>)
=item int B<librdf_model_set_feature>(librdf_model* I<model>, librdf_uri* I<feature>, librdf_node* I<value>)

=back

=head2 class storage

=over 4

=item void B<librdf_storage_register_factory>(const char* I<name>, void (*I<factory>) (librdf_storage_factory*))

=item librdf_storage* B<librdf_new_storage>(librdf_world* I<world>, char* I<storage_name>, char* I<name>, char* I<options_string>)

=item librdf_storage* B<librdf_new_storage_with_options>(librdf_world* I<world>, char* I<storage_name>, char* I<name>, librdf_hash* I<options>)

=item librdf_storage* B<librdf_new_storage_from_storage>(librdf_storage* I<old_storage>)

=item librdf_storage* B<librdf_new_storage_from_factory>(librdf_world* I<world>, librdf_storage_factory* I<factory>, char* I<name>, librdf_hash* I<options>)

=item void B<librdf_free_storage>(librdf_storage* I<storage>)

=item int B<librdf_storage_open>(librdf_storage* I<storage>, librdf_model* I<model>)

=item int B<librdf_storage_close>(librdf_storage* I<storage>)

=item int B<librdf_storage_get>(librdf_storage* I<storage>, void* I<key>, size_t I<key_len>, void **I<value>, size_t* I<value_len>, unsigned int I<flags>)

=item int B<librdf_storage_size>(librdf_storage* I<storage>)

=item int B<librdf_storage_add_statement>(librdf_storage* I<storage>, librdf_statement* I<statement>)

=item int B<librdf_storage_add_statements>(librdf_storage* I<storage>, librdf_stream* I<statement_stream>)

=item int B<librdf_storage_remove_statement>(librdf_storage* I<storage>, librdf_statement* I<statement>)

=item int B<librdf_storage_contains_statement>(librdf_storage* I<storage>, librdf_statement* I<statement>)

=item librdf_stream* B<librdf_storage_serialise>(librdf_storage* I<storage>)

=item librdf_stream* B<librdf_storage_find_statements>(librdf_storage* I<storage>, librdf_statement* I<statement>)

=item librdf_iterator* B<librdf_storage_get_sources>(librdf_storage* I<storage>, librdf_node* I<arc>, librdf_node* I<target>)

=item librdf_iterator* B<librdf_storage_get_arcs>(librdf_storage* I<storage>, librdf_node* I<source>, librdf_node* I<target>)

=item librdf_iterator* B<librdf_storage_get_targets>(librdf_storage* I<storage>, librdf_node* I<source>, librdf_node* I<arc>)

=item librdf_iterator* B<librdf_storage_get_arcs_in>(librdf_storage* I<storage>, librdf_node* I<node>)

=item librdf_iterator* B<librdf_storage_get_arcs_out>(librdf_storage* I<storage>, librdf_node* I<node>)

=item int B<librdf_storage_has_arc_in>(librdf_storage* I<storage>, librdf_node* I<node>, librdf_node* I<property>)

=item int B<librdf_storage_has_arc_out>(librdf_storage* I<storage>, librdf_node* I<node>, librdf_node* I<property>)

=item int B<librdf_storage_context_add_statement>(librdf_storage* I<storage>, librdf_node* I<context>, librdf_statement* I<statement>)

=item int B<librdf_storage_context_add_statements>(librdf_storage* I<storage>, librdf_node* I<context>, librdf_stream* I<stream>)

=item int B<librdf_storage_context_remove_statement>(librdf_storage* I<storage>, librdf_node* I<context>, librdf_statement* I<statement>)

=item int B<librdf_storage_context_remove_statements>(librdf_storage* I<storage>, librdf_node* I<context>)

=item librdf_stream* B<librdf_storage_context_as_stream>(librdf_storage* I<storage>, librdf_node* I<context>)

=item int B<librdf_storage_supports_query>(librdf_storage* I<storage>, librdf_query* I<query>)

=item librdf_stream* B<librdf_storage_query>(librdf_storage* I<storage>, librdf_query* I<query>)

=item void B<librdf_storage_sync>(librdf_storage* I<storage>)

=back

=head2 class parser

=over 4

=item void B<librdf_parser_register_factory>(librdf_world* I<world>, const char* I<name>, const char* I<mime_type>, const char* I<uri_string>, void (*I<factory>) (librdf_parser_factory*))

=item librdf_parser* B<librdf_new_parser>(librdf_world* I<world>, const char* I<name>, const char* I<mime_type>, librdf_uri* I<type_uri>)

=item librdf_parser* B<librdf_new_parser_from_factory>(librdf_world* I<world>, librdf_parser_factory* I<factory>)

=item void B<librdf_free_parser>(librdf_parser* I<parser>)

=item librdf_stream* B<librdf_parser_parse_as_stream>(librdf_parser* I<parser>, librdf_uri* I<uri>, librdf_uri* I<base_uri>)

=item int B<librdf_parser_parse_into_model>(librdf_parser* I<parser>, librdf_uri* I<uri>, librdf_uri* I<base_uri>, librdf_model* I<model>)

=item librdf_stream* B<librdf_parser_parse_string_as_stream>(librdf_parser* I<parser>, const unsigned char* I<string>, librdf_uri* I<base_uri>)

=item int librdf_parser_parse_string_into_model(librdf_parser* I<parser>, const unsigned char* I<string>, librdf_uri* I<base_uri>, librdf_model* I<model>)

=item void B<librdf_parser_set_error>(librdf_parser* I<parser>, void* I<user_data>, void (*I<error_fn>)(void* I<user_data>, const char* I<msg>, ...))

=item void B<librdf_parser_set_warning>(librdf_parser* I<parser>, void* I<user_data>, void (*I<warning_fn>)(void* I<user_data>, const char* I<msg>, ...))

=item librdf_node* B<librdf_parser_get_feature>(librdf_parser* I<parser>, librdf_uri* I<feature>)

=item int B<librdf_parser_set_feature>(librdf_parser* I<parser>, librdf_uri* I<feature>, librdf_node* I<value>)

=back


=head2 class serializer

=over 4

=item librdf_serializer* librdf_new_serializer(librdf_world* I<world>, const char *I<name>, const char *I<mime_type>, librdf_uri *I<type_uri>)

=item librdf_serializer* librdf_new_serializer_from_factory(librdf_world* I<world>, librdf_serializer_factory *I<factory>)

=item void librdf_free_serializer(librdf_serializer *I<serializer>)

=item int librdf_serializer_serialize_model(librdf_serializer* I<serializer>, FILE* I<handle>, librdf_uri* I<base_uri>, librdf_model* I<model>)

=item int librdf_serializer_serialize_model_to_file(librdf_serializer* I<serializer>, const char *I<name>, librdf_uri* I<base_uri>, librdf_model* I<model>)

=item void librdf_serializer_set_error(librdf_serializer* I<serializer>, void *I<user_data>, void (*I<error_fn>)(void *user_data, const char *msg, ...))

=item void librdf_serializer_set_warning(librdf_serializer* I<serializer>, void *I<user_data>, void (*I<warning_fn>)(void *user_data, const char *msg, ...))

=item librdf_node* librdf_serializer_get_feature(librdf_serializer* I<serializer>, librdf_uri* I<feature>)

=item int librdf_serializer_set_feature(librdf_serializer* I<serializer>, librdf_uri* I<feature>, librdf_node* I<value>)b

=item int librdf_serializer_set_namespace(librdf_serializer* I<serializer>, librdf_uri* I<uri>, const char* I<prefix>)

=back


=head2 class stream

=over 4

=item librdf_stream* B<librdf_new_stream>(librdf_world* I<world>, void* I<context>, int (*I<end_of_stream>)(void*), librdf_statement* (*I<next_statement>)(void*), void (*I<finished>)(void*))

=item librdf_stream* B<librdf_new_stream_from_node_iterator>(librdf_iterator* I<iterator>, librdf_statement* I<statement>, librdf_statement_part I<field>)

=item void B<librdf_free_stream>(librdf_stream* I<stream>)

=item int B<librdf_stream_end>(librdf_stream* I<stream>)

=item int B<librdf_stream_next>(librdf_stream* I<stream>)

=item librdf_statement* B<librdf_stream_get_object>(librdf_stream* I<stream>)

=item void* B<librdf_stream_get_context>(librdf_stream* I<stream>)

=item void B<librdf_stream_set_map>(librdf_stream* I<stream>, librdf_statement* (*I<map>)(void* I<context>, librdf_statement* I<statement>), void* I<map_context>)

=item void B<librdf_stream_print>(librdf_stream* I<stream>, FILE* I<fh>)

=back


=head1 EXAMPLES

  #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);

=head1 SEE ALSO

libraptor(3), libxml(4).

=head1 HISTORY

The B<redland> RDF library was created by Dave Beckett in June 2000.


=head1 AUTHOR

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

=cut
