sord.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 SORD_SORD_H
#define SORD_SORD_H
 
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
 
#include "serd/serd.h"
 
#ifdef SORD_SHARED
#    ifdef _WIN32
#        define SORD_LIB_IMPORT __declspec(dllimport)
#        define SORD_LIB_EXPORT __declspec(dllexport)
#    else
#        define SORD_LIB_IMPORT __attribute__((visibility("default")))
#        define SORD_LIB_EXPORT __attribute__((visibility("default")))
#    endif
#    ifdef SORD_INTERNAL
#        define SORD_API SORD_LIB_EXPORT
#    else
#        define SORD_API SORD_LIB_IMPORT
#    endif
#else
#    define SORD_API
#endif
 
#ifdef __cplusplus
extern "C" {
#else
#    include <stdbool.h>
#endif


typedef struct SordWorldImpl SordWorld;

typedef struct SordModelImpl SordModel;

typedef struct SordInserterImpl SordInserter;

typedef struct SordIterImpl SordIter;

typedef struct SordNodeImpl SordNode;

typedef const SordNode* SordQuad[4];

typedef enum {
        SORD_SUBJECT   = 0,  
        SORD_PREDICATE = 1,  
        SORD_OBJECT    = 2,  
        SORD_GRAPH     = 3   
} SordQuadIndex;

typedef enum {
        SORD_URI     = 1,  
        SORD_BLANK   = 2,  
        SORD_LITERAL = 3   
} SordNodeType;

typedef enum {
        SORD_SPO = 1,       
        SORD_SOP = 1 << 1,  
        SORD_OPS = 1 << 2,  
        SORD_OSP = 1 << 3,  
        SORD_PSO = 1 << 4,  
        SORD_POS = 1 << 5   
} SordIndexOption;


SORD_API
SordWorld*
sord_world_new(void);

SORD_API
void
sord_world_free(SordWorld* world);

SORD_API
void
sord_world_set_error_sink(SordWorld*    world,
                          SerdErrorSink error_sink,
                          void*         handle);


SORD_API
SordNode*
sord_new_uri(SordWorld* world, const uint8_t* uri);

SORD_API
SordNode*
sord_new_relative_uri(SordWorld*     world,
                      const uint8_t* str,
                      const uint8_t* base_uri);

SORD_API
SordNode*
sord_new_blank(SordWorld* world, const uint8_t* str);

SORD_API
SordNode*
sord_new_literal(SordWorld*     world,
                 SordNode*      datatype,
                 const uint8_t* str,
                 const char*    lang);

SORD_API
SordNode*
sord_node_copy(const SordNode* node);

SORD_API
void
sord_node_free(SordWorld* world, SordNode* node);

SORD_API
SordNodeType
sord_node_get_type(const SordNode* node);

SORD_API
const uint8_t*
sord_node_get_string(const SordNode* node);

SORD_API
const uint8_t*
sord_node_get_string_counted(const SordNode* node, size_t* bytes);

SORD_API
const uint8_t*
sord_node_get_string_measured(const SordNode* node,
                              size_t*         bytes,
                              size_t*         chars);

SORD_API
const char*
sord_node_get_language(const SordNode* node);

SORD_API
SordNode*
sord_node_get_datatype(const SordNode* node);

SORD_API
SerdNodeFlags
sord_node_get_flags(const SordNode* node);

SORD_API
bool
sord_node_is_inline_object(const SordNode* node);

SORD_API
bool
sord_node_equals(const SordNode* a,
                 const SordNode* b);

SORD_API
const SerdNode*
sord_node_to_serd_node(const SordNode* node);

SORD_API
SordNode*
sord_node_from_serd_node(SordWorld*      world,
                         SerdEnv*        env,
                         const SerdNode* node,
                         const SerdNode* datatype,
                         const SerdNode* lang);


SORD_API
SordModel*
sord_new(SordWorld* world,
         unsigned  indices,
         bool      graphs);

SORD_API
void
sord_free(SordModel* model);

SORD_API
SordWorld*
sord_get_world(SordModel* model);

SORD_API
size_t
sord_num_nodes(const SordWorld* world);

SORD_API
size_t
sord_num_quads(const SordModel* model);

SORD_API
SordIter*
sord_begin(const SordModel* model);

SORD_API
SordIter*
sord_find(SordModel* model, const SordQuad pat);

SORD_API
SordIter*
sord_search(SordModel*      model,
            const SordNode* s,
            const SordNode* p,
            const SordNode* o,
            const SordNode* g);
SORD_API
SordNode*
sord_get(SordModel*      model,
         const SordNode* s,
         const SordNode* p,
         const SordNode* o,
         const SordNode* g);

SORD_API
bool
sord_ask(SordModel*      model,
         const SordNode* s,
         const SordNode* p,
         const SordNode* o,
         const SordNode* g);

SORD_API
uint64_t
sord_count(SordModel*      model,
           const SordNode* s,
           const SordNode* p,
           const SordNode* o,
           const SordNode* g);

SORD_API
bool
sord_contains(SordModel* model, const SordQuad pat);

SORD_API
bool
sord_add(SordModel* model, const SordQuad quad);

SORD_API
void
sord_remove(SordModel* model, const SordQuad quad);

SORD_API
SerdStatus
sord_erase(SordModel* model, SordIter* iter);


SORD_API
SordInserter*
sord_inserter_new(SordModel* model,
                  SerdEnv*   env);

SORD_API
void
sord_inserter_free(SordInserter* inserter);

SORD_API
SerdStatus
sord_inserter_set_base_uri(SordInserter*   inserter,
                           const SerdNode* uri);

SORD_API
SerdStatus
sord_inserter_set_prefix(SordInserter*   inserter,
                         const SerdNode* name,
                         const SerdNode* uri);

SORD_API
SerdStatus
sord_inserter_write_statement(SordInserter*      inserter,
                              SerdStatementFlags flags,
                              const SerdNode*    graph,
                              const SerdNode*    subject,
                              const SerdNode*    predicate,
                              const SerdNode*    object,
                              const SerdNode*    object_datatype,
                              const SerdNode*    object_lang);


SORD_API
void
sord_iter_get(const SordIter* iter, SordQuad quad);

SORD_API
const SordNode*
sord_iter_get_node(const SordIter* iter, SordQuadIndex index);

SORD_API
const SordModel*
sord_iter_get_model(SordIter* iter);

SORD_API
bool
sord_iter_next(SordIter* iter);

SORD_API
bool
sord_iter_end(const SordIter* iter);

SORD_API
void
sord_iter_free(SordIter* iter);


SORD_API
bool
sord_quad_match(const SordQuad x, const SordQuad y);


SORD_API
SerdReader*
sord_new_reader(SordModel* model,
                SerdEnv*   env,
                SerdSyntax syntax,
                SordNode*  graph);

SORD_API
bool
sord_write(SordModel*  model,
           SerdWriter* writer,
           SordNode*   graph);

SORD_API
bool
sord_write_iter(SordIter*   iter,
                SerdWriter* writer);

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