/**
* 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;
}
RdfNode RdfStorePrivate::LibRdfNodeToRdfNode(librdf_node* node) const
{
RdfNode mitkNode;
if (!node) return mitkNode;
if (librdf_node_is_resource(node))
{
mitkNode.SetType(RdfNode::URI);
librdf_uri *uri = librdf_node_get_uri(node);
mitkNode.SetValue(LibRdfUriToRdfUri(uri).ToString());
}
else if (librdf_node_is_literal(node))
{
mitkNode.SetType(RdfNode::LITERAL);
std::string value = (const char*) librdf_node_get_literal_value(node);
if (!value.empty()) mitkNode.SetValue(value);
librdf_uri* typeUri = librdf_node_get_literal_value_datatype_uri(node);
if (typeUri) mitkNode.SetDatatype(LibRdfUriToRdfUri(typeUri));
}
else if (librdf_node_is_blank(node))
{
mitkNode.SetType(RdfNode::BLANK);
std::string str = (const char*) librdf_node_get_blank_identifier(node);
if (!str.empty()) mitkNode.SetValue(str);
}
return mitkNode;
}
/**
* librdf_statement_is_complete:
* @statement: #librdf_statement object
*
* Check if statement is a complete and legal RDF triple.
*
* Checks that all subject, predicate, object fields are present
* and they have the allowed node types.
*
* Return value: non 0 if the statement is complete and legal
**/
int
librdf_statement_is_complete(librdf_statement *statement)
{
LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(statement, librdf_statement, 0);
if(!statement->subject ||
(!librdf_node_is_resource(statement->subject) &&
!librdf_node_is_blank(statement->subject)))
return 0;
if(!statement->predicate || !librdf_node_is_resource(statement->predicate))
return 0;
if(!statement->object)
return 0;
return 1;
}
void output_node(librdf_node* n)
{
if (librdf_node_is_literal(n)) {
std::cout << librdf_node_get_literal_value(n);
}
if (librdf_node_is_resource(n)) {
librdf_uri* uri = librdf_node_get_uri(n);
std::cout << librdf_uri_as_string(uri);
}
}
rasqal_literal*
redland_node_to_rasqal_literal(librdf_world* world, librdf_node *node)
{
rasqal_literal* l;
if(librdf_node_is_resource(node)) {
raptor_uri* uri=(raptor_uri*)librdf_new_uri_from_uri(librdf_node_get_uri(node));
l=rasqal_new_uri_literal(world->rasqal_world_ptr, uri); /* transfer uri ownership to literal */
} else if(librdf_node_is_literal(node)) {
unsigned char *string;
librdf_uri *uri;
unsigned char *new_string;
char *new_language=NULL;
raptor_uri *new_datatype=NULL;
size_t len;
string=librdf_node_get_literal_value_as_counted_string(node, &len);
new_string=(unsigned char*)rasqal_alloc_memory(len+1);
if(!new_string)
return NULL;
strcpy((char*)new_string, (const char*)string);
string=(unsigned char*)librdf_node_get_literal_value_language(node);
if(string) {
new_language=(char*)rasqal_alloc_memory(strlen((const char*)string)+1);
if(!new_language) {
rasqal_free_memory((void*)new_string);
return NULL;
}
strcpy((char*)new_language, (const char*)string);
}
uri=librdf_node_get_literal_value_datatype_uri(node);
if(uri)
new_datatype=(raptor_uri*)librdf_new_uri_from_uri(uri);
/* transfer new_string,new_language,new_datatype ownership to literal */
l = rasqal_new_string_literal(world->rasqal_world_ptr, (const unsigned char*)new_string, new_language, new_datatype, NULL);
} else {
unsigned char *blank=librdf_node_get_blank_identifier(node);
unsigned char *new_blank;
if(!blank)
return NULL;
new_blank=(unsigned char*)rasqal_alloc_memory(strlen((const char*)blank)+1);
if(!new_blank)
return NULL;
strcpy((char*)new_blank, (const char*)blank);
/* transfer new_blank ownership to literal */
l = rasqal_new_simple_literal(world->rasqal_world_ptr, RASQAL_LITERAL_BLANK, (const unsigned char*)new_blank);
}
return l;
}
/*
* Convert the given resource librdf_node to a Ruby URI object and return it.
*/
VALUE
rleaf_librdf_uri_node_to_object( librdf_node *node ) {
VALUE node_object = Qnil;
librdf_uri *uri;
const unsigned char *uristring = NULL;
if ( !librdf_node_is_resource(node) )
rb_raise( rleaf_eRedleafError, "cannot convert a non-resource to a URI" );
if ( (uri = librdf_node_get_uri( node )) == NULL )
rb_raise( rleaf_eRedleafError, "unable to fetch a uri from resource node" );
if ( (uristring = librdf_uri_as_string( uri )) == NULL )
rb_raise( rleaf_eRedleafError, "unable to fetch a string from uri" );
// rleaf_log( "debug", "converting %s to a URI object", uristring );
node_object = rb_funcall( rleaf_rb_cURI, rb_intern("parse"), 1,
rb_str_new2((const char *)uristring) );
return node_object;
}
static void
librdf_serializer_print_statement_as_ntriple(librdf_statement * statement,
FILE *stream)
{
librdf_node *subject=librdf_statement_get_subject(statement);
librdf_node *predicate=librdf_statement_get_predicate(statement);
librdf_node *object=librdf_statement_get_object(statement);
char *lang=NULL;
librdf_uri *dt_uri=NULL;
if(librdf_node_is_blank(subject))
fprintf(stream, "_:%s", librdf_node_get_blank_identifier(subject));
else if(librdf_node_is_resource(subject)) {
/* Must be a URI */
fputc('<', stream);
raptor_print_ntriples_string(stream, librdf_uri_as_string(librdf_node_get_uri(subject)), '\0');
fputc('>', stream);
} else {
LIBRDF_ERROR2(statement->world, "Do not know how to print triple subject type %d\n", librdf_node_get_type(subject));
return;
}
if(!librdf_node_is_resource(predicate)) {
LIBRDF_ERROR2(statement->world, "Do not know how to print triple predicate type %d\n", librdf_node_get_type(predicate));
return;
}
fputc(' ', stream);
fputc('<', stream);
raptor_print_ntriples_string(stream, librdf_uri_as_string(librdf_node_get_uri(predicate)), '\0');
fputc('>', stream);
fputc(' ', stream);
switch(librdf_node_get_type(object)) {
case LIBRDF_NODE_TYPE_LITERAL:
fputc('"', stream);
raptor_print_ntriples_string(stream, librdf_node_get_literal_value(object), '"');
fputc('"', stream);
lang=librdf_node_get_literal_value_language(object);
dt_uri=librdf_node_get_literal_value_datatype_uri(object);
if(lang) {
fputc('@', stream);
fputs(lang, stream);
}
if(dt_uri) {
fputs("^^<", stream);
raptor_print_ntriples_string(stream, librdf_uri_as_string(dt_uri), '\0');
fputc('>', stream);
}
break;
case LIBRDF_NODE_TYPE_BLANK:
fputs("_:", stream);
fputs((const char*)librdf_node_get_blank_identifier(object), stream);
break;
case LIBRDF_NODE_TYPE_RESOURCE:
fputc('<', stream);
raptor_print_ntriples_string(stream, librdf_uri_as_string(librdf_node_get_uri(object)), '\0');
fputc('>', stream);
break;
default:
LIBRDF_ERROR2(statement->world, "Do not know how to print triple object type %d\n", librdf_node_get_type(object));
return;
}
fputs(" .", stream);
}
