/**
* raptor_new_iostream_from_file_handle:
* @world: raptor world
* @handle: Input file_handle to open and read from
*
* Constructor - create a new iostream reading from a file_handle.
*
* The @handle must already be open for reading.
* NOTE: This does not fclose the @handle when it is finished.
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_from_file_handle(raptor_world *world, FILE *handle)
{
raptor_iostream* iostr;
const raptor_iostream_handler* handler;
const unsigned int mode = RAPTOR_IOSTREAM_MODE_READ;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!handle)
return NULL;
raptor_world_open(world);
handler = &raptor_iostream_read_file_handle_handler;
if(!raptor_iostream_check_handler(handler, mode))
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr)
return NULL;
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)handle;
iostr->mode = mode;
if(iostr->handler->init &&
iostr->handler->init(iostr->user_data)) {
RAPTOR_FREE(raptor_iostream, iostr);
return NULL;
}
return iostr;
}
/**
* raptor_new_iostream_from_handler:
* @world: raptor_world object
* @user_data: pointer to context information to pass in to calls
* @handler: pointer to handler methods
*
* Create a new iostream over a user-defined handler
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_from_handler(raptor_world *world,
void *user_data,
const raptor_iostream_handler* const handler)
{
raptor_iostream* iostr;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(handler, raptor_iostream_handler, NULL);
raptor_world_open(world);
if(!raptor_iostream_check_handler(handler, 0))
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr)
return NULL;
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)user_data;
iostr->mode = raptor_iostream_calculate_modes(handler);
if(iostr->handler->init &&
iostr->handler->init(iostr->user_data)) {
RAPTOR_FREE(raptor_iostream, iostr);
return NULL;
}
return iostr;
}
/**
* raptor_new_sax2:
* @world: raptor world
* @locator: raptor locator to use for errors
* @user_data: pointer context information to pass to SAX handlers
*
* Constructor - Create a new SAX2 with error handlers
*
* Return value: new #raptor_sax2 object or NULL on failure
*/
raptor_sax2*
raptor_new_sax2(raptor_world *world, raptor_locator *locator,
void* user_data)
{
raptor_sax2* sax2;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!locator)
return NULL;
raptor_world_open(world);
sax2 = RAPTOR_CALLOC(raptor_sax2*, 1, sizeof(*sax2));
if(!sax2)
return NULL;
#ifdef RAPTOR_XML_LIBXML
sax2->magic = RAPTOR_LIBXML_MAGIC;
#endif
sax2->world = world;
sax2->locator = locator;
sax2->user_data = user_data;
sax2->enabled = 1;
raptor_object_options_init(&sax2->options, RAPTOR_OPTION_AREA_SAX2);
return sax2;
}
/**
* librdf_init_raptor:
* @world: librdf_world object
*
* INTERNAL - Initialize the raptor library.
*
* Initializes the raptor library unless a raptor instance is provided
* externally with librdf_world_set_raptor() (and using raptor v2 APIs).
* Sets raptor uri handlers to work with #librdf_uri objects.
*
* Return value: non-0 on failure
**/
int
librdf_init_raptor(librdf_world* world)
{
if(!world->raptor_world_ptr) {
world->raptor_world_ptr = raptor_new_world();
world->raptor_world_allocated_here = 1;
if(world->raptor_world_ptr && world->raptor_init_handler) {
world->raptor_init_handler(world->raptor_init_handler_user_data,
world->raptor_world_ptr);
}
if(!world->raptor_world_ptr || raptor_world_open(world->raptor_world_ptr)) {
LIBRDF_FATAL1(world, LIBRDF_FROM_PARSER, "failed to initialize raptor");
return 1;
}
}
/* New in-memory hash for mapping bnode IDs */
world->bnode_hash = librdf_new_hash(world, NULL);
if(!world->bnode_hash)
return 1;
/* set up log handler */
raptor_world_set_log_handler(world->raptor_world_ptr, world,
librdf_raptor_log_handler);
/* set up blank node identifier generation handler */
raptor_world_set_generate_bnodeid_handler(world->raptor_world_ptr,
world,
librdf_raptor_generate_id_handler);
return 0;
}
int main (int argc, char *argv[])
{
const char *program = raptor_basename(argv[0]);
raptor_world *world;
const char *uri_string;
raptor_www *www;
const char *user_agent = "raptor_www_test/0.1";
raptor_uri *uri;
void *string = NULL;
size_t string_length = 0;
if(argc > 1)
uri_string = argv[1];
else
uri_string = "http://librdf.org/";
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
uri = raptor_new_uri(world, (const unsigned char*)uri_string);
if(!uri) {
fprintf(stderr, "%s: Failed to create Raptor URI for %s\n",
program, uri_string);
exit(1);
}
www = raptor_new_www(world);
raptor_www_set_content_type_handler(www, write_content_type, (void*)stderr);
raptor_www_set_user_agent(www, user_agent);
/* start retrieval (always a GET) */
if(raptor_www_fetch_to_string(www, uri,
&string, &string_length, malloc)) {
fprintf(stderr, "%s: WWW fetch failed\n", program);
} else {
#if defined(RAPTOR_DEBUG) && RAPTOR_DEBUG > 1
fprintf(stderr, "%s: HTTP response status %d\n",
program, www->status_code);
fprintf(stderr, "%s: Returned %d bytes of content\n",
program, (int)string_length);
#endif
}
if(string)
free(string);
raptor_free_www(www);
raptor_free_uri(uri);
raptor_free_world(world);
return 0;
}
/**
* raptor_new_www:
* @world: raptor_world object
*
* Constructor - create a new #raptor_www object.
*
* Return value: a new #raptor_www or NULL on failure.
**/
raptor_www*
raptor_new_www(raptor_world* world)
{
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
return raptor_new_www_with_connection(world, NULL);
}
/**
* raptor_new_iostream_from_sink:
* @world: raptor world
*
* Create a new read iostream from a sink.
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_from_sink(raptor_world *world)
{
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
return raptor_new_iostream_from_handler(world, NULL,
&raptor_iostream_sink_handler);
}
/**
* raptor_world_is_serializer_name:
* @world: raptor_world object
* @name: the syntax name
*
* Check name of a serializer.
*
* Return value: non 0 if name is a known syntax name
*/
int
raptor_world_is_serializer_name(raptor_world* world, const char *name)
{
if(!name)
return 0;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, 0);
raptor_world_open(world);
return (raptor_get_serializer_factory(world, name) != NULL);
}
/**
* raptor_new_term_from_blank:
* @world: raptor world
* @blank: UTF-8 encoded blank node identifier (or NULL)
*
* Constructor - create a new blank node statement term from a UTF-8 encoded blank node ID
*
* Takes a copy of the passed in @blank
*
* If @blank is NULL, creates a new internal identifier and uses it.
* This will use the handler set with
* raptor_world_set_generate_bnodeid_parameters()
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_blank(raptor_world* world, const unsigned char* blank)
{
size_t length = 0;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if (blank)
length = strlen((const char*)blank);
return raptor_new_term_from_counted_blank(world, blank, length);
}
/**
* raptor_new_turtle_writer:
* @world: raptor_world object
* @base_uri: Base URI for the writer (or NULL)
* @write_base_uri: non-0 to write '@base' directive to output
* @nstack: Namespace stack for the writer to start with (or NULL)
* @iostr: I/O stream to write to
*
* Constructor - Create a new Turtle Writer writing Turtle to a raptor_iostream
*
* Return value: a new #raptor_turtle_writer object or NULL on failure
**/
raptor_turtle_writer*
raptor_new_turtle_writer(raptor_world* world,
raptor_uri* base_uri, int write_base_uri,
raptor_namespace_stack *nstack,
raptor_iostream* iostr)
{
raptor_turtle_writer* turtle_writer;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!nstack || !iostr)
return NULL;
raptor_world_open(world);
turtle_writer = (raptor_turtle_writer*)RAPTOR_CALLOC(raptor_turtle_writer, 1,
sizeof(*turtle_writer));
if(!turtle_writer)
return NULL;
turtle_writer->world = world;
turtle_writer->nstack_depth = 0;
turtle_writer->nstack = nstack;
if(!turtle_writer->nstack) {
turtle_writer->nstack = raptor_new_namespaces(world, 1);
turtle_writer->my_nstack = 1;
}
turtle_writer->iostr = iostr;
turtle_writer->flags = 0;
turtle_writer->indent = 2;
turtle_writer->base_uri = NULL;
/* Ensure any initial base URI is not written relative */
if(base_uri && write_base_uri)
raptor_turtle_writer_base(turtle_writer, base_uri);
turtle_writer->base_uri = base_uri;
turtle_writer->xsd_boolean_uri = raptor_new_uri(world, (const unsigned char*)"http://www.w3.org/2001/XMLSchema#boolean");
turtle_writer->xsd_decimal_uri = raptor_new_uri(world, (const unsigned char*)"http://www.w3.org/2001/XMLSchema#decimal");
turtle_writer->xsd_double_uri = raptor_new_uri(world, (const unsigned char*)"http://www.w3.org/2001/XMLSchema#double");
turtle_writer->xsd_integer_uri = raptor_new_uri(world, (const unsigned char*)"http://www.w3.org/2001/XMLSchema#integer");
return turtle_writer;
}
/**
* raptor_new_iostream_from_string:
* @world: raptor world
* @string: pointer to string
* @length: length of string
*
* Constructor - create a new iostream reading from a string.
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_from_string(raptor_world *world,
void *string, size_t length)
{
raptor_iostream* iostr;
struct raptor_read_string_iostream_context* con;
const raptor_iostream_handler* handler;
const unsigned int mode = RAPTOR_IOSTREAM_MODE_READ;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!string)
return NULL;
raptor_world_open(world);
handler = &raptor_iostream_read_string_handler;
if(!raptor_iostream_check_handler(handler, mode))
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr)
return NULL;
con = RAPTOR_CALLOC(struct raptor_read_string_iostream_context*, 1,
sizeof(*con));
if(!con) {
RAPTOR_FREE(raptor_iostream, iostr);
return NULL;
}
con->string = string;
con->length = length;
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)con;
iostr->mode = mode;
if(iostr->handler->init && iostr->handler->init(iostr->user_data)) {
raptor_free_iostream(iostr);
return NULL;
}
return iostr;
}
/**
* raptor_new_term_from_counted_literal:
* @world: raptor world
* @literal: UTF-8 encoded literal string (or NULL for empty literal)
* @literal_len: length of literal
* @datatype: literal datatype URI (or NULL)
* @language: literal language (or NULL for no language)
* @language_len: literal language length
*
* Constructor - create a new literal statement term from a counted UTF-8 encoded literal string
*
* Takes copies of the passed in @literal, @datatype, @language
*
* Only one of @language or @datatype may be given. If both are
* given, NULL is returned. If @language is the empty string, it is
* the equivalent to NULL.
*
* Note: The @literal need not be NULL terminated - a NULL will be
* added to the copied string used.
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_counted_literal(raptor_world* world,
const unsigned char* literal,
size_t literal_len,
raptor_uri* datatype,
const unsigned char* language,
unsigned char language_len)
{
raptor_term *t;
unsigned char* new_literal = NULL;
unsigned char* new_language = NULL;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if(language && !*language)
language = NULL;
if(language && datatype)
return NULL;
new_literal = RAPTOR_MALLOC(unsigned char*, literal_len + 1);
if(!new_literal)
return NULL;
if(!literal || !*literal)
literal_len = 0;
if(literal_len) {
memcpy(new_literal, literal, literal_len);
new_literal[literal_len] = '\0';
} else
*new_literal = '\0';
if(language) {
new_language = RAPTOR_MALLOC(unsigned char*, language_len + 1);
if(!new_language) {
RAPTOR_FREE(char*, new_literal);
return NULL;
}
memcpy(new_language, language, language_len);
new_language[language_len] = '\0';
} else
/**
* raptor_world_get_serializer_description:
* @world: world object
* @counter: index into the list of serializers
*
* Get serializer descriptive syntax information
*
* Return value: description or NULL if counter is out of range
**/
const raptor_syntax_description*
raptor_world_get_serializer_description(raptor_world* world,
unsigned int counter)
{
raptor_serializer_factory *factory;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
raptor_world_open(world);
factory = (raptor_serializer_factory*)raptor_sequence_get_at(world->serializers,
counter);
if(!factory)
return NULL;
return &factory->desc;
}
/**
* raptor_new_xml_writer:
* @world: raptor_world object
* @nstack: Namespace stack for the writer to start with (or NULL)
* @iostr: I/O stream to write to
*
* Constructor - Create a new XML Writer writing XML to a raptor_iostream
*
* Return value: a new #raptor_xml_writer object or NULL on failure
**/
raptor_xml_writer*
raptor_new_xml_writer(raptor_world* world,
raptor_namespace_stack *nstack,
raptor_iostream* iostr)
{
raptor_xml_writer* xml_writer;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!iostr)
return NULL;
raptor_world_open(world);
xml_writer = (raptor_xml_writer*)RAPTOR_CALLOC(raptor_xml_writer, 1,
sizeof(*xml_writer));
if(!xml_writer)
return NULL;
xml_writer->world = world;
xml_writer->nstack_depth = 0;
xml_writer->nstack = nstack;
if(!xml_writer->nstack) {
xml_writer->nstack = raptor_new_namespaces(world, 1);
xml_writer->my_nstack = 1;
}
xml_writer->iostr = iostr;
raptor_object_options_init(&xml_writer->options,
RAPTOR_OPTION_AREA_XML_WRITER);
RAPTOR_OPTIONS_SET_NUMERIC(xml_writer, RAPTOR_OPTION_WRITER_INDENT_WIDTH, 2);
RAPTOR_OPTIONS_SET_NUMERIC(xml_writer, RAPTOR_OPTION_WRITER_XML_VERSION, 10);
/* Write XML declaration */
RAPTOR_OPTIONS_SET_NUMERIC(xml_writer, RAPTOR_OPTION_WRITER_XML_DECLARATION, 1);
return xml_writer;
}
/**
* raptor_new_iostream_to_filename:
* @world: raptor world
* @filename: Output filename to open and write to
*
* Constructor - create a new iostream writing to a filename.
*
* Return value: new #raptor_iostream object or NULL on failure
**/
raptor_iostream*
raptor_new_iostream_to_filename(raptor_world *world, const char *filename)
{
FILE *handle;
raptor_iostream* iostr;
const raptor_iostream_handler* handler;
const unsigned int mode = RAPTOR_IOSTREAM_MODE_WRITE;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if(!filename)
return NULL;
handler = &raptor_iostream_write_filename_handler;
if(!raptor_iostream_check_handler(handler, mode))
return NULL;
handle = fopen(filename, "wb");
if(!handle)
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr) {
fclose(handle);
return NULL;
}
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)handle;
iostr->mode = mode;
if(iostr->handler->init &&
iostr->handler->init(iostr->user_data)) {
raptor_free_iostream(iostr);
return NULL;
}
return iostr;
}
/**
* raptor_new_term_from_literal:
* @world: raptor world
* @literal: UTF-8 encoded literal string (or NULL for empty literal)
* @datatype: literal datatype URI (or NULL)
* @language: literal language (or NULL)
*
* Constructor - create a new literal statement term
*
* Takes copies of the passed in @literal, @datatype, @language
*
* Only one of @language or @datatype may be given. If both are
* given, NULL is returned. If @language is the empty string, it is
* the equivalent to NULL.
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_literal(raptor_world* world,
const unsigned char* literal,
raptor_uri* datatype,
const unsigned char* language)
{
size_t literal_len = 0;
unsigned char language_len = 0;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if(literal)
literal_len = strlen((const char*)literal);
if(language)
language_len = strlen((const char*)language);
return raptor_new_term_from_counted_literal(world, literal, literal_len,
datatype, language, language_len);
}
/**
* raptor_new_www_with_connection:
* @world: raptor_world object
* @connection: external WWW connection object.
*
* Constructor - create a new #raptor_www object over an existing WWW connection.
*
* At present this only works with a libcurl CURL handle object
* when raptor is compiled with libcurl suppport. Otherwise the
* @connection is ignored. This allows such things as setting
* up special flags on the curl handle before passing into the constructor.
*
* Return value: a new #raptor_www object or NULL on failure.
**/
raptor_www*
raptor_new_www_with_connection(raptor_world* world, void *connection)
{
raptor_www* www;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
www = (raptor_www* )RAPTOR_CALLOC(www, 1, sizeof(*www));
if(!www)
return NULL;
www->world = world;
www->type = NULL;
www->free_type = 1; /* default is to free content type */
www->total_bytes = 0;
www->failed = 0;
www->status_code = 0;
www->write_bytes = NULL;
www->content_type = NULL;
www->uri_filter = NULL;
www->connection_timeout = 10;
www->cache_control = NULL;
#ifdef RAPTOR_WWW_LIBCURL
www->curl_handle = (CURL*)connection;
raptor_www_curl_init(www);
#endif
#ifdef RAPTOR_WWW_LIBXML
raptor_www_libxml_init(www);
#endif
#ifdef RAPTOR_WWW_LIBFETCH
raptor_www_libfetch_init(www);
#endif
return www;
}
/**
* raptor_new_serializer:
* @world: raptor_world object
* @name: the serializer name or NULL for default syntax
*
* Constructor - create a new raptor_serializer object.
*
* Return value: a new #raptor_serializer object or NULL on failure
*/
raptor_serializer*
raptor_new_serializer(raptor_world* world, const char *name)
{
raptor_serializer_factory* factory;
raptor_serializer* rdf_serializer;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
factory = raptor_get_serializer_factory(world, name);
if(!factory)
return NULL;
rdf_serializer = RAPTOR_CALLOC(raptor_serializer*, 1, sizeof(*rdf_serializer));
if(!rdf_serializer)
return NULL;
rdf_serializer->world = world;
rdf_serializer->context = RAPTOR_CALLOC(void*, 1, factory->context_length);
if(!rdf_serializer->context) {
raptor_free_serializer(rdf_serializer);
return NULL;
}
rdf_serializer->factory = factory;
raptor_object_options_init(&rdf_serializer->options,
RAPTOR_OPTION_AREA_SERIALIZER);
if(factory->init(rdf_serializer, name)) {
raptor_free_serializer(rdf_serializer);
return NULL;
}
return rdf_serializer;
}
/**
* raptor_new_term_from_uri:
* @world: raptor world
* @uri: uri
*
* Constructor - create a new URI statement term
*
* Takes a copy (reference) of the passed in @uri
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_uri(raptor_world* world, raptor_uri* uri)
{
raptor_term *t;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!uri)
return NULL;
raptor_world_open(world);
t = (raptor_term*)RAPTOR_CALLOC(raptor_term, 1, sizeof(*t));
if(!t)
return NULL;
t->usage = 1;
t->world = world;
t->type = RAPTOR_TERM_TYPE_URI;
t->value.uri = raptor_uri_copy(uri);
return t;
}
/**
* raptor_new_term_from_counted_blank:
* @world: raptor world
* @blank: UTF-8 encoded blank node identifier (or NULL)
* @length: length of identifier (or 0)
*
* Constructor - create a new blank node statement term from a counted UTF-8 encoded blank node ID
*
* Takes a copy of the passed in @blank
*
* If @blank is NULL, creates a new internal identifier and uses it.
* This will use the handler set with
* raptor_world_set_generate_bnodeid_parameters()
*
* Note: The @blank need not be NULL terminated - a NULL will be
* added to the copied string used.
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_counted_blank(raptor_world* world,
const unsigned char* blank, size_t length)
{
raptor_term *t;
unsigned char* new_id;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if (blank) {
new_id = (unsigned char*)RAPTOR_MALLOC(cstring, length + 1);
if(!new_id)
return NULL;
memcpy(new_id, blank, length);
new_id[length] = '\0';
} else {
new_id = raptor_world_generate_bnodeid(world);
length = strlen((const char*)new_id);
}
t = (raptor_term*)RAPTOR_CALLOC(raptor_term, 1, sizeof(*t));
if(!t) {
RAPTOR_FREE(cstring, new_id);
return NULL;
}
t->usage = 1;
t->world = world;
t->type = RAPTOR_TERM_TYPE_BLANK;
t->value.blank.string = new_id;
t->value.blank.string_len = length;
return t;
}
/**
* raptor_get_serializer_factory:
* @world: raptor_world object
* @name: the factory name or NULL for the default factory
*
* Get a serializer factory by name.
*
* Return value: the factory object or NULL if there is no such factory
**/
static raptor_serializer_factory*
raptor_get_serializer_factory(raptor_world* world, const char *name)
{
raptor_serializer_factory *factory = NULL;
RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
raptor_world_open(world);
/* return 1st serializer if no particular one wanted - why? */
if(!name) {
factory = (raptor_serializer_factory *)raptor_sequence_get_at(world->serializers, 0);
if(!factory) {
RAPTOR_DEBUG1("No (default) serializers registered\n");
return NULL;
}
} else {
int i;
for(i = 0;
(factory = (raptor_serializer_factory*)raptor_sequence_get_at(world->serializers, i));
i++) {
int namei;
const char* fname;
for(namei = 0; (fname = factory->desc.names[namei]); namei++) {
if(!strcmp(fname, name))
break;
}
if(fname)
break;
}
}
return factory;
}
int
main(int argc, char *argv[])
{
raptor_world *world;
const char *program = raptor_basename(argv[0]);
#define ITEM_COUNT 8
const char *items[ITEM_COUNT+1] = { "ron", "amy", "jen", "bij", "jib", "daj", "jim", "def", NULL };
#define DELETE_COUNT 2
const char *delete_items[DELETE_COUNT+1] = { "jen", "jim", NULL };
#define RESULT_COUNT (ITEM_COUNT-DELETE_COUNT)
const char *results[RESULT_COUNT+1] = { "amy", "bij", "daj", "def", "jib", "ron", NULL};
raptor_avltree* tree;
raptor_avltree_iterator* iter;
visit_state vs;
int i;
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
tree = raptor_new_avltree(compare_strings,
NULL, /* no free as they are static pointers above */
0);
if(!tree) {
fprintf(stderr, "%s: Failed to create tree\n", program);
exit(1);
}
for(i = 0; items[i]; i++) {
int rc;
void* node;
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Adding tree item '%s'\n", program, items[i]);
#endif
rc = raptor_avltree_add(tree, (void*)items[i]);
if(rc) {
fprintf(stderr,
"%s: Adding tree item %d '%s' failed, returning error %d\n",
program, i, items[i], rc);
exit(1);
}
#ifdef RAPTOR_DEBUG
raptor_avltree_check(tree);
#endif
node = raptor_avltree_search(tree, (void*)items[i]);
if(!node) {
fprintf(stderr,
"%s: Tree did NOT contain item %d '%s' as expected\n",
program, i, items[i]);
exit(1);
}
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Printing tree\n", program);
vs.fh = stderr;
vs.count = 0;
raptor_avltree_visit(tree, print_string, &vs);
fprintf(stderr, "%s: Dumping tree\n", program);
raptor_avltree_dump(tree, stderr);
#endif
for(i = 0; delete_items[i]; i++) {
int rc;
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Deleting tree item '%s'\n", program, delete_items[i]);
#endif
rc = raptor_avltree_delete(tree, (void*)delete_items[i]);
if(!rc) {
fprintf(stderr,
"%s: Deleting tree item %d '%s' failed, returning error %d\n",
program, i, delete_items[i], rc);
exit(1);
}
#ifdef RAPTOR_DEBUG
raptor_avltree_check(tree);
#endif
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Walking tree forwards via iterator\n", program);
#endif
iter = raptor_new_avltree_iterator(tree, NULL, NULL, 1);
for(i = 0; 1; i++) {
const char* data = (const char*)raptor_avltree_iterator_get(iter);
const char* result = results[i];
if((!data && data != result) || (data && strcmp(data, result))) {
fprintf(stderr, "%3d: Forwards iterator expected '%s' but found '%s'\n",
i, result, data);
exit(1);
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%3d: Got '%s'\n", i, data);
#endif
if(raptor_avltree_iterator_next(iter))
break;
if(i > RESULT_COUNT) {
fprintf(stderr, "Forward iterator did not end on result %i as expected\n", i);
exit(1);
}
}
raptor_free_avltree_iterator(iter);
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Checking tree\n", program);
#endif
vs.count = 0;
vs.results = results;
vs.failed = 0;
raptor_avltree_visit(tree, check_string, &vs);
if(vs.failed) {
fprintf(stderr, "%s: Checking tree failed\n", program);
exit(1);
}
for(i = 0; results[i]; i++) {
const char* result = results[i];
char* data = (char*)raptor_avltree_remove(tree, (void*)result);
if(!data) {
fprintf(stderr, "%s: remove %i failed at item '%s'\n", program, i,
result);
exit(1);
}
if(strcmp(data, result)) {
fprintf(stderr, "%s: remove %i returned %s not %s as expected\n", program,
i, data, result);
exit(1);
}
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Freeing tree\n", program);
#endif
raptor_free_avltree(tree);
raptor_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
int
main(int argc, char *argv[])
{
flickcurl *fc = NULL;
int rc = 0;
int usage = 0;
int help = 0;
const char* home;
char config_path[1024];
char* photo_id = NULL;
const char* prefix_uri = "http://www.flickr.com/photos/";
size_t prefix_uri_len = strlen(prefix_uri);
const char *serializer_syntax_name = "ntriples";
raptor_uri* base_uri = NULL;
raptor_serializer* serializer = NULL;
int request_delay= -1;
flickcurl_serializer* fs = NULL;
flickcurl_photo* photo = NULL;
program = my_basename(argv[0]);
flickcurl_init();
rworld = raptor_new_world();
raptor_world_open(rworld);
home = getenv("HOME");
if(home)
sprintf(config_path, "%s/%s", home, config_filename);
else
strcpy(config_path, config_filename);
while (!usage && !help)
{
int c;
#ifdef HAVE_GETOPT_LONG
int option_index = 0;
c = getopt_long (argc, argv, GETOPT_STRING, long_options, &option_index);
#else
c = getopt (argc, argv, GETOPT_STRING);
#endif
if (c == -1)
break;
switch (c) {
case 0:
case '?': /* getopt() - unknown option */
usage = 1;
break;
case 'd':
if(optarg)
request_delay = atoi(optarg);
break;
case 'D':
debug = 1;
break;
case 'h':
help = 1;
break;
case 'o':
if(optarg) {
if(raptor_world_is_serializer_name(rworld, optarg))
serializer_syntax_name = optarg;
else {
int i;
fprintf(stderr,
"%s: invalid argument `%s' for `" HELP_ARG(o, output) "'\n",
program, optarg);
fprintf(stderr, "Valid arguments are:\n");
for(i = 0; 1; i++) {
const raptor_syntax_description *d;
d = raptor_world_get_serializer_description(rworld, i);
if(!d)
break;
printf(" %-12s for %s\n", d->names[0], d->label);
}
usage = 1;
break;
}
}
break;
case 'v':
fputs(flickcurl_version_string, stdout);
fputc('\n', stdout);
exit(0);
}
}
argv+= optind;
argc-= optind;
if(!help && argc < 1)
usage = 2; /* Title and usage */
if(!help && !argc) {
fprintf(stderr, "%s: No photo URI given\n", program);
usage = 1;
goto usage;
}
if(usage || help)
goto usage;
photo_id = argv[0];
if(strncmp(photo_id, prefix_uri, prefix_uri_len))
usage = 1;
else {
size_t len;
photo_id+= prefix_uri_len;
len = strlen(photo_id);
if(!len)
usage = 1;
else {
if(photo_id[len-1] == '/')
photo_id[--len] = '\0';
while(*photo_id && *photo_id != '/')
photo_id++;
if(!*photo_id)
usage = 1;
else
photo_id++;
}
}
if(usage) {
fprintf(stderr,
"%s: Argument is not a Flickr photo URI like\n"
" http://www.flickr.com/photos/USER/PHOTO/\n",
program);
goto usage;
}
serializer = raptor_new_serializer(rworld, serializer_syntax_name);
if(!serializer) {
fprintf(stderr,
"%s: Failed to create raptor serializer type %s\n", program,
serializer_syntax_name);
return(1);
}
base_uri = raptor_new_uri(rworld, (const unsigned char*)argv[0]);
raptor_serializer_start_to_file_handle(serializer, base_uri, stdout);
/* Initialise the Flickcurl library */
fc = flickcurl_new();
if(!fc) {
rc = 1;
goto tidy;
}
flickcurl_set_error_handler(fc, my_message_handler, NULL);
if(!access((const char*)config_path, R_OK)) {
if(flickcurl_config_read_ini(fc, config_path, config_section, fc,
flickcurl_config_var_handler)) {
rc = 1;
goto tidy;
}
}
usage:
if(usage) {
if(usage>1) {
fprintf(stderr, title_format_string, flickcurl_version_string);
fputs("Flickcurl home page: ", stderr);
fputs(flickcurl_home_url_string, stderr);
fputc('\n', stderr);
fputs(flickcurl_copyright_string, stderr);
fputs("\nLicense: ", stderr);
fputs(flickcurl_license_string, stderr);
fputs("\n\n", stderr);
}
fprintf(stderr, "Try `%s " HELP_ARG(h, help) "' for more information.\n",
program);
rc = 1;
goto tidy;
}
if(help) {
int i;
printf(title_format_string, flickcurl_version_string);
puts("Get Triples from Flickr photos.");
printf("Usage: %s [OPTIONS] FLICKR-PHOTO-URI\n\n", program);
fputs(flickcurl_copyright_string, stdout);
fputs("\nLicense: ", stdout);
puts(flickcurl_license_string);
fputs("Flickcurl home page: ", stdout);
puts(flickcurl_home_url_string);
fputs("\n", stdout);
puts(HELP_TEXT("d", "delay DELAY ", "Set delay between requests in milliseconds"));
puts(HELP_TEXT("D", "debug ", "Print lots of output"));
puts(HELP_TEXT("h", "help ", "Print this help, then exit"));
puts(HELP_TEXT("o", "output FORMAT ", "Set output format to one of:"));
for(i = 0; 1; i++) {
const raptor_syntax_description* d;
d = raptor_world_get_serializer_description(rworld, i);
if(!d)
break;
if(!strcmp(d->names[0], serializer_syntax_name))
printf(" %-15s %s (default)\n", d->names[0], d->label);
else
printf(" %-15s %s\n", d->names[0], d->label);
}
#ifdef HAVE_RAPTOR
printf(" via Raptor %s serializers\n", raptor_version_string);
#else
puts(" via internal RDF serializer");
#endif
puts(HELP_TEXT("v", "version ", "Print the flickcurl version"));
rc = 0;
goto tidy;
}
if(request_delay >= 0)
flickcurl_set_request_delay(fc, request_delay);
fs = flickcurl_new_serializer(fc, serializer, &flickrdf_serializer_factory);
if(!fs) {
fprintf(stderr, "%s: Failed to create Flickcurl serializer\n", program);
goto tidy;
}
photo = flickcurl_photos_getInfo(fc, photo_id);
if(!photo)
goto tidy;
if(debug)
fprintf(stderr, "%s: Photo with URI %s ID %s has %d tags\n",
program, photo->uri, photo->id, photo->tags_count);
rc = flickcurl_serialize_photo(fs, photo);
tidy:
if(photo)
flickcurl_free_photo(photo);
if(fs)
flickcurl_free_serializer(fs);
if(fc)
flickcurl_free(fc);
if(serializer)
raptor_free_serializer(serializer);
if(base_uri)
raptor_free_uri(base_uri);
if(rworld)
raptor_free_world(rworld);
flickcurl_finish();
return(rc);
}
/**
* raptor_new_term_from_counted_literal:
* @world: raptor world
* @literal: UTF-8 encoded literal string (or NULL for empty literal)
* @literal_len: length of literal
* @datatype: literal datatype URI (or NULL)
* @language: literal language (or NULL for no language)
* @language_len: literal language length
*
* Constructor - create a new literal statement term from a counted UTF-8 encoded literal string
*
* Takes copies of the passed in @literal, @datatype, @language
*
* Only one of @language or @datatype may be given. If both are
* given, NULL is returned. If @language is the empty string, it is
* the equivalent to NULL.
*
* Note: The @literal need not be NULL terminated - a NULL will be
* added to the copied string used.
*
* Return value: new term or NULL on failure
*/
raptor_term*
raptor_new_term_from_counted_literal(raptor_world* world,
const unsigned char* literal,
size_t literal_len,
raptor_uri* datatype,
const unsigned char* language,
unsigned char language_len)
{
raptor_term *t;
unsigned char* new_literal = NULL;
unsigned char* new_language = NULL;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
raptor_world_open(world);
if(language && !*language)
language = NULL;
if(language && datatype)
return NULL;
new_literal = (unsigned char*)RAPTOR_MALLOC(cstring, literal_len + 1);
if(!new_literal)
return NULL;
if(!literal || !*literal)
literal_len = 0;
if(literal_len) {
memcpy(new_literal, literal, literal_len);
new_literal[literal_len] = '\0';
} else
*new_literal = '\0';
if(language) {
new_language = (unsigned char*)RAPTOR_MALLOC(cstring, language_len + 1);
if(!new_language) {
RAPTOR_FREE(cstring, new_literal);
return NULL;
}
memcpy(new_language, language, language_len);
new_language[language_len] = '\0';
} else
language_len = 0;
if(datatype)
datatype = raptor_uri_copy(datatype);
t = (raptor_term*)RAPTOR_CALLOC(raptor_term, 1, sizeof(*t));
if(!t) {
if(new_literal)
RAPTOR_FREE(cstring, new_literal);
if(new_language)
RAPTOR_FREE(cstring, new_language);
if(datatype)
raptor_free_uri(datatype);
return NULL;
}
t->usage = 1;
t->world = world;
t->type = RAPTOR_TERM_TYPE_LITERAL;
t->value.literal.string = new_literal;
t->value.literal.string_len = literal_len;
t->value.literal.language = new_language;
t->value.literal.language_len = language_len;
t->value.literal.datatype = datatype;
return t;
}
/**
* raptor_new_iostream_to_string:
* @world: raptor world
* @string_p: pointer to location to hold string
* @length_p: pointer to location to hold length of string (or NULL)
* @malloc_handler: pointer to malloc() to use to make string (or NULL)
*
* Constructor - create a new iostream writing to a string.
*
* If @malloc_handler is null, raptor will allocate it using it's
* own memory allocator. *@string_p is set to NULL on failure (and
* *@length_p to 0 if @length_p is not NULL).
*
* Return value: new #raptor_iostream object or NULL on failure
**/
RAPTOR_EXTERN_C
raptor_iostream*
raptor_new_iostream_to_string(raptor_world *world,
void **string_p, size_t *length_p,
raptor_data_malloc_handler const malloc_handler)
{
raptor_iostream* iostr;
struct raptor_write_string_iostream_context* con;
const raptor_iostream_handler* handler;
const unsigned int mode = RAPTOR_IOSTREAM_MODE_WRITE;
RAPTOR_CHECK_CONSTRUCTOR_WORLD(world);
if(!string_p)
return NULL;
raptor_world_open(world);
handler = &raptor_iostream_write_string_handler;
if(!raptor_iostream_check_handler(handler, mode))
return NULL;
iostr = RAPTOR_CALLOC(raptor_iostream*, 1, sizeof(*iostr));
if(!iostr)
return NULL;
con = RAPTOR_CALLOC(struct raptor_write_string_iostream_context*, 1,
sizeof(*con));
if(!con) {
RAPTOR_FREE(raptor_iostream, iostr);
return NULL;
}
con->sb = raptor_new_stringbuffer();
if(!con->sb) {
RAPTOR_FREE(raptor_iostream, iostr);
RAPTOR_FREE(raptor_write_string_iostream_context, con);
return NULL;
}
con->string_p = string_p;
*string_p = NULL;
con->length_p = length_p;
if(length_p)
*length_p = 0;
if(malloc_handler)
con->malloc_handler = malloc_handler;
else
con->malloc_handler = raptor_alloc_memory;
iostr->world = world;
iostr->handler = handler;
iostr->user_data = (void*)con;
iostr->mode = mode;
if(iostr->handler->init && iostr->handler->init(iostr->user_data)) {
raptor_free_iostream(iostr);
return NULL;
}
return iostr;
}
int
main(int argc, char *argv[])
{
raptor_world *world;
const char *program = raptor_basename(argv[0]);
raptor_iostream *iostr;
raptor_namespace_stack *nstack;
raptor_namespace* foo_ns;
raptor_xml_writer* xml_writer;
raptor_uri* base_uri;
raptor_qname* el_name;
raptor_xml_element *element;
unsigned long offset;
raptor_qname **attrs;
raptor_uri* base_uri_copy = NULL;
/* for raptor_new_iostream_to_string */
void *string = NULL;
size_t string_len = 0;
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
iostr = raptor_new_iostream_to_string(world, &string, &string_len, NULL);
if(!iostr) {
fprintf(stderr, "%s: Failed to create iostream to string\n", program);
exit(1);
}
nstack = raptor_new_namespaces(world, 1);
xml_writer = raptor_new_xml_writer(world, nstack, iostr);
if(!xml_writer) {
fprintf(stderr, "%s: Failed to create xml_writer to iostream\n", program);
exit(1);
}
base_uri = raptor_new_uri(world, base_uri_string);
foo_ns = raptor_new_namespace(nstack,
(const unsigned char*)"foo",
(const unsigned char*)"http://example.org/foo-ns#",
0);
el_name = raptor_new_qname_from_namespace_local_name(world,
foo_ns,
(const unsigned char*)"bar",
NULL);
base_uri_copy = base_uri ? raptor_uri_copy(base_uri) : NULL;
element = raptor_new_xml_element(el_name,
NULL, /* language */
base_uri_copy);
raptor_xml_writer_start_element(xml_writer, element);
raptor_xml_writer_cdata_counted(xml_writer, (const unsigned char*)"hello\n", 6);
raptor_xml_writer_comment_counted(xml_writer, (const unsigned char*)"comment", 7);
raptor_xml_writer_cdata(xml_writer, (const unsigned char*)"\n");
raptor_xml_writer_end_element(xml_writer, element);
raptor_free_xml_element(element);
raptor_xml_writer_cdata(xml_writer, (const unsigned char*)"\n");
el_name = raptor_new_qname(nstack,
(const unsigned char*)"blah",
NULL /* no attribute value - element */);
base_uri_copy = base_uri ? raptor_uri_copy(base_uri) : NULL;
element = raptor_new_xml_element(el_name,
NULL, /* language */
base_uri_copy);
attrs = (raptor_qname **)RAPTOR_CALLOC(qnamearray, 1, sizeof(raptor_qname*));
attrs[0] = raptor_new_qname(nstack,
(const unsigned char*)"a",
(const unsigned char*)"b" /* attribute value */);
raptor_xml_element_set_attributes(element, attrs, 1);
raptor_xml_writer_empty_element(xml_writer, element);
raptor_xml_writer_cdata(xml_writer, (const unsigned char*)"\n");
raptor_free_xml_writer(xml_writer);
raptor_free_xml_element(element);
raptor_free_namespace(foo_ns);
raptor_free_namespaces(nstack);
raptor_free_uri(base_uri);
offset = raptor_iostream_tell(iostr);
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Freeing iostream\n", program);
#endif
raptor_free_iostream(iostr);
if(offset != OUT_BYTES_COUNT) {
fprintf(stderr, "%s: I/O stream wrote %d bytes, expected %d\n", program,
(int)offset, (int)OUT_BYTES_COUNT);
fputs("[[", stderr);
(void)fwrite(string, 1, string_len, stderr);
fputs("]]\n", stderr);
return 1;
}
if(!string) {
fprintf(stderr, "%s: I/O stream failed to create a string\n", program);
return 1;
}
string_len = strlen((const char*)string);
if(string_len != offset) {
fprintf(stderr, "%s: I/O stream created a string length %d, expected %d\n", program, (int)string_len, (int)offset);
return 1;
}
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Made XML string of %d bytes\n", program, (int)string_len);
fputs("[[", stderr);
(void)fwrite(string, 1, string_len, stderr);
fputs("]]\n", stderr);
#endif
raptor_free_memory(string);
raptor_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
int
main(int argc, char *argv[])
{
raptor_world *world;
const char *program = raptor_basename(argv[0]);
const char *items[8] = { "ron", "amy", "jen", "bij", "jib", "daj", "jim", NULL };
raptor_id_set *set;
raptor_uri *base_uri;
int i = 0;
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
base_uri = raptor_new_uri(world, (const unsigned char*)"http://example.org/base#");
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Creating set\n", program);
#endif
set = raptor_new_id_set(world);
if(!set) {
fprintf(stderr, "%s: Failed to create set\n", program);
exit(1);
}
for(i = 0; items[i]; i++) {
size_t len = strlen(items[i]);
int rc;
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Adding set item '%s'\n", program, items[i]);
#endif
rc = raptor_id_set_add(set, base_uri, (const unsigned char*)items[i], len);
if(rc) {
fprintf(stderr, "%s: Adding set item %d '%s' failed, returning error %d\n",
program, i, items[i], rc);
exit(1);
}
}
for(i = 0; items[i]; i++) {
size_t len = strlen(items[i]);
int rc;
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Adding duplicate set item '%s'\n", program, items[i]);
#endif
rc = raptor_id_set_add(set, base_uri, (const unsigned char*)items[i], len);
if(rc <= 0) {
fprintf(stderr, "%s: Adding duplicate set item %d '%s' succeeded, should have failed, returning error %d\n",
program, i, items[i], rc);
exit(1);
}
}
#if RAPTOR_DEBUG > 1
raptor_id_set_stats_print(set, stderr);
#endif
#if RAPTOR_DEBUG > 1
fprintf(stderr, "%s: Freeing set\n", program);
#endif
raptor_free_id_set(set);
raptor_free_uri(base_uri);
raptor_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
/**
* rasqal_world_open:
* @world: rasqal_world object
*
* Initialise the rasqal library.
*
* Initializes a #rasqal_world object created by rasqal_new_world().
* Allocation and initialization are decoupled to allow
* changing settings on the world object before init.
* These settings include e.g. the raptor library instance set with
* rasqal_world_set_raptor().
*
* The initialized world object is used with subsequent rasqal API calls.
*
* Return value: non-0 on failure
**/
int
rasqal_world_open(rasqal_world *world)
{
int rc;
if(!world)
return -1;
if(world->opened++)
return 0; /* not an error */
/* Create and init a raptor_world unless one is provided externally with rasqal_world_set_raptor() */
if(!world->raptor_world_ptr) {
world->raptor_world_ptr = raptor_new_world();
if(!world->raptor_world_ptr)
return -1;
world->raptor_world_allocated_here = 1;
rc = raptor_world_open(world->raptor_world_ptr);
if(rc)
return rc;
}
rc = rasqal_uri_init(world);
if(rc)
return rc;
rc = rasqal_xsd_init(world);
if(rc)
return rc;
world->query_languages = raptor_new_sequence((raptor_data_free_handler)rasqal_free_query_language_factory, NULL);
if(!world->query_languages)
return 1;
/* first query language declared is the default */
#ifdef RASQAL_QUERY_SPARQL
rc = rasqal_init_query_language_sparql(world);
if(rc)
return rc;
rc = rasqal_init_query_language_sparql11(world);
if(rc)
return rc;
#endif
#ifdef RASQAL_QUERY_LAQRS
rc = rasqal_init_query_language_laqrs(world);
if(rc)
return rc;
#endif
rc = rasqal_raptor_init(world);
if(rc)
return rc;
rc = rasqal_init_query_results();
if(rc)
return rc;
rc = rasqal_init_result_formats(world);
if(rc)
return rc;
return 0;
}
int
main(int argc, char *argv[])
{
raptor_world *world;
FILE *handle = NULL;
int failures = 0;
program = raptor_basename(argv[0]);
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
/* Write tests */
failures+= test_write_to_filename(world, (const char*)OUT_FILENAME,
TEST_STRING, TEST_STRING_LEN, (int)OUT_BYTES_COUNT);
handle = fopen((const char*)OUT_FILENAME, "wb");
if(!handle) {
fprintf(stderr, "%s: Failed to create write file handle to file %s\n",
program, OUT_FILENAME);
failures++;
} else {
failures+= test_write_to_file_handle(world,
handle, TEST_STRING, TEST_STRING_LEN,
(int)OUT_BYTES_COUNT);
fclose(handle);
remove(OUT_FILENAME);
}
failures+= test_write_to_string(world,
TEST_STRING,
TEST_STRING_LEN, (int)OUT_BYTES_COUNT);
failures+= test_write_to_sink(world,
TEST_STRING,
TEST_STRING_LEN, (int)OUT_BYTES_COUNT);
remove(OUT_FILENAME);
/* Read tests */
handle = fopen((const char*)IN_FILENAME, "wb");
if(!handle) {
fprintf(stderr, "%s: Failed to create write handle to file %s\n",
program, IN_FILENAME);
failures++;
} else {
fwrite(TEST_STRING, 1, TEST_STRING_LEN, handle);
fclose(handle);
failures+= test_read_from_filename(world,
(const char*)IN_FILENAME,
TEST_STRING, TEST_STRING_LEN,
TEST_STRING_LEN, 0);
handle = fopen((const char*)IN_FILENAME, "rb");
if(!handle) {
fprintf(stderr, "%s: Failed to create read file handle to file %s\n",
program, IN_FILENAME);
failures++;
} else {
failures+= test_read_from_file_handle(world,
handle,
TEST_STRING, TEST_STRING_LEN,
TEST_STRING_LEN, 0);
fclose(handle); handle = NULL;
}
}
failures+= test_read_from_string(world,
TEST_STRING, TEST_STRING_LEN,
TEST_STRING_LEN);
failures+= test_read_from_sink(world, TEST_STRING_LEN, 0);
remove(IN_FILENAME);
raptor_free_world(world);
return failures;
}
int
main(int argc, char *argv[])
{
raptor_world *world;
const char *program = raptor_basename(argv[0]);
int rc = 0;
raptor_term* term1 = NULL; /* URI string 1 */
raptor_term* term2 = NULL; /* literal string1 */
raptor_term* term3 = NULL; /* blank node 1 */
raptor_term* term4 = NULL; /* URI string 2 */
raptor_term* term5 = NULL; /* URI string 1 again */
raptor_uri* uri1;
unsigned char* uri_str;
size_t uri_len;
world = raptor_new_world();
if(!world || raptor_world_open(world))
exit(1);
/* check a term for NULL URI fails */
term1 = raptor_new_term_from_uri(world, NULL);
if(term1) {
fprintf(stderr, "%s: raptor_new_uri(NULL) returned object rather than failing\n", program);
rc = 1;
goto tidy;
}
/* check a term for non-NULL URI succeeds */
uri1 = raptor_new_uri(world, uri_string1);
if(!uri1) {
fprintf(stderr, "%s: raptor_new_uri(%s) failed\n", program, uri_string1);
rc = 1;
goto tidy;
}
term1 = raptor_new_term_from_uri(world, uri1);
if(!term1) {
fprintf(stderr, "%s: raptor_new_term_from_uri_string(URI %s) failed\n",
program, uri_string1);
rc = 1;
goto tidy;
}
raptor_free_uri(uri1); uri1 = NULL;
if(term1->type != uri_string1_type) {
fprintf(stderr, "%s: raptor term 1 is of type %d expected %d\n",
program, term1->type, uri_string1_type);
rc = 1;
goto tidy;
}
/* returns a pointer to shared string */
uri_str = raptor_uri_as_counted_string(term1->value.uri, &uri_len);
if(!uri_str) {
fprintf(stderr, "%s: raptor_uri_as_counted_string term 1 failed\n",
program);
rc = 1;
goto tidy;
}
if(uri_len != uri_string1_len) {
fprintf(stderr, "%s: raptor term 1 URI is of length %d expected %d\n",
program, (int)uri_len, (int)uri_string1_len);
rc = 1;
goto tidy;
}
/* check an empty literal is created from a NULL literal pointer succeeds */
term2 = raptor_new_term_from_counted_literal(world, NULL, 0, NULL, NULL, 0);
if(!term2) {
fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with all NULLs failed\n", program);
rc = 1;
goto tidy;
}
raptor_free_term(term2);
/* check an empty literal from an empty language literal pointer succeeds */
term2 = raptor_new_term_from_counted_literal(world, NULL, 0, NULL,
(const unsigned char*)"", 0);
if(!term2) {
fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with empty language failed\n", program);
rc = 1;
goto tidy;
}
raptor_free_term(term2);
/* check a literal with language and datatype fails */
uri1 = raptor_new_uri(world, uri_string1);
if(!uri1) {
fprintf(stderr, "%s: raptor_new_uri(%s) failed\n", program, uri_string1);
rc = 1;
goto tidy;
}
term2 = raptor_new_term_from_counted_literal(world, literal_string1,
literal_string1_len,
uri1, language1, 0);
raptor_free_uri(uri1); uri1 = NULL;
if(term2) {
fprintf(stderr, "%s: raptor_new_term_from_counted_literal() with language and datatype returned object rather than failing\n", program);
rc = 1;
goto tidy;
}
/* check a literal with no language and no datatype succeeds */
term2 = raptor_new_term_from_counted_literal(world, literal_string1,
literal_string1_len, NULL, NULL, 0);
if(!term2) {
fprintf(stderr, "%s: raptor_new_term_from_counted_literal(%s) failed\n",
program, literal_string1);
rc = 1;
goto tidy;
}
if(term2->type != literal_string1_type) {
fprintf(stderr, "%s: raptor term 2 is of type %d expected %d\n",
program, term2->type, literal_string1_type);
rc = 1;
goto tidy;
}
/* check a blank node term with NULL id generates a new identifier */
term3 = raptor_new_term_from_counted_blank(world, NULL, 0);
if(!term3) {
fprintf(stderr, "%s: raptor_new_term_from_counted_blank(NULL) failed\n",
program);
rc = 1;
goto tidy;
}
if(term3->type != bnodeid1_type) {
fprintf(stderr, "%s: raptor term 3 is of type %d expected %d\n",
program, term3->type, bnodeid1_type);
rc = 1;
goto tidy;
}
raptor_free_term(term3);
/* check a blank node term with an identifier succeeds */
term3 = raptor_new_term_from_counted_blank(world, bnodeid1, bnodeid1_len);
if(!term3) {
fprintf(stderr, "%s: raptor_new_term_from_counted_blank(%s) failed\n",
program, bnodeid1);
rc = 1;
goto tidy;
}
if(term3->type != bnodeid1_type) {
fprintf(stderr, "%s: raptor term 3 is of type %d expected %d\n",
program, term3->type, bnodeid1_type);
rc = 1;
goto tidy;
}
/* check a different URI term succeeds */
term4 = raptor_new_term_from_counted_uri_string(world, uri_string2,
uri_string2_len);
if(!term4) {
fprintf(stderr,
"%s: raptor_new_term_from_counted_uri_string(URI %s) failed\n",
program, uri_string2);
rc = 1;
goto tidy;
}
if(term4->type != uri_string2_type) {
fprintf(stderr, "%s: raptor term 4 is of type %d expected %d\n",
program, term4->type, uri_string2_type);
rc = 1;
goto tidy;
}
/* returns a pointer to shared string */
uri_str = raptor_uri_as_counted_string(term4->value.uri, &uri_len);
if(!uri_str) {
fprintf(stderr, "%s: raptor_uri_as_counted_string term 4 failed\n",
program);
rc = 1;
goto tidy;
}
if(uri_len != uri_string2_len) {
fprintf(stderr, "%s: raptor term 4 URI is of length %d expected %d\n",
program, (int)uri_len, (int)uri_string2_len);
rc = 1;
goto tidy;
}
/* check the same URI term as term1 succeeds */
term5 = raptor_new_term_from_uri_string(world, uri_string1);
if(!term5) {
fprintf(stderr, "%s: raptor_new_term_from_uri_string(URI %s) failed\n",
program, uri_string1);
rc = 1;
goto tidy;
}
if(raptor_term_equals(term1, term2)) {
fprintf(stderr, "%s: raptor_term_equals (URI %s, literal %s) returned equal, expected not-equal\n",
program, uri_string1, literal_string1);
rc = 1;
goto tidy;
}
if(raptor_term_equals(term1, term3)) {
fprintf(stderr, "%s: raptor_term_equals (URI %s, bnode %s) returned equal, expected not-equal\n",
program, uri_string1, bnodeid1);
rc = 1;
goto tidy;
}
if(raptor_term_equals(term1, term4)) {
fprintf(stderr, "%s: raptor_term_equals (URI %s, URI %s) returned equal, expected not-equal\n",
program, uri_string1, uri_string2);
rc = 1;
goto tidy;
}
if(!raptor_term_equals(term1, term5)) {
fprintf(stderr, "%s: raptor_term_equals (URI %s, URI %s) returned not-equal, expected equal\n",
program, uri_string1, uri_string1);
rc = 1;
goto tidy;
}
if(term1->value.uri != term5->value.uri) {
fprintf(stderr, "%s: term1 and term5 URI objects returned not-equal pointers, expected equal\n",
program);
/* This is not necessarily a failure if the raptor_uri module has had
* the URI interning disabled with
* raptor_world_set_flag(world, RAPTOR_WORLD_FLAG_URI_INTERNING, 0)
* however this test suite does not do that, so it is a failure here.
*/
rc = 1;
goto tidy;
}
tidy:
if(term1)
raptor_free_term(term1);
if(term2)
raptor_free_term(term2);
if(term3)
raptor_free_term(term3);
if(term4)
raptor_free_term(term4);
if(term5)
raptor_free_term(term5);
raptor_free_world(world);
return rc;
}
