/**
* librdf_world_set_feature:
* @world: #librdf_world object
* @feature: #librdf_uri feature property
* @value: #librdf_node feature property value
*
* Set the value of a world feature.
*
* Return value: non 0 on failure (negative if no such feature)
**/
int
librdf_world_set_feature(librdf_world* world, librdf_uri* feature,
librdf_node* value)
{
librdf_uri* genid_base;
librdf_uri* genid_counter;
int rc= -1;
genid_counter = librdf_new_uri(world,
(const unsigned char*)LIBRDF_WORLD_FEATURE_GENID_COUNTER);
genid_base = librdf_new_uri(world,
(const unsigned char*)LIBRDF_WORLD_FEATURE_GENID_BASE);
if(librdf_uri_equals(feature, genid_base)) {
if(!librdf_node_is_resource(value))
rc=1;
else {
int i = atoi((const char*)librdf_node_get_literal_value(value));
if(i < 1)
i = 1;
#ifdef WITH_THREADS
pthread_mutex_lock(world->mutex);
#endif
world->genid_base = 1;
#ifdef WITH_THREADS
pthread_mutex_unlock(world->mutex);
#endif
rc = 0;
}
} else if(librdf_uri_equals(feature, genid_counter)) {
if(!librdf_node_is_resource(value))
rc = 1;
else {
int i = atoi((const char*)librdf_node_get_literal_value(value));
if(i < 1)
i = 1;
#ifdef WITH_THREADS
pthread_mutex_lock(world->mutex);
#endif
world->genid_counter = 1;
#ifdef WITH_THREADS
pthread_mutex_unlock(world->mutex);
#endif
rc = 0;
}
}
librdf_free_uri(genid_base);
librdf_free_uri(genid_counter);
return rc;
}
/*
* librdf_parser_raptor_namespace_handler - helper callback function for raptor RDF when a namespace is seen
* @context: context for callback
* @statement: raptor_statement
*
* Adds the statement to the list of statements.
*/
static void
librdf_parser_raptor_namespace_handler(void* user_data,
raptor_namespace *nspace)
{
librdf_parser_raptor_context* pcontext=(librdf_parser_raptor_context*)user_data;
const unsigned char* prefix;
unsigned char* nprefix;
size_t prefix_length;
librdf_uri* uri;
int i;
uri=(librdf_uri*)raptor_namespace_get_uri(nspace);
if(!uri)
return;
for(i=0; i < raptor_sequence_size(pcontext->nspace_uris); i++) {
librdf_uri* u=(librdf_uri*)raptor_sequence_get_at(pcontext->nspace_uris, i);
if(librdf_uri_equals(uri, u))
return;
}
/* new namespace */
uri=librdf_new_uri_from_uri(uri);
raptor_sequence_push(pcontext->nspace_uris, uri);
prefix=raptor_namespace_get_counted_prefix(nspace, &prefix_length);
if(prefix) {
nprefix = LIBRDF_MALLOC(unsigned char*, prefix_length + 1);
/* FIXME: what if nprefix alloc failed? now just pushes NULL to sequence */
if(nprefix)
strncpy((char*)nprefix, (const char*)prefix, prefix_length+1);
} else
/**
* librdf_node_get_literal_value_is_wf_xml:
* @node: the node object
*
* Get the XML well-formness property of the node.
*
* Return value: 0 if the XML literal is NOT well formed XML content, or the node is not a literal
**/
int
librdf_node_get_literal_value_is_wf_xml(librdf_node *node)
{
raptor_uri* rdf_xml_literal_uri;
int rc;
LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(node, librdf_node, 0);
if(node->type != RAPTOR_TERM_TYPE_LITERAL)
return 0;
if(!node->value.literal.datatype)
return 0;
rdf_xml_literal_uri = raptor_new_uri_for_rdf_concept(node->world,
(const unsigned char *)"XMLLiteral");
rc = librdf_uri_equals(node->value.literal.datatype, rdf_xml_literal_uri);
raptor_free_uri(rdf_xml_literal_uri);
return rc;
}
int
main(int argc, char *argv[])
{
const unsigned char *hp_string=(const unsigned char*)"http://purl.org/net/dajobe/";
librdf_uri *uri1, *uri2, *uri3, *uri4, *uri5, *uri6, *uri7, *uri8, *uri9;
librdf_digest *d;
const char *program=librdf_basename((const char*)argv[0]);
const char *file_string="/big/long/directory/file";
const unsigned char *file_uri_string=(const unsigned char*)"file:///big/long/directory/file";
const unsigned char *uri_string=(const unsigned char*)"http://example.com/big/long/directory/blah#frag";
const unsigned char *relative_uri_string1=(const unsigned char*)"#foo";
const unsigned char *relative_uri_string2=(const unsigned char*)"bar";
librdf_world *world;
world=librdf_new_world();
librdf_world_open(world);
fprintf(stderr, "%s: Creating new URI from string\n", program);
uri1=librdf_new_uri(world, hp_string);
if(!uri1) {
fprintf(stderr, "%s: Failed to create URI from string '%s'\n", program,
hp_string);
return(1);
}
fprintf(stderr, "%s: Home page URI is ", program);
librdf_uri_print(uri1, stderr);
fputs("\n", stderr);
fprintf(stderr, "%s: Creating URI from URI\n", program);
uri2=librdf_new_uri_from_uri(uri1);
if(!uri2) {
fprintf(stderr, "%s: Failed to create new URI from old one\n", program);
return(1);
}
fprintf(stderr, "%s: New URI is ", program);
librdf_uri_print(uri2, stderr);
fputs("\n", stderr);
fprintf(stderr, "%s: Getting digest for URI\n", program);
d = librdf_uri_get_digest(world, uri2);
if(!d) {
fprintf(stderr, "%s: Failed to get digest for URI %s\n", program,
librdf_uri_as_string(uri2));
return(1);
}
fprintf(stderr, "%s: Digest is: ", program);
librdf_digest_print(d, stderr);
fputs("\n", stderr);
librdf_free_digest(d);
uri3=librdf_new_uri(world, (const unsigned char*)"file:/big/long/directory/");
uri4=librdf_new_uri(world, (const unsigned char*)"http://somewhere/dir/");
fprintf(stderr, "%s: Source URI is ", program);
librdf_uri_print(uri3, stderr);
fputs("\n", stderr);
fprintf(stderr, "%s: Base URI is ", program);
librdf_uri_print(uri4, stderr);
fputs("\n", stderr);
fprintf(stderr, "%s: URI string is '%s'\n", program, uri_string);
uri5=librdf_new_uri_normalised_to_base(uri_string, uri3, uri4);
fprintf(stderr, "%s: Normalised URI is ", program);
librdf_uri_print(uri5, stderr);
fputs("\n", stderr);
uri6=librdf_new_uri_relative_to_base(uri5, relative_uri_string1);
fprintf(stderr, "%s: URI + Relative URI %s gives ", program,
relative_uri_string1);
librdf_uri_print(uri6, stderr);
fputs("\n", stderr);
uri7=librdf_new_uri_relative_to_base(uri5, relative_uri_string2);
fprintf(stderr, "%s: URI + Relative URI %s gives ", program,
relative_uri_string2);
librdf_uri_print(uri7, stderr);
fputs("\n", stderr);
uri8=librdf_new_uri_from_filename(world, file_string);
uri9=librdf_new_uri(world, file_uri_string);
if(!librdf_uri_equals(uri8, uri9)) {
fprintf(stderr, "%s: URI string from filename %s returned %s, expected %s\n", program, file_string, librdf_uri_as_string(uri8), file_uri_string);
return(1);
}
fprintf(stderr, "%s: Freeing URIs\n", program);
librdf_free_uri(uri1);
librdf_free_uri(uri2);
librdf_free_uri(uri3);
librdf_free_uri(uri4);
librdf_free_uri(uri5);
librdf_free_uri(uri6);
librdf_free_uri(uri7);
librdf_free_uri(uri8);
librdf_free_uri(uri9);
librdf_free_world(world);
/* keep gcc -Wall happy */
return(0);
}
/**
* librdf_get_serializer_factory:
* @world: redland world object
* @name: the name of the factory (or NULL or empty string if don't care)
* @mime_type: the MIME type of the syntax (NULL or empty string if not used)
* @type_uri: URI of syntax (NULL if not used)
*
* Get a serializer factory by name.
*
* If all fields are NULL, this means any parser supporting
* MIME Type "application/rdf+xml"
*
* Return value: the factory or NULL if not found
**/
librdf_serializer_factory*
librdf_get_serializer_factory(librdf_world *world,
const char *name, const char *mime_type,
librdf_uri *type_uri)
{
librdf_serializer_factory *factory;
librdf_world_open(world);
if(name && !*name)
name=NULL;
if(!mime_type || (mime_type && !*mime_type)) {
if(!name && !type_uri)
name="rdfxml";
else
mime_type=NULL;
}
/* return 1st serializer if no particular one wanted */
if(!name && !mime_type && !type_uri) {
factory=(librdf_serializer_factory*)raptor_sequence_get_at(world->serializers, 0);
if(!factory) {
LIBRDF_DEBUG1("No serializers available\n");
return NULL;
}
} else {
int i;
for(i=0;
(factory=(librdf_serializer_factory*)raptor_sequence_get_at(world->serializers, i));
i++) {
/* next if name does not match */
if(name && strcmp(factory->name, name))
continue;
/* MIME type may need to match */
if(mime_type) {
if(!factory->mime_type)
continue;
if(strcmp(factory->mime_type, mime_type))
continue;
}
/* URI may need to match */
if(type_uri) {
if(!factory->type_uri)
continue;
if(!librdf_uri_equals(factory->type_uri, type_uri))
continue;
}
/* found it */
break;
}
/* else FACTORY with given arguments not found */
if(!factory)
return NULL;
}
return factory;
}
