libraptor(3)

NAME
libraptor - Raptor RDF parser toolkit library

SYNOPSIS
#include <raptor.h>
raptor_init();
raptor_parser *p=raptor_new_parser("rdfxml");
raptor_set_statement_handler(p,NULL,print_statements);
raptor_uri *file_uri=raptor_new_uri("http://example.org/");
raptor_parse_file(p,file_uri,base_uri);
raptor_parse_uri(p,uri,NULL);
raptor_free_parser(p);
raptor_free_uri(file_uri);
raptor_finish();
cc file.c -lraptor

DESCRIPTION
The Raptor library provides a high-level interface to a set of RDF format parsers, presently RDF/XML and N-Triples. The parsers turn the syntax into a sequence of RDF triples/statements. The RDF/XML parser uses either expat or libxml XML parser for providing the SAX event stream. The library functions are arranged in an object-oriented style with constructors, destructors and method calls. The statements and error messages are delivered via callback functions.

Raptor contains a URI-reference parsing and resolving (not retrieval) class (raptor_uri) sufficient for dealing with URI-references inside RDF. This functionality is modular and can be transparently replaced with another existing and compatible URI implementation.

It also provides a URI-retrieval class (raptor_www) for wrapping existing library such as libcurl or libxml2 that provides full or partial retrieval of data from URIs.

LIBRARY INITIALISATION AND CLEANUP

raptor_init()

raptor_finish()
    Initialise and cleanup the library. These must be called before any raptor_parser or raptor_uri is created or used.

PARSER CONSTRUCTORS

raptor_parser* raptor_new_parser(name)
    Create a new raptor parser object for the parser with name name currently either "rdfxml", "ntriples" or "rss-tag-soup" for the RSS Tag Soup parser.

PARSER DESTRUCTORS

void raptor_free_parser(raptor_parser *parser)
    Destroy a Raptor parser object.

PARSER MESSAGE CALLBACK METHODS
Several methods can be registered for the parser that return a variable-argument message in the style of printf(3). These also return a raptor_locator that can contain URI, file, line, column and byte counts of where the message is about. This structure can be used with the raptor_format_locator, raptor_print_locator functions below or the structures fields directly, which are defined in raptor.h

void raptor_set_fatal_error_handler(raptor_parser* parser, void *user_data, raptor_message_handler handler)
    Set fatal error handler callback.

void raptor_set_error_handler(raptor_parser* parser, void *user_data, raptor_message_handler handler)
    Set non-fatal error handler callback.

void raptor_set_warning_handler(raptor_parser* parser, void *user_data, raptor_message_handler handler)
    Set warning message handler callback.

PARSER STATEMENT CALLBACK METHOD
The parser allows the registration of a callback function to return the statements to the application.

void raptor_set_statement_handler(raptor_parser* parser, void *user_data, raptor_statement_handler handler)
    Set the statement callback function for the parser. The raptor_statement structure is defined in raptor.h and includes fields for the subject, predicate, object of the statements along with their types and for literals, language and datatype.

PARSER PARSING METHODS
These methods perform the entire parsing in one method. Statements warnings, errors and fatal errors are delivered via the registered statement, error etc. handler functions.

In both of these methods, the base URI is required for the RDF/XML parsers (name "rdfxml"). The N-Triples parser (name "ntriples") or RSS Tag Soup parser (name "rss-tag-soup") do not use this.

int raptor_parse_file(raptor_parser* parser,  raptor_uri *uri, raptor_uri *base_uri)
    Parse the given filename (a URI like file:filename) according to the base URI base_uri, or NULL if not needed.

int raptor_parse_uri(raptor_parser* parser,  raptor_uri* uri, raptor_uri *base_uri)
    Parse the URI according to the base URI base_uri, or NULL if not needed. If no base URI is given, the uri is used. This method depends on the raptor_www subsystem (see WWW Class section below) and an existing underlying URI retrieval implementation such as libcurl or libxml to retrieve the content.

PARSER CHUNKED PARSING METHODS
These methods perform the parsing in parts by working on multiple chunks of memory passed by the application. Statements warnings, errors and fatal errors are delivered via the registered statement, error etc. handler functions.

int raptor_start_parse(raptor_parser* parser, const char *uri)
    Start a parse of chunked content with the base URI uri or NULL if not needed. The base URI is required for the RDF/XML parsers (name "rdfxml"). The N-Triples parser (name "ntriples") or RSS Tag Soup parser (name "rss-tag-soup") do not use this.

int raptor_parse_chunk(raptor_parser* parser,  const unsigned char *buffer, size_t len, int is_end)
    Parse the memory at buffer of size len returning statements via the statement handler callback. If is_end is non-zero, it indicates the end of the parsing stream. This method can only be called after raptor_start_parse.

PARSER UTILITY METHODS

void raptor_set_parser_strict(raptor_parser *parser, int is_strict)
    Set the parser to strict (is_strict not zero) or lax (default) mode. The detail of the strictness can be controlled by raptor_set_feature.

void raptor_set_feature(raptor_parser *parser, raptor_feature feature, int value)
    Set a parser feature feature to a particular value. The current defined features are:
      Feature Values
      RAPTOR_FEATURE_SCANNING Boolean (non 0 true)
      RAPTOR_FEATURE_ASSUME_IS_RDF Boolean (non 0 true)
      RAPTOR_FEATURE_ALLOW_NON_NS_ATTRIBUTES Boolean (non 0 true)
      RAPTOR_FEATURE_ALLOW_OTHER_PARSETYPES Boolean (non 0 true)
      RAPTOR_FEATURE_ALLOW_BAGID Boolean (non 0 true)
      RAPTOR_FEATURE_ALLOW_RDF_TYPE_RDF_LIST Boolean (non 0 true) If the scanning feature is true, then the RDF/XML parser will look for embedded rdf:RDF elements inside the XML content, and not require that the XML start with an rdf:RDF root element.

If the assume_is_rdf feature is true, then the RDF/XML parser will assume the content is RDF/XML, not require that rdf:RDF root element, and immediately interpret the content as RDF/XML.

If the allow_non_ns_attributes feature is true, then the RDF/XML parser will allow non-XML namespaced attributes to be accepted as well as rdf: namespaced ones. For example, 'about' and 'ID' will be interpreted as if they were rdf:about and rdf:ID respectively.

If the allow_other_parsetypes feature is true then the RDF/XML parser will allow unknown parsetypes to be present and will pass them on to the user. Unimplemented at present.

If the allow_bagid feature is true then the RDF/XML parser will support the rdf:bagID attribute that was removed from the RDF/XML language when it was revised. This support may be removed in future.

If the allow_rdf_type_rdf_list feature is true then the RDF/XML parser will generate the idList rdf:type rdf:List triple in the handling of rdf:parseType="Collection". This triple was removed during the revising of RDF/XML after collections were initially added.

raptor_locator* raptor_get_locator(raptor_parser* rdf_parser)
    Return the current raptor_locator object for the parser. This is a public structure defined in raptor.h that can be used directly, or formatted via raptor_print_locator.

void raptor_get_name(raptor_parser *parser)
    Return the string short name for the parser.

void raptor_get_label(raptor_parser *parser)
    Return a string label for the parser.

void raptor_set_default_generate_id_parameters(raptor_parser* rdf_parser, char *prefix, int base)
    Control the default method for generation of IDs for blank nodes and bags. The method uses a short string prefix and an integer base to generate the identifier which is not guaranteed to be a strict concatenation. If prefix is NULL, the default is used. If base is less than 1, it is initialised to 1.

void raptor_set_generate_id_handler(raptor_parser* parser, void *user_data, raptor_generate_id_handler handler)
    Allow full customisation of the generated IDs by setting a callback handler and associated user_data that is called whenever a blank node or bag identifier is required.

STATEMENT UTILITY FUNCTIONS

void raptor_print_statement(const raptor_statement* const statement, FILE *stream)
    Print a raptor statement object in a simple format for debugging only. The format of this output is not guaranteed to remain the same between releases.

void raptor_print_statement_as_ntriples(const raptor_statement* statement, FILE *stream)
    Print a raptor statement object in N-Triples format, using all the escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples (http://www.w3.org/TR/rdf-testcases/#ntriples)

raptor_statement_part_as_counted_string(const void *term, raptor_identifier_type type, raptor_uri* literal_datatype, const unsigned char *literal_language, size_t* len_p)

char* raptor_statement_part_as_string(const void *term, raptor_identifier_type type, raptor_uri* literal_datatype, const unsigned char *literal_language)
    Turns part of raptor statement into N-Triples format, using all the escapes as defined in http://www.w3.org/TR/rdf-testcases/#ntriples (http://www.w3.org/TR/rdf-testcases/#ntriples) The part (subject, predicate, object) of the raptor_statement is passed in as term, the part type (subject_type, predicate_type, object_type) is passed in as type. When the part is a literal, the literal_datatype and literal_language fields are set, otherwise NULL (usually object_datatype, object_literal_language).

    If raptor_statement_part_as_counted_string is used, the length of the returned string is stored in *len_p if not NULL.

LOCATOR UTILITY FUNCTIONS

int raptor_format_locator(char *buffer, size_t length, raptor_locator* locator)
    This method takes a raptor_locator object as passed to an error, warning or other handler callback and formats it into the buffer of size length bytes. If buffer is NULL or length is insufficient for the size of the formatted locator, returns the number of additional bytes required in the buffer to write the locator. In particular, if this form is used:
      length=raptor_format_locator(NULL, 0, locator) it will return in length the size of a buffer that can be allocated for locator and a second call will perform the formatting:
      raptor_format_locator(buffer, length, locator)

void raptor_print_locator(FILE *stream, raptor_locator* locator)
    This method takes a raptor_locator object as passed to an error, warning or other handler callback, formats and prints it to the given stdio stream.

N-TRIPLES UTILITY FUNCTIONS

void raptor_print_ntriples_string(FILE* stream, const char* string, const char delim)
    This is a standalone function that prints the given string according to N-Triples escaping rules, expecting to be delimited by the character delim which is usually either " or <

const char* raptor_ntriples_term_as_string (raptor_ntriples_term_type term)

XML UTILITY FUNCTIONS

size_t raptor_xml_escape_string(const unsigned char *string, size_t len, unsigned char *buffer, size_t length, char quote, raptor_message_handler error_handler, void *error_data)
    Apply the XML escaping rules to the string given in (string, len) into the buffer of size length. If quote is given, the escaped content is for an XML attribute and the appropriate quote character XML element content (CDATA). The error_handler method along with error_data allow error reporting to be given. If buffer is NULL, returns the size of the buffer required to escape. Otherwise the return value is the number of bytes used or 0 on failure.

URI CLASS
Raptor has a raptor_uri class must be used for manipulating and passing URI references. The default internal implementation uses char* strings for URIs, manipulating them and constructing them. This URI implementation can be replaced by any other that provides the equivalent functionality, using the raptor_uri_set_handler function.

URI CONSTRUCTORS
There a several constructors for raptor_uri to build them from char* strings and existing raptor_uri objects.

raptor_uri* raptor_new_uri(const char* uri_string)
    Create a raptor URI from a string URI-reference uri_string.

raptor_uri* raptor_new_uri_from_uri_local_name(raptor_uri* uri, const char* local_name)
    Create a raptor URI from a string URI-reference local_name relative to an existing URI-reference. This performs concatenation of the local_name to the uri and not relative URI resolution, which is done by the raptor_new_uri_relative_to_base constructor.

raptor_uri* raptor_new_uri_relative_to_base(raptor_uri* base_uri, const char* uri_string)
    Create a raptor URI from a string URI-reference uri_string using relative URI resolution to the base_uri.

raptor_uri* raptor_new_uri_from_id(raptor_uri* base_uri, const unsigned char* id)
    Create a raptor URI from a string RDF ID id concatenated to the base_uri base URI.

raptor_uri* raptor_new_uri_for_rdf_concept(const char* name)
    Create a raptor URI for the RDF namespace concept name.

raptor_uri* raptor_new_uri_for_xmlbase(raptor_uri* old_uri))
    Create a raptor URI suitable for use with xml:base (throw away fragment)

URI DESTRUCTOR

void raptor_free_uri(raptor_uri* uri)
    Destroy a raptor URI object.

URI METHODS

int raptor_uri_equals(raptor_uri* uri1, raptor_uri* uri2)
    Return non-zero if the given URIs are equal.

raptor_uri* raptor_uri_copy(raptor_uri* uri)
    Return a copy of the given raptor URI uri.

char* raptor_uri_as_counted_string(raptor_uri *uri, size_t* len_p)

char* raptor_uri_as_string(raptor_uri* uri)
    Return a shared pointer to a string representation of the given raptor URI uri. This string is shared and must not be freed. If raptor_uri_as_counted_string is used, the length of the returned string is stored in *len_p if not NULL.

URI UTILITY FUNCTIONS

void raptor_uri_resolve_uri_reference (const char* base_uri, const char* reference_uri, char* buffer, size_t length)
    This is a standalone function that resolves the relative URI reference_uri against the base URI base_uri according to the URI resolution rules in RFC2396. The resulting URI is stored in buffer which is of length bytes. If this is too small, no work will be done.

char *raptor_uri_filename_to_uri_string(const char* filename)
    This is a standalone function that turns a local filename (Windows or Unix style as appropriate for platform) into a URI string (file).
     The returned string must be freed by the caller.

char *raptor_uri_uri_string_to_filename(const char* uri_string)
    This is a standalone function that turns a URI string that represents a local filename (file:) into a filename. The returned string must be freed by the caller.

int raptor_uri_is_file_uri(const char* uri_string)
    Returns non-zero if the given URI string represents a filename, is a file: URI.

URI CLASS IMPLEMENTATION

void raptor_uri_set_handler(raptor_uri_handler *handler, void *context)
    Change the URI class implementation to the functions provided by the handler URI implementation. The context user data is passed in to the handler URI implementation calls.

void raptor_uri_get_handler(raptor_uri_handler **handler, void **context)
    Return the current raptor URI class implementation handler and context

WWW CLASS
This is a small wrapper class around existing WWW libraries in order to provide HTTP GET or better URI retrieval for Raptor. It is not intended to be a general purpose WWW retrieval interface.

WWW CLASS INITIALISATION AND CLEANUP

void raptor_www_init(void)

void raptor_www_finish(void)
    Initialise or terminate the raptor_www infrastructure. raptor_www_init and raptor_finish are called by raptor_init and raptor_finish respecitively, otherwise must be called once each.

NOTE
    Several of the WWW library implementations require once-only initialisation and termination functions to be called, however raptor cannot determine whether this is already done before the library is initialised in raptor_www_init or terminated in raptor_www_finish, so always performs it. This can be changed by raptor_www_no_www_library_init_finish.

void raptor_www_no_www_library_init_finish(void)
    If this is called before raptor_www_init, it will not call the underlying WWW library global initialise or terminate functions. The application code must perform both operations.

    For example with curl, after this function is called, neither curl_global_init nor curl_global_cleanup will be called during raptor_www_init or raptor_www_finish respectively.

WWW CONSTRUCTORS

raptor_www *raptor_www_new(void)

raptor_www *raptor_www_new_with_connection(void* connection)
    Create a raptor WWW object capable of URI retrieval. If connection is given, it must match the connection object of the underlying WWW implementation. At present, this is only for libcurl, and allows you to re-use an existing curl handle, or use one which has been set up with some desired qualities.

WWW DESTRUCTOR

void raptor_www_free(raptor_www *www)
    Destroy a raptor WWW object.

WWW METHODS

void raptor_www_set_user_agent(raptor_www *www, const char *user_agent)
    Set the user agent, for HTTP requests typically.

void raptor_www_set_proxy(raptor_www *www, const char *proxy)
    Set the HTTP proxy - usually a string of the form http://server:port

raptor_www_set_write_bytes_handler(raptor_www *www, raptor_www_write_bytes_handler handler, void *user_data)
    Set the handler to receive bytes written by the raptor_www implementation.

void raptor_www_set_content_type_handler(raptor_www *www, raptor_www_content_type_handler handler, void *user_data)
    Set the handler to receive the HTTP Content-Type value, when/if discovered during retrieval by the raptor_www implementation.

void raptor_www_set_error_handler(raptor_www *www, raptor_message_handler error_handler, void *error_data)
    Set the error handler routine for the raptor_www class. This takes the same arguments as the raptor_parser error, warning handler methods.

void* raptor_www_get_connection(raptor_www *www)
    Return the underlying WWW library connection object. For example, for libcurl this is the curl_handle.

WWW ACTION METHODS

int raptor_www_fetch(raptor_www *www, raptor_uri *uri)
    Retrieve the given URL, returning non zero on failure.

void raptor_www_abort(raptor_www *www, const char *reason)
    Abort an ongoing raptor WWW operation. Typically used within one of the raptor WWW handlers.

API CHANGES

0.9.12
    Added raptor_new_uri_for_retrieval to turn URI references into URIs suitable for retrieval (no fragments).

0.9.11
    Added raptor_get_name, raptor_get_label. raptor_xml_escape_string now takes error message handler, data pointer, loses parser argument.
    Added raptor_set_default_generate_id_parameters and raptor_set_generate_id_handler to control the default generation of IDs, allow full customisation.

0.9.10
    Added raptor_set_parser_strict, raptor_www_no_www_library_init_finish. raptor_xml_escape_string now takes an output string length pointer.
    Added raptor_statement_part_as_counted_string, raptor_statement_part_as_string, raptor_parse_abort.
    Deprecated raptor_parser_abort.

0.9.9
    Added raptor_www class and all its constructors, destructor, methods, calls.
    Added raptor_parse_uri, raptor_parser_abort, raptor_ntriples_term_as_string and raptor_xml_escape_string.

0.9.7
    raptor_parse_chunk, raptor_new_uri_from_id, arguments are now unsigned char.
    Added raptor_new_uri_for_xmlbase.

0.9.6

In this version, the raptor/ntriples parser calling APIs were modified. The following table lists the changes:
  OLD API NEW API (0.9.6+)
  raptor_new() raptor_new_parser("rdfxml")
  ntriples_new() raptor_new_parser("ntriples")
  raptor_free raptor_free_parser
  ntriples_free raptor_ntriples_parser
  raptor_ntriples_parse_file raptor_parse_file
  raptor_ntriples_set_error_handler raptor_set_error_handler
  raptor_ntriples_set_fatal_error_handler raptor_set_fatal_error_handler
  raptor_ntriples_set_statement_handler raptor_set_statement_handler

CONFORMING TO
RDF/XML Syntax (Revised), W3C Working Draft (work in progress), http://www.w3.org/TR/rdf-syntax-grammar/ (http://www.w3.org/TR/rdf-syntax-grammar/) N-Triples, W3C Working Draft (work in progress), http://www.w3.org/TR/rdf-testcases/#ntriples (http://www.w3.org/TR/rdf-testcases/#ntriples)

SEE ALSO
rapper(1),raptor-config(1)

AUTHOR
Dave Beckett - http://purl.org/net/dajobe/ (http://purl.org/net/dajobe/)
Institute for Learning and Research Technology (ILRT) http://www.ilrt.bristol.ac.uk/
University of Bristol http://www.bristol.ac.uk/