/*
* call-seq:
* graph.dup -> graph
*
* Duplicate the receiver and return the copy.
*
*/
static VALUE
rleaf_redleaf_graph_dup( VALUE self ) {
rleaf_GRAPH *ptr = rleaf_get_graph( self );
VALUE dup = rleaf_redleaf_graph_s_allocate( CLASS_OF(self) );
rleaf_GRAPH *dup_ptr = ALLOC( rleaf_GRAPH );
librdf_stream *statements = librdf_model_as_stream( ptr->model );
rleaf_log_with_context( self, "debug", "Duping %s 0x%x", rb_obj_classname(self), self );
dup_ptr->store = ptr->store;
dup_ptr->model = librdf_new_model_from_model( ptr->model );
if ( ! dup_ptr->model ) {
librdf_free_stream( statements );
xfree( dup_ptr );
rb_raise( rleaf_eRedleafError, "couldn't create new model from model <%p>", ptr->model );
}
if ( (librdf_model_add_statements(dup_ptr->model, statements)) != 0 ) {
librdf_free_stream( statements );
librdf_free_model( dup_ptr->model );
xfree( dup_ptr );
rb_raise( rleaf_eRedleafError, "couldn't add statements from the original model" );
}
DATA_PTR( dup ) = dup_ptr;
OBJ_INFECT( dup, self );
return dup;
}
static int
librdf_storage_file_add_statements(librdf_storage* storage,
librdf_stream* statement_stream)
{
librdf_storage_file_instance* context=(librdf_storage_file_instance*)storage->instance;
context->changed=1;
return librdf_model_add_statements(context->model, statement_stream);
}
int main(int argc, char** argv)
{
try {
/*********************************************************************/
/* Initialise */
/*********************************************************************/
std::cout << "** Initialise" << std::endl;
librdf_world* world = librdf_new_world();
if (world == 0)
throw std::runtime_error("Didn't get world");
librdf_storage* storage =
librdf_new_storage(world, STORE, STORE_NAME, "new='yes'");
if (storage == 0)
throw std::runtime_error("Didn't get storage");
librdf_model* model =
librdf_new_model(world, storage, 0);
if (model == 0)
throw std::runtime_error("Couldn't construct model");
/*********************************************************************/
/* Create in-memory model */
/*********************************************************************/
std::cout << "** Create in-memory model" << std::endl;
librdf_storage* mstorage =
librdf_new_storage(world, "memory", 0, 0);
if (storage == 0)
throw std::runtime_error("Didn't get storage");
librdf_model* mmodel =
librdf_new_model(world, mstorage, 0);
if (model == 0)
throw std::runtime_error("Couldn't construct model");
for(int i = 0; i < 10; i++) {
char sbuf[256];
char obuf[256];
sprintf(sbuf, "http://gaffer.test/number#%d", i);
sprintf(obuf, "http://gaffer.test/number#%d", i+1);
librdf_node *s =
librdf_new_node_from_uri_string(world,
(const unsigned char *) sbuf);
librdf_node *p =
librdf_new_node_from_uri_string(world,
(const unsigned char *)
"http://gaffer.test/number#is_before");
librdf_node *o =
librdf_new_node_from_uri_string(world,
(const unsigned char*) obuf);
librdf_statement* st = librdf_new_statement_from_nodes(world,
s, p, o);
librdf_model_add_statement(mmodel, st);
librdf_free_statement(st);
}
/*********************************************************************/
/* Size */
/*********************************************************************/
std::cout << "** Model size is " << librdf_model_size(model)
<< std::endl;
/*********************************************************************/
/* Add statement */
/*********************************************************************/
std::cout << "** Add statement" << std::endl;
const char* fred = "http://gaffer.test/#fred";
const char* is_a = "http://gaffer.test/#is_a";
const char* cat = "http://gaffer.test/#cat";
librdf_node *s =
librdf_new_node_from_uri_string(world,
(const unsigned char *) fred);
librdf_node *p =
librdf_new_node_from_uri_string(world,
(const unsigned char *) is_a);
librdf_node *o =
librdf_new_node_from_uri_string(world,
(const unsigned char *) cat);
librdf_statement* st = librdf_new_statement_from_nodes(world, s, p, o);
librdf_model_add_statement(model, st);
/*********************************************************************/
/* Add memory model statements */
/*********************************************************************/
std::cout << "** Add statements" << std::endl;
librdf_stream* strm = librdf_model_as_stream(mmodel);
if (strm == 0)
throw std::runtime_error("Couldn't get memory stream");
int ret = librdf_model_add_statements(model, strm);
if (ret != 0)
throw std::runtime_error("Couldn't add_statements");
librdf_free_stream(strm);
librdf_free_model(mmodel);
librdf_free_storage(mstorage);
/*********************************************************************/
/* Run queries */
/*********************************************************************/
run_query(world, model, query_string8);
run_query(world, model, query_string1);
run_query(world, model, query_string2);
run_query(world, model, query_string3);
run_query(world, model, query_string4);
run_query(world, model, query_string5);
run_query(world, model, query_string6);
run_query2(world, model, query_string7);
/*********************************************************************/
/* Remove statement */
/*********************************************************************/
std::cout << "** Remove statements" << std::endl;
librdf_model_remove_statement(model, st);
/*********************************************************************/
/* Serialise */
/*********************************************************************/
std::cout << "** Serialise" << std::endl;
strm = librdf_model_as_stream(model);
if (strm == 0)
throw std::runtime_error("Couldn't get model as stream");
librdf_serializer* srl = librdf_new_serializer(world, "ntriples",
0, 0);
if (srl == 0)
throw std::runtime_error("Couldn't create serialiser");
size_t len;
unsigned char* out =
librdf_serializer_serialize_stream_to_counted_string(srl, 0,
strm, &len);
std::cout << "--------------------------------------------------------"
<< std::endl;
write(1, out, len);
std::cout << "--------------------------------------------------------"
<< std::endl;
free(out);
librdf_free_stream(strm);
librdf_free_serializer(srl);
/*********************************************************************/
/* Cleanup */
/*********************************************************************/
librdf_free_statement(st);
librdf_free_model(model);
librdf_free_storage(storage);
librdf_free_world(world);
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
}
int
print_query_results(librdf_world* world, librdf_model* model, librdf_query_results *results)
{
int i;
char *name;
librdf_stream* stream;
librdf_serializer* serializer;
const char *query_graph_serializer_syntax_name="rdfxml";
if(librdf_query_results_is_bindings(results)) {
fprintf(stdout, ": Query returned bindings results:\n");
while(!librdf_query_results_finished(results)) {
fputs("result: [", stdout);
for(i=0; i<librdf_query_results_get_bindings_count(results); i++) {
librdf_node *value=librdf_query_results_get_binding_value(results, i);
name=(char*)librdf_query_results_get_binding_name(results, i);
if(i>0)
fputs(", ", stdout);
fprintf(stdout, "%s=", name);
if(value) {
librdf_node_print(value, stdout);
librdf_free_node(value);
} else
fputs("NULL", stdout);
}
fputs("]\n", stdout);
librdf_query_results_next(results);
}
fprintf(stdout, ": Query returned %d results\n", librdf_query_results_get_count(results));
} else if(librdf_query_results_is_boolean(results)) {
fprintf(stdout, ": Query returned boolean result: %s\n", librdf_query_results_get_boolean(results) ? "true" : "false");
} else if(librdf_query_results_is_graph(results)) {
librdf_storage* tmp_storage;
librdf_model* tmp_model;
tmp_storage=librdf_new_storage(world, NULL, NULL, NULL);
tmp_model=librdf_new_model(world, tmp_storage, NULL);
fprintf(stdout, ": Query returned graph result:\n");
stream=librdf_query_results_as_stream(results);
if(!stream) {
fprintf(stderr, ": Failed to get query results graph\n");
return -1;
}
librdf_model_add_statements(tmp_model, stream);
librdf_free_stream(stream);
fprintf(stdout, ": Total %d triples\n", librdf_model_size(model));
serializer=librdf_new_serializer(world, query_graph_serializer_syntax_name, NULL, NULL);
if(!serializer) {
fprintf(stderr, ": Failed to create serializer type %s\n", query_graph_serializer_syntax_name);
return -1;
}
librdf_serializer_serialize_model_to_file_handle(serializer, stdout, NULL, tmp_model);
librdf_free_serializer(serializer);
librdf_free_model(tmp_model);
librdf_free_storage(tmp_storage);
} else {
fprintf(stdout, ": Query returned unknown result format\n");
return -1;
}
return 0;
}
