serd.h

Go to the documentation of this file.

/*
  Copyright 2011-2016 David Robillard <http://drobilla.net>
 
  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
  copyright notice and this permission notice appear in all copies.
 
  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

 
#ifndef SERD_SERD_H
#define SERD_SERD_H
 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
 
#ifdef SERD_SHARED
#    ifdef _WIN32
#        define SERD_LIB_IMPORT __declspec(dllimport)
#        define SERD_LIB_EXPORT __declspec(dllexport)
#    else
#        define SERD_LIB_IMPORT __attribute__((visibility("default")))
#        define SERD_LIB_EXPORT __attribute__((visibility("default")))
#    endif
#    ifdef SERD_INTERNAL
#        define SERD_API SERD_LIB_EXPORT
#    else
#        define SERD_API SERD_LIB_IMPORT
#    endif
#else
#    define SERD_API
#endif
 
#ifdef __cplusplus
extern "C" {
#else
#    include <stdbool.h>
#endif


typedef struct SerdEnvImpl SerdEnv;

typedef struct SerdReaderImpl SerdReader;

typedef struct SerdWriterImpl SerdWriter;

typedef enum {
        SERD_SUCCESS,         
        SERD_FAILURE,         
        SERD_ERR_UNKNOWN,     
        SERD_ERR_BAD_SYNTAX,  
        SERD_ERR_BAD_ARG,     
        SERD_ERR_NOT_FOUND,   
        SERD_ERR_ID_CLASH,    
        SERD_ERR_BAD_CURIE,   
        SERD_ERR_INTERNAL     
} SerdStatus;

typedef enum {
        SERD_TURTLE = 1,

        SERD_NTRIPLES = 2
} SerdSyntax;

typedef enum {
        SERD_EMPTY_S      = 1 << 1,  
        SERD_EMPTY_O      = 1 << 2,  
        SERD_ANON_S_BEGIN = 1 << 3,  
        SERD_ANON_O_BEGIN = 1 << 4,  
        SERD_ANON_CONT    = 1 << 5,  
        SERD_LIST_S_BEGIN = 1 << 6,  
        SERD_LIST_O_BEGIN = 1 << 7,  
        SERD_LIST_CONT    = 1 << 8   
} SerdStatementFlag;

typedef uint32_t SerdStatementFlags;

typedef enum {
        SERD_NOTHING = 0,

        SERD_LITERAL = 1,

        SERD_URI = 2,

        SERD_CURIE = 3,

        SERD_BLANK = 4
 
} SerdType;

typedef enum {
        SERD_HAS_NEWLINE = 1,      
        SERD_HAS_QUOTE   = 1 << 1  
} SerdNodeFlag;

typedef uint32_t SerdNodeFlags;

typedef struct {
        const uint8_t* buf;      
        size_t         n_bytes;  
        size_t         n_chars;  
        SerdNodeFlags  flags;    
        SerdType       type;     
} SerdNode;

typedef struct {
        const uint8_t* buf;  
        size_t         len;  
} SerdChunk;

typedef struct {
        SerdStatus     status;    
        const uint8_t* filename;  
        unsigned       line;      
        unsigned       col;       
        const char*    fmt;       
        va_list*       args;      
} SerdError;

typedef struct {
        SerdChunk scheme;     
        SerdChunk authority;  
        SerdChunk path_base;  
        SerdChunk path;       
        SerdChunk query;      
        SerdChunk fragment;   
} SerdURI;

typedef enum {
        SERD_STYLE_ABBREVIATED = 1,       
        SERD_STYLE_ASCII       = 1 << 1,  
        SERD_STYLE_RESOLVED    = 1 << 2,  
        SERD_STYLE_CURIED      = 1 << 3,  
        SERD_STYLE_BULK        = 1 << 4   
} SerdStyle;


SERD_API
const uint8_t*
serd_strerror(SerdStatus status);

SERD_API
size_t
serd_strlen(const uint8_t* str, size_t* n_bytes, SerdNodeFlags* flags);

SERD_API
double
serd_strtod(const char* str, char** endptr);

SERD_API
void*
serd_base64_decode(const uint8_t* str, size_t len, size_t* size);

 
static const SerdURI SERD_URI_NULL = {
        {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}, {NULL, 0}
};

SERD_API
const uint8_t*
serd_uri_to_path(const uint8_t* uri);

SERD_API
uint8_t*
serd_file_uri_parse(const uint8_t* uri, uint8_t** hostname);

SERD_API
bool
serd_uri_string_has_scheme(const uint8_t* utf8);

SERD_API
SerdStatus
serd_uri_parse(const uint8_t* utf8, SerdURI* out);

SERD_API
void
serd_uri_resolve(const SerdURI* uri, const SerdURI* base, SerdURI* out);

typedef size_t (*SerdSink)(const void* buf, size_t len, void* stream);

SERD_API
size_t
serd_uri_serialise(const SerdURI* uri, SerdSink sink, void* stream);

SERD_API
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 };

SERD_API
SerdNode
serd_node_from_string(SerdType type, const uint8_t* str);

SERD_API
SerdNode
serd_node_copy(const SerdNode* node);

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

SERD_API
SerdNode
serd_node_new_uri_from_node(const SerdNode* uri_node,
                            const SerdURI*  base,
                            SerdURI*        out);

SERD_API
SerdNode
serd_node_new_uri_from_string(const uint8_t* str,
                              const SerdURI* base,
                              SerdURI*       out);

SERD_API
SerdNode
serd_node_new_file_uri(const uint8_t* path,
                       const uint8_t* hostname,
                       SerdURI*       out,
                       bool           escape);

SERD_API
SerdNode
serd_node_new_uri(const SerdURI* uri, const SerdURI* base, SerdURI* out);

SERD_API
SerdNode
serd_node_new_relative_uri(const SerdURI* uri,
                           const SerdURI* base,
                           const SerdURI* root,
                           SerdURI*       out);

SERD_API
SerdNode
serd_node_new_decimal(double d, unsigned frac_digits);

SERD_API
SerdNode
serd_node_new_integer(int64_t i);

SERD_API
SerdNode
serd_node_new_blob(const void* buf, size_t size, bool wrap_lines);

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


SERD_API
SerdEnv*
serd_env_new(const SerdNode* base_uri);

SERD_API
void
serd_env_free(SerdEnv* env);

SERD_API
const SerdNode*
serd_env_get_base_uri(const SerdEnv* env,
                      SerdURI*       out);

SERD_API
SerdStatus
serd_env_set_base_uri(SerdEnv*        env,
                      const SerdNode* uri);

SERD_API
SerdStatus
serd_env_set_prefix(SerdEnv*        env,
                    const SerdNode* name,
                    const SerdNode* uri);

SERD_API
SerdStatus
serd_env_set_prefix_from_strings(SerdEnv*       env,
                                 const uint8_t* name,
                                 const uint8_t* uri);

SERD_API
bool
serd_env_qualify(const SerdEnv*  env,
                 const SerdNode* uri,
                 SerdNode*       prefix,
                 SerdChunk*      suffix);

SERD_API
SerdStatus
serd_env_expand(const SerdEnv*  env,
                const SerdNode* curie,
                SerdChunk*      uri_prefix,
                SerdChunk*      uri_suffix);

SERD_API
SerdNode
serd_env_expand_node(const SerdEnv*  env,
                     const SerdNode* node);

SERD_API
void
serd_env_foreach(const SerdEnv* env,
                 SerdPrefixSink func,
                 void*          handle);


SERD_API
SerdReader*
serd_reader_new(SerdSyntax        syntax,
                void*             handle,
                void              (*free_handle)(void*),
                SerdBaseSink      base_sink,
                SerdPrefixSink    prefix_sink,
                SerdStatementSink statement_sink,
                SerdEndSink       end_sink);

SERD_API
void
serd_reader_set_strict(SerdReader* reader, bool strict);

SERD_API
void
serd_reader_set_error_sink(SerdReader*   reader,
                           SerdErrorSink error_sink,
                           void*         handle);

SERD_API
void*
serd_reader_get_handle(const SerdReader* reader);

SERD_API
void
serd_reader_add_blank_prefix(SerdReader*    reader,
                             const uint8_t* prefix);

SERD_API
void
serd_reader_set_default_graph(SerdReader*     reader,
                              const SerdNode* graph);

SERD_API
SerdStatus
serd_reader_read_file(SerdReader*    reader,
                      const uint8_t* uri);

SERD_API
SerdStatus
serd_reader_start_stream(SerdReader*    me,
                         FILE*          file,
                         const uint8_t* name,
                         bool           bulk);

SERD_API
SerdStatus
serd_reader_read_chunk(SerdReader* me);

SERD_API
SerdStatus
serd_reader_end_stream(SerdReader* me);

SERD_API
SerdStatus
serd_reader_read_file_handle(SerdReader*    reader,
                             FILE*          file,
                             const uint8_t* name);

SERD_API
SerdStatus
serd_reader_read_string(SerdReader* me, const uint8_t* utf8);

SERD_API
void
serd_reader_free(SerdReader* reader);


SERD_API
SerdWriter*
serd_writer_new(SerdSyntax     syntax,
                SerdStyle      style,
                SerdEnv*       env,
                const SerdURI* base_uri,
                SerdSink       sink,
                void*          stream);

SERD_API
void
serd_writer_free(SerdWriter* writer);

SERD_API
SerdEnv*
serd_writer_get_env(SerdWriter* writer);

SERD_API
size_t
serd_file_sink(const void* buf, size_t len, void* stream);

SERD_API
size_t
serd_chunk_sink(const void* buf, size_t len, void* stream);

SERD_API
uint8_t*
serd_chunk_sink_finish(SerdChunk* stream);

SERD_API
void
serd_writer_set_error_sink(SerdWriter*   writer,
                           SerdErrorSink error_sink,
                           void*         handle);

SERD_API
void
serd_writer_chop_blank_prefix(SerdWriter*    writer,
                              const uint8_t* prefix);

SERD_API
SerdStatus
serd_writer_set_base_uri(SerdWriter*     writer,
                         const SerdNode* uri);

SERD_API
SerdStatus
serd_writer_set_root_uri(SerdWriter*     writer,
                         const SerdNode* uri);

SERD_API
SerdStatus
serd_writer_set_prefix(SerdWriter*     writer,
                       const SerdNode* name,
                       const SerdNode* uri);

SERD_API
SerdStatus
serd_writer_write_statement(SerdWriter*        writer,
                            SerdStatementFlags flags,
                            const SerdNode*    graph,
                            const SerdNode*    subject,
                            const SerdNode*    predicate,
                            const SerdNode*    object,
                            const SerdNode*    object_datatype,
                            const SerdNode*    object_lang);

SERD_API
SerdStatus
serd_writer_end_anon(SerdWriter*     writer,
                     const SerdNode* node);

SERD_API
SerdStatus
serd_writer_finish(SerdWriter* writer);

 
#ifdef __cplusplus
}  /* extern "C" */
#endif
 
#endif  /* SERD_SERD_H */