/** * 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_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_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; }
/** * 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_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_new_term_from_uri_string: * @world: raptor world * @uri_string: UTF-8 encoded URI string. * * Constructor - create a new URI statement term from a UTF-8 encoded Unicode string * * Return value: new term or NULL on failure */ raptor_term* raptor_new_term_from_uri_string(raptor_world* world, const unsigned char *uri_string) { raptor_term *t; raptor_uri* uri; RAPTOR_CHECK_CONSTRUCTOR_WORLD(world); uri = raptor_new_uri(world, uri_string); if(!uri) return NULL; t = raptor_new_term_from_uri(world, uri); raptor_free_uri(uri); return t; }
/** * 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_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; }
/** * 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; }