static int statement_helper(librdf_storage* storage, librdf_statement* statement, librdf_node* context, char** s, char** p, char** o, char** c) { librdf_node* sn = librdf_statement_get_subject(statement); librdf_node* pn = librdf_statement_get_predicate(statement); librdf_node* on = librdf_statement_get_object(statement); if (sn) *s = node_helper(storage, sn); else *s = 0; if (pn) *p = node_helper(storage, pn); else *p = 0; if (on) *o = node_helper(storage, on); else *o = 0; if (context) *c = node_helper(storage, context); else *c = 0; }
void statement_in_tl(GSList ** list_, librdf_statement * statement) { GSList * list=*list_; ssTriple_t * triple; librdf_node* sub_node ; librdf_node* pred_node; librdf_node* obj_node ; sub_node = librdf_statement_get_subject(statement); pred_node = librdf_statement_get_predicate(statement); obj_node = librdf_statement_get_object(statement); triple =(ssTriple_t *) g_new0(ssTriple_t,1); triple->subject= g_strdup(librdf_uri_as_string( librdf_node_get_uri(sub_node))); triple->predicate = g_strdup(librdf_uri_as_string( librdf_node_get_uri(pred_node))); if (librdf_node_is_literal(obj_node)) { triple->object = g_strdup(librdf_node_get_literal_value(obj_node)); triple->objType = ssElement_TYPE_LIT; } else { triple->object = g_strdup(librdf_uri_as_string( librdf_node_get_uri(obj_node))); triple->objType = ssElement_TYPE_URI; } //printf ("statement to TL %s_%s_%s_%d\n", (char *)triple->subject, (char *)triple->predicate, (char *)triple->object, (bool *)triple->objType); list=g_slist_prepend(list, triple); /////////////////////////////////////////////////////////// *list_=list; }
RdfTriple RdfStorePrivate::StatementToRdfTriple(librdf_statement* statement) const { librdf_node *subject = librdf_statement_get_subject(statement); librdf_node *predicate = librdf_statement_get_predicate(statement); librdf_node *object = librdf_statement_get_object(statement); RdfTriple triple(LibRdfNodeToRdfNode(subject), LibRdfNodeToRdfNode(predicate), LibRdfNodeToRdfNode(object)); return triple; }
/** * librdf_storage_find_statements - search the storage for matching statements * @storage: &librdf_storage object * @statement: &librdf_statement partial statement to find * * Searches the storage for a (partial) statement as described in * librdf_statement_match() and returns a &librdf_stream of * matching &librdf_statement objects. * * Return value: &librdf_stream of matching statements (may be empty) or NULL on failure **/ librdf_stream* librdf_storage_find_statements(librdf_storage* storage, librdf_statement* statement) { librdf_node *subject, *predicate, *object; librdf_iterator *iterator; LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(storage, librdf_storage, NULL); LIBRDF_ASSERT_OBJECT_POINTER_RETURN_VALUE(statement, librdf_statement, NULL); subject=librdf_statement_get_subject(statement); predicate=librdf_statement_get_predicate(statement); object=librdf_statement_get_object(statement); /* try to pick the most efficient storage back end */ /* only subject/source field blank -> use find_sources */ if(!subject && predicate && object && storage->factory->find_sources) { iterator=storage->factory->find_sources(storage, predicate, object); if(iterator) return librdf_new_stream_from_node_iterator(iterator, statement, LIBRDF_STATEMENT_SUBJECT); return NULL; } /* only predicate/arc field blank -> use find_arcs */ if(subject && !predicate && object && storage->factory->find_arcs) { iterator=storage->factory->find_arcs(storage, subject, object); if(iterator) return librdf_new_stream_from_node_iterator(iterator, statement, LIBRDF_STATEMENT_PREDICATE); return NULL; } /* only object/target field blank -> use find_targets */ if(subject && predicate && !object && storage->factory->find_targets) { iterator=storage->factory->find_targets(storage, subject, predicate); if(iterator) return librdf_new_stream_from_node_iterator(iterator, statement, LIBRDF_STATEMENT_OBJECT); return NULL; } return storage->factory->find_statements(storage, statement); }
RdfStatement::RdfStatement(IWorld* world, librdf_statement* statement) : IStatement(world) { RdfNode *s = new RdfNode(librdf_statement_get_subject(statement), world); RdfNode *p = new RdfNode(librdf_statement_get_predicate(statement), world); RdfNode *o = new RdfNode(librdf_statement_get_object(statement), world); subject = s; predicate = p; object = o; RdfWorld* rdfWorld = dynamic_cast<RdfWorld*>(world); assert(rdfWorld && "Failed to dynamic cast IWorld to RdfWorld"); if (rdfWorld) this->statement = librdf_new_statement_from_nodes(rdfWorld->world, s->node, p->node, o->node); else LogError("Failed to cast IWorld to RdfWorld."); }
static void* librdf_storage_stream_to_node_iterator_get_method(void* iterator, int flags) { librdf_storage_stream_to_node_iterator_context* context=(librdf_storage_stream_to_node_iterator_context*)iterator; librdf_node* node; librdf_statement* statement=librdf_stream_get_object(context->stream); if(!statement) return NULL; switch(flags) { case LIBRDF_ITERATOR_GET_METHOD_GET_OBJECT: switch(context->want) { case LIBRDF_STATEMENT_SUBJECT: /* SOURCES (subjects) */ node=librdf_statement_get_subject(statement); break; case LIBRDF_STATEMENT_PREDICATE: /* ARCS (predicates) */ node=librdf_statement_get_predicate(statement); break; case LIBRDF_STATEMENT_OBJECT: /* TARGETS (objects) */ node=librdf_statement_get_object(statement); break; default: /* error */ LIBRDF_ERROR2(statement->world, "Unknown statement part %d\n", context->want); node=NULL; } break; case LIBRDF_ITERATOR_GET_METHOD_GET_CONTEXT: node=(librdf_node*)librdf_stream_get_context(context->stream); break; default: LIBRDF_ERROR2(statement->world, "Unknown iterator method flag %d\n", flags); node=NULL; } return (void*)node; }
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); }
static rasqal_triple_parts rasqal_redland_bind_match(struct rasqal_triples_match_s* rtm, void *user_data, rasqal_variable* bindings[4], rasqal_triple_parts parts) { rasqal_redland_triples_match_context* rtmc=(rasqal_redland_triples_match_context*)rtm->user_data; rasqal_literal* l; librdf_statement* statement; rasqal_triple_parts result=(rasqal_triple_parts)0; librdf_world *world = rtmc->stream->world; statement=librdf_stream_get_object(rtmc->stream); if(!statement) return (rasqal_triple_parts)0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1(" matched statement "); librdf_statement_print(statement, stderr); fputc('\n', stderr); #endif /* set 1 or 2 variable values from the fields of statement */ if(bindings[0] && (parts & RASQAL_TRIPLE_SUBJECT)) { #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("binding subject to variable\n"); #endif l = redland_node_to_rasqal_literal(world, librdf_statement_get_subject(statement)); rasqal_variable_set_value(bindings[0], l); result= RASQAL_TRIPLE_SUBJECT; } if(bindings[1] && (parts & RASQAL_TRIPLE_PREDICATE)) { if(bindings[0] == bindings[1]) { /* check matching(?x, ?x, ...) / subject=predicate */ if(!librdf_node_equals(librdf_statement_get_subject(statement), librdf_statement_get_predicate(statement))) return (rasqal_triple_parts)0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("subject and predicate values match\n"); #endif } else { #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("binding predicate to variable\n"); #endif l = redland_node_to_rasqal_literal(world, librdf_statement_get_predicate(statement)); rasqal_variable_set_value(bindings[1], l); result= (rasqal_triple_parts)(result | RASQAL_TRIPLE_PREDICATE); } } if(bindings[2] && (parts & RASQAL_TRIPLE_OBJECT)) { int bind=1; if(bindings[0] == bindings[2]) { /* check matching (?x, ..., ?x) / subject=object */ if(!librdf_node_equals(librdf_statement_get_subject(statement), librdf_statement_get_object(statement))) return (rasqal_triple_parts)0; bind=0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("subject and object values match\n"); #endif } if((bindings[1] == bindings[2]) && !(bindings[0] == bindings[1])) { /* check matching (..., ?x, ?x) / predicate=object * Don't do this if matching (?x, ?x, ...) / subject=predicate * was already done since that would mean the match was (?x, ?x, ?x) */ if(!librdf_node_equals(librdf_statement_get_predicate(statement), librdf_statement_get_object(statement))) return (rasqal_triple_parts)0; bind=0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("predicate and object values match\n"); #endif } if(bind) { #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("binding object to variable\n"); #endif l = redland_node_to_rasqal_literal(world, librdf_statement_get_object(statement)); rasqal_variable_set_value(bindings[2], l); result= (rasqal_triple_parts)(result | RASQAL_TRIPLE_OBJECT); } } /* Contexts */ if(bindings[3] && (parts & RASQAL_TRIPLE_ORIGIN)) { int bind=1; librdf_node* context_node = librdf_stream_get_context2(rtmc->stream); if(bindings[0] == bindings[3]) { /* check matching (?x, ..., ...) in context ?x */ if(!librdf_node_equals(librdf_statement_get_subject(statement), context_node)) return (rasqal_triple_parts)0; bind=0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("subject and context values match\n"); #endif } if(bindings[1] == bindings[3]) { /* check matching (..., ?x, ...) in context ?x */ if(!librdf_node_equals(librdf_statement_get_predicate(statement), context_node)) return (rasqal_triple_parts)0; bind=0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("predicate and context values match\n"); #endif } if(bindings[2] == bindings[3]) { /* check matching (..., ..., ?x) in context ?x */ if(!librdf_node_equals(librdf_statement_get_object(statement), context_node)) return (rasqal_triple_parts)0; bind=0; #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("object and context values match\n"); #endif } if(bind) { #if defined(LIBRDF_DEBUG) && LIBRDF_DEBUG > 1 LIBRDF_DEBUG1("binding origin to variable\n"); #endif if(context_node) l = redland_node_to_rasqal_literal(world, context_node); else l=NULL; rasqal_variable_set_value(bindings[3], l); result= (rasqal_triple_parts)(result | RASQAL_TRIPLE_ORIGIN); } } return result; }
UT_Error IE_Imp_OpenDocument::_handleRDFStreams () { #ifndef WITH_REDLAND return UT_OK; #else UT_Error error = UT_OK; UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams()\n")); // // DEBUG. // { // PD_DocumentRDFHandle rdf = getDoc()->getDocumentRDF(); // PD_DocumentRDFMutationHandle m = rdf->createMutation(); // m->add( PD_URI("http://www.example.com/foo#bar" ), // PD_URI("http://www.example.com/foo#bar" ), // PD_Object("http://www.example.com/foo#bar" ) ); // m->commit(); // rdf->dumpModel("added foo"); // } RDFArguments args; librdf_model* model = args.model; // check if we can load a manifest.rdf file GsfInput* pRdfManifest = gsf_infile_child_by_name(m_pGsfInfile, "manifest.rdf"); if (pRdfManifest) { UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() have manifest.rdf\n")); error = _loadRDFFromFile( pRdfManifest, "manifest.rdf", &args ); g_object_unref (G_OBJECT (pRdfManifest)); if (error != UT_OK) return error; } // find other RDF/XML files referenced in the manifest const char* query_string = "" "prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> \n" "prefix odf: <http://docs.oasis-open.org/opendocument/meta/package/odf#> \n" "prefix odfcommon: <http://docs.oasis-open.org/opendocument/meta/package/common#> \n" "select ?subj ?fileName \n" " where { \n" " ?subj rdf:type odf:MetaDataFile . \n" " ?subj odfcommon:path ?fileName \n" " } \n"; librdf_uri* base_uri = 0; librdf_query* query = librdf_new_query( args.world, "sparql", 0, (unsigned char*)query_string, base_uri ); librdf_query_results* results = librdf_query_execute( query, model ); if( !results ) { // Query failed is a failure to execute the SPARQL, // in which case there might be results but we couldn't find them UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() SPARQL query to find auxillary RDF/XML files failed! q:%p\n", query )); error = UT_ERROR; } else { UT_DEBUGMSG(("IE_Imp_OpenDocument::_handleRDFStreams() aux RDF/XML file count:%d\n", librdf_query_results_get_count( results ))); // parse auxillary RDF/XML files too for( ; !librdf_query_results_finished( results ) ; librdf_query_results_next( results )) { librdf_node* fnNode = librdf_query_results_get_binding_value_by_name ( results, "fileName" ); UT_DEBUGMSG(("_handleRDFStreams() fnNode:%p\n", fnNode )); std::string fn = toString(fnNode); UT_DEBUGMSG(("_handleRDFStreams() loading auxilary RDF/XML file from:%s\n", fn.c_str())); GsfInput* pAuxRDF = gsf_infile_child_by_name(m_pGsfInfile, fn.c_str()); if (pAuxRDF) { error = _loadRDFFromFile( pAuxRDF, fn.c_str(), &args ); g_object_unref (G_OBJECT (pAuxRDF)); if( error != UT_OK ) break; } else { UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN); return UT_ERROR; } } librdf_free_query_results( results ); } librdf_free_query( query ); UT_DEBUGMSG(("_handleRDFStreams() error:%d model.sz:%d\n", error, librdf_model_size( model ))); if( error != UT_OK ) { return error; } // convert the redland model into native AbiWord RDF triples { PD_DocumentRDFHandle rdf = getDoc()->getDocumentRDF(); PD_DocumentRDFMutationHandle m = rdf->createMutation(); librdf_statement* statement = librdf_new_statement( args.world ); librdf_stream* stream = librdf_model_find_statements( model, statement ); while (!librdf_stream_end(stream)) { librdf_statement* current = librdf_stream_get_object( stream ); int objectType = PD_Object::OBJECT_TYPE_URI; std::string xsdType = ""; if( librdf_node_is_blank( librdf_statement_get_object( current ))) { objectType = PD_Object::OBJECT_TYPE_BNODE; } if( librdf_node_is_literal( librdf_statement_get_object( current ))) { objectType = PD_Object::OBJECT_TYPE_LITERAL; if( librdf_uri* u = librdf_node_get_literal_value_datatype_uri( librdf_statement_get_object( current ))) { xsdType = toString(u); } } if( DEBUG_RDF_IO ) { UT_DEBUGMSG(("_handleRDFStreams() adding s:%s p:%s o:%s rotv:%d otv:%d ots:%s\n", toString( librdf_statement_get_subject( current )).c_str(), toString( librdf_statement_get_predicate( current )).c_str(), toString( librdf_statement_get_object( current )).c_str(), librdf_node_get_type(librdf_statement_get_object( current )), objectType, xsdType.c_str() )); } m->add( PD_URI( toString( librdf_statement_get_subject( current ))), PD_URI( toString( librdf_statement_get_predicate( current ))), PD_Object( toString( librdf_statement_get_object( current )), objectType, xsdType )); // m->add( PD_URI( toString( librdf_statement_get_subject( current ))), // PD_URI( toString( librdf_statement_get_predicate( current ))), // PD_Object( toString( librdf_statement_get_object( current )), // objectType, // xsdType )); librdf_stream_next(stream); } librdf_free_stream( stream ); librdf_free_statement( statement ); // m->add( PD_URI("http://www.example.com/foo#bar" ), // PD_URI("http://www.example.com/foo#bar" ), // PD_Object("http://www.example.com/foo#bar" ) ); m->commit(); } if( DEBUG_RDF_IO ) { getDoc()->getDocumentRDF()->dumpModel("Loaded RDF from ODF file"); } return error; #endif }